ILocationContainer IWorker.References(string absFilename, long line, long column) { var param = new ReferenceParams(); param.context.includeDeclaration = true; return(CommonProcessingOfGoto(absFilename, line, column, param, (ITextDocumentPositionParams arg) => client_.Send.TextDocumentReferences((ReferenceParams)arg))); }
public Task <VSInternalReferenceItem[]?> GetTextDocumentReferencesAsync(ReferenceParams referencesParams, CancellationToken cancellationToken) { Contract.ThrowIfNull(_clientCapabilities, $"{nameof(InitializeAsync)} has not been called."); return(RequestDispatcher.ExecuteRequestAsync <ReferenceParams, VSInternalReferenceItem[]?>(Queue, Methods.TextDocumentReferencesName, referencesParams, _clientCapabilities, ClientName, cancellationToken)); }
public Task <Location[]> GetReferences(FilePath fileName, Position position, CancellationToken token) { if (!IsStarted) { return(Task.FromResult(new Location[0])); } if (!IsReferencesProvider) { Log("Get references is not supported by server for '{0}'. File: '{1}'", Methods.TextDocumentReferencesName, fileName); return(Task.FromResult(new Location [0])); } var message = new ReferenceParams { Context = new ReferenceContext { IncludeDeclaration = true }, TextDocument = TextDocumentIdentifierFactory.Create(fileName), Position = position }; Log("Sending '{0}'. File: '{1}'", Methods.TextDocumentReferencesName, fileName); return(jsonRpc.InvokeWithParameterObjectAsync( Methods.TextDocumentReferences, message, token)); }
/// <summary> /// Request References LocationInformation for a symbol location information at the specified document position. /// </summary> /// <param name="filePath"> /// The full file-system path of the text document. /// </param> /// <param name="line"> /// The target line (0-based). /// </param> /// <param name="column"> /// The target column (0-based). /// </param> /// <param name="includeDeclaration"></param> /// <param name="cancellationToken"> /// An optional <see cref="CancellationToken"/> that can be used to cancel the request. /// </param> /// <returns> /// A <see cref="Task{TResult}"/> that resolves to the hover information or <c>null</c> if no hover information is available at the specified position. /// </returns> public async Task <LocationContainer> References(string filePath, int line, int column, bool includeDeclaration, CancellationToken cancellationToken = default(CancellationToken)) { if (string.IsNullOrWhiteSpace(filePath)) { throw new ArgumentException("Argument cannot be null, empty, or entirely composed of whitespace: 'filePath'.", nameof(filePath)); } Uri documentUri = DocumentUri.FromFileSystemPath(filePath); var request = new ReferenceParams { TextDocument = new TextDocumentItem { LanguageId = "C++", Uri = documentUri }, Position = new Position { Line = line, Character = column }, Context = new ReferenceContext() { IncludeDeclaration = includeDeclaration } }; return(await Client.SendRequest <LocationContainer>(DocumentNames.References, request, cancellationToken).ConfigureAwait(false)); }
public Task <VSReferenceItem[]> GetTextDocumentReferencesAsync(ReferenceParams referencesParams, CancellationToken cancellationToken) { Contract.ThrowIfNull(_clientCapabilities, $"{nameof(InitializeAsync)} has not been called."); return(_requestHandlerProvider.ExecuteRequestAsync <ReferenceParams, VSReferenceItem[]>(_queue, Methods.TextDocumentReferencesName, referencesParams, _clientCapabilities, _clientName, cancellationToken)); }
public override Task <LocationContainer> Handle(ReferenceParams request, CancellationToken cancellationToken) { ScriptFile scriptFile = _workspaceService.GetFile(request.TextDocument.Uri); SymbolReference foundSymbol = _symbolsService.FindSymbolAtLocation( scriptFile, request.Position.Line + 1, request.Position.Character + 1); List <SymbolReference> referencesResult = _symbolsService.FindReferencesOfSymbol( foundSymbol, _workspaceService.ExpandScriptReferences(scriptFile), _workspaceService); var locations = new List <Location>(); if (referencesResult != null) { foreach (SymbolReference foundReference in referencesResult) { locations.Add(new Location { Uri = DocumentUri.From(foundReference.FilePath), Range = GetRangeFromScriptRegion(foundReference.ScriptRegion) }); } } return(Task.FromResult(new LocationContainer(locations))); }
public override async Task <LSP.VSReferenceItem[]> HandleRequestAsync( ReferenceParams referenceParams, ClientCapabilities clientCapabilities, string?clientName, CancellationToken cancellationToken) { Debug.Assert(clientCapabilities.HasVisualStudioLspCapability()); var document = SolutionProvider.GetDocument(referenceParams.TextDocument, clientName); if (document == null) { return(Array.Empty <LSP.VSReferenceItem>()); } var findUsagesService = document.GetRequiredLanguageService <IFindUsagesLSPService>(); var position = await document.GetPositionFromLinePositionAsync( ProtocolConversions.PositionToLinePosition(referenceParams.Position), cancellationToken).ConfigureAwait(false); var context = new FindUsagesLSPContext(document, position, _metadataAsSourceFileService, cancellationToken); // Finds the references for the symbol at the specific position in the document, reporting them via streaming to the LSP client. // TODO: Change back FAR to use streaming once the following LSP bug is fixed: // https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1094786/ await findUsagesService.FindReferencesAsync(document, position, context).ConfigureAwait(false); return(context.GetReferences().ToArray()); }
public override async Task <LSP.VSReferenceItem[]> HandleRequestAsync(ReferenceParams referenceParams, RequestContext context, CancellationToken cancellationToken) { Debug.Assert(context.ClientCapabilities.HasVisualStudioLspCapability()); var document = SolutionProvider.GetDocument(referenceParams.TextDocument, context.ClientName); if (document == null) { return(Array.Empty <LSP.VSReferenceItem>()); } var findUsagesService = document.GetRequiredLanguageService <IFindUsagesLSPService>(); var position = await document.GetPositionFromLinePositionAsync( ProtocolConversions.PositionToLinePosition(referenceParams.Position), cancellationToken).ConfigureAwait(false); var findUsagesContext = new FindUsagesLSPContext( referenceParams.PartialResultToken, document, position, _metadataAsSourceFileService, cancellationToken); // Finds the references for the symbol at the specific position in the document, reporting them via streaming to the LSP client. await findUsagesService.FindReferencesAsync(document, position, findUsagesContext).ConfigureAwait(false); await findUsagesContext.OnCompletedAsync().ConfigureAwait(false); // The results have already been reported to the client, so we don't need to return anything here. return(Array.Empty <LSP.VSReferenceItem>()); }
public override Task <LocationContainer> Handle(ReferenceParams request, CancellationToken cancellationToken) { var result = this.symbolResolver.ResolveSymbol(request.TextDocument.Uri, request.Position); if (result == null) { return(Task.FromResult(new LocationContainer())); } if (result.Symbol is PropertySymbol) { // TODO: Implement for PropertySymbol return(Task.FromResult(new LocationContainer())); } var references = result.Context.Compilation.GetEntrypointSemanticModel() .FindReferences(result.Symbol) .Where(referenceSyntax => request.Context.IncludeDeclaration || !(referenceSyntax is INamedDeclarationSyntax)) .Select(referenceSyntax => new Location { Uri = request.TextDocument.Uri, Range = PositionHelper.GetNameRange(result.Context.LineStarts, referenceSyntax), }); return(Task.FromResult(new LocationContainer(references))); }
public override async Task <LSP.ReferenceItem[]?> HandleRequestAsync(ReferenceParams referenceParams, RequestContext context, CancellationToken cancellationToken) { Debug.Assert(context.ClientCapabilities.HasVisualStudioLspCapability()); var document = context.Document; if (document == null) { return(Array.Empty <LSP.VSReferenceItem>()); } using var progress = BufferedProgress.Create <VSReferenceItem>(referenceParams.PartialResultToken); var findUsagesService = document.GetRequiredLanguageService <IFindUsagesLSPService>(); var position = await document.GetPositionFromLinePositionAsync( ProtocolConversions.PositionToLinePosition(referenceParams.Position), cancellationToken).ConfigureAwait(false); var findUsagesContext = new FindUsagesLSPContext( progress, document, position, _metadataAsSourceFileService, cancellationToken); // Finds the references for the symbol at the specific position in the document, reporting them via streaming to the LSP client. await findUsagesService.FindReferencesAsync(document, position, findUsagesContext).ConfigureAwait(false); await findUsagesContext.OnCompletedAsync().ConfigureAwait(false); return(progress.GetValues()); }
public async Task HandleRequestAsync_ProjectionNotFound_ReturnsNull() { // Arrange var documentManager = new TestDocumentManager(); documentManager.AddDocument(Uri, Mock.Of <LSPDocumentSnapshot>()); var requestInvoker = Mock.Of <LSPRequestInvoker>(); var projectionProvider = Mock.Of <LSPProjectionProvider>(); var documentMappingProvider = Mock.Of <LSPDocumentMappingProvider>(); var progressListener = Mock.Of <LSPProgressListener>(); var referencesHandler = new FindAllReferencesHandler(requestInvoker, documentManager, projectionProvider, documentMappingProvider, progressListener); referencesHandler.WaitForProgressNotificationTimeout = TestWaitForProgressNotificationTimeout; var referenceRequest = new ReferenceParams() { TextDocument = new TextDocumentIdentifier() { Uri = Uri }, Position = new Position(0, 1) }; // Act var result = await referencesHandler.HandleRequestAsync(referenceRequest, new ClientCapabilities(), CancellationToken.None).ConfigureAwait(false); // Assert Assert.Null(result); }
public object[] OnTextDocumentFindReferences(ReferenceParams parameter, CancellationToken token) { this.traceSource.TraceEvent(TraceEventType.Information, 0, $"Received: {JToken.FromObject(parameter)}"); var result = server.SendReferences(parameter, returnLocationsOnly: true, token: token); this.traceSource.TraceEvent(TraceEventType.Information, 0, $"Sent: {JToken.FromObject(result)}"); return(result); }
public Task <VSReferenceItem[]> FindAllReferencesAsync(ReferenceParams referenceParams, CancellationToken cancellationToken) { if (referenceParams is null) { throw new ArgumentNullException(nameof(referenceParams)); } return(ExecuteRequestAsync <ReferenceParams, VSReferenceItem[]>(Methods.TextDocumentReferencesName, referenceParams, _clientCapabilities, cancellationToken)); }
public async Task HandleRequestAsync_RemapFailure_DiscardsLocation() { // Arrange var progressReported = false; var documentManager = new TestDocumentManager(); documentManager.AddDocument(Uri, Mock.Of <LSPDocumentSnapshot>()); var virtualCSharpUri = new Uri("C:/path/to/file.razor.g.cs"); var csharpLocation = GetReferenceItem(100, virtualCSharpUri); var(requestInvoker, progressListener) = MockServices(csharpLocation, out var token); var projectionResult = new ProjectionResult() { LanguageKind = RazorLanguageKind.CSharp, }; var projectionProvider = new Mock <LSPProjectionProvider>(); projectionProvider.Setup(p => p.GetProjectionAsync(It.IsAny <LSPDocumentSnapshot>(), It.IsAny <Position>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(projectionResult)); var documentMappingProvider = new Mock <LSPDocumentMappingProvider>(); documentMappingProvider.Setup(d => d.MapToDocumentRangesAsync(RazorLanguageKind.CSharp, Uri, new[] { csharpLocation.Location.Range }, It.IsAny <CancellationToken>())). Returns(Task.FromResult <RazorMapToDocumentRangesResponse>(null)); var languageServiceBroker = Mock.Of <ILanguageServiceBroker2>(); var referencesHandler = new FindAllReferencesHandler(requestInvoker, documentManager, projectionProvider.Object, documentMappingProvider.Object, progressListener); referencesHandler.WaitForProgressNotificationTimeout = TestWaitForProgressNotificationTimeout; var progressToken = new ProgressWithCompletion <object>((val) => { var results = Assert.IsType <VSReferenceItem[]>(val); Assert.Empty(results); progressReported = true; }); var referenceRequest = new ReferenceParams() { TextDocument = new TextDocumentIdentifier() { Uri = Uri }, Position = new Position(10, 5), PartialResultToken = progressToken }; // Act var result = await referencesHandler.HandleRequestAsync(referenceRequest, new ClientCapabilities(), token, CancellationToken.None).ConfigureAwait(false); // Assert Assert.True(progressReported); Assert.Empty(result); }
public async Task HandleRequestAsync_CSharpProjection_DoesNotRemapNonRazorFiles() { // Arrange var progressReported = false; var documentManager = new TestDocumentManager(); documentManager.AddDocument(Uri, Mock.Of <LSPDocumentSnapshot>()); var externalCSharpUri = new Uri("C:/path/to/someotherfile.cs"); var externalCsharpLocation = GetReferenceItem(100, 100, 100, 100, externalCSharpUri); var(requestInvoker, progressListener) = MockServices(externalCsharpLocation, out var token); var projectionResult = new ProjectionResult() { LanguageKind = RazorLanguageKind.CSharp, }; var projectionProvider = new Mock <LSPProjectionProvider>(); projectionProvider.Setup(p => p.GetProjectionAsync(It.IsAny <LSPDocumentSnapshot>(), It.IsAny <Position>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(projectionResult)); var documentMappingProvider = Mock.Of <LSPDocumentMappingProvider>(); var languageServiceBroker = Mock.Of <ILanguageServiceBroker2>(); var referencesHandler = new FindAllReferencesHandler(requestInvoker, documentManager, projectionProvider.Object, documentMappingProvider, progressListener); referencesHandler.WaitForProgressNotificationTimeout = TestWaitForProgressNotificationTimeout; var progressToken = new ProgressWithCompletion <object>((val) => { var results = Assert.IsType <VSReferenceItem[]>(val); var actualLocation = Assert.Single(results); AssertVSReferenceItem(externalCsharpLocation, actualLocation); progressReported = true; }); var referenceRequest = new ReferenceParams() { TextDocument = new TextDocumentIdentifier() { Uri = Uri }, Position = new Position(10, 5), PartialResultToken = progressToken }; // Act var result = await referencesHandler.HandleRequestAsync(referenceRequest, new ClientCapabilities(), token, CancellationToken.None).ConfigureAwait(false); // Assert Assert.True(progressReported); }
public override Task <LocationContainer> Handle(ReferenceParams request, CancellationToken cancellationToken) { var port = Workspace.GetPortAt(request.TextDocument.Uri, request.Position.ToLocation()); if (port == null) { return(Task.FromResult(LocationContainer.From(Array.Empty <Location>()))); } var refs = Workspace.FindReferencesTo(request.TextDocument.Uri, port); return(Task.FromResult(LocationContainer.From(refs.Select(o => new Location { Range = o.Span.ToRange(), Uri = request.TextDocument.Uri })))); }
public void SimpleTest(string expected) { var model = new ReferenceParams { Context = new ReferenceContext { IncludeDeclaration = true, }, Position = new Position(1, 2), TextDocument = new TextDocumentIdentifier(new Uri("file:///abc/123.cs")) }; var result = Fixture.SerializeObject(model); result.Should().Be(expected); var deresult = new LspSerializer(ClientVersion.Lsp3).DeserializeObject <ReferenceParams>(expected); deresult.Should().BeEquivalentTo(model); }
public async Task HandleRequestAsync_ProgressListener_ReturnsNull() { // Arrange var documentManager = new TestDocumentManager(); documentManager.AddDocument(Uri, Mock.Of <LSPDocumentSnapshot>()); var requestInvoker = Mock.Of <LSPRequestInvoker>(); var projectionResult = new ProjectionResult() { LanguageKind = RazorLanguageKind.CSharp, }; var projectionProvider = new Mock <LSPProjectionProvider>(); projectionProvider.Setup(p => p.GetProjectionAsync(It.IsAny <LSPDocumentSnapshot>(), It.IsAny <Position>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(projectionResult)); Task onCompleted = null; var documentMappingProvider = Mock.Of <LSPDocumentMappingProvider>(); var progressListener = Mock.Of <LSPProgressListener>(l => l.TryListenForProgress( It.IsAny <string>(), It.IsAny <Func <JToken, CancellationToken, Task> >(), It.IsAny <TimeSpan>(), It.IsAny <CancellationToken>(), out onCompleted) == false); var referencesHandler = new FindAllReferencesHandler(requestInvoker, documentManager, projectionProvider.Object, documentMappingProvider, progressListener); referencesHandler.WaitForProgressNotificationTimeout = TestWaitForProgressNotificationTimeout; var referenceRequest = new ReferenceParams() { TextDocument = new TextDocumentIdentifier() { Uri = Uri }, Position = new Position(0, 1) }; // Act var result = await referencesHandler.HandleRequestAsync(referenceRequest, new ClientCapabilities(), CancellationToken.None).ConfigureAwait(false); // Assert Assert.Null(result); }
public async Task <LocationContainer> Handle(ReferenceParams request, CancellationToken cancellationToken) { return(await Task.Run <LocationContainer>(() => { bool includeDeclaration = request.Context.IncludeDeclaration; // Get the declaration key from the provided range and uri. var key = _languageServer.LastParse?.ScriptFromUri(request.TextDocument.Uri.ToUri())?.Elements.KeyFromPosition(request.Position).key; // Missing script or no definition found. if (key == null) { return new LocationContainer(); } // Get the locations. return new LocationContainer(_languageServer.LastParse.GetComponent <SymbolLinkComponent>().CallsFromDeclaration(key).Select(link => link.Location.ToLsLocation())); })); }
public async override Task <LocationContainer> Handle(ReferenceParams request, CancellationToken token) { var omnisharpRequest = new FindUsagesRequest { FileName = Helpers.FromUri(request.TextDocument.Uri), Column = Convert.ToInt32(request.Position.Character), Line = Convert.ToInt32(request.Position.Line), OnlyThisFile = false, ExcludeDefinition = !request.Context.IncludeDeclaration }; var omnisharpResponse = await _findUsagesHandler.Handle(omnisharpRequest); return(omnisharpResponse.QuickFixes?.Select(x => new Location { Uri = Helpers.ToUri(x.FileName), Range = x.ToRange() }).ToArray()); }
// not working! public void GetMethodFastInvoke_MethodNameAndTypeArrayAndParameterModifier() { // need to set this up to test // http://msdn.microsoft.com/en-us/library/4s2kzbw8.aspx // can do this in a better type safe way! ReferenceParams <TestClass, object> fast = typeof(TestClass).GetMethodFastInvokeAsRefenceCall <TestClass, object>("TestMethodReferenceParams", BindingFlags.Public | BindingFlags.Instance, null, CallingConventions.Any, new Type[] { typeof(string).MakeByRefType(), typeof(string).MakeByRefType() }, null); TestClass tc = new TestClass("injected"); string test = string.Empty; string param1 = "param1"; string param2 = "param2"; object[] arr = new object[] { param1, param2 }; //test = fast(tc, new object[] { param1, param2 }).ToString(); fast(tc, ref arr); // Assert.AreEqual(test, "param1:end-param2:end-injected"); Assert.AreEqual(arr[0], "param1:end"); Assert.AreEqual(arr[1], "param2:end"); }
public Location[] FindReferences(ReferenceParams parameter) { TextDocumentItem currentTextDocument = FindDocument(parameter.TextDocument); if (currentTextDocument == null) { Log(string.Format("FindReferences: TextDocument.Uri does not match any document.")); return(null); } string[] lines = currentTextDocument.Text.Split(new string[] { Environment.NewLine }, StringSplitOptions.None); string item = GetReferenceItem(lines, parameter.Position); if (string.IsNullOrEmpty(item)) { Log(string.Format("FindReferences: No item to search for.")); return(null); } Log(string.Format("FindReferences: Searching for '{0}' in '{1}'", item, currentTextDocument.Uri)); var locations = FindReferences(item, currentTextDocument.Uri, lines).ToList(); if (textDocuments.Count > 1) { lock (textDocuments) { foreach (var document in textDocuments.Where(doc => doc != currentTextDocument)) { Log(string.Format("FindReferences: Searching for '{0}' in '{1}'", item, document.Uri)); lines = document.Text.Split(new string[] { Environment.NewLine }, StringSplitOptions.None); var otherLocations = FindReferences(item, document.Uri, lines); locations.AddRange(otherLocations); } } } return(locations.ToArray()); }
public async Task <LocationContainer> Handle(ReferenceParams request, CancellationToken cancellationToken) { return(await Task.Run(() => { bool includeDeclaration = request.Context.IncludeDeclaration; var allSymbolLinks = _languageServer.LastParse?.GetComponent <SymbolLinkComponent>().GetSymbolLinks(); if (allSymbolLinks == null) { return new LocationContainer(); } ICallable use = null; Location declaredAt = null; foreach (var pair in allSymbolLinks) { foreach (var link in pair.Value) { if (link.Location.uri.Compare(request.TextDocument.Uri.ToUri()) && link.Location.range.IsInside(request.Position)) { use = pair.Key; declaredAt = link.Location; } } } if (use == null) { return new LocationContainer(); } return allSymbolLinks[use] .GetSymbolLinks(includeDeclaration) // Convert to Language Server API location. .Select(loc => loc.Location.ToLsLocation()) .ToArray(); })); }
public async Task <LocationContainer> Handle(ReferenceParams request, CancellationToken cancellationToken) { try { var scriptFile = _projectManager.GetScriptForFilePath(request.TextDocument.Uri.ToFilePath()); if (scriptFile == null) { return(null); } var identifier = scriptFile.Node.GetDescendantNodeOfTypeAtPosition <IdentifierNode>(request.Position.ToPosition()); if (identifier == null) { return(null); } var symbol = identifier.GetDeclaredOrReferencedSymbol(); if (symbol == null) { return(null); } var referencingNodes = await symbol.FindReferences(cancellationToken); return(referencingNodes.Select(node => new Location() { Range = node.Range.ToRange(), Uri = PathUtilities.ToFileUri(node.GetScriptFile().FilePath) }).ToArray()); } catch (Exception e) { _logger.LogWarning(e, "Error while handling request."); } return(null); }
public void GenerateRequest() { var procName = tables.Find(x => x.CDataTableName == tableInput.tableName); if (procName == null) { return; } var referenceParams = new ReferenceParams(); referenceParams.Fileds = GetFiledsRequest(); referenceParams.Order = GetOrderRequest(); referenceParams.Limit = tableInput.Limit; referenceParams.Page = tableInput.Page; referenceParams.TableName = procName.TableName; referenceParams.Conditions = GetConditionsRequest(); var jsonParams = JsonConvert.SerializeObject(referenceParams, Formatting.Indented); RequestBody = $"proc_name={procName.ReferenceProcName}¶ms=\n{jsonParams}"; this.StateHasChanged(); }
public async Task HandleRequestAsync_HtmlProjection_InvokesHtmlLanguageServer() { // Arrange var lspFarEndpointCalled = false; var progressReported = false; var expectedUri1 = new Uri("C:/path/to/file1.razor"); var expectedUri2 = new Uri("C:/path/to/file2.razor"); var expectedLocation1 = GetReferenceItem(5, expectedUri1); var expectedLocation2 = GetReferenceItem(10, expectedUri2); var documentManager = new TestDocumentManager(); documentManager.AddDocument(Uri, Mock.Of <LSPDocumentSnapshot>()); var virtualHtmlUri1 = new Uri("C:/path/to/file1.razor__virtual.html"); var virtualHtmlUri2 = new Uri("C:/path/to/file2.razor__virtual.html"); var htmlLocation1 = GetReferenceItem(100, virtualHtmlUri1); var htmlLocation2 = GetReferenceItem(200, virtualHtmlUri2); var languageServiceBroker = Mock.Of <ILanguageServiceBroker2>(); using var lspProgressListener = new DefaultLSPProgressListener(languageServiceBroker); var token = Guid.NewGuid().ToString(); var parameterToken = new JObject { { "token", token }, { "value", JArray.FromObject(new[] { htmlLocation1, htmlLocation2 }) } }; var requestInvoker = new Mock <LSPRequestInvoker>(); requestInvoker .Setup(r => r.ReinvokeRequestOnServerAsync <TextDocumentPositionParams, VSReferenceItem[]>(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <TextDocumentPositionParams>(), It.IsAny <CancellationToken>())) .Callback <string, string, TextDocumentPositionParams, CancellationToken>((method, serverContentType, definitionParams, ct) => { Assert.Equal(Methods.TextDocumentReferencesName, method); Assert.Equal(RazorLSPConstants.HtmlLSPContentTypeName, serverContentType); lspFarEndpointCalled = true; _ = lspProgressListener.ProcessProgressNotificationAsync(Methods.ProgressNotificationName, parameterToken); }) .Returns(Task.FromResult(Array.Empty <VSReferenceItem>())); var projectionResult = new ProjectionResult() { LanguageKind = RazorLanguageKind.Html, }; var projectionProvider = new Mock <LSPProjectionProvider>(); projectionProvider.Setup(p => p.GetProjectionAsync(It.IsAny <LSPDocumentSnapshot>(), It.IsAny <Position>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(projectionResult)); var remappingResult1 = new RazorMapToDocumentRangesResponse() { Ranges = new[] { expectedLocation1.Location.Range } }; var remappingResult2 = new RazorMapToDocumentRangesResponse() { Ranges = new[] { expectedLocation2.Location.Range } }; var documentMappingProvider = new Mock <LSPDocumentMappingProvider>(); documentMappingProvider .Setup(d => d.MapToDocumentRangesAsync(RazorLanguageKind.Html, It.IsAny <Uri>(), It.IsAny <Range[]>(), It.IsAny <CancellationToken>())) .Returns <RazorLanguageKind, Uri, Range[], CancellationToken>((languageKind, uri, ranges, ct) => Task.FromResult(uri.LocalPath.Contains("file1") ? remappingResult1 : remappingResult2)); var referencesHandler = new FindAllReferencesHandler(requestInvoker.Object, documentManager, projectionProvider.Object, documentMappingProvider.Object, lspProgressListener); referencesHandler.WaitForProgressNotificationTimeout = TestWaitForProgressNotificationTimeout; var progressToken = new ProgressWithCompletion <object>((val) => { var results = Assert.IsType <VSReferenceItem[]>(val); Assert.Collection(results, a => AssertVSReferenceItem(expectedLocation1, a), b => AssertVSReferenceItem(expectedLocation2, b)); progressReported = true; }); var referenceRequest = new ReferenceParams() { TextDocument = new TextDocumentIdentifier() { Uri = Uri }, Position = new Position(10, 5), PartialResultToken = progressToken }; // Act var result = await referencesHandler.HandleRequestAsync(referenceRequest, new ClientCapabilities(), token, CancellationToken.None).ConfigureAwait(false); // Assert Assert.True(lspFarEndpointCalled); Assert.True(progressReported); }
public Task <VSReferenceItem[]> GetTextDocumentReferencesAsync(ReferenceParams referencesParams, CancellationToken cancellationToken) => _requestHandlerProvider.ExecuteRequestAsync <ReferenceParams, VSReferenceItem[]>(Methods.TextDocumentReferencesName, referencesParams, _clientCapabilities, _clientName, cancellationToken);
/// <summary> /// Returns an array with all locations where the symbol at the given position - if any - is referenced. /// Returns null if the given file is listed as to be ignored, /// or if some parameters are unspecified (null), /// or if the specified position is not a valid position within the currently processed file content, /// or if no symbol exists at the specified position at this time. /// </summary> public Location[] SymbolReferences(ReferenceParams param) => ValidFileUri(param?.TextDocument?.Uri) && !IgnoreFile(param.TextDocument.Uri) ? this.Projects.SymbolReferences(param) : null;
public async Task HandleRequestAsync_LargeProject_InvokesCSharpLanguageServer() { // Validates batching mechanism for the progress notification on large projects // Arrange var lspFarEndpointCalled = false; const int BATCH_SIZE = 10; const int NUM_BATCHES = 10; const int NUM_DOCUMENTS = BATCH_SIZE * NUM_BATCHES; const int MAPPING_OFFSET = 10; var expectedUris = new Uri[NUM_DOCUMENTS]; var virtualUris = new Uri[NUM_DOCUMENTS]; var expectedReferences = new VSReferenceItem[NUM_BATCHES][]; var csharpUnmappedReferences = new VSReferenceItem[NUM_BATCHES][]; var parameterTokens = new JObject[NUM_BATCHES]; var token = Guid.NewGuid().ToString(); var documentNumber = 0; for (var batch = 0; batch < NUM_BATCHES; ++batch) { expectedReferences[batch] = new VSReferenceItem[BATCH_SIZE]; csharpUnmappedReferences[batch] = new VSReferenceItem[BATCH_SIZE]; for (var documentInBatch = 0; documentInBatch < BATCH_SIZE; ++documentInBatch) { expectedUris[documentNumber] = new Uri($"C:/path/to/file{documentNumber}.razor"); virtualUris[documentNumber] = new Uri($"C:/path/to/file{documentNumber}.razor.g.cs"); expectedReferences[batch][documentInBatch] = GetReferenceItem(documentNumber, expectedUris[documentNumber]); var umappedOffset = documentNumber * MAPPING_OFFSET; csharpUnmappedReferences[batch][documentInBatch] = GetReferenceItem(umappedOffset, virtualUris[documentNumber]); documentNumber++; } parameterTokens[batch] = new JObject { { "token", token }, { "value", JArray.FromObject(csharpUnmappedReferences[batch]) } }; } var documentManager = new TestDocumentManager(); documentManager.AddDocument(Uri, Mock.Of <LSPDocumentSnapshot>()); var languageServiceBroker = Mock.Of <ILanguageServiceBroker2>(); using var lspProgressListener = new DefaultLSPProgressListener(languageServiceBroker); var requestInvoker = new Mock <LSPRequestInvoker>(); requestInvoker .Setup(r => r.ReinvokeRequestOnServerAsync <TextDocumentPositionParams, VSReferenceItem[]>(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <TextDocumentPositionParams>(), It.IsAny <CancellationToken>())) .Callback <string, string, TextDocumentPositionParams, CancellationToken>((method, serverContentType, definitionParams, ct) => { Assert.Equal(Methods.TextDocumentReferencesName, method); Assert.Equal(RazorLSPConstants.CSharpContentTypeName, serverContentType); lspFarEndpointCalled = true; for (var i = 0; i < NUM_BATCHES; ++i) { _ = lspProgressListener.ProcessProgressNotificationAsync(Methods.ProgressNotificationName, parameterTokens[i]); } }) .Returns(Task.FromResult(Array.Empty <VSReferenceItem>())); var projectionResult = new ProjectionResult() { LanguageKind = RazorLanguageKind.CSharp, }; var projectionProvider = new Mock <LSPProjectionProvider>(); projectionProvider.Setup(p => p.GetProjectionAsync(It.IsAny <LSPDocumentSnapshot>(), It.IsAny <Position>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(projectionResult)); var documentMappingProvider = new Mock <LSPDocumentMappingProvider>(); documentMappingProvider .Setup(d => d.MapToDocumentRangesAsync(RazorLanguageKind.CSharp, It.IsAny <Uri>(), It.IsAny <Range[]>(), It.IsAny <CancellationToken>())) .Returns <RazorLanguageKind, Uri, Range[], CancellationToken>((languageKind, uri, ranges, ct) => { var unmappedPosition = ranges[0].Start.Line; var mappedPosition = unmappedPosition / MAPPING_OFFSET; var mappedRange = new Range() { Start = new Position(mappedPosition, mappedPosition), End = new Position(mappedPosition, mappedPosition) }; var response = new RazorMapToDocumentRangesResponse() { Ranges = new[] { mappedRange } }; return(Task.FromResult(response)); }); var referencesHandler = new FindAllReferencesHandler(requestInvoker.Object, documentManager, projectionProvider.Object, documentMappingProvider.Object, lspProgressListener); referencesHandler.WaitForProgressNotificationTimeout = TestWaitForProgressNotificationTimeout; var progressBatchesReported = new ConcurrentBag <VSReferenceItem[]>(); var progressToken = new ProgressWithCompletion <object>((val) => { var results = Assert.IsType <VSReferenceItem[]>(val); Assert.Equal(BATCH_SIZE, results.Length); progressBatchesReported.Add(results); }); var referenceRequest = new ReferenceParams() { TextDocument = new TextDocumentIdentifier() { Uri = Uri }, Position = new Position(10, 5), PartialResultToken = progressToken }; // Act var result = await referencesHandler.HandleRequestAsync(referenceRequest, new ClientCapabilities(), token, CancellationToken.None).ConfigureAwait(false); // Assert Assert.True(lspFarEndpointCalled); var sortedBatchesReported = progressBatchesReported.ToList(); sortedBatchesReported.Sort((VSReferenceItem[] a, VSReferenceItem[] b) => { var indexA = a[0].Location.Range.Start.Character; var indexB = b[0].Location.Range.Start.Character; return(indexA.CompareTo(indexB)); }); Assert.Equal(NUM_BATCHES, sortedBatchesReported.Count); for (var batch = 0; batch < NUM_BATCHES; ++batch) { for (var documentInBatch = 0; documentInBatch < BATCH_SIZE; ++documentInBatch) { AssertVSReferenceItem( expectedReferences[batch][documentInBatch], sortedBatchesReported[batch][documentInBatch]); } } }
public override TextDocumentIdentifier?GetTextDocumentIdentifier(ReferenceParams request) => request.TextDocument;