public async Task CanSendDefinitionRequest()
        {
            string scriptPath = NewTestFile(@"
function CanSendDefinitionRequest {

}

CanSendDefinitionRequest
");

            LocationOrLocationLinks locationOrLocationLinks =
                await LanguageClient.SendRequest <LocationOrLocationLinks>(
                    "textDocument/definition",
                    new DefinitionParams
            {
                TextDocument = new TextDocumentIdentifier
                {
                    Uri = new Uri(scriptPath)
                },
                Position = new Position
                {
                    Line      = 5,
                    Character = 2
                }
            });

            LocationOrLocationLink locationOrLocationLink =
                Assert.Single(locationOrLocationLinks);

            Assert.Equal(1, locationOrLocationLink.Location.Range.Start.Line);
            Assert.Equal(9, locationOrLocationLink.Location.Range.Start.Character);
            Assert.Equal(1, locationOrLocationLink.Location.Range.End.Line);
            Assert.Equal(33, locationOrLocationLink.Location.Range.End.Character);
        }
        public async Task <LocationOrLocationLinks> Handle(DefinitionParams request, CancellationToken cancellationToken)
        {
            _router.Window.LogMessage(new LogMessageParams()
            {
                Type    = MessageType.Log,
                Message = "Go to definition request at line: " + (request.Position.Line + 1),
            });

            _threadManager.AssertBackgroundThread();

            var document = await Task.Factory.StartNew(
                () =>
            {
                _snapshotManager.TryResolveDocument(request.TextDocument.Uri.AbsolutePath, out var doc);
                return(doc);
            },
                CancellationToken.None,
                TaskCreationOptions.None,
                _threadManager.ForegroundScheduler);

            var syntaxTree = await document.GetSyntaxTreeAsync();

            var child = syntaxTree.Root.GetNodeAt((int)request.Position.Line, (int)request.Position.Character);

            if (child.Parent is MethodNode && (child is InputNode || child is OutputNode))
            {
                //var declaringTypeNode = FindDeclaringTypeNode(syntaxTree.Root, child.Content);
                var declaringTypeNode = syntaxTree.Root.Messages.SingleOrDefault(c => c.Name == child.Content).NameNode;
                if (declaringTypeNode != null)
                {
                    var declaringTypeNodeLocation = new LocationOrLocationLink(
                        new Location()
                    {
                        Range = new Range(
                            new Position(declaringTypeNode.StartLine, declaringTypeNode.StartCol),
                            new Position(declaringTypeNode.EndLine, declaringTypeNode.EndCol)),
                        Uri = request.TextDocument.Uri,
                    });
                    var locations = new LocationOrLocationLinks(declaringTypeNodeLocation);
                    return(locations);
                }
            }

            var emptyLocations = new LocationOrLocationLinks();

            return(emptyLocations);
        }
Exemple #3
0
        public async Task <LocationOrLocationLinks> Handle(DefinitionParams definitionParams, CancellationToken token)
        {
            var links = _languageServer.LastParse?.ScriptFromUri(definitionParams.TextDocument.Uri)?.GetDefinitionLinks();

            if (links == null)
            {
                return(new LocationOrLocationLinks());
            }

            links = links.Where(link => ((DocRange)link.OriginSelectionRange).IsInside(definitionParams.Position)).ToArray();
            LocationOrLocationLink[] items = new LocationOrLocationLink[links.Length];
            for (int i = 0; i < items.Length; i++)
            {
                items[i] = new LocationOrLocationLink(links[i]);
            }

            return(new LocationOrLocationLinks(items));
        }