CodeAction

AbstractAddAnonymousTypeMemberNameCodeFixProvider.cs (1)

AbstractAddDocCommentNodesCodeFixProvider.cs (1)

AbstractAddExplicitCastCodeFixProvider.cs (3)

82using var actions = TemporaryArray<CodeAction>.Empty; 91actions.Add(CodeAction.Create( 99CodeAction.Create(CodeFixesResources.Add_explicit_cast, actions.ToImmutableAndClear(), isInlinable: false),

AbstractAddParameterCodeFixProvider.cs (12)

245ImmutableArray<CodeAction> NestByOverload() 247using var _ = ArrayBuilder<CodeAction>.GetInstance(codeFixData.Length, out var builder); 252var codeAction = CodeAction.Create( 263codeAction = CodeAction.Create( 267CodeAction.Create( 281ImmutableArray<CodeAction> NestByCascading() 283using var _ = ArrayBuilder<CodeAction>.GetInstance(capacity: 2, out var builder); 288return CodeAction.Create(title, data.CreateChangedSolutionNonCascading, equivalenceKey: title); 296return CodeAction.Create(title, data.CreateChangedSolutionCascading!, equivalenceKey: title); 304builder.Add(CodeAction.Create(nestedNonCascadingTitle, nonCascadingActions, isInlinable: false)); 311builder.Add(CodeAction.Create(nestedCascadingTitle, cascadingActions, isInlinable: false));

AbstractAliasAmbiguousTypeCodeFixProvider.cs (3)

53using var _ = ArrayBuilder<CodeAction>.GetInstance(out var actions); 59actions.Add(CodeAction.Create( 71CodeAction.Create(

AbstractChangeNamespaceToMatchFolderCodeFixProvider.cs (1)

31CodeAction.Create(

AbstractChangeNamespaceToMatchFolderCodeFixProvider.CustomFixAllProvider.cs (2)

30public override async Task<CodeAction?> GetFixAsync(FixAllContext fixAllContext) 44return CodeAction.Create(

AbstractConflictMarkerCodeFixProvider.cs (3)

284CodeAction.Create(takeTopText, 289CodeAction.Create(takeBottomText, 294CodeAction.Create(CodeFixesResources.Take_both,

AbstractConvertToAsyncCodeFixProvider.cs (3)

40var codeAction = await GetCodeActionAsync( 61private async Task<CodeAction> GetCodeActionAsync( 74return CodeAction.Create(

AbstractFileHeaderCodeFixProvider.cs (1)

36CodeAction.Create(

AbstractIteratorCodeFixProvider.cs (2)

24protected abstract Task<CodeAction> GetCodeFixAsync(SyntaxNode root, SyntaxNode node, Document document, Diagnostic diagnostics, CancellationToken cancellationToken); 36var codeAction = await GetCodeFixAsync(root, node, context.Document, diagnostic, context.CancellationToken).ConfigureAwait(false);

AbstractMakeMethodAsynchronousCodeFixProvider.cs (2)

68CodeAction.Create( 79CodeAction.Create(

AbstractMakeMethodSynchronousCodeFixProvider.cs (1)

39CodeAction.Create(

AbstractMultipleBlankLinesCodeFixProvider.cs (1)

37context.RegisterCodeFix(CodeAction.Create(

AbstractPopulateSwitchCodeFixProvider.cs (3)

68CodeAction.Create( 80CodeAction.Create( 92CodeAction.Create(

AbstractRemoveAsyncModifierCodeFixProvider.cs (1)

55CodeAction.Create(

AbstractRemoveDocCommentNodeCodeFixProvider.cs (1)

41CodeAction.Create(

AbstractRemoveUnnecessaryImportsCodeFixProvider.cs (1)

31CodeAction.Create(

AbstractUnsealClassCodeFixProvider.cs (1)

48CodeAction.Create(

AbstractUpgradeProjectCodeFixProvider.cs (4)

15using static Microsoft.CodeAnalysis.CodeActions.CodeAction; 41protected ImmutableArray<CodeAction> GetUpgradeProjectCodeActions(CodeFixContext context) 47var result = new List<CodeAction>(); 54return ImmutableArray<CodeAction>.Empty;

AbstractUseIsNullForReferenceEqualsCodeFixProvider.cs (1)

43CodeAction.Create(title, GetDocumentUpdater(context), title),

AddConstructorParametersFromMembers\AddConstructorParametersFromMembersCodeRefactoringProvider.cs (6)

82private static ImmutableArray<CodeAction> GetGroupedActions(AddConstructorParameterResult result) 84using var _ = ArrayBuilder<CodeAction>.GetInstance(out var actions); 89actions.Add(CodeAction.Create( 91result.RequiredParameterActions.Cast<AddConstructorParametersCodeAction, CodeAction>(), 95actions.Add(CodeAction.Create( 97result.OptionalParameterActions.Cast<AddConstructorParametersCodeAction, CodeAction>(),

AddDebuggerDisplay\AbstractAddDebuggerDisplayCodeRefactoringProvider.cs (1)

59context.RegisterRefactoring(CodeAction.CreateWithPriority(

AddFileBanner\AbstractAddFileBannerCodeRefactoringProvider.cs (1)

90CodeAction.Create(

AddImport\AbstractAddImportFeatureService.cs (3)

574public ImmutableArray<CodeAction> GetCodeActionsForFixes( 578using var _ = ArrayBuilder<CodeAction>.GetInstance(out var result); 590private static CodeAction? TryCreateCodeAction(Document document, AddImportFixData fixData, IPackageInstallerService? installerService)

AddImport\CodeActions\ParentInstallPackageCodeAction.cs (4)

24private class ParentInstallPackageCodeAction : CodeAction.CodeActionWithNestedActions 50private static ImmutableArray<CodeAction> CreateNestedActions( 59using var _ = ArrayBuilder<CodeAction>.GetInstance(out var codeActions); 79private static CodeAction CreateCodeAction(

AddImport\IAddImportFeatureService.cs (1)

48ImmutableArray<CodeAction> GetCodeActionsForFixes(

AddImport\References\Reference.cs (1)

118var cleanedDocument = await CodeAction.CleanupDocumentAsync(

AddImport\References\SymbolReference.cs (1)

72var cleanedDocument = await CodeAction.CleanupDocumentAsync(

AddMissingReference\AbstractAddMissingReferenceCodeFixProvider.cs (3)

55private static async Task<ImmutableArray<CodeAction>> GetAddReferencesCodeActionsAsync(CodeFixContext context, ISet<AssemblyIdentity> uniqueIdentities) 57var result = ArrayBuilder<CodeAction>.GetInstance(); 60var codeAction = await AddMissingReferenceCodeAction.CreateAsync(

AddMissingReference\AddMissingReferenceCodeAction.cs (1)

39public static async Task<CodeAction> CreateAsync(Project project, AssemblyIdentity missingAssemblyIdentity, CancellationToken cancellationToken)

AddPackage\AbstractAddPackageCodeFixProvider.cs (2)

41protected async Task<ImmutableArray<CodeAction>> GetAddPackagesCodeActionsAsync( 52var codeActions = ArrayBuilder<CodeAction>.GetInstance();

AddPackage\InstallPackageParentCodeAction.cs (4)

21internal class InstallPackageParentCodeAction : CodeAction.CodeActionWithNestedActions 47private static ImmutableArray<CodeAction> CreateNestedActions( 56var codeActions = ArrayBuilder<CodeAction>.GetInstance(); 73private static CodeAction CreateCodeAction(

AddRequiredParenthesesCodeFixProvider.cs (1)

39CodeAction.Create(

CodeFixes\AbstractConfigurationActionWithNestedActions.cs (2)

15internal abstract class AbstractConfigurationActionWithNestedActions : CodeAction.CodeActionWithNestedActions 17protected AbstractConfigurationActionWithNestedActions(ImmutableArray<CodeAction> nestedActions, string title)

CodeFixes\Configuration\ConfigureCodeStyle\ConfigureCodeStyleOptionCodeFixProvider.cs (4)

22using static Microsoft.CodeAnalysis.CodeActions.CodeAction; 78using var _ = ArrayBuilder<CodeAction>.GetInstance(out var nestedActions); 92var resultCodeAction = nestedActions.Count > 1 108using var _ = ArrayBuilder<CodeAction>.GetInstance(out var nestedActions);

CodeFixes\Configuration\ConfigureCodeStyle\ConfigureCodeStyleOptionCodeFixProvider.TopLevelConfigureCodeStyleOptionCodeAction.cs (2)

14public TopLevelConfigureCodeStyleOptionCodeAction(Diagnostic diagnostic, ImmutableArray<CodeAction> nestedActions) 19public TopLevelConfigureCodeStyleOptionCodeAction(string optionName, ImmutableArray<CodeAction> nestedActions)

CodeFixes\Configuration\ConfigureSeverity\ConfigureSeverityLevelCodeFixProvider.cs (3)

16using static Microsoft.CodeAnalysis.CodeActions.CodeAction; 59var nestedActions = ArrayBuilder<CodeAction>.GetInstance(); 100var nestedActions = ArrayBuilder<CodeAction>.GetInstance();

CodeFixes\Configuration\ConfigureSeverity\ConfigureSeverityLevelCodeFixProvider.TopLevelBulkConfigureSeverityCodeAction.cs (1)

14public TopLevelBulkConfigureSeverityCodeAction(ImmutableArray<CodeAction> nestedActions, string? category)

CodeFixes\Configuration\ConfigureSeverity\ConfigureSeverityLevelCodeFixProvider.TopLevelConfigureSeverityCodeAction.cs (1)

16public TopLevelConfigureSeverityCodeAction(Diagnostic diagnostic, ImmutableArray<CodeAction> nestedActions)

CodeFixes\GenerateMember\AbstractGenerateMemberCodeFixProvider.cs (1)

27protected abstract Task<ImmutableArray<CodeAction>> GetCodeActionsAsync(Document document, SyntaxNode node, CleanCodeGenerationOptionsProvider fallbackOptions, CancellationToken cancellationToken);

CodeFixes\Suppression\AbstractSuppressionBatchFixAllProvider.cs (29)

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.FixAllProvider.cs (1)

29public override async Task<CodeAction> GetFixAsync(FixAllContext fixAllContext)

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.GlobalSuppressMessageFixAllCodeAction.cs (2)

45internal static CodeAction Create(string title, AbstractSuppressionCodeFixProvider fixer, Document triggerDocument, ImmutableDictionary<Document, ImmutableArray<Diagnostic>> diagnosticsByDocument, CodeActionOptionsProvider fallbackOptions) 52internal static CodeAction Create(string title, AbstractSuppressionCodeFixProvider fixer, Project triggerProject, ImmutableDictionary<Project, ImmutableArray<Diagnostic>> diagnosticsByProject, CodeActionOptionsProvider fallbackOptions)

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.PragmaBatchFixHelpers.cs (3)

26public static CodeAction CreateBatchPragmaFix( 34return CodeAction.Create( 35((CodeAction)pragmaActions[0]).Title,

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.PragmaWarningBatchFixAllProvider.cs (2)

32ConcurrentBag<(Diagnostic diagnostic, CodeAction action)> fixes, 59var pragmaBatchFix = PragmaBatchFixHelpers.CreateBatchPragmaFix(

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.RemoveSuppressionCodeAction.BatchFixer.cs (8)

38ConcurrentBag<(Diagnostic diagnostic, CodeAction action)> fixes, 76var pragmaBatchFix = PragmaBatchFixHelpers.CreateBatchPragmaFix( 88ConcurrentBag<(Diagnostic diagnostic, CodeAction action)> bag, 107public override async Task<CodeAction> TryGetMergedFixAsync( 108ImmutableArray<(Diagnostic diagnostic, CodeAction action)> batchOfFixes, 120var newBatchOfFixes = new List<(Diagnostic diagnostic, CodeAction action)>(); 148var batchAttributeRemoveFix = CodeAction.Create(

CodeFixes\Suppression\TopLevelSuppressionCodeAction.cs (1)

15: base(ImmutableArray<CodeAction>.CastUp(nestedActions), string.Format(FeaturesResources.Suppress_0, diagnostic.Id))

CodeRefactorings\AddAwait\AbstractAddAwaitCodeRefactoringProvider.cs (2)

53CodeAction.Create( 61CodeAction.Create(

CodeRefactorings\AddMissingImports\AbstractAddMissingImportsFeatureService.cs (1)

197CodeAction codeAction,

CodeRefactorings\AddMissingImports\AbstractAddMissingImportsRefactoringProvider.cs (2)

53var addImportsCodeAction = CodeAction.Create(

CodeRefactorings\CodeRefactoring.cs (2)

27public ImmutableArray<(CodeAction action, TextSpan? applicableToSpan)> CodeActions { get; } 35ImmutableArray<(CodeAction, TextSpan?)> actions,

CodeRefactorings\CodeRefactoringContextExtensions.cs (1)

23where TCodeAction : CodeAction

CodeRefactorings\CodeRefactoringService.cs (1)

174using var _ = ArrayBuilder<(CodeAction action, TextSpan? applicableToSpan)>.GetInstance(out var actions);

CodeRefactorings\ExtractMethod\AbstractExtractMethodCodeRefactoringProvider.cs (9)

67private static async Task<ImmutableArray<CodeAction>> GetCodeActionsAsync( 74using var _ = ArrayBuilder<CodeAction>.GetInstance(out var actions); 75var methodAction = await ExtractMethodAsync(document, textSpan, extractOptions, cleanupOptions, cancellationToken).ConfigureAwait(false); 78var localFunctionAction = await ExtractLocalFunctionAsync(document, textSpan, extractOptions, cleanupOptions, cancellationToken).ConfigureAwait(false); 84private static async Task<CodeAction> ExtractMethodAsync(Document document, TextSpan textSpan, ExtractMethodGenerationOptions extractOptions, CodeCleanupOptions cleanupOptions, CancellationToken cancellationToken) 98return CodeAction.Create( 108private static async Task<CodeAction> ExtractLocalFunctionAsync(Document document, TextSpan textSpan, ExtractMethodGenerationOptions extractOptions, CodeCleanupOptions cleanupOptions, CancellationToken cancellationToken) 127var codeAction = CodeAction.Create(

CodeRefactorings\MoveType\AbstractMoveTypeService.cs (7)

34public abstract Task<ImmutableArray<CodeAction>> GetRefactoringAsync(Document document, TextSpan textSpan, CodeCleanupOptionsProvider fallbackOptions, CancellationToken cancellationToken); 45public override async Task<ImmutableArray<CodeAction>> GetRefactoringAsync( 52return ImmutableArray<CodeAction>.Empty; 95private ImmutableArray<CodeAction> CreateActions(State state, CancellationToken cancellationToken) 107return ImmutableArray<CodeAction>.Empty; 110using var _ = ArrayBuilder<CodeAction>.GetInstance(out var actions); 169private CodeAction GetCodeAction(State state, string fileName, MoveTypeOperationKind operationKind)

CodeRefactorings\MoveType\IMoveTypeService.cs (1)

20Task<ImmutableArray<CodeAction>> GetRefactoringAsync(Document document, TextSpan textSpan, CodeCleanupOptionsProvider fallbackOptions, CancellationToken cancellationToken);

CodeRefactorings\SyncNamespace\AbstractSyncNamespaceCodeRefactoringProvider.cs (3)

13using static Microsoft.CodeAnalysis.CodeActions.CodeAction; 77var solutionChangeAction = CodeAction.Create(

Common\DocumentNavigationOperation.cs (2)

14/// When <see cref="CodeAction.GetOperationsAsync(CancellationToken)"/> is called an implementation 15/// of <see cref="CodeAction"/> can return an instance of this operation along with the other

ConsecutiveStatementPlacementCodeFixProvider.cs (1)

37context.RegisterCodeFix(CodeAction.Create(

ConvertAnonymousType\AbstractConvertAnonymousTypeToClassCodeRefactoringProvider.cs (2)

66CodeAction.Create( 74CodeAction.Create(

ConvertAnonymousType\AbstractConvertAnonymousTypeToTupleCodeRefactoringProvider.cs (4)

55CodeAction.Create( 58CodeAction.Create(FeaturesResources.just_this_anonymous_type, c => FixInCurrentMemberAsync(document, anonymousNode, anonymousType, allAnonymousTypes: false, c), nameof(FeaturesResources.just_this_anonymous_type)), 59CodeAction.Create(FeaturesResources.all_anonymous_types_in_container, c => FixInCurrentMemberAsync(document, anonymousNode, anonymousType, allAnonymousTypes: true, c), nameof(FeaturesResources.all_anonymous_types_in_container))), 67CodeAction.Create(FeaturesResources.Convert_to_tuple, c => FixInCurrentMemberAsync(document, anonymousNode, anonymousType, allAnonymousTypes: false, c), nameof(FeaturesResources.Convert_to_tuple)),

ConvertAutoPropertyToFullProperty\AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs (1)

50CodeAction.Create(

ConvertCast\AbstractConvertCastCodeRefactoringProvider.cs (1)

60CodeAction.Create(

ConvertForEachToFor\AbstractConvertForEachToForCodeRefactoringProvider.cs (1)

78CodeAction.Create(

ConvertForToForEach\AbstractConvertForToForEachCodeRefactoringProvider.cs (1)

135CodeAction.Create(

ConvertIfToSwitch\AbstractConvertIfToSwitchCodeRefactoringProvider.cs (2)

52CodeAction.Create( 62CodeAction.Create(

ConvertLinq\AbstractConvertLinqQueryToForEachProvider.cs (1)

48CodeAction.Create(

ConvertLinq\ConvertForEachToLinqQuery\AbstractConvertForEachToLinqQueryProvider.cs (2)

114CodeAction.Create( 137CodeAction.Create(

ConvertNumericLiteral\AbstractConvertNumericLiteralCodeRefactoringProvider.cs (1)

108CodeAction.Create(title, c => ReplaceTokenAsync(document, root, numericToken, value, text, suffix), title),

ConvertToInterpolatedString\AbstractConvertConcatenationToInterpolatedStringRefactoringProvider.cs (1)

109CodeAction.Create(

ConvertToInterpolatedString\AbstractConvertPlaceholderToInterpolatedStringRefactoringProvider.cs (1)

106CodeAction.Create(

ConvertToInterpolatedString\ConvertRegularStringToInterpolatedStringRefactoringProvider.cs (1)

76CodeAction.CreateWithPriority(

ConvertTupleToStruct\AbstractConvertTupleToStructCodeRefactoringProvider.cs (6)

98CodeAction.Create( 110CodeAction.Create( 119ImmutableArray<CodeAction> CreateChildActions( 128using var scopes = TemporaryArray<CodeAction>.Empty; 172private CodeAction CreateAction(Document document, TextSpan span, Scope scope, CleanCodeGenerationOptionsProvider fallbackOptions, bool isRecord) 173=> CodeAction.Create(GetTitle(scope), c => ConvertToStructAsync(document, span, scope, fallbackOptions, isRecord, c), scope.ToString());

EmbeddedLanguages\Json\LanguageServices\AbstractJsonDetectionCodeFixProvider.cs (1)

39CodeAction.Create(

EncapsulateField\AbstractEncapsulateFieldService.cs (9)

50public async Task<ImmutableArray<CodeAction>> GetEncapsulateFieldCodeActionsAsync(Document document, TextSpan span, CleanCodeGenerationOptionsProvider fallbackOptions, CancellationToken cancellationToken) 54return ImmutableArray<CodeAction>.Empty; 63using var _ = ArrayBuilder<CodeAction>.GetInstance(out var builder); 76private ImmutableArray<CodeAction> EncapsulateAllFields(Document document, ImmutableArray<IFieldSymbol> fields, CleanCodeGenerationOptionsProvider fallbackOptions) 79CodeAction.Create( 83CodeAction.Create( 89private ImmutableArray<CodeAction> EncapsulateOneField(Document document, IFieldSymbol field, CleanCodeGenerationOptionsProvider fallbackOptions) 93CodeAction.Create( 97CodeAction.Create(

Formatting\AbstractNewDocumentFormattingService.cs (1)

56document = await CodeAction.CleanupDocumentAsync(document, options, cancellationToken).ConfigureAwait(false);

FormattingCodeFixProvider.cs (1)

51CodeAction.DocumentChangeAction.Create(

FullyQualify\AbstractFullyQualifyCodeFixProvider.cs (2)

37d => CodeAction.Create( 50context.RegisterCodeFix(CodeAction.Create(

FullyQualify\AbstractFullyQualifyService.cs (1)

222var cleanedDocument = await CodeAction.CleanupDocumentAsync(

GenerateComparisonOperators\GenerateComparisonOperatorsCodeRefactoringProvider.cs (4)

97context.RegisterRefactoring(CodeAction.Create( 104using var _2 = ArrayBuilder<CodeAction>.GetInstance(out var nestedActions); 110nestedActions.Add(CodeAction.Create( 116context.RegisterRefactoring(CodeAction.Create(

GenerateConstructorFromMembers\AbstractGenerateConstructorFromMembersCodeRefactoringProvider.cs (10)

80using var _ = ArrayBuilder<CodeAction>.GetInstance(out var actions); 98foreach (var action in actions) 106static async Task<IntentProcessorResult?> GetIntentProcessorResultAsync(Document priorDocument, CodeAction codeAction, CancellationToken cancellationToken) 125CodeAction action, 149Action<CodeAction, TextSpan> registerSingleAction, 150Action<ImmutableArray<CodeAction>> registerMultipleActions, 177private async Task<(CodeAction CodeAction, TextSpan ApplicableToSpan)?> HandleNonSelectionAsync( 248public async Task<ImmutableArray<CodeAction>> GenerateConstructorFromMembersAsync( 265private ImmutableArray<CodeAction> GetCodeActions(Document document, State state, bool addNullChecks, CleanCodeGenerationOptionsProvider fallbackOptions) 267using var _ = ArrayBuilder<CodeAction>.GetInstance(out var result);

GenerateConstructorFromMembers\AbstractGenerateConstructorFromMembersCodeRefactoringProvider.GenerateConstructorWithDialogCodeAction.cs (2)

117var codeAction = state.DelegatedConstructor != null 119: (CodeAction)new FieldDelegatingCodeAction(_service, _document, state, addNullChecks, _fallbackOptions);

GenerateDefaultConstructors\AbstractGenerateDefaultConstructorsService.cs (2)

28public async Task<ImmutableArray<CodeAction>> GenerateDefaultConstructorsAsync( 39using var _ = ArrayBuilder<CodeAction>.GetInstance(out var result);

GenerateDefaultConstructors\IGenerateDefaultConstructorsService.cs (1)

17Task<ImmutableArray<CodeAction>> GenerateDefaultConstructorsAsync(

GenerateEqualsAndGetHashCodeFromMembers\GenerateEqualsAndGetHashCodeFromMembersCodeRefactoringProvider.cs (6)

169public async Task<ImmutableArray<CodeAction>> GenerateEqualsAndGetHashCodeFromMembersAsync( 201private async Task<ImmutableArray<CodeAction>> CreateActionsAsync( 206using var _ = ArrayBuilder<Task<CodeAction>>.GetInstance(out var tasks); 241private Task<CodeAction> CreateCodeActionAsync( 251private async Task<CodeAction> CreateCodeActionWithDialogAsync( 290private static async Task<CodeAction> CreateCodeActionWithoutDialogAsync(

GenerateMember\GenerateConstructor\AbstractGenerateConstructorService.cs (6)

79public async Task<ImmutableArray<CodeAction>> GenerateConstructorAsync(Document document, SyntaxNode node, CodeAndImportGenerationOptionsProvider fallbackOptions, CancellationToken cancellationToken) 90using var _ = ArrayBuilder<CodeAction>.GetInstance(out var result); 95result.Add(CodeAction.Create( 104result.Add(CodeAction.Create( 111result.Add(CodeAction.Create( 120return ImmutableArray<CodeAction>.Empty;

GenerateMember\GenerateConstructor\IGenerateConstructorService.cs (1)

16Task<ImmutableArray<CodeAction>> GenerateConstructorAsync(Document document, SyntaxNode node, CodeAndImportGenerationOptionsProvider fallbackOptions, CancellationToken cancellationToken);

GenerateMember\GenerateEnumMember\AbstractGenerateEnumMemberService.cs (3)

29public async Task<ImmutableArray<CodeAction>> GenerateEnumMemberAsync(Document document, SyntaxNode node, CodeAndImportGenerationOptionsProvider fallbackOptions, CancellationToken cancellationToken) 37return ImmutableArray<CodeAction>.Empty; 40return ImmutableArray.Create<CodeAction>(new GenerateEnumMemberCodeAction(document, state, fallbackOptions));

GenerateMember\GenerateEnumMember\IGenerateEnumMemberService.cs (1)

16Task<ImmutableArray<CodeAction>> GenerateEnumMemberAsync(Document document, SyntaxNode node, CodeAndImportGenerationOptionsProvider fallbackOptions, CancellationToken cancellationToken);

GenerateMember\GenerateParameterizedMember\AbstractGenerateConversionService.cs (2)

29public async Task<ImmutableArray<CodeAction>> GenerateConversionAsync( 41return ImmutableArray<CodeAction>.Empty;

GenerateMember\GenerateParameterizedMember\AbstractGenerateDeconstructMethodService.cs (2)

24public async Task<ImmutableArray<CodeAction>> GenerateDeconstructMethodAsync( 38return state != null ? await GetActionsAsync(document, state, fallbackOptions, cancellationToken).ConfigureAwait(false) : ImmutableArray<CodeAction>.Empty;

GenerateMember\GenerateParameterizedMember\AbstractGenerateMethodService.cs (2)

30public async Task<ImmutableArray<CodeAction>> GenerateMethodAsync( 42return ImmutableArray<CodeAction>.Empty;

GenerateMember\GenerateParameterizedMember\AbstractGenerateParameterizedMemberService.cs (2)

42protected async ValueTask<ImmutableArray<CodeAction>> GetActionsAsync(Document document, State state, CodeAndImportGenerationOptionsProvider fallbackOptions, CancellationToken cancellationToken) 44using var _ = ArrayBuilder<CodeAction>.GetInstance(out var result);

GenerateMember\GenerateParameterizedMember\IGenerateConversionService.cs (1)

16Task<ImmutableArray<CodeAction>> GenerateConversionAsync(Document document, SyntaxNode node, CodeAndImportGenerationOptionsProvider fallbackOptions, CancellationToken cancellationToken);

GenerateMember\GenerateParameterizedMember\IGenerateDeconstructMemberService.cs (1)

16Task<ImmutableArray<CodeAction>> GenerateDeconstructMethodAsync(

GenerateMember\GenerateParameterizedMember\IGenerateParameterizedMemberService.cs (1)

16Task<ImmutableArray<CodeAction>> GenerateMethodAsync(Document document, SyntaxNode node, CodeAndImportGenerationOptionsProvider fallbackOptions, CancellationToken cancellationToken);

GenerateMember\GenerateVariable\AbstractGenerateVariableService.cs (10)

40public async Task<ImmutableArray<CodeAction>> GenerateVariableAsync( 53return ImmutableArray<CodeAction>.Empty; 56using var _ = ArrayBuilder<CodeAction>.GetInstance(out var actions); 84return ImmutableArray.Create(CodeAction.Create( 98ArrayBuilder<CodeAction> result, SemanticDocument document, State state, CodeAndImportGenerationOptionsProvider fallbackOptions, CancellationToken cancellationToken) 141private static void GenerateWritableProperty(ArrayBuilder<CodeAction> result, SemanticDocument document, State state, CodeAndImportGenerationOptionsProvider fallbackOptions) 148private static void AddFieldCodeActions(ArrayBuilder<CodeAction> result, SemanticDocument document, State state, CodeAndImportGenerationOptionsProvider fallbackOptions) 180private static void GenerateWriteableField(ArrayBuilder<CodeAction> result, SemanticDocument document, State state, CodeAndImportGenerationOptionsProvider fallbackOptions) 187ArrayBuilder<CodeAction> result, Document document, State state, CodeGenerationOptionsProvider fallbackOptions, CancellationToken cancellationToken) 203ArrayBuilder<CodeAction> result, Document document, State state, CodeGenerationOptionsProvider fallbackOptions, CancellationToken cancellationToken)

GenerateMember\GenerateVariable\IGenerateVariableService.cs (1)

18Task<ImmutableArray<CodeAction>> GenerateVariableAsync(Document document, SyntaxNode node, CodeAndImportGenerationOptionsProvider fallbackOptions, CancellationToken cancellationToken);

GenerateType\AbstractGenerateTypeService.cs (5)

72public async Task<ImmutableArray<CodeAction>> GenerateTypeAsync( 90return ImmutableArray.Create(CodeAction.Create( 101return ImmutableArray<CodeAction>.Empty; 105private ImmutableArray<CodeAction> GetActions( 112using var _ = ArrayBuilder<CodeAction>.GetInstance(out var result);

GenerateType\IGenerateTypeService.cs (1)

16Task<ImmutableArray<CodeAction>> GenerateTypeAsync(Document document, SyntaxNode node, CleanCodeGenerationOptionsProvider fallbackOptions, CancellationToken cancellationToken);

ImplementAbstractClass\AbstractImplementAbstractClassCodeFixProvider.cs (2)

49CodeAction.Create( 63CodeAction.Create(

ImplementInterface\AbstractImplementInterfaceService.cs (2)

63public ImmutableArray<CodeAction> GetCodeActions(Document document, ImplementTypeGenerationOptions options, SemanticModel model, SyntaxNode node, CancellationToken cancellationToken) 69private IEnumerable<CodeAction> GetActions(Document document, ImplementTypeGenerationOptions options, State state)

ImplementInterface\IImplementInterfaceService.cs (1)

17ImmutableArray<CodeAction> GetCodeActions(Document document, ImplementTypeGenerationOptions options, SemanticModel model, SyntaxNode node, CancellationToken cancellationToken);

InitializeParameter\AbstractAddParameterCheckCodeRefactoringProvider.cs (10)

49protected override async Task<ImmutableArray<CodeAction>> GetRefactoringsForAllParametersAsync( 72return ImmutableArray<CodeAction>.Empty; 75return ImmutableArray.Create<CodeAction>(CodeAction.Create( 81protected override async Task<ImmutableArray<CodeAction>> GetRefactoringsForSingleParameterAsync( 95return ImmutableArray<CodeAction>.Empty; 100using var result = TemporaryArray<CodeAction>.Empty; 101result.Add(CodeAction.Create( 110result.Add(CodeAction.Create( 115result.Add(CodeAction.Create(

InitializeParameter\AbstractInitializeMemberFromParameterCodeRefactoringProviderMemberCreation.cs (23)

51protected override Task<ImmutableArray<CodeAction>> GetRefactoringsForAllParametersAsync( 56return SpecializedTasks.EmptyImmutableArray<CodeAction>(); 59protected override async Task<ImmutableArray<CodeAction>> GetRefactoringsForSingleParameterAsync( 71return ImmutableArray<CodeAction>.Empty; 75return ImmutableArray<CodeAction>.Empty; 81return ImmutableArray<CodeAction>.Empty; 90return ImmutableArray<CodeAction>.Empty; 106private async Task<ImmutableArray<CodeAction>> HandleNoExistingFieldOrPropertyAsync( 118using var _ = ArrayBuilder<CodeAction>.GetInstance(out var allActions); 159private (CodeAction? fieldAction, CodeAction? propertyAction) AddAllParameterInitializationActions( 179var allFieldsAction = CodeAction.Create( 184var allPropertiesAction = CodeAction.Create( 193private (CodeAction fieldAction, CodeAction propertyAction) AddSpecificParameterInitializationActions( 208var fieldAction = CodeAction.Create( 212var propertyAction = CodeAction.Create( 243private ImmutableArray<CodeAction> HandleExistingFieldOrProperty( 261return ImmutableArray.Create(CodeAction.Create(

InitializeParameter\AbstractInitializeParameterCodeRefactoringProvider.cs (2)

39protected abstract Task<ImmutableArray<CodeAction>> GetRefactoringsForAllParametersAsync( 49protected abstract Task<ImmutableArray<CodeAction>> GetRefactoringsForSingleParameterAsync(

InlineMethod\AbstractInlineMethodRefactoringProvider.cs (8)

238var nestedCodeAction = CodeAction.Create( 246private ImmutableArray<CodeAction> GenerateCodeActions(Document document, 256var codeActionRemovesCallee = CodeAction.Create( 271var codeActionKeepsCallee = CodeAction.Create( 286return ImmutableArray.Create<CodeAction>(codeActionRemovesCallee, codeActionKeepsCallee);

IntroduceParameter\AbstractIntroduceParameterCodeRefactoringProvider.cs (8)

97CodeAction.Create( 106CodeAction.Create( 137private async Task<(ImmutableArray<CodeAction> actions, ImmutableArray<CodeAction> actionsAllOccurrences)?> GetActionsAsync(Document document, 146using var actionsBuilder = TemporaryArray<CodeAction>.Empty; 147using var actionsBuilderAllOccurrences = TemporaryArray<CodeAction>.Empty; 175CodeAction CreateNewCodeAction(string actionName, bool allOccurrences, IntroduceParameterCodeActionKind selectedCodeAction) 177return CodeAction.Create(

IntroduceUsingStatement\AbstractIntroduceUsingStatementCodeRefactoringProvider.cs (1)

54CodeAction.Create(

IntroduceVariable\AbstractIntroduceLocalForExpressionCodeRefactoringProvider.cs (2)

56CodeAction.Create( 64CodeAction.Create(

IntroduceVariable\AbstractIntroduceVariableService.cs (8)

25using static Microsoft.CodeAnalysis.CodeActions.CodeAction; 63public async Task<CodeAction> IntroduceVariableAsync( 85return CodeAction.Create(title, actions, isInlinable: true); 93private (string title, ImmutableArray<CodeAction>) CreateActions(State state, CancellationToken cancellationToken) 95using var _ = ArrayBuilder<CodeAction>.GetInstance(out var actions); 101private string AddActionsAndGetTitle(State state, ArrayBuilder<CodeAction> actions, CancellationToken cancellationToken) 184private void CreateConstantFieldActions(State state, ArrayBuilder<CodeAction> actions, CancellationToken cancellationToken) 248private CodeAction CreateAction(State state, bool allOccurrences, bool isConstant, bool isLocal, bool isQueryLocal)

IntroduceVariable\IIntroduceVariableService.cs (1)

18Task<CodeAction> IntroduceVariableAsync(Document document, TextSpan textSpan, CodeCleanupOptions options, CancellationToken cancellationToken);

IntroduceVariable\IntroduceVariableCodeRefactoringProvider.cs (1)

36var action = await service.IntroduceVariableAsync(document, textSpan, cleanupOptions, cancellationToken).ConfigureAwait(false);

InvertConditional\AbstractInvertConditionalCodeRefactoringProvider.cs (1)

32CodeAction.Create(

InvertIf\AbstractInvertIfCodeRefactoringProvider.cs (1)

97CodeAction.Create(

InvertLogical\AbstractInvertLogicalCodeRefactoringProvider.cs (1)

76CodeAction.Create(

MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceCodeRefactoringProvider.cs (1)

46CodeAction.CreateWithPriority(

NameTupleElement\AbstractNameTupleElementCodeRefactoringProvider.cs (1)

34CodeAction.Create(

PreferFrameworkType\PreferFrameworkTypeCodeFixProvider.cs (1)

37CodeAction.Create(

PullMemberUp\AbstractPullMemberUpRefactoringProvider.cs (3)

15using static Microsoft.CodeAnalysis.CodeActions.CodeAction; 92var nestedCodeAction = CodeAction.Create(

PullMemberUp\MembersPuller.cs (2)

25using static Microsoft.CodeAnalysis.CodeActions.CodeAction; 38public static CodeAction TryComputeCodeAction(

RemoveUnusedVariable\AbstractRemoveUnusedVariableCodeFixProvider.cs (1)

52CodeAction.Create(

ReplaceConditionalWithStatements\AbstractReplaceConditionalWithStatementsCodeRefactoringProvider.cs (2)

152context.RegisterRefactoring(CodeAction.Create( 180context.RegisterRefactoring(CodeAction.Create(

ReplaceDocCommentTextWithTag\AbstractReplaceDocCommentTextWithTagCodeRefactoringProvider.cs (1)

145CodeAction.Create(

ReplaceMethodWithProperty\ReplaceMethodWithPropertyCodeRefactoringProvider.cs (2)

76context.RegisterRefactoring(CodeAction.Create( 89context.RegisterRefactoring(CodeAction.Create(

ReplacePropertyWithMethods\ReplacePropertyWithMethodsCodeRefactoringProvider.cs (1)

68CodeAction.Create(

SimplifyThisOrMe\AbstractSimplifyThisOrMeCodeFixProvider.cs (1)

34CodeAction.Create(

SimplifyTypeNames\AbstractSimplifyTypeNamesCodeFixProvider.cs (1)

94CodeAction.Create(

SpellCheck\AbstractSpellCheckCodeFixProvider.cs (4)

184.ToImmutableArrayOrEmpty<CodeAction>(); 191CodeAction.CreateWithPriority( 217private CodeAction CreateCodeAction(SyntaxToken nameToken, string oldName, string newName, Document document) 219return CodeAction.CreateWithPriority(

SplitOrMergeIfStatements\AbstractMergeIfStatementsCodeRefactoringProvider.cs (1)

25protected abstract CodeAction CreateCodeAction(

SplitOrMergeIfStatements\AbstractSplitIfStatementCodeRefactoringProvider.cs (1)

23protected abstract CodeAction CreateCodeAction(Func<CancellationToken, Task<Document>> createChangedDocument, string ifKeywordText);

SplitOrMergeIfStatements\Consecutive\AbstractMergeConsecutiveIfStatementsCodeRefactoringProvider.cs (2)

48protected sealed override CodeAction CreateCodeAction(Func<CancellationToken, Task<Document>> createChangedDocument, MergeDirection direction, string ifKeywordText) 52return CodeAction.Create(title, createChangedDocument, title);

SplitOrMergeIfStatements\Consecutive\AbstractSplitIntoConsecutiveIfStatementsCodeRefactoringProvider.cs (2)

48protected sealed override CodeAction CreateCodeAction(Func<CancellationToken, Task<Document>> createChangedDocument, string ifKeywordText) 49=> CodeAction.Create(

SplitOrMergeIfStatements\Nested\AbstractMergeNestedIfStatementsCodeRefactoringProvider.cs (2)

36protected sealed override CodeAction CreateCodeAction(Func<CancellationToken, Task<Document>> createChangedDocument, MergeDirection direction, string ifKeywordText) 40return CodeAction.Create(title, createChangedDocument, title);

SplitOrMergeIfStatements\Nested\AbstractSplitIntoNestedIfStatementsCodeRefactoringProvider.cs (2)

34protected sealed override CodeAction CreateCodeAction(Func<CancellationToken, Task<Document>> createChangedDocument, string ifKeywordText) 35=> CodeAction.Create(

SyncNamespaces\AbstractSyncNamespacesService.cs (2)

108CodeAction? action = null; 140var fixAllAction = await fixAllProvider.GetFixAsync(fixAllContext).ConfigureAwait(false);

UseNamedArguments\AbstractUseNamedArgumentsCodeRefactoringProvider.cs (3)

114CodeAction.Create( 121CodeAction.Create( 130CodeAction.Create(

Wrapping\AbstractCodeActionComputer.cs (5)

20using static Microsoft.CodeAnalysis.CodeActions.CodeAction; 270public async Task<ImmutableArray<CodeAction>> GetTopLevelCodeActionsAsync() 277var result = ArrayBuilder<CodeAction>.GetInstance(); 296var sorted = WrapItemsAction.SortActionsByMostRecentlyUsed(ImmutableArray<CodeAction>.CastUp(wrappingActions)); 301result.Add(CodeAction.Create(

Wrapping\ICodeActionComputer.cs (1)

18Task<ImmutableArray<CodeAction>> GetTopLevelCodeActionsAsync();

Wrapping\WrapItemsAction.cs (4)

14using static Microsoft.CodeAnalysis.CodeActions.CodeAction; 65public static ImmutableArray<CodeAction> SortActionsByMostRecentlyUsed(ImmutableArray<CodeAction> codeActions) 96private static string GetSortTitle(CodeAction codeAction)