public async Task TestGetSignatureHelpAsync()
        {
            var markup =
                @"class A
{
    void M()
    {
        M2({|caret:|}'a');
    }
    /// <summary>
    /// M2 is a method.
    /// </summary>
    int M2(string a)
    {
        return 1;
    }

}";

            using var testLspServer = await CreateTestLspServerAsync(markup);

            var expected = new LSP.SignatureHelp()
            {
                ActiveParameter = 0,
                ActiveSignature = 0,
                Signatures      = new LSP.SignatureInformation[] { CreateSignatureInformation("int A.M2(string a)", "M2 is a method.", "a", "") }
            };

            var results = await RunGetSignatureHelpAsync(testLspServer, testLspServer.GetLocations("caret").Single());

            AssertJsonEquals(expected, results);
        }
Example #2
0
        public async Task TestGetSignatureHelpAsync()
        {
            var markup =
                @"class A
{
    void M()
    {
        M2({|caret:|}'a');
    }
    /// <summary>
    /// M2 is a method.
    /// </summary>
    int M2(string a)
    {
        return 1;
    }

}";

            using var workspace = CreateTestWorkspace(markup, out var locations);
            var expected = new LSP.SignatureHelp()
            {
                ActiveParameter = 0,
                ActiveSignature = 0,
                Signatures      = new LSP.SignatureInformation[] { CreateSignatureInformation("int A.M2(string a)", "M2 is a method.", "a", "") }
            };

            var results = await RunGetSignatureHelpAsync(workspace.CurrentSolution, locations["caret"].Single());

            AssertJsonEquals(expected, results);
        }
Example #3
0
        public override async Task <LSP.SignatureHelp?> HandleRequestAsync(
            LSP.TextDocumentPositionParams request,
            RequestContext context,
            CancellationToken cancellationToken
            )
        {
            var document = context.Document;

            if (document == null)
            {
                return(null);
            }

            var position = await document
                           .GetPositionFromLinePositionAsync(
                ProtocolConversions.PositionToLinePosition(request.Position),
                cancellationToken
                )
                           .ConfigureAwait(false);

            var providers = _allProviders.Where(
                p => p.Metadata.Language == document.Project.Language
                );
            var triggerInfo = new SignatureHelpTriggerInfo(
                SignatureHelpTriggerReason.InvokeSignatureHelpCommand
                );

            foreach (var provider in providers)
            {
                var items = await provider.Value
                            .GetItemsAsync(document, position, triggerInfo, cancellationToken)
                            .ConfigureAwait(false);

                if (items != null)
                {
                    var sigInfos = new ArrayBuilder <LSP.SignatureInformation>();

                    foreach (var item in items.Items)
                    {
                        LSP.SignatureInformation sigInfo;
                        if (context.ClientCapabilities?.HasVisualStudioLspCapability() == true)
                        {
                            sigInfo = new LSP.VSSignatureInformation
                            {
                                ColorizedLabel = GetSignatureClassifiedText(item)
                            };
                        }
                        else
                        {
                            sigInfo = new LSP.SignatureInformation();
                        }

                        sigInfo.Label         = GetSignatureText(item);
                        sigInfo.Documentation = new LSP.MarkupContent
                        {
                            Kind  = LSP.MarkupKind.PlainText,
                            Value = item.DocumentationFactory(cancellationToken).GetFullText()
                        };
                        sigInfo.Parameters = item.Parameters
                                             .Select(
                            p =>
                            new LSP.ParameterInformation
                        {
                            Label         = p.Name,
                            Documentation = new LSP.MarkupContent
                            {
                                Kind  = LSP.MarkupKind.PlainText,
                                Value = p.DocumentationFactory(cancellationToken)
                                        .GetFullText()
                            }
                        }
                            )
                                             .ToArray();
                        sigInfos.Add(sigInfo);
                    }

                    var sigHelp = new LSP.SignatureHelp
                    {
                        ActiveSignature = GetActiveSignature(items),
                        ActiveParameter = items.ArgumentIndex,
                        Signatures      = sigInfos.ToArrayAndFree()
                    };

                    return(sigHelp);
                }
            }

            return(null);
        }