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);
}