257 lines
12 KiB
Python
257 lines
12 KiB
Python
# Python imports
|
|
|
|
# Lib imports
|
|
|
|
# Application imports
|
|
from . import lsp_structs
|
|
|
|
|
|
|
|
class LspClient(object):
|
|
def __init__(self, lsp_endpoint):
|
|
"""
|
|
Constructs a new LspClient instance.
|
|
|
|
:param lsp_endpoint: TODO
|
|
"""
|
|
|
|
self.lsp_endpoint = lsp_endpoint
|
|
|
|
def initialize(self, processId, rootPath, rootUri, initializationOptions, capabilities, trace, workspaceFolders):
|
|
"""
|
|
The initialize request is sent as the first request from the client to the server. If the server receives a request or notification
|
|
before the initialize request it should act as follows:
|
|
|
|
1. For a request the response should be an error with code: -32002. The message can be picked by the server.
|
|
2. Notifications should be dropped, except for the exit notification. This will allow the exit of a server without an initialize request.
|
|
|
|
Until the server has responded to the initialize request with an InitializeResult, the client must not send any additional requests or
|
|
notifications to the server. In addition the server is not allowed to send any requests or notifications to the client until it has responded
|
|
with an InitializeResult, with the exception that during the initialize request the server is allowed to send the notifications window/showMessage,
|
|
window/logMessage and telemetry/event as well as the window/showMessageRequest request to the client.
|
|
|
|
The initialize request may only be sent once.
|
|
|
|
:param int processId: The process Id of the parent process that started the server. Is null if the process has not been started by another process.
|
|
If the parent process is not alive then the server should exit (see exit notification) its process.
|
|
:param str rootPath: The rootPath of the workspace. Is null if no folder is open. Deprecated in favour of rootUri.
|
|
:param DocumentUri rootUri: The rootUri of the workspace. Is null if no folder is open. If both `rootPath` and `rootUri` are set
|
|
`rootUri` wins.
|
|
:param any initializationOptions: User provided initialization options.
|
|
:param ClientCapabilities capabilities: The capabilities provided by the client (editor or tool).
|
|
:param Trace trace: The initial trace setting. If omitted trace is disabled ('off').
|
|
:param list workspaceFolders: The workspace folders configured in the client when the server starts. This property is only available if the client supports workspace folders.
|
|
It can be `null` if the client supports workspace folders but none are configured.
|
|
"""
|
|
|
|
self.lsp_endpoint.start()
|
|
return self.lsp_endpoint.call_method("initialize",
|
|
processId = processId,
|
|
rootPath = rootPath,
|
|
rootUri = rootUri,
|
|
initializationOptions = initializationOptions,
|
|
capabilities = capabilities,
|
|
trace = trace,
|
|
workspaceFolders = workspaceFolders
|
|
)
|
|
|
|
def initialized(self):
|
|
"""
|
|
The initialized notification is sent from the client to the server after the client received the result of the initialize request
|
|
but before the client is sending any other request or notification to the server. The server can use the initialized notification
|
|
for example to dynamically register capabilities. The initialized notification may only be sent once.
|
|
"""
|
|
|
|
self.lsp_endpoint.send_notification("initialized")
|
|
|
|
def shutdown(self):
|
|
"""
|
|
"""
|
|
|
|
return self.lsp_endpoint.call_method("shutdown")
|
|
|
|
def exit(self):
|
|
"""
|
|
"""
|
|
|
|
self.lsp_endpoint.send_notification("exit")
|
|
self.lsp_endpoint.stop()
|
|
|
|
|
|
def didOpen(self, textDocument):
|
|
"""
|
|
The document open notification is sent from the client to the server to signal newly opened text documents. The document's truth is
|
|
now managed by the client and the server must not try to read the document's truth using the document's uri. Open in this sense
|
|
means it is managed by the client. It doesn't necessarily mean that its content is presented in an editor. An open notification must
|
|
not be sent more than once without a corresponding close notification send before. This means open and close notification must be
|
|
balanced and the max open count for a particular textDocument is one. Note that a server's ability to fulfill requests is independent
|
|
of whether a text document is open or closed.
|
|
|
|
The DidOpenTextDocumentParams contain the language id the document is associated with. If the language Id of a document changes, the
|
|
client needs to send a textDocument/didClose to the server followed by a textDocument/didOpen with the new language id if the server
|
|
handles the new language id as well.
|
|
|
|
:param TextDocumentItem textDocument: The document that was opened.
|
|
"""
|
|
|
|
return self.lsp_endpoint.send_notification("textDocument/didOpen", textDocument = textDocument)
|
|
|
|
def didSave(self, textDocument):
|
|
"""
|
|
:param TextDocumentIdentifier textDocument: The document that was saved.
|
|
"""
|
|
|
|
return self.lsp_endpoint.send_notification("textDocument/didSave", textDocument = textDocument)
|
|
|
|
def didClose(self, textDocument):
|
|
"""
|
|
:param TextDocumentIdentifier textDocument: The document that was closed.
|
|
"""
|
|
return self.lsp_endpoint.send_notification("textDocument/didClose", textDocument = textDocument)
|
|
|
|
def didChange(self, textDocument, contentChanges):
|
|
"""
|
|
The document change notification is sent from the client to the server to signal changes to a text document.
|
|
In 2.0 the shape of the params has changed to include proper version numbers and language ids.
|
|
|
|
:param VersionedTextDocumentIdentifier textDocument: The initial trace setting. If omitted trace is disabled ('off').
|
|
:param TextDocumentContentChangeEvent[] contentChanges: The actual content changes. The content changes describe single state changes
|
|
to the document. So if there are two content changes c1 and c2 for a document in state S then c1 move the document
|
|
to S' and c2 to S''.
|
|
"""
|
|
|
|
return self.lsp_endpoint.send_notification("textDocument/didChange", textDocument = textDocument, contentChanges = contentChanges)
|
|
|
|
def documentSymbol(self, textDocument):
|
|
"""
|
|
The document symbol request is sent from the client to the server to
|
|
return a flat list of all symbols found in a given text document.
|
|
Neither the symbol's location range nor the symbol's container name
|
|
should be used to infer a hierarchy.
|
|
|
|
:param TextDocumentItem textDocument: The text document.
|
|
"""
|
|
result_dict = self.lsp_endpoint.call_method( "textDocument/documentSymbol", textDocument=textDocument )
|
|
|
|
if not result_dict: return []
|
|
return [lsp_structs.SymbolInformation(**sym) for sym in result_dict]
|
|
|
|
def declaration(self, textDocument, position):
|
|
"""
|
|
The go to declaration request is sent from the client to the server to
|
|
resolve the declaration location of a symbol at a given text document
|
|
position.
|
|
|
|
The result type LocationLink[] got introduce with version 3.14.0 and
|
|
depends in the corresponding client capability
|
|
`clientCapabilities.textDocument.declaration.linkSupport`.
|
|
|
|
:param TextDocumentItem textDocument: The text document.
|
|
:param Position position: The position inside the text document.
|
|
"""
|
|
|
|
result_dict = self.lsp_endpoint.call_method("textDocument/declaration",
|
|
textDocument = textDocument,
|
|
position = position
|
|
)
|
|
|
|
if not result_dict: return []
|
|
|
|
if "uri" in result_dict:
|
|
return lsp_structs.Location(**result_dict)
|
|
|
|
return [lsp_structs.Location(**loc) if "uri" in loc else lsp_structs.LinkLocation(**loc) for loc in result_dict]
|
|
|
|
def definition(self, textDocument, position):
|
|
"""
|
|
The goto definition request is sent from the client to the server to
|
|
resolve the definition location of a symbol at a given text document
|
|
position.
|
|
|
|
:param TextDocumentItem textDocument: The text document.
|
|
:param Position position: The position inside the text document.
|
|
"""
|
|
|
|
result_dict = self.lsp_endpoint.call_method("textDocument/definition",
|
|
textDocument = textDocument,
|
|
position = position
|
|
)
|
|
|
|
if not result_dict: return []
|
|
return [lsp_structs.Location(**loc) for loc in result_dict]
|
|
|
|
def typeDefinition(self, textDocument, position):
|
|
"""
|
|
The goto type definition request is sent from the client to the server
|
|
to resolve the type definition location of a symbol at a given text
|
|
document position.
|
|
|
|
:param TextDocumentItem textDocument: The text document.
|
|
:param Position position: The position inside the text document.
|
|
"""
|
|
|
|
result_dict = self.lsp_endpoint.call_method("textDocument/typeDefinition",
|
|
textDocument = textDocument,
|
|
position = position
|
|
)
|
|
|
|
if not result_dict: return []
|
|
return [lsp_structs.Location(**loc) for loc in result_dict]
|
|
|
|
def signatureHelp(self, textDocument, position):
|
|
"""
|
|
The signature help request is sent from the client to the server to
|
|
request signature information at a given cursor position.
|
|
|
|
:param TextDocumentItem textDocument: The text document.
|
|
:param Position position: The position inside the text document.
|
|
"""
|
|
|
|
result_dict = self.lsp_endpoint.call_method( "textDocument/signatureHelp",
|
|
textDocument = textDocument,
|
|
position = position
|
|
)
|
|
|
|
if not result_dict: return []
|
|
return lsp_structs.SignatureHelp(**result_dict)
|
|
|
|
def completion(self, textDocument, position, context):
|
|
"""
|
|
The signature help request is sent from the client to the server to
|
|
request signature information at a given cursor position.
|
|
|
|
:param TextDocumentItem textDocument: The text document.
|
|
:param Position position: The position inside the text document.
|
|
:param CompletionContext context: The completion context. This is only
|
|
available if the client specifies
|
|
to send this using `ClientCapabilities.textDocument.completion.contextSupport === true`
|
|
"""
|
|
|
|
result_dict = self.lsp_endpoint.call_method("textDocument/completion",
|
|
textDocument = textDocument,
|
|
position = position,
|
|
context = context
|
|
)
|
|
if not result_dict: return []
|
|
|
|
if "isIncomplete" in result_dict:
|
|
return lsp_structs.CompletionList(**result_dict)
|
|
|
|
return [lsp_structs.CompletionItem(**loc) for loc in result_dict]
|
|
|
|
def references(self, textDocument, position):
|
|
"""
|
|
The references request is sent from the client to the server to resolve
|
|
project-wide references for the symbol denoted by the given text
|
|
document position.
|
|
|
|
:param TextDocumentItem textDocument: The text document.
|
|
:param Position position: The position inside the text document.
|
|
"""
|
|
|
|
result_dict = self.lsp_endpoint.call_method("textDocument/references",
|
|
textDocument = textDocument,
|
|
position = position)
|
|
|
|
if not result_dict: return []
|
|
return [lsp_structs.Location(**loc) for loc in result_dict] |