private static async Task <object[]> RunGetDocumentSymbolsAsync(Solution solution, bool hierarchicalSupport)
{
var document = solution.Projects.First().Documents.First();
var request = new LSP.DocumentSymbolParams
{
TextDocument = CreateTextDocumentIdentifier(new Uri(document.FilePath))
};
var clientCapabilities = new LSP.ClientCapabilities()
{
TextDocument = new LSP.TextDocumentClientCapabilities()
{
DocumentSymbol = new LSP.DocumentSymbolSetting()
{
HierarchicalDocumentSymbolSupport = hierarchicalSupport
}
}
};
return(await GetLanguageServer(solution).GetDocumentSymbolsAsync(solution, request, clientCapabilities, CancellationToken.None));
}
private static async Task <object[]> RunGetDocumentSymbolsAsync(TestLspServer testLspServer, bool hierarchicalSupport)
{
var document = testLspServer.GetCurrentSolution().Projects.First().Documents.First();
var request = new LSP.DocumentSymbolParams
{
TextDocument = CreateTextDocumentIdentifier(new Uri(document.FilePath))
};
var clientCapabilities = new LSP.ClientCapabilities()
{
TextDocument = new LSP.TextDocumentClientCapabilities()
{
DocumentSymbol = new LSP.DocumentSymbolSetting()
{
HierarchicalDocumentSymbolSupport = hierarchicalSupport
}
}
};
return(await testLspServer.ExecuteRequestAsync <LSP.DocumentSymbolParams, object[]>(LSP.Methods.TextDocumentDocumentSymbolName,
request, clientCapabilities, null, CancellationToken.None));
}
private static async Task <LSP.CompletionList> RunGetCompletionsAsync(
TestLspServer testLspServer,
LSP.CompletionParams completionParams,
LSP.ClientCapabilities clientCapabilities)
{
var completionList = await testLspServer.ExecuteRequestAsync <LSP.CompletionParams, LSP.CompletionList>(LSP.Methods.TextDocumentCompletionName,
completionParams, clientCapabilities, null, CancellationToken.None);
// Emulate client behavior of promoting "Data" completion list properties onto completion items.
if (clientCapabilities.HasCompletionListDataCapability() &&
completionList is VSCompletionList vsCompletionList &&
vsCompletionList.Data != null)
{
foreach (var completionItem in completionList.Items)
{
Assert.Null(completionItem.Data);
completionItem.Data = vsCompletionList.Data;
}
}
return(completionList);
}
protected async Task <DocumentOutlineTestMocks> CreateMocksAsync(string code)
{
var workspace = TestWorkspace.CreateCSharp(code, composition: s_composition);
var threadingContext = workspace.GetService <IThreadingContext>();
var clientCapabilities = new LSP.ClientCapabilities()
{
TextDocument = new LSP.TextDocumentClientCapabilities()
{
DocumentSymbol = new LSP.DocumentSymbolSetting()
{
HierarchicalDocumentSymbolSupport = true
}
}
};
var testLspServer = await CreateTestLspServerAsync(workspace, new InitializationOptions { ClientCapabilities = clientCapabilities });
var languageServiceBrokerMock = new Mock <ILanguageServiceBroker2>(MockBehavior.Strict);
#pragma warning disable CS0618 // Type or member is obsolete
languageServiceBrokerMock
.Setup(l => l.RequestAsync(It.IsAny <ITextBuffer>(), It.IsAny <Func <JToken, bool> >(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <Func <ITextSnapshot, JToken> >(), It.IsAny <CancellationToken>()))
.Returns <ITextBuffer, Func <JToken, bool>, string, string, Func <ITextSnapshot, JToken>, CancellationToken>(RequestAsync);
#pragma warning restore CS0618 // Type or member is obsolete
var mocks = new DocumentOutlineTestMocks(languageServiceBrokerMock.Object, threadingContext, workspace, testLspServer);
return(mocks);
async Task <ManualInvocationResponse?> RequestAsync(ITextBuffer textBuffer, Func <JToken, bool> capabilitiesFilter, string languageServerName, string method, Func <ITextSnapshot, JToken> parameterFactory, CancellationToken cancellationToken)
{
var request = parameterFactory(textBuffer.CurrentSnapshot).ToObject <RoslynDocumentSymbolParams>();
var response = await testLspServer.ExecuteRequestAsync <RoslynDocumentSymbolParams, DocumentSymbol[]>(method, request !, cancellationToken);
return(new ManualInvocationResponse(string.Empty, JToken.FromObject(response !)));
}
}
public async Task <object> HandleRequestAsync(Solution solution, LSP.TextDocumentPositionParams request,
LSP.ClientCapabilities clientCapabilities, CancellationToken cancellationToken)
{
var locations = ArrayBuilder <LSP.Location> .GetInstance();
var document = solution.GetDocumentFromURI(request.TextDocument.Uri);
if (document == null)
{
return(locations.ToArrayAndFree());
}
var findUsagesService = document.Project.LanguageServices.GetService <IFindUsagesService>();
var position = await document.GetPositionFromLinePositionAsync(ProtocolConversions.PositionToLinePosition(request.Position), cancellationToken).ConfigureAwait(false);
var context = new SimpleFindUsagesContext(cancellationToken);
await FindImplementationsAsync(findUsagesService, document, position, context).ConfigureAwait(false);
foreach (var definition in context.GetDefinitions())
{
var text = definition.GetClassifiedText();
foreach (var sourceSpan in context.GetDefinitions().SelectMany(definition => definition.SourceSpans))
{
if (clientCapabilities?.HasVisualStudioLspCapability() == true)
{
locations.Add(await ProtocolConversions.DocumentSpanToLocationWithTextAsync(sourceSpan, text, cancellationToken).ConfigureAwait(false));
}
else
{
locations.Add(await ProtocolConversions.DocumentSpanToLocationAsync(sourceSpan, cancellationToken).ConfigureAwait(false));
}
}
}
return(locations.ToArrayAndFree());
}
private static async Task <T> GetCompletionItemToResolveAsync <T>(
TestLspServer testLspServer,
string label,
LSP.ClientCapabilities clientCapabilities = null) where T : LSP.CompletionItem
{
var completionParams = CreateCompletionParams(
testLspServer.GetLocations("caret").Single(), LSP.VSInternalCompletionInvokeKind.Explicit, "\0", LSP.CompletionTriggerKind.Invoked);
clientCapabilities ??= new LSP.VSInternalClientCapabilities {
SupportsVisualStudioExtensions = true
};
var completionList = await RunGetCompletionsAsync(testLspServer, completionParams, clientCapabilities);
if (clientCapabilities.HasCompletionListDataCapability())
{
var vsCompletionList = Assert.IsAssignableFrom <VSInternalCompletionList>(completionList);
Assert.NotNull(vsCompletionList.Data);
}
var serverCompletionItem = completionList.Items.FirstOrDefault(item => item.Label == label);
var clientCompletionItem = ConvertToClientCompletionItem((T)serverCompletionItem);
return(clientCompletionItem);
}
private TestLspServer(TestWorkspace testWorkspace, Dictionary <string, IList <LSP.Location> > locations, LSP.ClientCapabilities clientCapabilities, WellKnownLspServerKinds serverKind)
{
TestWorkspace = testWorkspace;
ClientCapabilities = clientCapabilities;
_locations = locations;
var(clientStream, serverStream) = FullDuplexStream.CreatePair();
_languageServer = CreateLanguageServer(serverStream, serverStream, TestWorkspace, serverKind);
_clientRpc = new JsonRpc(new HeaderDelimitedMessageHandler(clientStream, clientStream, CreateJsonMessageFormatter()))
{
ExceptionStrategy = ExceptionProcessing.ISerializable,
};
_clientRpc.StartListening();
var workspaceWaiter = GetWorkspaceWaiter(testWorkspace);
Assert.False(workspaceWaiter.HasPendingWork);
// Clear any LSP solutions that were created when the workspace was initialized.
// This ensures that the workspace manager starts with a clean slate.
GetManagerAccessor().ResetLspSolutions();
}
private static List <Task <TestResponse> > StartTestRun(
TestLspServer testLspServer,
TestRequest[] requests
)
{
var clientCapabilities = new LSP.ClientCapabilities();
var waitables = new List <Task <TestResponse> >();
foreach (var request in requests)
{
waitables.Add(
testLspServer.ExecuteRequestAsync <TestRequest, TestResponse>(
request.MethodName,
request,
clientCapabilities,
null,
CancellationToken.None
)
);
}
return(waitables);
}
/// <summary> /// Answers a signature help request to get signature information at a given cursor position. /// https://microsoft.github.io/language-server-protocol/specification#textDocument_signatureHelp /// </summary> /// <param name="solution">the solution containing the document.</param> /// <param name="request">the request document position.</param> /// <param name="clientCapabilities">the client capabilities for the request.</param> /// <param name="cancellationToken">a cancellation token.</param> /// <returns>the signature help at a given location.</returns> public Task <LSP.SignatureHelp> GetSignatureHelpAsync(Solution solution, LSP.TextDocumentPositionParams request, LSP.ClientCapabilities clientCapabilities, CancellationToken cancellationToken) => ExecuteRequestAsync <LSP.TextDocumentPositionParams, LSP.SignatureHelp>(LSP.Methods.TextDocumentSignatureHelpName, solution, request, clientCapabilities, cancellationToken);
public override async Task <LSP.CompletionItem[]> HandleRequestAsync(LSP.CompletionParams request, LSP.ClientCapabilities clientCapabilities, string?clientName,
CancellationToken cancellationToken)
{
var document = SolutionProvider.GetDocument(request.TextDocument, clientName);
if (document == null)
{
return(Array.Empty <LSP.CompletionItem>());
}
var position = await document.GetPositionFromLinePositionAsync(ProtocolConversions.PositionToLinePosition(request.Position), cancellationToken).ConfigureAwait(false);
// Filter out snippets as they are not supported in the LSP client
// https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1139740
// Filter out unimported types for now as there are two issues with providing them:
// 1. LSP client does not currently provide a way to provide detail text on the completion item to show the namespace.
// https://dev.azure.com/devdiv/DevDiv/_workitems/edit/1076759
// 2. We need to figure out how to provide the text edits along with the completion item or provide them in the resolve request.
// https://devdiv.visualstudio.com/DevDiv/_workitems/edit/985860/
// 3. LSP client should support completion filters / expanders
var documentOptions = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
var completionOptions = documentOptions
.WithChangedOption(CompletionOptions.SnippetsBehavior, SnippetsRule.NeverInclude)
.WithChangedOption(CompletionOptions.ShowItemsFromUnimportedNamespaces, false)
.WithChangedOption(CompletionServiceOptions.IsExpandedCompletion, false);
var completionService = document.Project.LanguageServices.GetRequiredService <CompletionService>();
var list = await completionService.GetCompletionsAsync(document, position, options : completionOptions, cancellationToken : cancellationToken).ConfigureAwait(false);
if (list == null)
{
return(Array.Empty <LSP.CompletionItem>());
}
var lspVSClientCapability = clientCapabilities?.HasVisualStudioLspCapability() == true;
return(list.Items.Select(item => CreateLSPCompletionItem(request, item, lspVSClientCapability)).ToArray());
public Task <object> HandleRequestAsync(Solution solution, LSP.ExecuteCommandParams request, LSP.ClientCapabilities clientCapabilities,
string?clientName, CancellationToken cancellationToken)
{
var commandName = request.Command;
if (string.IsNullOrEmpty(commandName) || !_executeCommandHandlers.TryGetValue(commandName, out var executeCommandHandler))
{
throw new ArgumentException(string.Format("Command name ({0}) is invalid", commandName));
}
return(executeCommandHandler.Value.HandleRequestAsync(solution, request, clientCapabilities, cancellationToken));
}
/// <summary> /// Answers an implementation request by returning the implementation location(s) of a given symbol. /// https://microsoft.github.io/language-server-protocol/specification#textDocument_implementation /// </summary> /// <param name="solution">the solution containing the request document.</param> /// <param name="request">the request document symbol location.</param> /// <param name="clientCapabilities">the client capabilities for the request.</param> /// <param name="cancellationToken">a cancellation token.</param> /// <returns>the location(s) of the implementations of the symbol.</returns> public Task <object> FindImplementationsAsync(Solution solution, LSP.TextDocumentPositionParams request, LSP.ClientCapabilities clientCapabilities, CancellationToken cancellationToken) => ExecuteRequestAsync <LSP.TextDocumentPositionParams, object>(LSP.Methods.TextDocumentImplementationName, solution, request, clientCapabilities, cancellationToken);
/// <summary> /// Answers a format document request to format the entire document. /// https://microsoft.github.io/language-server-protocol/specification#textDocument_formatting /// </summary> /// <param name="solution">the solution containing the document.</param> /// <param name="request">the request document and formatting options.</param> /// <param name="clientCapabilities">the client capabilities for the request.</param> /// <param name="cancellationToken">a cancellation token.</param> /// <returns>the text edits describing the document modifications.</returns> public Task <LSP.TextEdit[]> FormatDocumentAsync(Solution solution, LSP.DocumentFormattingParams request, LSP.ClientCapabilities clientCapabilities, CancellationToken cancellationToken) => ExecuteRequestAsync <LSP.DocumentFormattingParams, LSP.TextEdit[]>(LSP.Methods.TextDocumentFormattingName, solution, request, clientCapabilities, cancellationToken);
internal static async Task <TestLspServer> CreateAsync(TestWorkspace testWorkspace, LSP.ClientCapabilities clientCapabilities, LanguageServerTarget target, Stream clientStream)
{
var locations = await GetAnnotatedLocationsAsync(testWorkspace, testWorkspace.CurrentSolution);
var server = new TestLspServer(testWorkspace, locations, clientCapabilities, target, clientStream);
await server.ExecuteRequestAsync <LSP.InitializeParams, LSP.InitializeResult>(LSP.Methods.InitializeName, new LSP.InitializeParams
{
Capabilities = clientCapabilities,
}, CancellationToken.None);
return(server);
}
/// <summary> /// Answers an execute workspace command request by handling the specified command name. /// https://microsoft.github.io/language-server-protocol/specification#workspace_executeCommand /// </summary> /// <param name="solution">the solution relevant to the workspace.</param> /// <param name="request">the request command name and arguments.</param> /// <param name="clientCapabilities">the client capabilities for the request.</param> /// <param name="cancellationToken">a cancellation token.</param> /// <returns>any or null.</returns> public Task <object> ExecuteWorkspaceCommandAsync(Solution solution, LSP.ExecuteCommandParams request, LSP.ClientCapabilities clientCapabilities, CancellationToken cancellationToken) => ExecuteRequestAsync <LSP.ExecuteCommandParams, object>(LSP.Methods.WorkspaceExecuteCommandName, solution, request, clientCapabilities, cancellationToken);
public async Task <LSP.TextEdit[]> HandleRequestAsync(Solution solution, LSP.DocumentFormattingParams request, LSP.ClientCapabilities clientCapabilities,
CancellationToken cancellationToken)
{
return(await GetTextEdits(solution, request.TextDocument.Uri, cancellationToken).ConfigureAwait(false));
}
public async Task <LSP.Location[]> HandleRequestAsync(Solution solution, LSP.TextDocumentPositionParams request,
LSP.ClientCapabilities clientCapabilities, CancellationToken cancellationToken)
{
return(await GetDefinitionAsync(solution, request, typeOnly : true, cancellationToken : cancellationToken).ConfigureAwait(false));
}
private static async Task <LSP.Command[]> RunCodeActionsAsync(Solution solution, LSP.Location caret, LSP.ClientCapabilities clientCapabilities = null) => await GetLanguageServer(solution).GetCodeActionsAsync(solution, CreateCodeActionParams(caret), clientCapabilities, CancellationToken.None);
public override async Task <LSP.CompletionItem> HandleRequestAsync(LSP.CompletionItem completionItem, LSP.ClientCapabilities clientCapabilities,
string?clientName, CancellationToken cancellationToken)
{
CompletionResolveData data;
if (completionItem.Data is CompletionResolveData)
{
data = (CompletionResolveData)completionItem.Data;
}
else
{
data = ((JToken)completionItem.Data).ToObject <CompletionResolveData>();
}
var document = SolutionProvider.GetDocument(data.TextDocument, clientName);
if (document == null)
{
return(completionItem);
}
var position = await document.GetPositionFromLinePositionAsync(ProtocolConversions.PositionToLinePosition(data.Position), cancellationToken).ConfigureAwait(false);
var completionService = document.Project.LanguageServices.GetRequiredService <CompletionService>();
var list = await completionService.GetCompletionsAsync(document, position, cancellationToken : cancellationToken).ConfigureAwait(false);
if (list == null)
{
return(completionItem);
}
var selectedItem = list.Items.FirstOrDefault(i => i.DisplayText == data.DisplayText);
if (selectedItem == null)
{
return(completionItem);
}
var description = await completionService.GetDescriptionAsync(document, selectedItem, cancellationToken).ConfigureAwait(false);
var lspVSClientCapability = clientCapabilities?.HasVisualStudioLspCapability() == true;
LSP.CompletionItem resolvedCompletionItem;
if (lspVSClientCapability)
{
resolvedCompletionItem = CloneVSCompletionItem(completionItem);
((LSP.VSCompletionItem)resolvedCompletionItem).Description = new ClassifiedTextElement(description.TaggedParts
.Select(tp => new ClassifiedTextRun(tp.Tag.ToClassificationTypeName(), tp.Text)));
}
else
{
resolvedCompletionItem = RoslynCompletionItem.From(completionItem);
((RoslynCompletionItem)resolvedCompletionItem).Description = description.TaggedParts.Select(
tp => new RoslynTaggedText {
Tag = tp.Tag, Text = tp.Text
}).ToArray();
}
resolvedCompletionItem.Detail = description.TaggedParts.GetFullText();
return(resolvedCompletionItem);
}
/// <summary> /// Answers a Hover request by returning the quick info at the requested location. /// https://microsoft.github.io/language-server-protocol/specification#textDocument_hover /// </summary> /// <param name="solution">the solution containing any documents in the request.</param> /// <param name="request">the hover requesst.</param> /// <param name="clientCapabilities">the client capabilities for the request.</param> /// <param name="cancellationToken">a cancellation token.</param> /// <returns>the Hover using MarkupContent.</returns> public Task <LSP.Hover> GetHoverAsync(Solution solution, LSP.TextDocumentPositionParams request, LSP.ClientCapabilities clientCapabilities, CancellationToken cancellationToken) => ExecuteRequestAsync <LSP.TextDocumentPositionParams, LSP.Hover>(LSP.Methods.TextDocumentHoverName, solution, request, clientCapabilities, cancellationToken);
/// <summary> /// Answers a folding range request by returning all folding ranges in a given document. /// https://microsoft.github.io/language-server-protocol/specification#textDocument_foldingRange /// </summary> /// <param name="solution">the solution containing the document.</param> /// <param name="request">the request document.</param> /// <param name="clientCapabilities">the client capabilities for the request.</param> /// <param name="cancellationToken">a cancellation token.</param> /// <returns>a list of folding ranges in the document.</returns> public Task <LSP.FoldingRange[]> GetFoldingRangeAsync(Solution solution, LSP.FoldingRangeParams request, LSP.ClientCapabilities clientCapabilities, CancellationToken cancellationToken) => ExecuteRequestAsync <LSP.FoldingRangeParams, LSP.FoldingRange[]>(LSP.Methods.TextDocumentFoldingRangeName, solution, request, clientCapabilities, cancellationToken);
/// <summary> /// Answers a document symbols request by returning a list of symbols in the document. /// https://microsoft.github.io/language-server-protocol/specification#textDocument_documentSymbol /// </summary> /// <param name="solution">the solution containing the document.</param> /// <param name="request">the document to get symbols from.</param> /// <param name="clientCapabilities">the client capabilities for the request.</param> /// <param name="cancellationToken">a cancellation token.</param> /// <returns>a list of symbols in the document.</returns> public Task <object[]> GetDocumentSymbolsAsync(Solution solution, LSP.DocumentSymbolParams request, LSP.ClientCapabilities clientCapabilities, CancellationToken cancellationToken) => ExecuteRequestAsync <LSP.DocumentSymbolParams, object[]>(LSP.Methods.TextDocumentDocumentSymbolName, solution, request, clientCapabilities, cancellationToken);
public override LSP.ServerCapabilities GetCapabilities(LSP.ClientCapabilities clientCapabilities) => new();
/// <summary> /// Answers a workspace symbols request by providing a list of symbols found in a given workspace. /// https://microsoft.github.io/language-server-protocol/specification#workspace_symbol /// </summary> /// <param name="solution">the current solution.</param> /// <param name="request">the workspace request with the query to invoke.</param> /// <param name="clientCapabilities">the client capabilities for the request.</param> /// <param name="cancellationToken">a cancellation token.</param> /// <returns>a list of symbols in the workspace.</returns> public Task <LSP.SymbolInformation[]> GetWorkspaceSymbolsAsync(Solution solution, LSP.WorkspaceSymbolParams request, LSP.ClientCapabilities clientCapabilities, CancellationToken cancellationToken) => ExecuteRequestAsync <LSP.WorkspaceSymbolParams, LSP.SymbolInformation[]>(LSP.Methods.WorkspaceSymbolName, solution, request, clientCapabilities, cancellationToken);
public Task <LSP.Location[]> HandleRequestAsync(Solution solution, LSP.TextDocumentPositionParams request,
LSP.ClientCapabilities clientCapabilities, string?clientName, CancellationToken cancellationToken)
=> GetDefinitionAsync(solution, request, typeOnly: false, clientName, cancellationToken: cancellationToken);
/// <summary> /// Answers a goto type definition request by returning the location of a given type definition. /// https://microsoft.github.io/language-server-protocol/specification#textDocument_typeDefinition /// </summary> /// <param name="solution">the solution containing the request.</param> /// <param name="request">the document position of the type to go to.</param> /// <param name="clientCapabilities">the client capabilities for the request.</param> /// <param name="cancellationToken">a cancellation token.</param> /// <returns>the location of a type definition.</returns> public Task <LSP.Location[]> GoToTypeDefinitionAsync(Solution solution, LSP.TextDocumentPositionParams request, LSP.ClientCapabilities clientCapabilities, CancellationToken cancellationToken) => ExecuteRequestAsync <LSP.TextDocumentPositionParams, LSP.Location[]>(LSP.Methods.TextDocumentTypeDefinitionName, solution, request, clientCapabilities, cancellationToken);
private static async Task <object> RunResolveCompletionItemAsync(Solution solution, LSP.CompletionItem completionItem, LSP.ClientCapabilities clientCapabilities = null)
=> await GetLanguageServer(solution).ExecuteRequestAsync <LSP.CompletionItem, LSP.CompletionItem>(LSP.Methods.TextDocumentCompletionResolveName,
completionItem, clientCapabilities, null, CancellationToken.None);
/// <summary> /// Answers an initialize request by returning the server capabilities. /// https://microsoft.github.io/language-server-protocol/specification#initialize /// </summary> /// <param name="solution">the solution containing the document.</param> /// <param name="request">the initialize parameters.</param> /// <param name="clientCapabilities">the client capabilities for the request.</param> /// <param name="cancellationToken">a cancellation token.</param> /// <returns>the server capabilities.</returns> public Task <LSP.InitializeResult> InitializeAsync(Solution solution, LSP.InitializeParams request, LSP.ClientCapabilities clientCapabilities, CancellationToken cancellationToken) => ExecuteRequestAsync <LSP.InitializeParams, LSP.InitializeResult>(LSP.Methods.InitializeName, solution, request, clientCapabilities, cancellationToken);
public override async Task <LSP.VSCodeAction[]> HandleRequestAsync(
LSP.CodeActionParams request,
LSP.ClientCapabilities clientCapabilities,
string?clientName,
CancellationToken cancellationToken)
{
var document = SolutionProvider.GetDocument(request.TextDocument, clientName);
if (document == null)
{
return(Array.Empty <VSCodeAction>());
}
var(codeFixCollections, codeRefactorings) = await CodeActionHelpers.GetCodeFixesAndRefactoringsAsync(
document, _codeFixService, _codeRefactoringService,
request.Range, cancellationToken).ConfigureAwait(false);
var codeFixes = codeFixCollections.SelectMany(c => c.Fixes);
using var _ = ArrayBuilder <VSCodeAction> .GetInstance(out var results);
// Go through code fixes and code refactorings separately so that we can properly set the CodeActionKind.
foreach (var codeFix in codeFixes)
{
// Filter out code actions with options since they'll show dialogs and we can't remote the UI and the options.
if (codeFix.Action is CodeActionWithOptions)
{
continue;
}
// Temporarily filter out suppress and configure code actions, as we'll later combine them under a top-level
// code action.
if (codeFix.Action is AbstractConfigurationActionWithNestedActions)
{
continue;
}
results.Add(GenerateVSCodeAction(request, codeFix.Action, CodeActionKind.QuickFix));
}
foreach (var(action, _) in codeRefactorings.SelectMany(codeRefactoring => codeRefactoring.CodeActions))
{
// Filter out code actions with options since they'll show dialogs and we can't remote the UI and the options.
if (action is CodeActionWithOptions)
{
continue;
}
results.Add(GenerateVSCodeAction(request, action, CodeActionKind.Refactor));
}
// Special case (also dealt with specially in local Roslyn):
// If we have configure/suppress code actions, combine them under one top-level code action.
var configureSuppressActions = codeFixes.Where(a => a.Action is AbstractConfigurationActionWithNestedActions);
if (configureSuppressActions.Any())
{
results.Add(GenerateVSCodeAction(request, new CodeActionWithNestedActions(
CodeFixesResources.Suppress_or_Configure_issues,
configureSuppressActions.Select(a => a.Action).ToImmutableArray(), true), CodeActionKind.QuickFix));
}
return(results.ToArray());
/// <summary> /// Answers a request to resolve a completion item. /// https://microsoft.github.io/language-server-protocol/specification#completionItem_resolve /// </summary> /// <param name="solution">the solution containing the document.</param> /// <param name="request">the completion item to resolve.</param> /// <param name="clientCapabilities">the client capabilities for the request.</param> /// <param name="cancellationToken">a cancellation token.</param> /// <returns>a resolved completion item.</returns> public Task <LSP.CompletionItem> ResolveCompletionItemAsync(Solution solution, LSP.CompletionItem request, LSP.ClientCapabilities clientCapabilities, CancellationToken cancellationToken) => ExecuteRequestAsync <LSP.CompletionItem, LSP.CompletionItem>(LSP.Methods.TextDocumentCompletionResolveName, solution, request, clientCapabilities, cancellationToken);