public override async Task <SymbolInformation[]> WorkspaceSymbols(WorkspaceSymbolParams @params, CancellationToken cancellationToken)
{
await WaitForCompleteAnalysisAsync(cancellationToken);
var members = Enumerable.Empty <IMemberResult>();
var opts = GetMemberOptions.ExcludeBuiltins | GetMemberOptions.DeclaredOnly;
foreach (var entry in ProjectFiles)
{
members = members.Concat(
await GetModuleVariablesAsync(entry as ProjectEntry, opts, @params.query, 50, cancellationToken)
);
}
members = members.GroupBy(mr => mr.Name).Select(g => g.First());
return(members.Select(ToSymbolInformation).ToArray());
}
Handle(WorkspaceSymbolParams request, CancellationToken cancellationToken)
{
var omnisharpRequest = new FindSymbolsRequest {
Filter = request.Query,
MaxItemsToReturn = 100,
};
var omnisharpResponse = await _FindSymbolsHandler.Handle(omnisharpRequest);
var symbols = omnisharpResponse.QuickFixes?.Cast <SymbolLocation>().Select(
x => new SymbolInformation {
Name = x.Text,
Kind = Helpers.ToSymbolKind(x.Kind),
Location = new OmniSharp.Extensions.LanguageServer.Protocol.Models.Location {
Uri = Helpers.ToUri(x.FileName),
Range = Helpers.ToRange((x.Column, x.Line), (x.EndColumn, x.EndLine))
}
})
private async Task <ImmutableArray <SymbolInformation> > GetVsSearchResultsAsync(TestWorkspace workspace, string query)
{
var solution = workspace.CurrentSolution;
var client = (InProcRemoteHostClient)await InProcRemoteHostClient.CreateAsync(workspace.Services, runCacheCleanup : false);
var document = solution.Projects.First().Documents.First();
await UpdatePrimaryWorkspace(client, solution.WithDocumentFilePath(document.Id, Path.Combine(TempRoot.Root, document.FilePath)));
var workspaceSymbolParams = new WorkspaceSymbolParams
{
Query = query,
};
var symbolResultsBuilder = ArrayBuilder <SymbolInformation> .GetInstance();
var threadingContext = workspace.ExportProvider.GetExportedValue <IThreadingContext>();
var awaitableProgress = new ProgressWithCompletion <SymbolInformation[]>(symbols =>
{
symbolResultsBuilder.AddRange(symbols);
}, threadingContext.JoinableTaskFactory);
workspaceSymbolParams.PartialResultToken = awaitableProgress;
using (var jsonRpc = JsonRpc.Attach(await client.RequestServiceAsync(WellKnownServiceHubService.LanguageServer)))
{
var result = await jsonRpc.InvokeWithCancellationAsync <JObject>(
Methods.InitializeName,
new object[] { new InitializeParams() },
CancellationToken.None);
Assert.True(result["capabilities"]["workspaceSymbolProvider"].ToObject <bool>());
var symbolResult = await jsonRpc.InvokeWithCancellationAsync <SymbolInformation[]>(
Methods.WorkspaceSymbolName,
new object[] { workspaceSymbolParams },
CancellationToken.None);
await awaitableProgress.WaitAsync(CancellationToken.None);
}
return(symbolResultsBuilder.ToImmutableAndFree());
}
protected async Task HandleWorkspaceSymbolRequest(
WorkspaceSymbolParams workspaceSymbolParams,
EditorSession editorSession,
RequestContext <SymbolInformation[], object> requestContext)
{
var symbols = new List <SymbolInformation>();
foreach (ScriptFile scriptFile in editorSession.Workspace.GetOpenedFiles())
{
FindOccurrencesResult foundSymbols =
editorSession.LanguageService.FindSymbolsInFile(
scriptFile);
// TODO: Need to compute a relative path that is based on common path for all workspace files
string containerName = Path.GetFileNameWithoutExtension(scriptFile.FilePath);
if (foundSymbols != null)
{
var matchedSymbols =
foundSymbols
.FoundOccurrences
.Where(r => IsQueryMatch(workspaceSymbolParams.Query, r.SymbolName))
.Select(r =>
{
return(new SymbolInformation
{
ContainerName = containerName,
Kind = r.SymbolType == SymbolType.Variable ? SymbolKind.Variable : SymbolKind.Function,
Location = new Location
{
Uri = new Uri(r.FilePath).AbsoluteUri,
Range = GetRangeFromScriptRegion(r.ScriptRegion)
},
Name = GetDecoratedSymbolName(r)
});
});
symbols.AddRange(matchedSymbols);
}
}
await requestContext.SendResult(symbols.ToArray());
}
public Task <SymbolInformation[]> GetWorkspaceSymbols(string query, CancellationToken token)
{
if (!IsStarted)
{
return(Task.FromResult <SymbolInformation[]> (null));
}
if (!IsWorkspaceSymbolProvider)
{
Log("Workspace symbols are not supported by server.", Methods.WorkspaceSymbolName);
return(Task.FromResult <SymbolInformation[]> (null));
}
Log("Sending '{0}'.", Methods.WorkspaceSymbolName);
var message = new WorkspaceSymbolParams {
Query = query
};
return(workspaceSymbolProvider.RequestWorkspaceSymbols(message, token));
}
public Task <Container <SymbolInformation> > Handle(WorkspaceSymbolParams request, CancellationToken cancellationToken)
{
var symbols = new List <SymbolInformation>();
foreach (ScriptFile scriptFile in _workspaceService.GetOpenedFiles())
{
List <SymbolReference> foundSymbols =
_symbolsService.FindSymbolsInFile(
scriptFile);
// TODO: Need to compute a relative path that is based on common path for all workspace files
string containerName = Path.GetFileNameWithoutExtension(scriptFile.FilePath);
foreach (SymbolReference foundOccurrence in foundSymbols)
{
if (!IsQueryMatch(request.Query, foundOccurrence.SymbolName))
{
continue;
}
var location = new Location
{
Uri = PathUtils.ToUri(foundOccurrence.FilePath),
Range = GetRangeFromScriptRegion(foundOccurrence.ScriptRegion)
};
symbols.Add(new SymbolInformation
{
ContainerName = containerName,
Kind = foundOccurrence.SymbolType == SymbolType.Variable ? SymbolKind.Variable : SymbolKind.Function,
Location = location,
Name = GetDecoratedSymbolName(foundOccurrence)
});
}
}
_logger.LogWarning("Logging in a handler works now.");
return(Task.FromResult(new Container <SymbolInformation>(symbols)));
}
private async Task <SymbolInformation[]> GetVsSearchResultsAsync(TestWorkspace workspace, string query, IProgress <SymbolInformation[]> progress = null)
{
var solution = workspace.CurrentSolution;
using var client = await RemoteHostClient.TryGetClientAsync(workspace, CancellationToken.None).ConfigureAwait(false);
Assert.NotNull(client);
var document = solution.Projects.First().Documents.First();
await UpdatePrimaryWorkspace(client, solution.WithDocumentFilePath(document.Id, Path.Combine(TempRoot.Root, document.FilePath)));
var workspaceSymbolParams = new WorkspaceSymbolParams
{
Query = query,
};
workspaceSymbolParams.PartialResultToken = progress;
var result = await client.RunRemoteAsync <JObject>(
WellKnownServiceHubService.RemoteLanguageServer,
Methods.InitializeName,
solution : null,
new object[] { new InitializeParams() },
callbackTarget : null,
CancellationToken.None).ConfigureAwait(false);
Assert.True(result["capabilities"]["workspaceSymbolProvider"].ToObject <bool>());
return(await client.RunRemoteAsync <SymbolInformation[]>(
WellKnownServiceHubService.RemoteLanguageServer,
Methods.WorkspaceSymbolName,
solution : null,
new object[] { workspaceSymbolParams },
callbackTarget : null,
CancellationToken.None).ConfigureAwait(false));
}
public async Task <Container <SymbolInformation> > Handle(
WorkspaceSymbolParams request,
CancellationToken cancellationToken
)
{
using var reporter = _serverWorkDoneManager.For(
request, new WorkDoneProgressBegin {
Cancellable = true,
Message = "This might take a while...",
Title = "Some long task....",
Percentage = 0
}
);
using var partialResults = _progressManager.For(request, cancellationToken);
if (partialResults != null)
{
await Task.Delay(2000, cancellationToken).ConfigureAwait(false);
reporter.OnNext(
new WorkDoneProgressReport {
Cancellable = true,
Percentage = 20
}
);
await Task.Delay(500, cancellationToken).ConfigureAwait(false);
reporter.OnNext(
new WorkDoneProgressReport {
Cancellable = true,
Percentage = 40
}
);
await Task.Delay(500, cancellationToken).ConfigureAwait(false);
reporter.OnNext(
new WorkDoneProgressReport {
Cancellable = true,
Percentage = 50
}
);
await Task.Delay(500, cancellationToken).ConfigureAwait(false);
partialResults.OnNext(
new[] {
new SymbolInformation {
ContainerName = "Partial Container",
Deprecated = true,
Kind = SymbolKind.Constant,
Location = new Location {
Range = new Range(
new Position(2, 1),
new Position(2, 10)
)
},
Name = "Partial name"
}
}
);
reporter.OnNext(
new WorkDoneProgressReport {
Cancellable = true,
Percentage = 70
}
);
await Task.Delay(500, cancellationToken).ConfigureAwait(false);
reporter.OnNext(
new WorkDoneProgressReport {
Cancellable = true,
Percentage = 90
}
);
partialResults.OnCompleted();
return(new SymbolInformation[] { });
}
try
{
return(new[] {
new SymbolInformation {
ContainerName = "Container",
Deprecated = true,
Kind = SymbolKind.Constant,
Location = new Location {
Range = new Range(
new Position(1, 1),
new Position(1, 10)
)
},
Name = "name"
}
});
}
finally
{
reporter.OnNext(
new WorkDoneProgressReport {
Cancellable = true,
Percentage = 100
}
);
}
}
public override Task <Container <SymbolInformation> > Handle(WorkspaceSymbolParams request, CancellationToken cancellationToken) => _handler.Invoke(request, cancellationToken);
public Task <SymbolInformation[]> GetWorkspaceSymbolsAsync(WorkspaceSymbolParams workspaceSymbolParams, CancellationToken cancellationToken)
=> _requestHandlerProvider.ExecuteRequestAsync <WorkspaceSymbolParams, SymbolInformation[]>(Methods.WorkspaceSymbolName,
workspaceSymbolParams, _clientCapabilities, _clientName, cancellationToken);
private async Task <ImmutableArray <SymbolInformation> > SearchAsync(Solution solution, WorkspaceSymbolParams args, CancellationToken cancellationToken)
{
Contract.ThrowIfNull(args.PartialResultToken);
var tasks = solution.Projects.SelectMany(p => p.Documents).Select(d => SearchDocumentAndReportSymbolsAsync(d, args, cancellationToken));
await Task.WhenAll(tasks).ConfigureAwait(false);
return(ImmutableArray <SymbolInformation> .Empty);
}
public Task <SymbolInformation[]> GetWorkspaceSymbolsAsync(WorkspaceSymbolParams workspaceSymbolParams, CancellationToken cancellationToken)
=> _protocol.ExecuteRequestAsync <WorkspaceSymbolParams, SymbolInformation[]>(Methods.WorkspaceSymbolName,
_workspace.CurrentSolution, workspaceSymbolParams, _clientCapabilities, _clientName, cancellationToken);
public abstract RpcResult Symbol(WorkspaceSymbolParams args);
public static Task <Container <SymbolInformation> > WorkspaceSymbol(this ILanguageClientWorkspace router, WorkspaceSymbolParams @params, CancellationToken cancellationToken = default)
{
return(router.SendRequest <WorkspaceSymbolParams, Container <SymbolInformation> >(WorkspaceNames.WorkspaceSymbol, @params, cancellationToken));
}
public virtual Task <SymbolInformation[]> WorkspaceSymbols(WorkspaceSymbolParams @params, CancellationToken cancellationToken) => Task.FromResult(Array.Empty <SymbolInformation>());
Task <SymbolInformation[]> RequestWorkspaceSymbolsInternal(WorkspaceSymbolParams param, CancellationToken token)
{
return(jsonRpc.InvokeWithParameterObjectAsync(Methods.WorkspaceSymbol, param, token));
}
public static Task <SymbolInformationContainer> WorkspaceSymbol(this ILanguageClientWorkspace router, WorkspaceSymbolParams @params)
{
return(router.SendRequest <WorkspaceSymbolParams, SymbolInformationContainer>(WorkspaceNames.WorkspaceSymbol, @params));
}
public async override Task<Container<SymbolInformation>> Handle(WorkspaceSymbolParams request, CancellationToken cancellationToken)
{
using var reporter = ProgressManager.WorkDone(request, new WorkDoneProgressBegin()
{
Cancellable = true,
Message = "This might take a while...",
Title = "Some long task....",
Percentage = 0
});
using var partialResults = ProgressManager.For(request, cancellationToken);
if (partialResults != null)
{
await Task.Delay(2000, cancellationToken);
reporter.OnNext(new WorkDoneProgressReport()
{
Cancellable = true,
Percentage = 20
});
await Task.Delay(500, cancellationToken);
reporter.OnNext(new WorkDoneProgressReport()
{
Cancellable = true,
Percentage = 40
});
await Task.Delay(500, cancellationToken);
reporter.OnNext(new WorkDoneProgressReport()
{
Cancellable = true,
Percentage = 50
});
await Task.Delay(500, cancellationToken);
partialResults.OnNext(new[] {
new SymbolInformation() {
ContainerName = "Partial Container",
Deprecated = true,
Kind = SymbolKind.Constant,
Location = new Location() { Range = new OmniSharp.Extensions.LanguageServer.Protocol.Models.Range(new Position(2, 1), new Position(2, 10)) {} },
Name = "Partial name"
}
});
reporter.OnNext(new WorkDoneProgressReport()
{
Cancellable = true,
Percentage = 70
});
await Task.Delay(500, cancellationToken);
reporter.OnNext(new WorkDoneProgressReport()
{
Cancellable = true,
Percentage = 90
});
partialResults.OnCompleted();
return new SymbolInformation[] { };
}
try
{
return new[] {
new SymbolInformation() {
ContainerName = "Container",
Deprecated = true,
Kind = SymbolKind.Constant,
Location = new Location() { Range = new OmniSharp.Extensions.LanguageServer.Protocol.Models.Range(new Position(1, 1), new Position(1, 10)) {} },
Name = "name"
}
};
}
finally
{
reporter.OnNext(new WorkDoneProgressReport()
{
Cancellable = true,
Percentage = 100
});
}
}
/// <summary>
/// Search the document and report the results back using <see cref="IProgress{T}"/>
/// <see cref="IProgress{T}.Report(T)"/> implementation for symbol search is threadsafe.
/// </summary>
private static async Task SearchDocumentAndReportSymbolsAsync(Document document, WorkspaceSymbolParams args, CancellationToken cancellationToken)
{
Contract.ThrowIfNull(args.PartialResultToken);
var convertedResults = await SearchDocumentAsync(document, args.Query, cancellationToken).ConfigureAwait(false);
args.PartialResultToken.Report(convertedResults.ToArray());
}
public abstract Task <Container <SymbolInformation> > Handle(WorkspaceSymbolParams request, CancellationToken cancellationToken);
public Task <SymbolInformation[]?> GetWorkspaceSymbolsAsync(WorkspaceSymbolParams workspaceSymbolParams, CancellationToken cancellationToken)
{
Contract.ThrowIfNull(_clientCapabilities, $"{nameof(InitializeAsync)} has not been called.");
return(RequestDispatcher.ExecuteRequestAsync <WorkspaceSymbolParams, SymbolInformation[]?>(Queue, Methods.WorkspaceSymbolName, workspaceSymbolParams, _clientCapabilities, ClientName, cancellationToken));
}
public Task <SymbolInformation[]> RequestWorkspaceSymbols(
WorkspaceSymbolParams param,
Func <WorkspaceSymbolParams, Task <SymbolInformation[]> > sendRequest)
{
return(sendRequest(param));
}
