6c53bad58f
The server is multi-threaded and will spawn a new thread for each new request. Thus, the completers need not manage their own threads or even provide async APIs; we _want_ them to block because now were implementing the request-response networking API. The client gets the async API through the network (i.e., it can do something else while the request is pending).
329 lines
11 KiB
Python
329 lines
11 KiB
Python
#!/usr/bin/env python
|
|
#
|
|
# Copyright (C) 2011, 2012 Strahinja Val Markovic <val@markovic.io>
|
|
#
|
|
# This file is part of YouCompleteMe.
|
|
#
|
|
# YouCompleteMe is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# YouCompleteMe is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with YouCompleteMe. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
from collections import defaultdict
|
|
import ycm_core
|
|
import logging
|
|
from ycm.server import responses
|
|
from ycm import extra_conf_store
|
|
from ycm.utils import ToUtf8IfNeeded
|
|
from ycm.completers.completer import Completer
|
|
from ycm.completers.cpp.flags import Flags, PrepareFlagsForClang
|
|
|
|
CLANG_FILETYPES = set( [ 'c', 'cpp', 'objc', 'objcpp' ] )
|
|
MIN_LINES_IN_FILE_TO_PARSE = 5
|
|
PARSING_FILE_MESSAGE = 'Still parsing file, no completions yet.'
|
|
NO_COMPILE_FLAGS_MESSAGE = 'Still no compile flags, no completions yet.'
|
|
INVALID_FILE_MESSAGE = 'File is invalid.'
|
|
NO_COMPLETIONS_MESSAGE = 'No completions found; errors in the file?'
|
|
FILE_TOO_SHORT_MESSAGE = (
|
|
'File is less than {} lines long; not compiling.'.format(
|
|
MIN_LINES_IN_FILE_TO_PARSE ) )
|
|
NO_DIAGNOSTIC_MESSAGE = 'No diagnostic for current line!'
|
|
|
|
|
|
class ClangCompleter( Completer ):
|
|
def __init__( self, user_options ):
|
|
super( ClangCompleter, self ).__init__( user_options )
|
|
self._max_diagnostics_to_display = user_options[
|
|
'max_diagnostics_to_display' ]
|
|
self._completer = ycm_core.ClangCompleter()
|
|
self._last_prepared_diagnostics = []
|
|
self._flags = Flags()
|
|
self._diagnostic_store = None
|
|
self._logger = logging.getLogger( __name__ )
|
|
|
|
|
|
def SupportedFiletypes( self ):
|
|
return CLANG_FILETYPES
|
|
|
|
|
|
def GetUnsavedFilesVector( self, request_data ):
|
|
files = ycm_core.UnsavedFileVec()
|
|
for filename, file_data in request_data[ 'file_data' ].iteritems():
|
|
if not ClangAvailableForFiletypes( file_data[ 'filetypes' ] ):
|
|
continue
|
|
contents = file_data[ 'contents' ]
|
|
if not contents or not filename:
|
|
continue
|
|
|
|
unsaved_file = ycm_core.UnsavedFile()
|
|
utf8_contents = ToUtf8IfNeeded( contents )
|
|
unsaved_file.contents_ = utf8_contents
|
|
unsaved_file.length_ = len( utf8_contents )
|
|
unsaved_file.filename_ = ToUtf8IfNeeded( filename )
|
|
|
|
files.append( unsaved_file )
|
|
return files
|
|
|
|
|
|
def ComputeCandidatesInner( self, request_data ):
|
|
filename = request_data[ 'filepath' ]
|
|
if not filename:
|
|
return
|
|
|
|
if self._completer.UpdatingTranslationUnit( ToUtf8IfNeeded( filename ) ):
|
|
self._logger.info( PARSING_FILE_MESSAGE )
|
|
raise RuntimeError( PARSING_FILE_MESSAGE )
|
|
|
|
flags = self._FlagsForRequest( request_data )
|
|
if not flags:
|
|
self._logger.info( NO_COMPILE_FLAGS_MESSAGE )
|
|
raise RuntimeError( NO_COMPILE_FLAGS_MESSAGE )
|
|
|
|
files = self.GetUnsavedFilesVector( request_data )
|
|
line = request_data[ 'line_num' ] + 1
|
|
column = request_data[ 'start_column' ] + 1
|
|
results = self._completer.CandidatesForLocationInFile(
|
|
ToUtf8IfNeeded( filename ),
|
|
line,
|
|
column,
|
|
files,
|
|
flags )
|
|
|
|
if not results:
|
|
self._logger.warning( NO_COMPLETIONS_MESSAGE )
|
|
raise RuntimeError( NO_COMPLETIONS_MESSAGE )
|
|
|
|
return [ ConvertCompletionData( x ) for x in results ]
|
|
|
|
|
|
def DefinedSubcommands( self ):
|
|
return [ 'GoToDefinition',
|
|
'GoToDeclaration',
|
|
'GoToDefinitionElseDeclaration',
|
|
'ClearCompilationFlagCache']
|
|
|
|
|
|
def OnUserCommand( self, arguments, request_data ):
|
|
if not arguments:
|
|
raise ValueError( self.UserCommandsHelpMessage() )
|
|
|
|
command = arguments[ 0 ]
|
|
if command == 'GoToDefinition':
|
|
return self._GoToDefinition( request_data )
|
|
elif command == 'GoToDeclaration':
|
|
return self._GoToDeclaration( request_data )
|
|
elif command == 'GoToDefinitionElseDeclaration':
|
|
return self._GoToDefinitionElseDeclaration( request_data )
|
|
elif command == 'ClearCompilationFlagCache':
|
|
return self._ClearCompilationFlagCache()
|
|
raise ValueError( self.UserCommandsHelpMessage() )
|
|
|
|
|
|
def _LocationForGoTo( self, goto_function, request_data ):
|
|
filename = request_data[ 'filepath' ]
|
|
if not filename:
|
|
self._logger.warning( INVALID_FILE_MESSAGE )
|
|
raise ValueError( INVALID_FILE_MESSAGE )
|
|
|
|
flags = self._FlagsForRequest( request_data )
|
|
if not flags:
|
|
self._logger.info( NO_COMPILE_FLAGS_MESSAGE )
|
|
raise ValueError( NO_COMPILE_FLAGS_MESSAGE )
|
|
|
|
files = self.GetUnsavedFilesVector( request_data )
|
|
line = request_data[ 'line_num' ] + 1
|
|
column = request_data[ 'column_num' ] + 1
|
|
return getattr( self._completer, goto_function )(
|
|
ToUtf8IfNeeded( filename ),
|
|
line,
|
|
column,
|
|
files,
|
|
flags )
|
|
|
|
|
|
def _GoToDefinition( self, request_data ):
|
|
location = self._LocationForGoTo( 'GetDefinitionLocation', request_data )
|
|
if not location or not location.IsValid():
|
|
raise RuntimeError( 'Can\'t jump to definition.' )
|
|
|
|
return responses.BuildGoToResponse( location.filename_,
|
|
location.line_number_ - 1,
|
|
location.column_number_ - 1)
|
|
|
|
|
|
def _GoToDeclaration( self, request_data ):
|
|
location = self._LocationForGoTo( 'GetDeclarationLocation', request_data )
|
|
if not location or not location.IsValid():
|
|
raise RuntimeError( 'Can\'t jump to declaration.' )
|
|
|
|
return responses.BuildGoToResponse( location.filename_,
|
|
location.line_number_ - 1,
|
|
location.column_number_ - 1)
|
|
|
|
|
|
def _GoToDefinitionElseDeclaration( self, request_data ):
|
|
location = self._LocationForGoTo( 'GetDefinitionLocation', request_data )
|
|
if not location or not location.IsValid():
|
|
location = self._LocationForGoTo( 'GetDeclarationLocation', request_data )
|
|
if not location or not location.IsValid():
|
|
raise RuntimeError( 'Can\'t jump to definition or declaration.' )
|
|
|
|
return responses.BuildGoToResponse( location.filename_,
|
|
location.line_number_ - 1,
|
|
location.column_number_ - 1)
|
|
|
|
|
|
|
|
def _ClearCompilationFlagCache( self ):
|
|
self._flags.Clear()
|
|
|
|
|
|
def OnFileReadyToParse( self, request_data ):
|
|
filename = request_data[ 'filepath' ]
|
|
contents = request_data[ 'file_data' ][ filename ][ 'contents' ]
|
|
if contents.count( '\n' ) < MIN_LINES_IN_FILE_TO_PARSE:
|
|
self._logger.warning( FILE_TOO_SHORT_MESSAGE )
|
|
raise ValueError( FILE_TOO_SHORT_MESSAGE )
|
|
|
|
if not filename:
|
|
self._logger.warning( INVALID_FILE_MESSAGE )
|
|
raise ValueError( INVALID_FILE_MESSAGE )
|
|
|
|
flags = self._FlagsForRequest( request_data )
|
|
if not flags:
|
|
self._logger.info( NO_COMPILE_FLAGS_MESSAGE )
|
|
raise ValueError( NO_COMPILE_FLAGS_MESSAGE )
|
|
|
|
self._completer.UpdateTranslationUnit(
|
|
ToUtf8IfNeeded( filename ),
|
|
self.GetUnsavedFilesVector( request_data ),
|
|
flags )
|
|
|
|
|
|
def OnBufferUnload( self, request_data ):
|
|
self._completer.DeleteCachesForFile(
|
|
ToUtf8IfNeeded( request_data[ 'unloaded_buffer' ] ) )
|
|
|
|
|
|
def DiagnosticsForCurrentFileReady( self ):
|
|
# if not self.parse_future:
|
|
# return False
|
|
# return self.parse_future.ResultsReady()
|
|
pass
|
|
|
|
|
|
def GettingCompletions( self, request_data ):
|
|
return self._completer.UpdatingTranslationUnit(
|
|
ToUtf8IfNeeded( request_data[ 'filepath' ] ) )
|
|
|
|
|
|
def GetDiagnosticsForCurrentFile( self, request_data ):
|
|
filename = request_data[ 'filepath' ]
|
|
if self.DiagnosticsForCurrentFileReady():
|
|
diagnostics = self._completer.DiagnosticsForFile(
|
|
ToUtf8IfNeeded( filename ) )
|
|
self._diagnostic_store = DiagnosticsToDiagStructure( diagnostics )
|
|
self._last_prepared_diagnostics = [
|
|
responses.BuildDiagnosticData( x ) for x in
|
|
diagnostics[ : self._max_diagnostics_to_display ] ]
|
|
# self.parse_future = None
|
|
|
|
# if self.extra_parse_desired:
|
|
# self.OnFileReadyToParse( request_data )
|
|
|
|
return self._last_prepared_diagnostics
|
|
|
|
|
|
def GetDetailedDiagnostic( self, request_data ):
|
|
current_line = request_data[ 'line_num' ] + 1
|
|
current_column = request_data[ 'column_num' ] + 1
|
|
current_file = request_data[ 'filepath' ]
|
|
|
|
if not self._diagnostic_store:
|
|
return responses.BuildDisplayMessageResponse(
|
|
NO_DIAGNOSTIC_MESSAGE )
|
|
|
|
diagnostics = self._diagnostic_store[ current_file ][ current_line ]
|
|
if not diagnostics:
|
|
return responses.BuildDisplayMessageResponse(
|
|
NO_DIAGNOSTIC_MESSAGE )
|
|
|
|
closest_diagnostic = None
|
|
distance_to_closest_diagnostic = 999
|
|
|
|
for diagnostic in diagnostics:
|
|
distance = abs( current_column - diagnostic.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 DebugInfo( self, request_data ):
|
|
filename = request_data[ 'filepath' ]
|
|
if not filename:
|
|
return ''
|
|
flags = self._FlagsForRequest( request_data ) or []
|
|
source = extra_conf_store.ModuleFileForSourceFile( filename )
|
|
return 'Flags for {0} loaded from {1}:\n{2}'.format( filename,
|
|
source,
|
|
list( flags ) )
|
|
|
|
def _FlagsForRequest( self, request_data ):
|
|
filename = request_data[ 'filepath' ]
|
|
if 'compilation_flags' in request_data:
|
|
return PrepareFlagsForClang( request_data[ 'compilation_flags' ],
|
|
filename )
|
|
return self._flags.FlagsForFile( filename )
|
|
|
|
# TODO: Make this work again
|
|
# def DiagnosticToDict( diagnostic ):
|
|
# # see :h getqflist for a description of the dictionary fields
|
|
# return {
|
|
# # TODO: wrap the bufnr generation into a function
|
|
# 'bufnr' : int( vim.eval( "bufnr('{0}', 1)".format(
|
|
# diagnostic.filename_ ) ) ),
|
|
# 'lnum' : diagnostic.line_number_,
|
|
# 'col' : diagnostic.column_number_,
|
|
# 'text' : diagnostic.text_,
|
|
# 'type' : diagnostic.kind_,
|
|
# 'valid' : 1
|
|
# }
|
|
|
|
|
|
def ConvertCompletionData( completion_data ):
|
|
return responses.BuildCompletionData(
|
|
insertion_text = completion_data.TextToInsertInBuffer(),
|
|
menu_text = completion_data.MainCompletionText(),
|
|
extra_menu_info = completion_data.ExtraMenuInfo(),
|
|
kind = completion_data.kind_,
|
|
detailed_info = completion_data.DetailedInfoForPreviewWindow() )
|
|
|
|
|
|
def DiagnosticsToDiagStructure( diagnostics ):
|
|
structure = defaultdict(lambda : defaultdict(list))
|
|
for diagnostic in diagnostics:
|
|
structure[ diagnostic.filename_ ][ diagnostic.line_number_ ].append(
|
|
diagnostic )
|
|
return structure
|
|
|
|
|
|
def ClangAvailableForFiletypes( filetypes ):
|
|
return any( [ filetype in CLANG_FILETYPES for filetype in filetypes ] )
|
|
|
|
|
|
def InCFamilyFile( filetypes ):
|
|
return ClangAvailableForFiletypes( filetypes )
|
|
|
|
|