private static VSCodeAction GenerateVSCodeAction( CodeActionParams request, CodeAction codeAction, CodeActionKind codeActionKind, string currentTitle = "") { using var _ = ArrayBuilder <VSCodeAction> .GetInstance(out var nestedActions); if (!string.IsNullOrEmpty(currentTitle)) { // Adding a delimiter for nested code actions, e.g. 'Suppress or Configure issues|Suppress IDEXXXX|in Source' currentTitle += '|'; } currentTitle += codeAction.Title; // Nested code actions' unique identifiers consist of: parent code action unique identifier + '|' + title of code action foreach (var action in codeAction.NestedCodeActions) { nestedActions.Add(GenerateVSCodeAction(request, action, codeActionKind, currentTitle)); } return(new VSCodeAction { Title = codeAction.Title, Kind = codeActionKind, Diagnostics = request.Context.Diagnostics, Children = nestedActions.ToArray(), Data = new CodeActionResolveData(currentTitle, request.Range, request.TextDocument) }); }
internal CodeFix(Project project, CodeAction action, ImmutableArray<Diagnostic> diagnostics) { Debug.Assert(!diagnostics.IsDefault); this.Project = project; this.Action = action; this.Diagnostics = diagnostics; }
public SuggestedActionWithNestedActions( SuggestedActionsSourceProvider sourceProvider, Workspace workspace, ITextBuffer subjectBuffer, object provider, CodeAction codeAction, SuggestedActionSet nestedActionSet) : base(sourceProvider, workspace, subjectBuffer, provider, codeAction) { NestedActionSet = nestedActionSet; }
private async Task ExecuteCodeAction(CodeAction codeAction) { var operations = await codeAction.GetOperationsAsync(CancellationToken.None).ConfigureAwait(true); foreach (var operation in operations) { operation.Apply(_roslynHost.GetDocument(_documentId).Project.Solution.Workspace, CancellationToken.None); } }
protected SuggestedActionWithFlavors( Workspace workspace, ITextBuffer subjectBuffer, ICodeActionEditHandlerService editHandler, CodeAction codeAction, object provider) : base(workspace, subjectBuffer, editHandler, codeAction, provider) { }
public SuggestedActionWithPreview( Workspace workspace, ITextBuffer subjectBuffer, ICodeActionEditHandlerService editHandler, IWaitIndicator waitIndicator, CodeAction codeAction, object provider, IAsynchronousOperationListener operationListener) : base(workspace, subjectBuffer, editHandler, waitIndicator, codeAction, provider, operationListener, actionSets: null) { }
/// <summary> /// Add supplied <paramref name="action"/> to the list of refactorings that will be offered to the user. /// </summary> /// <param name="action">The <see cref="CodeAction"/> that will be invoked to apply the refactoring.</param> public void RegisterRefactoring(CodeAction action) { if (action == null) { throw new ArgumentNullException(nameof(action)); } _registerRefactoring(action); }
public CodeRefactoringSuggestedAction( Workspace workspace, ITextBuffer subjectBuffer, ICodeActionEditHandlerService editHandler, CodeAction codeAction, CodeRefactoringProvider provider) : base(workspace, subjectBuffer, editHandler, codeAction, provider) { }
public CodeRefactoringSuggestedAction( SuggestedActionsSourceProvider sourceProvider, Workspace workspace, ITextBuffer subjectBuffer, CodeRefactoringProvider provider, CodeAction codeAction) : base(sourceProvider, workspace, subjectBuffer, provider, codeAction) { }
protected SuggestedActionWithFlavors( Workspace workspace, ITextBuffer subjectBuffer, ICodeActionEditHandlerService editHandler, IWaitIndicator waitIndicator, CodeAction codeAction, object provider, IAsynchronousOperationListener operationListener) : base(workspace, subjectBuffer, editHandler, waitIndicator, codeAction, provider, operationListener) { }
public SuggestedActionWithNestedFlavors( SuggestedActionsSourceProvider sourceProvider, Workspace workspace, ITextBuffer subjectBuffer, object provider, CodeAction codeAction, SuggestedActionSet additionalFlavors = null) : base(sourceProvider, workspace, subjectBuffer, provider, codeAction) { _additionalFlavors = additionalFlavors; }
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<IEnumerable<CodeActionOperation>> GetFixAllOperationsAsync(CodeAction codeAction, FixAllContext fixAllContext, string fixAllPreviewChangesTitle, bool showPreviewChangesDialog) { // We have computed the fix all occurrences code fix. // Now fetch the new solution with applied fix and bring up the Preview changes dialog. var cancellationToken = fixAllContext.CancellationToken; var workspace = fixAllContext.Project.Solution.Workspace; cancellationToken.ThrowIfCancellationRequested(); var operations = await codeAction.GetOperationsAsync(cancellationToken).ConfigureAwait(false); if (operations == null) { return null; } cancellationToken.ThrowIfCancellationRequested(); var newSolution = await codeAction.GetChangedSolutionInternalAsync(cancellationToken).ConfigureAwait(false); if (showPreviewChangesDialog) { cancellationToken.ThrowIfCancellationRequested(); using (Logger.LogBlock(FunctionId.CodeFixes_FixAllOccurrencesPreviewChanges, cancellationToken)) { var previewService = workspace.Services.GetService<IPreviewDialogService>(); var glyph = fixAllContext.Project.Language == LanguageNames.CSharp ? Glyph.CSharpProject : Glyph.BasicProject; var changedSolution = previewService.PreviewChanges( string.Format(EditorFeaturesResources.PreviewChangesOf, fixAllPreviewChangesTitle), "vs.codefix.fixall", codeAction.Title, fixAllPreviewChangesTitle, glyph, newSolution, fixAllContext.Project.Solution); if (changedSolution == null) { // User clicked cancel. FixAllLogger.LogPreviewChangesResult(applied: false); return null; } FixAllLogger.LogPreviewChangesResult(applied: true, allChangesApplied: changedSolution == newSolution); newSolution = changedSolution; } } // Get a code action, with apply changes operation replaced with the newSolution. return GetNewFixAllOperations(operations, newSolution, cancellationToken); }
public RefactoringPreviewTooltipWindow (TextEditor editor, DocumentContext documentContext, CodeAction codeAction) { this.editor = editor; this.documentContext = documentContext; this.codeAction = codeAction; TransientFor = IdeApp.Workbench.RootWindow; fontDescription = Pango.FontDescription.FromString (DefaultSourceEditorOptions.Instance.FontName); fontDescription.Size = (int)(fontDescription.Size * 0.8f); using (var metrics = PangoContext.GetMetrics (fontDescription, PangoContext.Language)) { lineHeight = (int)Math.Ceiling (0.5 + (metrics.Ascent + metrics.Descent) / Pango.Scale.PangoScale); } }
public static void CodeAction(CodeAction codeAction, Document document, string expectedCode) { var operations = codeAction.GetOperationsAsync(CancellationToken.None).Result; Assert.That(operations.Count(), Is.EqualTo(1)); var operation = operations.Single(); var workspace = document.Project.Solution.Workspace; operation.Apply(workspace, CancellationToken.None); var newDocument = workspace.CurrentSolution.GetDocument(document.Id); var sourceText = newDocument.GetTextAsync(CancellationToken.None).Result; var text = sourceText.ToString(); Assert.That(text, Is.EqualTo(expectedCode)); }
private static bool TryGetRedundantLambdaParameterAction(SyntaxNode syntaxNode, SyntaxNode root, Document document, out CodeAction action) { var parameterList = syntaxNode.Parent?.Parent as ParameterListSyntax; if (parameterList == null) { action = null; return false; } action = CodeAction.Create(TitleRedundantLambdaParameterType, c => { var newParameterList = parameterList.WithParameters( SyntaxFactory.SeparatedList(parameterList.Parameters.Select(p => SyntaxFactory.Parameter(p.Identifier).WithTriviaFrom(p)))); var newRoot = root.ReplaceNode(parameterList, newParameterList); return Task.FromResult(document.WithSyntaxRoot(newRoot)); }, TitleRedundantLambdaParameterType); return true; }
public static void CodeAction(CodeAction codeAction, Document document, string expectedCode) { var operations = codeAction.GetOperationsAsync(CancellationToken.None).Result; Assert.That(operations.Count(), Is.EqualTo(1)); var operation = operations.Single(); var workspace = document.Project.Solution.Workspace; operation.Apply(workspace, CancellationToken.None); var newDocument = workspace.CurrentSolution.GetDocument(document.Id); var sourceText = newDocument.GetTextAsync(CancellationToken.None).Result; var text = sourceText.ToString(); Console.WriteLine($"New code:\r\n{text}"); // Need to replace win-style line ending to unix-style to avoid build breaks on AppVeyor text = text.Replace("\r\n", "\n"); expectedCode = expectedCode.Replace("\r\n", "\n"); Assert.That(text, Is.EqualTo(expectedCode)); }
static VSCodeAction GenerateVSCodeAction( CodeActionParams request, CodeAction codeAction, CodeActionKind codeActionKind, string currentTitle = "") { using var _ = ArrayBuilder <VSCodeAction> .GetInstance(out var nestedActions); if (!string.IsNullOrEmpty(currentTitle)) { // Adding a delimiter for nested code actions, e.g. 'Suppress IDEXXXX|in Source' currentTitle += '|'; } // Don't include Suppress or Configure issues in the unique identifier, as when we // resolve these code actions, we won't be able to see the Suppress or Configure title // (since it utilizes special logic). // Once we make the logic between local and LSP uniform, this should no longer be necessary. // https://github.com/dotnet/roslyn/issues/45726 if (codeAction.Title != CodeFixesResources.Suppress_or_Configure_issues) { currentTitle += codeAction.Title; } // Nested code actions' unique identifiers consist of: parent code action unique identifier + '|' + title of code action foreach (var action in codeAction.NestedCodeActions) { nestedActions.Add(GenerateVSCodeAction(request, action, codeActionKind, currentTitle)); } return(new VSCodeAction { Title = codeAction.Title, Kind = codeActionKind, Diagnostics = request.Context.Diagnostics, Children = nestedActions.ToArray(), Data = new CodeActionResolveData(currentTitle, request.Range, request.TextDocument) }); }
private async Task<IEnumerable<CodeActionOperation>> GetFixAllOperationsAsync(CodeAction codeAction, FixAllContext fixAllContext, bool showPreviewChangesDialog) { // We have computed the fix all occurrences code fix. // Now fetch the new solution with applied fix and bring up the Preview changes dialog. var cancellationToken = fixAllContext.CancellationToken; var workspace = fixAllContext.Project.Solution.Workspace; cancellationToken.ThrowIfCancellationRequested(); var operations = await codeAction.GetOperationsAsync(cancellationToken).ConfigureAwait(false); if (operations == null) { return null; } cancellationToken.ThrowIfCancellationRequested(); var newSolution = await codeAction.GetChangedSolutionInternalAsync(cancellationToken: cancellationToken).ConfigureAwait(false); if (showPreviewChangesDialog) { newSolution = PreviewChanges( fixAllContext.Project.Solution, newSolution, FeaturesResources.FixAllOccurrences, codeAction.Title, fixAllContext.Project.Language, workspace, cancellationToken); if (newSolution == null) { return null; } } // Get a code action, with apply changes operation replaced with the newSolution. return GetNewFixAllOperations(operations, newSolution, cancellationToken); }
internal CodeFix(Project project, CodeAction action, Diagnostic diagnostic) { this.Project = project; this.Action = action; this.Diagnostics = ImmutableArray.Create(diagnostic); }
/// <summary> /// Apply the inputted CodeAction to the inputted document. /// Meant to be used to apply codefixes. /// </summary> /// <param name="document">The Document to apply the fix on</param> /// <param name="codeAction">A CodeAction that will be applied to the Document.</param> /// <returns>A Document with the changes from the CodeAction</returns> private static Document ApplyFix(Document document, CodeAction codeAction) { var operations = codeAction.GetOperationsAsync(CancellationToken.None).Result; var solution = operations.OfType<ApplyChangesOperation>().Single().ChangedSolution; return solution.GetDocument(document.Id); }
public PreviewChangesCodeAction(Workspace workspace, CodeAction originalCodeAction, SolutionChangeSummary changeSummary) { _workspace = workspace; _originalCodeAction = originalCodeAction; _changeSummary = changeSummary; }
/// <summary> /// Add supplied <paramref name="action"/> to the list of fixes that will be offered to the user. /// </summary> /// <param name="action">The <see cref="CodeAction"/> that will be invoked to apply the fix.</param> /// <param name="diagnostics">The subset of <see cref="Diagnostics"/> being addressed / fixed by the <paramref name="action"/>.</param> public void RegisterCodeFix(CodeAction action, ImmutableArray<Diagnostic> diagnostics) { if (action == null) { throw new ArgumentNullException(nameof(action)); } VerifyDiagnosticsArgument(diagnostics, _span); // TODO: // - Check that all diagnostics are unique (no duplicates). // - Check that supplied diagnostics form subset of diagnostics originally // passed to the provider via CodeFixContext.Diagnostics. _registerCodeFix(action, diagnostics); }
/// <summary> /// Add supplied <paramref name="action"/> to the list of fixes that will be offered to the user. /// </summary> /// <param name="action">The <see cref="CodeAction"/> that will be invoked to apply the fix.</param> /// <param name="diagnostics">The subset of <see cref="Diagnostics"/> being addressed / fixed by the <paramref name="action"/>.</param> public void RegisterCodeFix(CodeAction action, IEnumerable<Diagnostic> diagnostics) { if (diagnostics == null) { throw new ArgumentNullException(nameof(diagnostics)); } RegisterCodeFix(action, diagnostics.ToImmutableArray()); }
/// <summary> /// Add supplied <paramref name="action"/> to the list of fixes that will be offered to the user. /// </summary> /// <param name="action">The <see cref="CodeAction"/> that will be invoked to apply the fix.</param> /// <param name="diagnostic">The subset of <see cref="Diagnostics"/> being addressed / fixed by the <paramref name="action"/>.</param> public void RegisterCodeFix(CodeAction action, Diagnostic diagnostic) { if (action == null) { throw new ArgumentNullException(nameof(action)); } if (diagnostic == null) { throw new ArgumentNullException(nameof(diagnostic)); } _registerCodeFix(action, ImmutableArray.Create(diagnostic)); }
private static bool TryGetAction(SyntaxNode syntaxNode, SyntaxNode root, RedundantDeclaration.RedundancyType diagnosticType, Document document, out CodeAction action) { switch (diagnosticType) { case RedundantDeclaration.RedundancyType.LambdaParameterType: return TryGetRedundantLambdaParameterAction(syntaxNode, root, document, out action); case RedundantDeclaration.RedundancyType.ArraySize: return TryGetRedundantArraySizeAction(syntaxNode, root, document, out action); case RedundantDeclaration.RedundancyType.ArrayType: return TryGetRedundantArrayTypeAction(syntaxNode, root, document, out action); case RedundantDeclaration.RedundancyType.ExplicitDelegate: case RedundantDeclaration.RedundancyType.ExplicitNullable: return TryGetRedundantExplicitObjectCreationAction(syntaxNode, root, document, diagnosticType, out action); case RedundantDeclaration.RedundancyType.ObjectInitializer: return TryGetRedundantObjectInitializerAction(syntaxNode, root, document, out action); case RedundantDeclaration.RedundancyType.DelegateParameterList: return TryGetRedundantParameterTypeAction(syntaxNode, root, document, out action); default: throw new NotSupportedException(); } }
private static bool TryGetRedundantArraySizeAction(SyntaxNode syntaxNode, SyntaxNode root, Document document, out CodeAction action) { var arrayRank = syntaxNode.Parent as ArrayRankSpecifierSyntax; if (arrayRank == null) { action = null; return false; } action = CodeAction.Create(TitleRedundantArraySize, c => { var newArrayRankSpecifier = arrayRank.WithSizes( SyntaxFactory.SeparatedList<ExpressionSyntax>(arrayRank.Sizes.Select(s => SyntaxFactory.OmittedArraySizeExpression()))); var newRoot = root.ReplaceNode(arrayRank, newArrayRankSpecifier); return Task.FromResult(document.WithSyntaxRoot(newRoot)); }, TitleRedundantArraySize); return true; }
/// <summary> /// If the provided fix all context is non-null and the context's code action Id matches the given code action's Id then, /// returns the set of fix all occurrences actions associated with the code action. /// </summary> internal SuggestedActionSet GetFixAllSuggestedActionSet( CodeAction action, int actionCount, FixAllState fixAllState, ImmutableArray<FixAllScope> supportedScopes, Diagnostic firstDiagnostic, Workspace workspace) { if (fixAllState == null) { return null; } if (actionCount > 1 && action.EquivalenceKey == null) { return null; } var fixAllSuggestedActions = ArrayBuilder<FixAllSuggestedAction>.GetInstance(); foreach (var scope in supportedScopes) { var fixAllStateForScope = fixAllState.WithScopeAndEquivalenceKey(scope, action.EquivalenceKey); var fixAllSuggestedAction = new FixAllSuggestedAction( _owner, workspace, _subjectBuffer, fixAllStateForScope, firstDiagnostic, action); fixAllSuggestedActions.Add(fixAllSuggestedAction); } return new SuggestedActionSet( fixAllSuggestedActions.ToImmutableAndFree(), title: EditorFeaturesResources.Fix_all_occurrences_in); }
private bool IsApplicable(CodeAction action, Workspace workspace) { if (!action.PerformFinalApplicabilityCheck) { // If we don't even need to perform the final applicability check, // then the code actoin is applicable. return true; } // Otherwise, defer to the action to make the decision. this.AssertIsForeground(); return action.IsApplicable(workspace); }
private static bool TryGetCodeActionToApply(string codeFixTitle, IEnumerable<CodeAction> codeActions, out CodeAction codeAction) { codeAction = codeFixTitle != null ? codeActions.SingleOrDefault(action => action.Title == codeFixTitle) : codeActions.FirstOrDefault(); return codeAction != null; }
private static Document ApplyFix(Document document, CodeAction codeAction) => codeAction.GetOperationsAsync(CancellationToken.None).Result.OfType<ApplyChangesOperation>().Single().ChangedSolution.GetDocument(document.Id);
internal static bool IsAnalysisOrErrorFix(Microsoft.CodeAnalysis.CodeActions.CodeAction act) { return(false); }
/// <summary> /// Apply the inputted CodeAction to the inputted document. /// Meant to be used to apply codefixes. /// </summary> /// <param name="document">The Document to apply the fix on</param> /// <param name="codeAction">A CodeAction that will be applied to the Document.</param> /// <returns>A Document with the changes from the CodeAction</returns> private static Document ApplyFix(Document document, CodeAction codeAction) { System.Collections.Immutable.ImmutableArray<CodeActionOperation> operations = codeAction.GetOperationsAsync(CancellationToken.None).Result; Solution solution = operations.OfType<ApplyChangesOperation>().Single().ChangedSolution; return solution.GetDocument(document.Id); }