protected abstract AddImportFixData GetFixData(
Document document,
ImmutableArray <TextChange> textChanges,
string description,
ImmutableArray <string> tags,
CodeActionPriority priority
);
public static AddImportFixData CreateForProjectSymbol(
ImmutableArray <TextChange> textChanges,
string title,
ImmutableArray <string> tags,
CodeActionPriority priority,
ProjectId projectReferenceToAdd
) =>
protected override AddImportFixData GetFixData(
Document document, ImmutableArray <TextChange> textChanges, string description,
ImmutableArray <string> tags, CodeActionPriority priority)
{
return(AddImportFixData.CreateForProjectSymbol(
textChanges, description, tags, priority, _project.Id));
}
public AddImportFixData(
AddImportFixKind kind,
ImmutableArray <TextChange> textChanges,
string title = null,
ImmutableArray <string> tags = default,
CodeActionPriority priority = default,
ProjectId projectReferenceToAdd = null,
ProjectId portableExecutableReferenceProjectId = null,
string portableExecutableReferenceFilePathToAdd = null,
string assemblyReferenceAssemblyName = null,
string assemblyReferenceFullyQualifiedTypeName = null,
string packageSource = null,
string packageName = null,
string packageVersionOpt = null
)
{
Kind = kind;
TextChanges = textChanges;
Title = title;
Tags = tags;
Priority = priority;
ProjectReferenceToAdd = projectReferenceToAdd;
PortableExecutableReferenceProjectId = portableExecutableReferenceProjectId;
PortableExecutableReferenceFilePathToAdd = portableExecutableReferenceFilePathToAdd;
AssemblyReferenceAssemblyName = assemblyReferenceAssemblyName;
AssemblyReferenceFullyQualifiedTypeName = assemblyReferenceFullyQualifiedTypeName;
PackageSource = packageSource;
PackageName = packageName;
PackageVersionOpt = packageVersionOpt;
}
protected SolutionChangeAction(
string title,
Func <CancellationToken, Task <Solution> > createChangedSolution,
string?equivalenceKey,
CodeActionPriority priority = CodeActionPriority.Default)
: this(title, createChangedSolution, equivalenceKey, priority, createdFromFactoryMethod : false)
{
}
public InstallPackageAndAddImportCodeAction(
string title, CodeActionPriority priority,
AsyncLazy <InstallPackageAndAddImportData> installData)
{
_title = title;
_priority = priority;
_installData = installData;
}
public MyCodeAction(
string title,
CodeActionPriority priority,
Func <CancellationToken, Task <Document> > createChangedDocument
) : base(title, createChangedDocument)
{
Priority = priority;
}
public UseAutoPropertyCodeAction(
string title,
Func <CancellationToken, Task <Solution> > createChangedSolution,
CodeActionPriority priority
) : base(title, createChangedSolution, title)
{
Priority = priority;
}
protected override AddImportFixData GetFixData(
Document document, ImmutableArray <TextChange> textChanges, string description,
ImmutableArray <string> tags, CodeActionPriority priority)
{
return(AddImportFixData.CreateForMetadataSymbol(
textChanges, description, tags, priority,
_referenceProjectId, _reference.FilePath));
}
protected CodeActionWithNestedActions(
string title,
ImmutableArray <CodeAction> nestedActions,
bool isInlinable,
CodeActionPriority priority = CodeActionPriority.Medium)
: this(title, nestedActions, isInlinable, priority, createdFromFactoryMethod : false)
{
}
private NoChangeAction(
string title,
string?equivalenceKey,
CodeActionPriority priority,
bool createdFromFactoryMethod)
: base(title, equivalenceKey, priority, createdFromFactoryMethod)
{
}
public UnifiedCodeRefactoringSuggestedAction(
Workspace workspace,
CodeAction codeAction,
CodeActionPriority codeActionPriority,
CodeRefactoringProvider codeRefactoringProvider)
: base(workspace, codeAction, codeActionPriority)
{
CodeRefactoringProvider = codeRefactoringProvider;
}
public UnifiedFixAllCodeRefactoringSuggestedAction(
Workspace workspace,
CodeAction codeAction,
CodeActionPriority codeActionPriority,
IFixAllState fixAllState)
: base(workspace, codeAction, codeActionPriority)
{
FixAllState = fixAllState;
}
private DocumentChangeAction(
string title,
Func <CancellationToken, Task <Document> > createChangedDocument,
string?equivalenceKey,
CodeActionPriority priority,
bool createdFromFactoryMethod)
: base(title, equivalenceKey, priority, createdFromFactoryMethod)
{
_createChangedDocument = createChangedDocument;
}
public DocumentChangeAction(
string title,
Func <CancellationToken, Task <Document> > createChangedDocument,
string?equivalenceKey,
CodeActionPriority priority)
: base(title, equivalenceKey)
{
_createChangedDocument = createChangedDocument;
Priority = priority;
}
private SolutionChangeAction(
string title,
Func <CancellationToken, Task <Solution> > createChangedSolution,
string?equivalenceKey,
CodeActionPriority priority,
bool createdFromFactoryMethod)
: base(title, equivalenceKey, priority, createdFromFactoryMethod)
{
_createChangedSolution = createChangedSolution;
}
public UnifiedSuggestedAction(
Workspace workspace,
CodeAction codeAction,
CodeActionPriority codeActionPriority
)
{
Workspace = workspace;
OriginalCodeAction = codeAction;
CodeActionPriority = codeActionPriority;
}
protected AddImportCodeAction(Document originalDocument, AddImportFixData fixData)
{
OriginalDocument = originalDocument;
FixData = fixData;
Title = fixData.Title;
Tags = fixData.Tags.ToImmutableArrayOrEmpty();
Priority = fixData.Priority;
_textChanges = fixData.TextChanges.ToImmutableArrayOrEmpty();
}
public CodeActionWithNestedActions(
string title, ImmutableArray <CodeAction> nestedActions,
bool isInlinable, CodeActionPriority priority = CodeActionPriority.Medium)
: base(title, ComputeEquivalenceKey(nestedActions))
{
Debug.Assert(nestedActions.Length > 0);
NestedCodeActions = nestedActions;
IsInlinable = isInlinable;
Priority = priority;
}
protected SimpleCodeAction(
string title,
string?equivalenceKey,
CodeActionPriority priority,
bool createdFromFactoryMethod)
{
Title = title;
EquivalenceKey = equivalenceKey;
Priority = priority;
CreatedFromFactoryMethod = createdFromFactoryMethod;
}
public OperationBasedCodeAction(
string title, Glyph?glyph, CodeActionPriority priority,
Func <CancellationToken, Task <ImmutableArray <CodeActionOperation> > > getOperations,
Func <Workspace, bool> isApplicable)
{
_title = title;
_glyph = glyph;
_priority = priority;
_getOperations = getOperations;
_isApplicable = isApplicable;
}
public SymbolReferenceCodeAction(
string title, Glyph?glyph, CodeActionPriority priority,
AsyncLazy <CodeActionOperation> getOperation,
Func <Workspace, bool> isApplicable)
{
_title = title;
_glyph = glyph;
_priority = priority;
_getOperation = getOperation;
_isApplicable = isApplicable;
}
public UseAutoPropertyCodeAction(string title, Func <CancellationToken, Task <Solution> > createChangedSolution
#if !CODE_STYLE // 'CodeActionPriority' is not a public API, hence not supported in CodeStyle layer.
, CodeActionPriority priority
#endif
)
: base(title, createChangedSolution, title)
{
#if !CODE_STYLE // 'CodeActionPriority' is not a public API, hence not supported in CodeStyle layer.
Priority = priority;
#endif
}
public UnifiedSuggestedActionWithNestedActions(
Workspace workspace,
CodeAction codeAction,
CodeActionPriority codeActionPriority,
object?provider,
ImmutableArray <UnifiedSuggestedActionSet> nestedActionSets
) : base(workspace, codeAction, codeActionPriority)
{
Provider = provider;
NestedActionSets = nestedActionSets;
}
public UnifiedCodeRefactoringSuggestedAction(
Workspace workspace,
CodeAction codeAction,
CodeActionPriority codeActionPriority,
CodeRefactoringProvider codeRefactoringProvider,
UnifiedSuggestedActionSet?fixAllFlavors)
: base(workspace, codeAction, codeActionPriority)
{
CodeRefactoringProvider = codeRefactoringProvider;
FixAllFlavors = fixAllFlavors;
}
public UnifiedFixAllSuggestedAction(
Workspace workspace,
CodeAction codeAction,
CodeActionPriority codeActionPriority,
FixAllState?fixAllState,
Diagnostic diagnostic)
: base(workspace, codeAction, codeActionPriority)
{
Diagnostic = diagnostic;
FixAllState = fixAllState;
}
protected AddImportCodeAction(
Document originalDocument,
AddImportFixData fixData)
{
OriginalDocument = originalDocument;
FixData = fixData;
Title = fixData.Title;
Tags = fixData.Tags;
Priority = fixData.Priority;
_textChanges = fixData.TextChanges;
}
public SymbolReferenceCodeAction(
string title, ImmutableArray <string> tags,
CodeActionPriority priority,
AsyncLazy <CodeActionOperation> getOperation,
Func <Workspace, bool> isApplicable)
{
Title = title;
Tags = tags;
Priority = priority;
_getOperation = getOperation;
_isApplicable = isApplicable;
}
private CodeActionWithNestedActions(
string title,
ImmutableArray <CodeAction> nestedActions,
bool isInlinable,
CodeActionPriority priority,
bool createdFromFactoryMethod)
: base(title, ComputeEquivalenceKey(nestedActions), priority, createdFromFactoryMethod)
{
Debug.Assert(nestedActions.Length > 0);
NestedCodeActions = nestedActions;
IsInlinable = isInlinable;
}
public UnifiedCodeFixSuggestedAction(
Workspace workspace,
CodeAction codeAction,
CodeActionPriority codeActionPriority,
CodeFix codeFix,
object provider,
UnifiedSuggestedActionSet?fixAllFlavors)
: base(workspace, codeAction, codeActionPriority)
{
CodeFix = codeFix;
Provider = provider;
FixAllFlavors = fixAllFlavors;
}
internal static async Task<IEnumerable<CodeActionOperation>> VerifyInputsAndGetOperationsAsync(
int index, IList<CodeAction> actions, CodeActionPriority? priority = null)
{
Assert.NotNull(actions);
if (actions.Count == 1)
{
var suppressionAction = actions.Single() as SuppressionCodeAction;
if (suppressionAction != null)
{
actions = suppressionAction.GetCodeActions().ToList();
}
}
Assert.InRange(index, 0, actions.Count - 1);
var action = actions[index];
if (priority != null)
{
Assert.Equal(priority.Value, action.Priority);
}
return await action.GetOperationsAsync(CancellationToken.None);
}
internal async Task<Tuple<Solution, Solution>> TestActionsAsync(
TestWorkspace workspace, string expected,
int index, IList<CodeAction> actions,
IList<TextSpan> conflictSpans, IList<TextSpan> renameSpans, IList<TextSpan> warningSpans,
bool compareTokens,
ParseOptions parseOptions = null,
CodeActionPriority? priority = null)
{
var operations = await VerifyInputsAndGetOperationsAsync(index, actions, priority);
return await TestOperationsAsync(workspace, expected, operations.ToList(), conflictSpans, renameSpans, warningSpans, compareTokens, expectedChangedDocumentId: null, parseOptions: parseOptions);
}
internal async Task TestAsync(
string initialMarkup, string expectedMarkup,
ParseOptions parseOptions, CompilationOptions compilationOptions,
int index = 0, bool compareTokens = true,
IDictionary<OptionKey, object> options = null,
string fixAllActionEquivalenceKey = null,
object fixProviderData = null,
CodeActionPriority? priority = null)
{
string expected;
IDictionary<string, IList<TextSpan>> spanMap;
MarkupTestFile.GetSpans(expectedMarkup.NormalizeLineEndings(), out expected, out spanMap);
var conflictSpans = spanMap.GetOrAdd("Conflict", _ => new List<TextSpan>());
var renameSpans = spanMap.GetOrAdd("Rename", _ => new List<TextSpan>());
var warningSpans = spanMap.GetOrAdd("Warning", _ => new List<TextSpan>());
using (var workspace = IsWorkspaceElement(initialMarkup)
? await TestWorkspace.CreateAsync(initialMarkup)
: await CreateWorkspaceFromFileAsync(initialMarkup, parseOptions, compilationOptions))
{
workspace.ApplyOptions(options);
var actions = await GetCodeActionsAsync(workspace, fixAllActionEquivalenceKey, fixProviderData);
await TestActionsAsync(
workspace, expected, index,
actions,
conflictSpans, renameSpans, warningSpans,
compareTokens: compareTokens,
parseOptions: parseOptions,
priority: priority);
}
}
internal async Task TestAsync(
string initialMarkup, string expectedMarkup,
ParseOptions parseOptions,
int index = 0, bool compareTokens = true,
IDictionary<OptionKey, object> options = null,
string fixAllActionEquivalenceKey = null,
object fixProviderData = null,
bool withScriptOption = false,
CodeActionPriority? priority = null)
{
await TestAsync(initialMarkup, expectedMarkup, parseOptions, null, index, compareTokens, options, fixAllActionEquivalenceKey, fixProviderData, priority);
if (withScriptOption)
{
await TestAsync(initialMarkup, expectedMarkup, parseOptions.WithKind(SourceCodeKind.Script), null, index, compareTokens, options, fixAllActionEquivalenceKey, fixProviderData, priority);
}
}
internal async Task TestAsync(
string initialMarkup, string expectedMarkup,
int index = 0, bool compareTokens = true,
IDictionary<OptionKey, object> options = null,
string fixAllActionEquivalenceKey = null,
object fixProviderData = null,
CodeActionPriority? priority = null)
{
await TestAsync(initialMarkup, expectedMarkup, null, index, compareTokens, options, fixAllActionEquivalenceKey, fixProviderData, priority: priority);
await TestAsync(initialMarkup, expectedMarkup, GetScriptOptions(), index, compareTokens, options, fixAllActionEquivalenceKey, fixProviderData, priority: priority);
}
private static SuggestedActionSetPriority GetSuggestedActionSetPriority(CodeActionPriority key)
{
switch (key)
{
case CodeActionPriority.None: return SuggestedActionSetPriority.None;
case CodeActionPriority.Low: return SuggestedActionSetPriority.Low;
case CodeActionPriority.Medium: return SuggestedActionSetPriority.Medium;
case CodeActionPriority.High: return SuggestedActionSetPriority.High;
default:
throw new InvalidOperationException();
}
}
