def _JumpToLocation(self, definition_list):
if len(definition_list) == 1:
definition = definition_list[0]
if definition.in_builtin_module():
if isinstance(definition.definition, jedi.keywords.Keyword):
vimsupport.PostVimMessage(
"Cannot get the definition of Python keywords.")
else:
vimsupport.PostVimMessage(
"Builtin modules cannot be displayed.")
else:
vimsupport.JumpToLocation(definition.module_path,
definition.line_nr,
definition.column + 1)
else:
# multiple definitions
defs = []
for definition in definition_list:
if definition.in_builtin_module():
defs.append( {'text': 'Builtin ' + \
definition.description.encode( 'utf-8' ) } )
else:
defs.append({
'filename':
definition.module_path.encode('utf-8'),
'lnum':
definition.line_nr,
'col':
definition.column + 1,
'text':
definition.description.encode('utf-8')
})
vim.eval('setqflist( %s )' % repr(defs))
vim.eval('youcompleteme#OpenGoToList()')
def ShowDetailedDiagnostic(self):
current_line, current_column = vimsupport.CurrentLineAndColumn()
# CurrentLineAndColumn() numbers are 0-based, clang numbers are 1-based
current_line += 1
current_column += 1
current_file = vim.current.buffer.name
if not self.diagnostic_store:
vimsupport.PostVimMessage("No diagnostic for current line!")
return
diagnostics = self.diagnostic_store[current_file][current_line]
if not diagnostics:
vimsupport.PostVimMessage("No diagnostic for current line!")
return
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
vimsupport.EchoText(closest_diagnostic.long_formatted_text_)
def CandidatesForQueryAsync(self, query, start_column):
filename = vim.current.buffer.name
if not filename:
return
if self.completer.UpdatingTranslationUnit(filename):
vimsupport.PostVimMessage(
'Still parsing file, no completions yet.')
self.completions_future = None
return
flags = self.flags.FlagsForFile(filename)
if not flags:
vimsupport.PostVimMessage(
'Still no compile flags, no completions yet.')
self.completions_future = None
return
# TODO: sanitize query, probably in C++ code
files = ycm_core.UnsavedFileVec()
if not query:
files = self.GetUnsavedFilesVector()
line, _ = vim.current.window.cursor
column = start_column + 1
self.completions_future = (
self.completer.CandidatesForQueryAndLocationInFileAsync(
query, filename, line, column, files, flags))
def CandidatesForQueryAsyncInner(self, query):
if not self.omnifunc:
self.stored_candidates = None
return
try:
return_value = int(vim.eval(self.omnifunc + '(1,"")'))
if return_value < 0:
self.stored_candidates = None
return
omnifunc_call = [
self.omnifunc, "(0,'",
vimsupport.EscapeForVim(query), "')"
]
items = vim.eval(''.join(omnifunc_call))
if hasattr(items, 'words'):
items = items.words
if not hasattr(items, '__iter__'):
raise TypeError(OMNIFUNC_NOT_LIST)
self.stored_candidates = filter(bool, items)
except (TypeError, ValueError) as error:
vimsupport.PostVimMessage(OMNIFUNC_RETURNED_BAD_VALUE + ' ' +
str(error))
self.stored_candidates = None
return
def NotifyUserIfServerCrashed(self):
if (not self._server_popen or self._user_notified_about_crash
or self.IsServerAlive()):
return
self._user_notified_about_crash = True
return_code = self._server_popen.poll()
logfile = os.path.basename(self._server_stderr)
# See https://github.com/Valloric/ycmd#exit-codes for the list of exit
# codes.
if return_code == 3:
error_message = CORE_UNEXPECTED_MESSAGE.format(logfile=logfile)
elif return_code == 4:
error_message = CORE_MISSING_MESSAGE
elif return_code == 5:
error_message = CORE_PYTHON2_MESSAGE
elif return_code == 6:
error_message = CORE_PYTHON3_MESSAGE
elif return_code == 7:
error_message = CORE_OUTDATED_MESSAGE
else:
error_message = EXIT_CODE_UNEXPECTED_MESSAGE.format(
code=return_code, logfile=logfile)
self._logger.error(error_message)
error_message = SERVER_SHUTDOWN_MESSAGE + ' ' + error_message
vimsupport.PostVimMessage(error_message)
def _GetDefinitionsList(self, declaration=False):
definitions = []
script = self._GetJediScript()
try:
if declaration:
definitions = script.get_definition()
else:
definitions = script.goto()
except jedi.NotFoundError:
vimsupport.PostVimMessage(
"Cannot follow nothing. Put your cursor on a valid name.")
except Exception as e:
vimsupport.PostVimMessage(
"Caught exception, aborting. Full error: " + str(e))
return definitions
def _GoToDeclaration(self):
location = self._LocationForGoTo('GetDeclarationLocation')
if not location or not location.IsValid():
vimsupport.PostVimMessage('Can\'t jump to declaration.')
return
vimsupport.JumpToLocation(location.filename_, location.line_number_,
location.column_number_)
def CandidatesFromStoredRequest( self ):
if not self.completions_future:
return []
results = [ CompletionDataToDict( x ) for x in
self.completions_future.GetResults() ]
if not results:
vimsupport.PostVimMessage( 'No completions found; errors in the file?' )
return results
def _GoToDefinitionElseDeclaration(self):
definitions = self._GetDefinitionsList() or \
self._GetDefinitionsList( declaration = True )
if definitions:
self._JumpToLocation(definitions)
else:
vimsupport.PostVimMessage(
'Can\'t jump to definition or declaration.')
def DisplayServerException( exception, truncate_message = False ):
serialized_exception = str( exception )
# We ignore the exception about the file already being parsed since it comes
# up often and isn't something that's actionable by the user.
if 'already being parsed' in serialized_exception:
return
vimsupport.PostVimMessage( serialized_exception, truncate = truncate_message )
def _SetUpServer(self):
if self.vim:
self._user_options = base.GetUserOptions()
else:
self._user_options = {}
self._user_options['log_level'] = 0
options_dict = dict(self._user_options)
pprint(options_dict)
server_port = utils.GetUnusedLocalhostPort()
BaseRequest.server_location = 'http://127.0.0.1:' + str(server_port)
self.server_location = BaseRequest.server_location
print(BaseRequest.server_location)
with NamedTemporaryFile(delete=False, mode='w+') as options_file:
json.dump(options_dict, options_file)
try:
python_interpreter = paths.PathToPythonInterpreter()
self._logger.info(python_interpreter)
except RuntimeError as error:
error_message = ("Unable to start the ycmd server. {0}. "
"Correct the error then restart the server "
"with ':YcmRestartServer'.".format(
str(error).rstrip('.')))
self._logger.exception(error_message)
vimsupport.PostVimMessage(error_message)
return
path = os.path.normpath('/Users/phil/nvidia/editor/server/main.py')
print(python_interpreter)
args = [
python_interpreter,
path,
'--port={0}'.format(server_port),
'--options_file={0}'.format(
'/Users/phil/nvidia/editor/options.json'
), #options_file.name),
'--log={0}'.format(self._user_options['log_level']),
'--idle_suicide_seconds={0}'.format(SERVER_IDLE_SUICIDE_SECONDS)
]
self._server_stdout = utils.logfile
self._server_stderr = utils.logfile
args.append('--stdout={0}'.format(self._server_stdout))
args.append('--stderr={0}'.format(self._server_stderr))
#TODO: add logging
#log = open("./erroroutput", "w")
pprint(args)
self._server_popen = Popen(args, stdout=PIPE,
stderr=PIPE) #, stdout=PIPE, stderr=PIPE)
def _LocationForGoTo(self, goto_function):
filename = vim.current.buffer.name
if not filename:
return None
flags = self.flags.FlagsForFile(filename)
if not flags:
vimsupport.PostVimMessage(
'Still no compile flags, can\'t compile.')
return None
files = self.GetUnsavedFilesVector()
line, column = vimsupport.CurrentLineAndColumn()
# Making the line & column 1-based instead of 0-based
line += 1
column += 1
return getattr(self.completer, goto_function)(filename, line, column,
files, flags)
def FlagsForFile(self, filename):
try:
return self.flags_for_file[filename]
except KeyError:
flags_module = self._FlagsModuleForFile(filename)
if not flags_module:
if not self.no_extra_conf_file_warning_posted:
vimsupport.PostVimMessage(NO_EXTRA_CONF_FILENAME_MESSAGE)
self.no_extra_conf_file_warning_posted = True
return None
results = flags_module.FlagsForFile(filename)
if not results.get('flags_ready', True):
return None
results['flags'] += self.special_clang_flags
sanitized_flags = _SanitizeFlags(results['flags'])
if results['do_cache']:
self.flags_for_file[filename] = sanitized_flags
return sanitized_flags
# You should have received a copy of the GNU General Public License
# along with YouCompleteMe. If not, see <http://www.gnu.org/licenses/>.
import imp
import os
import sys
import vimsupport
import vim
import ycm_utils as utils
try:
import ycm_core
except ImportError as e:
vimsupport.PostVimMessage(
'Error importing ycm_core. Are you sure you have placed a version 3.2+ '
'libclang.[so|dll|dylib] in folder "{0}"? See the Installation Guide in '
'the docs. Full error: {1}'.format(
os.path.dirname(os.path.abspath(__file__)), str(e)))
from completers.all.identifier_completer import IdentifierCompleter
from completers.all.omni_completer import OmniCompleter
FILETYPE_SPECIFIC_COMPLETION_TO_DISABLE = vim.eval(
'g:ycm_filetype_specific_completion_to_disable')
class YouCompleteMe(object):
def __init__(self):
self.identcomp = IdentifierCompleter()
self.omnicomp = OmniCompleter()
self.filetype_completers = {}
import vim
from completers.threaded_completer import ThreadedCompleter
import vimsupport
import sys
from os.path import join, abspath, dirname
# We need to add the jedi package to sys.path, but it's important that we clean
# up after ourselves, because ycm.YouCompletMe.GetFiletypeCompleterForFiletype
# removes sys.path[0] after importing completers.python.hook
sys.path.insert(0, join(abspath(dirname(__file__)), 'jedi'))
try:
import jedi
except ImportError:
vimsupport.PostVimMessage(
'Error importing jedi. Make sure the jedi submodule has been checked out. '
'In the YouCompleteMe folder, run "git submodule update --init --recursive"'
)
sys.path.pop(0)
USER_COMMANDS_HELP_MESSAGE = """
Supported commands are:
GoToDefinition
GoToDeclaration
GoToDefinitionElseDeclaration
See the docs for information on what they do."""
class JediCompleter(ThreadedCompleter):
"""
A Completer that uses the Jedi completion engine.
https://jedi.readthedocs.org/en/latest/
def OnUserCommand(self, arguments):
vimsupport.PostVimMessage(NO_USER_COMMANDS)
def _GoToDefinition(self):
definitions = self._GetDefinitionsList()
if definitions:
self._JumpToLocation(definitions)
else:
vimsupport.PostVimMessage('Can\'t jump to definition.')
