def ConvertNotificationToMessage( self, request_data, notification ):
if notification[ 'method' ] == 'language/status':
message = notification[ 'params' ][ 'message' ]
if notification[ 'params' ][ 'type' ] == 'Started':
self._started_message_sent = True
return responses.BuildDisplayMessageResponse(
f'Initializing Java completer: { message }' )
if not self._started_message_sent:
return responses.BuildDisplayMessageResponse(
f'Initializing Java completer: { message }' )
return super().ConvertNotificationToMessage( request_data, notification )
def ConvertNotificationToMessage( self, request_data, notification ):
if notification[ 'method' ] == 'experimental/serverStatus':
message = notification[ 'params' ][ 'health' ]
if message != 'ok' and notification[ 'params' ][ 'message' ] is not None:
message += ' - ' + notification[ 'params' ][ 'message' ]
return responses.BuildDisplayMessageResponse(
f'Initializing Rust completer: { message }' )
# TODO: Once rustup catches up, we should drop this notification.
if notification[ 'method' ] == 'rust-analyzer/status':
message = notification[ 'params' ]
if message != 'invalid': # RA produces a better message for `invalid`
return responses.BuildDisplayMessageResponse(
f'Initializing Rust completer: { message }' )
return super().ConvertNotificationToMessage( request_data, notification )
def GetType(self, request_data):
try:
hover_response = self.GetHoverResponse(request_data)['value']
except language_server_completer.NoHoverInfoException:
raise RuntimeError('Unknown type.')
# rust-analyzer's hover format looks like this:
#
# ```rust
# namespace
# ```
#
# ```rust
# type info
# ```
#
# ___
# docstring
#
# To extract the type info, we take everything up to `___` line,
# then find the last occurence of "```" as the end index and "```rust"
# as the start index and return the slice.
hover_response = hover_response.split('\n___\n', 2)[0]
start = hover_response.rfind('```rust\n') + len('```rust\n')
end = hover_response.rfind('\n```')
return responses.BuildDisplayMessageResponse(hover_response[start:end])
def ConvertNotificationToMessage(self, request_data, notification):
if notification['method'] == 'rust-analyzer/status':
message = notification['params']
if message != 'invalid': # RA produces a better message for `invalid`
return responses.BuildDisplayMessageResponse(
'Initializing Rust completer: {}'.format(message))
return super().ConvertNotificationToMessage(request_data, notification)
def GetType( self, request_data ):
try:
result = json.loads(
self.GetHoverResponse( request_data )[ 'value' ] )[ 'signature' ]
return responses.BuildDisplayMessageResponse( result )
except language_server_completer.NoHoverInfoException:
raise RuntimeError( 'Unknown type.' )
def GetDetailedDiagnostic(self, request_data):
ts_diagnostics = self.GetTsDiagnosticsForCurrentFile(request_data)
ts_diagnostics_on_line = list(
filter(
partial(IsLineInTsDiagnosticRange, request_data['line_num']),
ts_diagnostics))
if not ts_diagnostics_on_line:
raise ValueError(NO_DIAGNOSTIC_MESSAGE)
closest_ts_diagnostic = None
distance_to_closest_ts_diagnostic = None
line_value = request_data['line_value']
current_byte_offset = request_data['column_num']
for ts_diagnostic in ts_diagnostics_on_line:
distance = GetByteOffsetDistanceFromTsDiagnosticRange(
current_byte_offset, line_value, ts_diagnostic)
if (not closest_ts_diagnostic
or distance < distance_to_closest_ts_diagnostic):
distance_to_closest_ts_diagnostic = distance
closest_ts_diagnostic = ts_diagnostic
closest_diagnostic = self._TsDiagnosticToYcmdDiagnostic(
request_data, closest_ts_diagnostic)
return responses.BuildDisplayMessageResponse(closest_diagnostic.text_)
def OnUserCommand(self, arguments, request_data):
memfilepath, cfile, _ = _CreateTmpFile(request_data)
completion = _GetCompletions(cfile, memfilepath,
request_data['line_num'],
request_data['column_num'], 'def')
if not completion:
raise ValueError("No idea")
completion = completion[0].split('\t')
if len(completion) < 6:
raise ValueError("No such symbol")
_, ctype, fullname, rtype, ffile, row, col, docstr = completion
if not arguments:
raise ValueError(self.UserCommandsHelpMessage())
elif arguments[0] == 'GetType':
reply = '[' + TokenTypeMap.get(ctype, '') + '] (' + fullname + ')'
if len(rtype) != 0:
reply += ': ' + rtype + '\n--------------------------------------------------------------------------------\n' + FormatDocStr(
docstr)
return responses.BuildDisplayMessageResponse(ToUtf8IfNeeded(reply))
elif arguments[0] == 'GoTo':
return responses.BuildGoToResponse(
ToUtf8IfNeeded(ffile), int(row),
int(col) + 1, ToUtf8IfNeeded(FormatDocStr(docstr)))
else:
raise RuntimeError(arguments)
def GetDetailedDiagnostic( self, request_data ):
current_line = request_data[ 'line_num' ]
current_column = request_data[ 'column_num' ]
current_file = request_data[ 'filepath' ]
if not self._diagnostic_store:
raise ValueError( NO_DIAGNOSTIC_MESSAGE )
diagnostics = self._diagnostic_store[ current_file ][ current_line ]
if not diagnostics:
raise ValueError( NO_DIAGNOSTIC_MESSAGE )
closest_diagnostic = None
distance_to_closest_diagnostic = 999
# FIXME: all of these calculations are currently working with byte
# offsets, which are technically incorrect. We should be working with
# codepoint offsets, as we want the nearest character-wise diagnostic
for diagnostic in diagnostics:
distance = abs( current_column - diagnostic.location_.column_number_ )
if distance < distance_to_closest_diagnostic:
distance_to_closest_diagnostic = distance
closest_diagnostic = diagnostic
return responses.BuildDisplayMessageResponse(
closest_diagnostic.text_ )
def _GetSemanticInfo(self, request_data, func, reparse=True):
filename = request_data['filepath']
if not filename:
raise ValueError(INVALID_FILE_MESSAGE)
gotofilename = filename
filename = self._ParentForRequest(filename)
flags = self._FlagsForRequest(request_data)
if not flags:
raise ValueError(NO_COMPILE_FLAGS_MESSAGE)
files = self.GetUnsavedFilesVector(request_data)
line = request_data['line_num']
column = request_data['column_num']
message = getattr(self._completer,
func)(ToUtf8IfNeeded(filename),
ToUtf8IfNeeded(gotofilename), line, column,
files, flags, reparse)
if not message:
message = "No semantic information available"
return responses.BuildDisplayMessageResponse(message)
def GetType(self, request_data):
hover_response = self.GetHoverResponse(request_data)
# The LSP defines the hover response as either:
# - a string
# - a list of strings
# - an object with keys language, value
# - a list of objects with keys language, value
# - an object with keys kind, value
# That's right. All of the above.
# However it would appear that dart only ever returns useful data when it
# is a list of objects-with-keys-language-value, and the type information is
# always in the first such list element, so we only handle that case and
# throw any other time.
# Strictly we seem to receive:
# - [""]
# when there really is no documentation or type info available
# - [{language:dart, value:<type info>}]
# when there only the type information is available
# - [{language:dart, value:<type info>},
# 'doc line 1',
# 'doc line 2',
# ...]
# when there is type and documentation information available.
try:
get_type_dart = hover_response[0]['value']
except (KeyError, TypeError, IndexError):
raise RuntimeError('Unknown type')
return responses.BuildDisplayMessageResponse(get_type_dart)
def GetType(self, request_data):
hover_response = self.GetHoverResponse(request_data)
for item in hover_response:
if isinstance(item, dict) and 'value' in item:
return responses.BuildDisplayMessageResponse(item['value'])
raise RuntimeError('Unknown type.')
def _GetType(self, request_data):
query = {
'type': 'type',
}
response = self._GetResponse(query, request_data)
return responses.BuildDisplayMessageResponse(response['type'])
def GetType(self, request_data):
try:
result = self.GetHoverResponse(request_data)['value']
return responses.BuildDisplayMessageResponse(result)
except RuntimeError as e:
if e.args[0] == 'No hover information.':
raise RuntimeError('Unknown type.')
raise
def ConvertNotificationToMessage(self, request_data, notification):
if notification['method'] == 'language/status':
message = notification['params']['message']
return responses.BuildDisplayMessageResponse(
'Initializing Dart completer: {0}'.format(message))
return super(DartCompleter, self).ConvertNotificationToMessage(
request_data, notification)
def _GetType( self, request_data ):
self._Reload( request_data )
info = self._SendRequest( 'quickinfo', {
'file': request_data[ 'filepath' ],
'line': request_data[ 'line_num' ],
'offset': request_data[ 'column_codepoint' ]
} )
return responses.BuildDisplayMessageResponse( info[ 'displayString' ] )
def _GetType( self, request_data ):
request = self._DefaultParameters( request_data )
request[ "IncludeDocumentation" ] = False
result = self._GetResponse( '/typelookup', request )
message = result[ "Type" ]
return responses.BuildDisplayMessageResponse( message )
def _GetType( self, request_data ):
with self._jedi_lock:
definitions = self._GetJediScript( request_data ).goto_definitions()
type_info = [ self._BuildTypeInfo( definition )
for definition in definitions ]
type_info = ', '.join( type_info )
if type_info:
return responses.BuildDisplayMessageResponse( type_info )
raise RuntimeError( 'No type information available.' )
def GetDoc( self, request_data ):
assert self._settings[ 'hoverKind' ] == 'Structured'
try:
result = json.loads( self.GetHoverResponse( request_data )[ 'value' ] )
docs = result[ 'signature' ] + '\n' + result[ 'fullDocumentation' ]
return responses.BuildDisplayMessageResponse( docs.strip() )
except RuntimeError as e:
if e.args[ 0 ] == 'No hover information.':
raise RuntimeError( 'No documentation available.' )
raise
def GetType( self, request_data ): # Clangd's hover response looks like this: # Declared in namespace <namespace name> # # <declaration line> # # <docstring> # GetType gets the first two lines. value = self.GetHoverResponse( request_data )[ 'value' ].split( '\n\n', 2 ) return responses.BuildDisplayMessageResponse( '\n\n'.join( value[ : 2 ] ) )
def _GetType(self, request_data):
request = self._DefaultParameters(request_data)
request["IncludeDocumentation"] = False
result = self._GetResponse('/typelookup', request)
message = result["Type"]
if not message:
raise RuntimeError('No type info available.')
return responses.BuildDisplayMessageResponse(message)
def _GetType( self, request_data ):
with self._lock:
self._Reload( request_data )
seq = self._SendRequest( 'quickinfo', {
'file': request_data[ 'filepath' ],
'line': request_data[ 'line_num' ],
'offset': request_data[ 'column_num' ]
})
info = self._ReadResponse( seq )[ 'body' ]
return responses.BuildDisplayMessageResponse( info[ 'displayString' ] )
def _GetType( self, request_data ):
with self._jedi_lock:
line = request_data[ 'line_num' ]
# Jedi expects columns to start at 0, not 1, and for them to be Unicode
# codepoint offsets.
column = request_data[ 'start_codepoint' ] - 1
definitions = self._GetJediScript( request_data ).infer( line, column )
type_info = [ self._BuildTypeInfo( definition )
for definition in definitions ]
type_info = ', '.join( type_info )
if type_info:
return responses.BuildDisplayMessageResponse( type_info )
raise RuntimeError( 'No type information available.' )
def _GetDoc(self, request_data, args):
query = self._GetQueryWord(request_data)
if query in self._raw_names:
type = self._raw_names[query]
ret = subprocess.run(
['cmake', '--help-{}'.format(type), query],
capture_output=True)
if ret.returncode == 0:
msg = ret.stdout.decode()
return responses.BuildDetailedInfoResponse(str(request_data))
msg = "Can't find doc for {}".format(query)
return responses.BuildDisplayMessageResponse(msg)
def GetDetailedDiagnostic(self, request_data):
self._UpdateServerWithFileContents(request_data)
current_line_lsp = request_data['line_num'] - 1
current_file = request_data['filepath']
if not self._latest_diagnostics:
return responses.BuildDisplayMessageResponse(
'Diagnostics are not ready yet.')
with self._server_info_mutex:
diagnostics = list(
self._latest_diagnostics[lsp.FilePathToUri(current_file)])
if not diagnostics:
return responses.BuildDisplayMessageResponse(
'No diagnostics for current file.')
current_column = lsp.CodepointsToUTF16CodeUnits(
GetFileLines(request_data, current_file)[current_line_lsp],
request_data['column_codepoint'])
minimum_distance = None
message = 'No diagnostics for current line.'
for diagnostic in diagnostics:
start = diagnostic['range']['start']
end = diagnostic['range']['end']
if current_line_lsp < start['line'] or end[
'line'] < current_line_lsp:
continue
point = {'line': current_line_lsp, 'character': current_column}
distance = DistanceOfPointToRange(point, diagnostic['range'])
if minimum_distance is None or distance < minimum_distance:
message = diagnostic['message']
if distance == 0:
break
minimum_distance = distance
return responses.BuildDisplayMessageResponse(message)
def GetType(self, request_data):
try:
hover_value = self.GetHoverResponse(request_data)['value']
# Last "paragraph" contains the signature/declaration - i.e. type info.
type_info = hover_value.split('\n\n')[-1]
# The first line might contain the info of enclosing scope.
if type_info.startswith('// In'):
comment, signature = type_info.split('\n', 1)
type_info = signature + '; ' + comment
# Condense multi-line function declarations into one line.
type_info = re.sub(r'\s+', ' ', type_info)
return responses.BuildDisplayMessageResponse(type_info)
except language_server_completer.NoHoverInfoException:
raise RuntimeError('Unknown type.')
def GetType( self, request_data ):
try:
# Clangd's hover response looks like this:
# Declared in namespace <namespace name>
#
# <declaration line>
#
# <docstring>
# GetType gets the first two lines.
hover_value = self.GetHoverResponse( request_data )[ 'value' ]
type_info = '\n\n'.join( hover_value.split( '\n\n', 2 )[ : 2 ] )
return responses.BuildDisplayMessageResponse( type_info )
except language_server_completer.NoHoverInfoException:
raise RuntimeError( 'Unknown type.' )
def GetType(self, request_data):
hover_response = self.GetHoverResponse(request_data)
# The LSP defines the hover response as either:
# - a string
# - a list of strings
# - an object with keys language, value
# - a list of objects with keys language, value
# - an object with keys kind, value
# That's right. All of the above.
# However it would appear that jdt.ls only ever returns useful data when it
# is a list of objects-with-keys-language-value, and the type information is
# always in the first such list element, so we only handle that case and
# throw any other time.
# Strictly we seem to receive:
# - ""
# when there really is no documentation or type info available
# - {language:java, value:<type info>}
# when there only the type information is available
# - [{language:java, value:<type info>},
# 'doc line 1',
# 'doc line 2',
# ...]
# when there is type and documentation information available.
if not hover_response:
raise RuntimeError('Unknown type')
if isinstance(hover_response, list):
hover_response = hover_response[0]
if (not isinstance(hover_response, dict)
or hover_response.get('language') != 'java'
or 'value' not in hover_response):
raise RuntimeError('Unknown type')
return responses.BuildDisplayMessageResponse(hover_response['value'])
def GetDetailedDiagnostic( self, request_data ):
current_line = request_data[ 'line_num' ]
current_column = request_data[ 'column_num' ]
current_file = request_data[ 'filepath' ]
if not self._diagnostic_store:
raise ValueError( NO_DIAGNOSTIC_MESSAGE )
diagnostics = self._diagnostic_store[ current_file ][ current_line ]
if not diagnostics:
raise ValueError( NO_DIAGNOSTIC_MESSAGE )
closest_diagnostic = None
distance_to_closest_diagnostic = 999
for diagnostic in diagnostics:
distance = abs( current_column - diagnostic.location_.column_number_ )
if distance < distance_to_closest_diagnostic:
distance_to_closest_diagnostic = distance
closest_diagnostic = diagnostic
return responses.BuildDisplayMessageResponse(
closest_diagnostic.long_formatted_text_ )
def GetType(self, request_data):
hover_response = self.GetHoverResponse(request_data)
return responses.BuildDisplayMessageResponse(hover_response['value'])
def GetType( self, request_data ):
try:
result = self.GetHoverResponse( request_data )[ 'value' ]
return responses.BuildDisplayMessageResponse( result )
except language_server_completer.ResponseFailedException:
raise RuntimeError( 'Unknown type.' )