public async Task HandleSignatureHelpRequestNonMssqlFile() { InitializeTestObjects(); // setup the mock for SendResult var signatureRequestContext = new Mock <RequestContext <SignatureHelp> >(); SignatureHelp result = null; signatureRequestContext.Setup(rc => rc.SendResult(It.IsAny <SignatureHelp>())) .Returns <SignatureHelp>((signature) => { result = signature; return(Task.FromResult(0)); }); signatureRequestContext.Setup(rc => rc.SendError(It.IsAny <string>(), It.IsAny <int>())).Returns(Task.FromResult(0)); langService.CurrentWorkspaceSettings.SqlTools.IntelliSense.EnableIntellisense = true; await langService.HandleDidChangeLanguageFlavorNotification(new LanguageFlavorChangeParams { Uri = textDocument.TextDocument.Uri, Language = LanguageService.SQL_LANG.ToLower(), Flavor = "NotMSSQL" }, null); await langService.HandleSignatureHelpRequest(textDocument, signatureRequestContext.Object); // verify that the response was sent with a null response value signatureRequestContext.Verify(m => m.SendResult(It.IsAny <SignatureHelp>()), Times.Once()); Assert.Null(result); signatureRequestContext.Verify(m => m.SendError(It.IsAny <string>(), It.IsAny <int>()), Times.Never()); }
public async Task GetsParameterHintsOnCommand() { await this.SendOpenFileEvent("TestFiles\\FindReferences.ps1"); SignatureHelp signatureHelp = await this.SendRequest( SignatureHelpRequest.Type, new TextDocumentPositionParams { TextDocument = new TextDocumentIdentifier { Uri = "TestFiles\\FindReferences.ps1" }, Position = new Position { Line = 12, Character = 14 } }); Assert.NotNull(signatureHelp); Assert.Equal(1, signatureHelp.Signatures.Length); Assert.Equal(2, signatureHelp.Signatures[0].Parameters.Length); Assert.Equal( "Write-Output [-InputObject] <psobject[]> [-NoEnumerate] [<CommonParameters>]", signatureHelp.Signatures[0].Label); }
public async Task NonUniqueNameTest() { string content = @"x <- select()"; using (var hostScript = new RHostScript(Workflow.RSessions)) { //await Workflow.RSession.ExecuteAsync("install.packages('dplyr')"); var session = await TriggerSessionAsync(content, 12); var parametersInfo = SignatureHelp.GetParametersInfoFromBuffer(session.Ast, session.TextBuffer.CurrentSnapshot, 10); session.ApplicableSpan.Should().NotBeNull(); session.QuickInfoContent.Should().BeEmpty(); await Workflow.RSession.ExecuteAsync("library(MASS)"); EventsPump.DoEvents(500); session = await TriggerSessionAsync(content, 12); session.ApplicableSpan.Should().NotBeNull(); session.QuickInfoContent.Should().ContainSingle().Which.ToString().Should().StartWith("select(formula"); await Workflow.RSession.ExecuteAsync("library(dplyr)"); EventsPump.DoEvents(500); session = await TriggerSessionAsync(content, 12); session.ApplicableSpan.Should().NotBeNull(); session.QuickInfoContent.Should().ContainSingle().Which.ToString().Should().StartWith("select(.data"); } }
public void SimpleTest(string expected) { var model = new SignatureHelp() { ActiveParameter = 1, ActiveSignature = 2, Signatures = new[] { new SignatureInformation() { Documentation = "ab", Label = "ab", Parameters = new[] { new ParameterInformation() { Documentation = "param", Label = "param" } } } } }; var result = Fixture.SerializeObject(model); result.Should().Be(expected); var deresult = JsonConvert.DeserializeObject <SignatureHelp>(expected); deresult.ShouldBeEquivalentTo(model); }
public async Task LoadUnloadPackageTest() { string content = @"do()"; using (var hostScript = new RHostScript(Workflow.RSessions)) { //await Workflow.RSession.ExecuteAsync("install.packages('dplyr')"); var session = await TriggerSessionAsync(content, 3); var parametersInfo = SignatureHelp.GetParametersInfoFromBuffer(session.Ast, session.TextBuffer.CurrentSnapshot, 10); session.ApplicableSpan.Should().NotBeNull(); session.QuickInfoContent.Should().BeEmpty(); await Workflow.RSession.ExecuteAsync("library(dplyr)"); session = await TriggerSessionAsync(content, 3); session.ApplicableSpan.Should().NotBeNull(); session.QuickInfoContent.Should().ContainSingle().Which.ToString().Should().StartWith("do(.data"); await Workflow.RSession.ExecuteAsync("detach(\"package:dplyr\", unload = TRUE)"); EventsPump.DoEvents(1000); session = await TriggerSessionAsync(content, 3); session.QuickInfoContent.Should().BeEmpty(); } }
public async Task <SignatureHelp> SignatureHelp(IEditor editor, List <UnsavedFile> unsavedFiles, int offset, string methodName) { SignatureHelp result = null; var clangUnsavedFiles = new List <ClangUnsavedFile>(); foreach (var unsavedFile in unsavedFiles) { if (Platform.CompareFilePath(unsavedFile.FileName, editor.SourceFile.Location) != 0) { clangUnsavedFiles.Add(new ClangUnsavedFile(unsavedFile.FileName, unsavedFile.Contents)); } } var symbols = await GetSymbolsAsync(editor, unsavedFiles, methodName); if (symbols.Count > 0) { result = new SignatureHelp(offset - methodName.Length); foreach (var symbol in symbols) { result.Signatures.Add(SignatureFromSymbol(symbol)); } } return(result); }
public async Task ParameterTest_ComputeCurrentParameter02() { await PackageIndexUtility.GetFunctionInfoAsync(FunctionIndex, "legend"); REditorSettings.PartialArgumentNameMatch = true; ITextBuffer textBuffer = new TextBufferMock("legend(bty=1, lt=3)", RContentTypeDefinition.ContentType); SignatureHelpSource source = new SignatureHelpSource(textBuffer, EditorShell); SignatureHelpSessionMock session = new SignatureHelpSessionMock(textBuffer, 0); TextViewMock textView = session.TextView as TextViewMock; List <ISignature> signatures = new List <ISignature>(); using (var tree = new EditorTree(textBuffer, EditorShell)) { tree.Build(); using (var document = new EditorDocumentMock(tree)) { session.TrackingPoint = new TrackingPointMock(textBuffer, 7, PointTrackingMode.Positive, TrackingFidelityMode.Forward); tree.TakeThreadOwnerShip(); await source.AugmentSignatureHelpSessionAsync(session, signatures, tree.AstRoot); signatures.Should().ContainSingle(); textView.Caret = new TextCaretMock(textView, 8); SignatureHelp sh = signatures[0] as SignatureHelp; int index = sh.ComputeCurrentParameter(tree.TextSnapshot, tree.AstRoot, 8); index.Should().Be(11); textView.Caret = new TextCaretMock(textView, 15); index = sh.ComputeCurrentParameter(tree.TextSnapshot, tree.AstRoot, 15); index.Should().Be(6); } } }
public void SimpleTest(string expected) { var model = new SignatureHelp { ActiveParameter = 1, ActiveSignature = 2, Signatures = new[] { new SignatureInformation { Documentation = "ab", Label = "ab", Parameters = new[] { new ParameterInformation { Documentation = "param", Label = "param" } } } } }; var result = Fixture.SerializeObject(model); result.Should().Be(expected); var deresult = new LspSerializer(ClientVersion.Lsp3).DeserializeObject <SignatureHelp>(expected); deresult.Should().BeEquivalentTo(model, x => x.UsingStructuralRecordEquality()); }
public void ParameterTest01() { string content = @"x <- foo(a,b,c,d)"; AstRoot ast = RParser.Parse(content); ITextBuffer textBuffer = new TextBufferMock(content, RContentTypeDefinition.ContentType); ParameterInfo parametersInfo = SignatureHelp.GetParametersInfoFromBuffer(ast, textBuffer.CurrentSnapshot, 10); parametersInfo.Should().NotBeNull() .And.HaveFunctionCall() .And.HaveFunctionName("foo") .And.HaveParameterIndex(0) .And.HaveSignatureEnd(17); parametersInfo = SignatureHelp.GetParametersInfoFromBuffer(ast, textBuffer.CurrentSnapshot, 11); parametersInfo.Should().HaveParameterIndex(1); parametersInfo = SignatureHelp.GetParametersInfoFromBuffer(ast, textBuffer.CurrentSnapshot, 12); parametersInfo.Should().HaveParameterIndex(1); parametersInfo = SignatureHelp.GetParametersInfoFromBuffer(ast, textBuffer.CurrentSnapshot, 13); parametersInfo.Should().HaveParameterIndex(2); parametersInfo = SignatureHelp.GetParametersInfoFromBuffer(ast, textBuffer.CurrentSnapshot, 14); parametersInfo.Should().HaveParameterIndex(2); parametersInfo = SignatureHelp.GetParametersInfoFromBuffer(ast, textBuffer.CurrentSnapshot, 15); parametersInfo.Should().HaveParameterIndex(3); parametersInfo = SignatureHelp.GetParametersInfoFromBuffer(ast, textBuffer.CurrentSnapshot, 16); parametersInfo.Should().HaveParameterIndex(3); }
public async Task <SignatureHelp> SignatureHelp(ISourceFile file, UnsavedFile buffer, List <UnsavedFile> unsavedFiles, int line, int column, int offset, string methodName) { SignatureHelp result = null; var clangUnsavedFiles = new List <ClangUnsavedFile>(); unsavedFiles.Add(buffer); foreach (var unsavedFile in unsavedFiles) { if (Platform.CompareFilePath(unsavedFile.FileName, buffer.FileName) != 0) { clangUnsavedFiles.Add(new ClangUnsavedFile(unsavedFile.FileName, unsavedFile.Contents)); } } var symbols = await GetSymbolsAsync(file, unsavedFiles, methodName); if (symbols.Count > 0) { result = new SignatureHelp(); result.Offset = offset; foreach (var symbol in symbols) { result.Signatures.Add(SignatureFromSymbol(symbol)); } } return(result); }
/// <summary> /// Reads the current signature help test, located in the TestSignatures directory, deserializes and /// asserts and compares its value with <see cref="SignatureHelp"/>, then increments the index, /// <see cref="SignatureHelpId"/>. /// </summary> /// <param name="signatureHelp"> /// Signature help value to test /// </param> private void CheckSignatureHelpTest(SignatureHelp signatureHelp, int helpId) { var directory = _signatureHelpDirectory; var signatureHelpPath = Path.Join(_signatureHelpDirectory, helpId + ".json"); if (File.Exists(signatureHelpPath)) { var expectedSignatureHelp = ReadSignatureHelpFile(signatureHelpPath); var actualSignatureHelp = SerializeSignatureHelp(signatureHelp); if (RegenerateSignatureHelp) { if (!JToken.DeepEquals(actualSignatureHelp, expectedSignatureHelp)) { WriteSignatureHelp(signatureHelpPath, signatureHelp); } } else { Assert.True(JToken.DeepEquals(actualSignatureHelp, expectedSignatureHelp)); } } else { Assert.True(RegenerateSignatureHelp, "Snapshot regeneration must be explicitly enabled to make new snapshot tests. Target path is: " + signatureHelpPath); if (!Directory.Exists(directory)) { Directory.CreateDirectory(directory); } WriteSignatureHelp(signatureHelpPath, signatureHelp); } }
public SignatureHelp OnTextDocumentSignatureHelp(JToken arg) { this.traceSource.TraceEvent(TraceEventType.Information, 0, $"Received: {arg}"); SignatureHelp retVal = null; if (callCounter < 4) { retVal = new SignatureHelp() { ActiveParameter = callCounter % 2, ActiveSignature = callCounter / 2, Signatures = new SignatureInformation[] { new SignatureInformation() { Label = "foo(param1, param2)", Parameters = new ParameterInformation[] { new ParameterInformation() { Label = "param1" }, new ParameterInformation() { Label = "param2" } }, }, new SignatureInformation() { Label = "foo(param1, param2, param3)", Parameters = new ParameterInformation[] { new ParameterInformation() { Label = "param1" }, new ParameterInformation() { Label = "param2" }, new ParameterInformation() { Label = "param3" } }, } }, }; } callCounter = (callCounter + 1) % 5; this.traceSource.TraceEvent(TraceEventType.Information, 0, $"Sent: {JToken.FromObject(retVal)}"); return(retVal); }
public SignatureHelp BuildSignatureHelp() { var result = new SignatureHelp(Receiver.SpanStart); int activeParameter = 0; foreach (var comma in Separators) { if (comma.Span.Start > Position) { break; } activeParameter += 1; } var types = ArgumentTypes; ISymbol throughSymbol = null; ISymbol throughType = null; var bestScore = int.MinValue; Signature bestScoredItem = null; var methodGroup = SemanticModel.GetMemberGroup(Receiver).OfType <IMethodSymbol>(); if (Receiver is MemberAccessExpressionSyntax) { var throughExpression = ((MemberAccessExpressionSyntax)Receiver).Expression; throughSymbol = SemanticModel.GetSpeculativeSymbolInfo(Position, throughExpression, SpeculativeBindingOption.BindAsExpression).Symbol; throughType = SemanticModel.GetSpeculativeTypeInfo(Position, throughExpression, SpeculativeBindingOption.BindAsTypeOrNamespace).Type; var includeInstance = throughSymbol != null && !(throughSymbol is ITypeSymbol); var includeStatic = (throughSymbol is INamedTypeSymbol) || throughType != null; methodGroup = methodGroup.Where(m => (m.IsStatic && includeStatic) || (!m.IsStatic && includeInstance)); } else if (Receiver is SimpleNameSyntax && IsInStaticContext) { methodGroup = methodGroup.Where(m => m.IsStatic); } foreach (var methodOverload in methodGroup) { var signature = BuildSignature(methodOverload); result.Signatures.Add(signature); var score = InvocationScore(methodOverload, types); if (score > bestScore) { bestScore = score; bestScoredItem = signature; } } result.ActiveSignature = result.Signatures.IndexOf(bestScoredItem); result.ActiveParameter = activeParameter; return(result); }
public SignatureHelp GetSignatureHelp(Position position, PageInfoStore store) { var node = TraceNode(position); Node lastNode = null; while (node != null) { switch (node) { case Template template: var templateName = MwParserUtility.NormalizeTitle(template.Name); if (string.IsNullOrEmpty(templateName)) { return(null); } // i.e. redirect target var redirectSource = store.TryGetTransclusionPageInfo(templateName); if (redirectSource == null) { return(null); } var templateInfo = store.ResolveRedirectTarget(redirectSource); if (templateInfo == null) { templateInfo = redirectSource; redirectSource = null; } var help = new SignatureHelp { Signatures = new[] { templateInfo.ToSignatureInformation(redirectSource) }, ActiveSignature = 0, ActiveParameter = -1, }; if (lastNode is TemplateArgument arg) { // Magic Words are always positional, while it can fake "named arguments" if (templateInfo.Type == PageType.MagicWord) { var pos = template.Arguments.IndexOf(arg); help.ActiveParameter = pos; } else { var argName = arg.ArgumentName(); help.ActiveParameter = templateInfo.Arguments.IndexOf(p => p.Name == argName); } } return(help); case WikiLink wikiLink: return(null); } lastNode = node; node = node.ParentNode; } return(null); }
public IReadOnlyCollection <RCompletion> GetEntries(RCompletionContext context) { List <RCompletion> completions = new List <RCompletion>(); ImageSource functionGlyph = GlyphService.GetGlyph(StandardGlyphGroup.GlyphGroupValueType, StandardGlyphItem.GlyphItemPublic); // Safety checks FunctionCall funcCall = context.AstRoot.GetNodeOfTypeFromPosition <FunctionCall>(context.Position); if (funcCall == null || funcCall.OpenBrace == null || funcCall.Arguments == null) { return(completions); } if (context.Position < funcCall.OpenBrace.End || context.Position >= funcCall.SignatureEnd) { return(completions); } // Retrieve parameter positions from the current text buffer snapshot ParameterInfo parametersInfo = SignatureHelp.GetParametersInfoFromBuffer(context.AstRoot, context.TextBuffer.CurrentSnapshot, context.Position); if (parametersInfo == null) { return(completions); } // Get collection of function signatures from documentation (parsed RD file) IFunctionInfo functionInfo = FunctionIndex.GetFunctionInfo(parametersInfo.FunctionName, o => { }, context.Session.TextView); if (functionInfo == null) { return(completions); } // Collect parameter names from all signatures IEnumerable <KeyValuePair <string, IArgumentInfo> > arguments = new Dictionary <string, IArgumentInfo>(); foreach (ISignatureInfo signature in functionInfo.Signatures) { var args = signature.Arguments.ToDictionary(x => x.Name); arguments = arguments.Union(args); } // Add names of arguments that are not yet specified to the completion // list with '=' sign so user can tell them from function names. IEnumerable <string> declaredArguments = funcCall.Arguments.Where(x => x is NamedArgument).Select(x => ((NamedArgument)x).Name); IEnumerable <KeyValuePair <string, IArgumentInfo> > possibleArguments = arguments.Where(x => x.Key != "..." && !declaredArguments.Contains(x.Key)); foreach (KeyValuePair <string, IArgumentInfo> arg in possibleArguments) { string displayText = arg.Key + " ="; string insertionText = arg.Key + " = "; completions.Add(new RCompletion(displayText, insertionText, arg.Value.Description, functionGlyph)); } return(completions); }
public void Signature(string content, int position, string expectedFunctionName, int expectedSignatureEnd) { AstRoot ast = RParser.Parse(content); int signatureEnd; string functionName = SignatureHelp.GetFunctionNameFromBuffer(ast, ref position, out signatureEnd); functionName.Should().Be(expectedFunctionName); signatureEnd.Should().Be(expectedSignatureEnd); }
public static void NormalizeSignatureData(this SignatureHelp signatureHelp) { foreach (var signature in signatureHelp.Signatures) { signature.ConvertXmlDocumentation(); signature.DetectReturnType(); signature.DetectParameterTypes(); } }
internal bool AugmentQuickInfoSession(AstRoot ast, int position, IQuickInfoSession session, IList <object> quickInfoContent, out ITrackingSpan applicableToSpan, Action <object, string> retriggerAction, string packageName) { int signatureEnd = position; applicableToSpan = null; string functionName = SignatureHelp.GetFunctionNameFromBuffer(ast, ref position, out signatureEnd); if (!string.IsNullOrEmpty(functionName)) { ITextSnapshot snapshot = session.TextView.TextBuffer.CurrentSnapshot; position = Math.Min(signatureEnd, position); int start = Math.Min(position, snapshot.Length); int end = Math.Min(signatureEnd, snapshot.Length); applicableToSpan = snapshot.CreateTrackingSpan(Span.FromBounds(start, end), SpanTrackingMode.EdgeInclusive); packageName = packageName ?? _packageName; _packageName = null; var functionInfo = FunctionIndex.GetFunctionInfo(functionName, packageName, retriggerAction, session); if (functionInfo != null && functionInfo.Signatures != null) { foreach (ISignatureInfo sig in functionInfo.Signatures) { string signatureString = sig.GetSignatureString(functionName); int wrapLength = Math.Min(SignatureInfo.MaxSignatureLength, signatureString.Length); string text; if (string.IsNullOrWhiteSpace(functionInfo.Description)) { text = string.Empty; } else { /// VS may end showing very long tooltip so we need to keep /// description reasonably short: typically about /// same length as the function signature. text = signatureString + "\r\n" + functionInfo.Description.Wrap(wrapLength); } if (text.Length > 0) { quickInfoContent.Add(text); return(true); } } } } return(false); }
public void NoSignaturesTest(string expected) { var model = new SignatureHelp(); var result = Fixture.SerializeObject(model); result.Should().Be(expected); var deresult = new LspSerializer(ClientVersion.Lsp3).DeserializeObject <SignatureHelp>(expected); deresult.Should().BeEquivalentTo(model, x => x.UsingStructuralRecordEquality()); }
public void PushMethod(SignatureHelp methodInfo) { if (CurrentMethod != null) { methodStack.Push(CurrentMethod); } CurrentMethod = new SignatureHelpViewModel(methodInfo); IsVisible = true; }
public void ParameterTest03() { string content = @"x <- foo(,,"; AstRoot ast = RParser.Parse(content); ITextBuffer textBuffer = new TextBufferMock(content, RContentTypeDefinition.ContentType); var parametersInfo = SignatureHelp.GetParametersInfoFromBuffer(ast, textBuffer.CurrentSnapshot, 11); parametersInfo.Should().HaveParameterIndex(2); }
private int GetCurrentParameterIndex(SignatureHelp sh, IParameter parameter) { for (int i = 0; i < sh.Parameters.Count; i++) { if (sh.Parameters[i] == parameter) { return(i); } } return(-1); }
public async Task AliasTest() { // 'as.Date.character' RD contains no function info for 'as.Date.character', but the one for 'as.Date' // and as.Date.character appears as alias. We verify as.Date.character is shown in the signature info. string content = @"x <- as.Date.character(x)"; var session = await TriggerSessionAsync(content, 23); var parametersInfo = SignatureHelp.GetParametersInfoFromBuffer(session.Ast, session.TextBuffer.CurrentSnapshot, 10); session.ApplicableSpan.Should().NotBeNull(); session.QuickInfoContent.Should().ContainSingle() .Which.ToString().Should().StartWith("as.Date.character(x, ...)"); }
public void PushMethod(SignatureHelp methodInfo) { CurrentMethod = new SignatureHelpViewModel(methodInfo); methodStack.Insert(0, CurrentMethod.Model); methodVmStack.Insert(0, CurrentMethod); IsVisible = true; if (IoC.Get <IShell>().DebugMode) { IoC.Get <IConsole>().WriteLine($"[Signature Help] - PushMethod - {CurrentMethod.SelectedSignature.Name}"); } }
public void GetSignatureHelpReturnsNullIfParseInfoNotInitialized() { // Given service doesn't have parseinfo intialized for a document const string docContent = "SELECT * FROM sys.objects"; LanguageService service = TestObjects.GetTestLanguageService(); var scriptFile = new ScriptFile(); scriptFile.SetFileContents(docContent); // When requesting SignatureHelp SignatureHelp signatureHelp = service.GetSignatureHelp(CreateDummyDocPosition(), scriptFile); // Then null is returned as no parse info can be used to find the signature Assert.Null(signatureHelp); }
async Task <SignatureHelp> ComputeSignatureHelpAsync( int position, SourceText sourceText, CancellationToken cancellationToken) { var signatureHelp = new SignatureHelp(); if (position <= 0) { return(signatureHelp); } var document = compilationWorkspace.GetSubmissionDocument(sourceText.Container); var root = await document.GetSyntaxRootAsync(cancellationToken); var syntaxToken = root.FindToken(position); var semanticModel = await document.GetSemanticModelAsync(cancellationToken); var currentNode = syntaxToken.Parent; do { var creationExpression = currentNode as ObjectCreationExpressionSyntax; if (creationExpression != null && creationExpression.ArgumentList.Span.Contains(position)) { return(CreateMethodGroupSignatureHelp( creationExpression, creationExpression.ArgumentList, position, semanticModel)); } var invocationExpression = currentNode as InvocationExpressionSyntax; if (invocationExpression != null && invocationExpression.ArgumentList.Span.Contains(position)) { return(CreateMethodGroupSignatureHelp( invocationExpression.Expression, invocationExpression.ArgumentList, position, semanticModel)); } currentNode = currentNode.Parent; } while (currentNode != null); return(signatureHelp); }
public async Task CacheTest(bool cached) { if (!cached) { Support.Help.Packages.PackageIndex.ClearCache(); } string content = @"x <- as.matrix(x)"; var session = await TriggerSessionAsync(content, 15); var parametersInfo = SignatureHelp.GetParametersInfoFromBuffer(session.Ast, session.TextBuffer.CurrentSnapshot, 10); session.ApplicableSpan.Should().NotBeNull(); session.QuickInfoContent.Should().ContainSingle() .Which.ToString().Should().StartWith("as.matrix(x, ...)"); }
static SignatureHelp CreateMethodGroupSignatureHelp( ExpressionSyntax expression, ArgumentListSyntax argumentList, int position, SemanticModel semanticModel) { var signatureHelp = new SignatureHelp(); // Happens for object initializers with no preceding parens, as soon as user types comma if (argumentList == null) { return(signatureHelp); } int currentArg; if (TryGetCurrentArgumentIndex(argumentList, position, out currentArg)) { signatureHelp.ActiveParameter = currentArg; } var symbolInfo = semanticModel.GetSymbolInfo(expression); var bestGuessMethod = symbolInfo.Symbol as IMethodSymbol; var methods = semanticModel .GetMemberGroup(expression) .OfType <IMethodSymbol> () .ToArray(); var signatures = new List <SignatureInformation> (); for (var i = 0; i < methods.Length; i++) { if (methods [i] == bestGuessMethod) { signatureHelp.ActiveSignature = i; } var signatureInfo = new SignatureInformation(methods [i]); signatures.Add(signatureInfo); } signatureHelp.Signatures = signatures.ToArray(); return(signatureHelp); }
public async Task HandleRequestAsync_CSharpProjection_InvokesCSharpLanguageServer_ReturnsItem() { // Arrange var called = false; var expectedResult = new SignatureHelp(); var documentManager = new TestDocumentManager(); documentManager.AddDocument(Uri, Mock.Of <LSPDocumentSnapshot>()); var virtualCSharpUri = new Uri("C:/path/to/file.razor.g.cs"); var requestInvoker = new Mock <LSPRequestInvoker>(MockBehavior.Strict); requestInvoker .Setup(r => r.ReinvokeRequestOnServerAsync <TextDocumentPositionParams, SignatureHelp>(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <TextDocumentPositionParams>(), It.IsAny <CancellationToken>())) .Callback <string, string, TextDocumentPositionParams, CancellationToken>((method, serverContentType, definitionParams, ct) => { Assert.Equal(Methods.TextDocumentSignatureHelpName, method); Assert.Equal(RazorLSPConstants.CSharpContentTypeName, serverContentType); called = true; }) .Returns(Task.FromResult(expectedResult)); var projectionResult = new ProjectionResult() { LanguageKind = RazorLanguageKind.CSharp, }; var projectionProvider = new Mock <LSPProjectionProvider>(MockBehavior.Strict); projectionProvider.Setup(p => p.GetProjectionAsync(It.IsAny <LSPDocumentSnapshot>(), It.IsAny <Position>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(projectionResult)); var signatureHelpHandler = new SignatureHelpHandler(requestInvoker.Object, documentManager, projectionProvider.Object); var signatureHelpRequest = new TextDocumentPositionParams() { TextDocument = new TextDocumentIdentifier() { Uri = Uri }, Position = new Position(10, 5) }; // Act var result = await signatureHelpHandler.HandleRequestAsync(signatureHelpRequest, new ClientCapabilities(), CancellationToken.None).ConfigureAwait(false); // Assert Assert.True(called); Assert.Equal(expectedResult, result); }
public async Task <SignatureHelp> SignatureHelp(ISourceFile file, UnsavedFile buffer, List <UnsavedFile> unsavedFiles, int line, int column, int offset, string methodName) { SignatureHelp result = null; var dataAssociation = GetAssociatedData(file); result = await dataAssociation.Solution.Server.SignatureHelp(file.FilePath, unsavedFiles.FirstOrDefault()?.Contents, line, column); if (result != null) { result.NormalizeSignatureData(); result.Offset = offset; } return(result); }