def test_IncludeCache_Cached_NoNewMtime( self ):
include_cache = IncludeCache()
assert_that( include_cache._cache, equal_to( {} ) )
old_includes = include_cache.GetIncludes( PathToTestFile( 'cache_test' ) )
old_mtime = os.path.getmtime( PathToTestFile( 'cache_test' ) )
assert_that( old_includes, contains_exactly( has_properties( {
'name': 'foo.h',
'entry_type': 1
} ) ) )
assert_that( include_cache._cache,
has_entry( PathToTestFile( 'cache_test' ),
has_entries( { 'mtime': old_mtime,
'includes': contains_exactly( has_properties( {
'name': 'foo.h',
'entry_type': 1
} ) ) } ) ) )
new_includes = include_cache.GetIncludes( PathToTestFile( 'cache_test' ) )
new_mtime = os.path.getmtime( PathToTestFile( 'cache_test' ) )
assert_that( new_mtime, equal_to( old_mtime ) )
assert_that( new_includes, contains_exactly( has_properties( {
'name': 'foo.h',
'entry_type': 1
} ) ) )
assert_that( include_cache._cache,
has_entry( PathToTestFile( 'cache_test' ),
has_entries( { 'mtime': new_mtime,
'includes': contains_exactly( has_properties( {
'name': 'foo.h',
'entry_type': 1
} ) ) } ) ) )
def IncludeCache_NotCached_DirAccessible_test():
include_cache = IncludeCache()
assert_that(include_cache._cache, equal_to({}))
includes = include_cache.GetIncludes(PathToTestFile('cache_test'))
mtime = os.path.getmtime(PathToTestFile('cache_test'))
assert_that(
includes,
contains_exactly(has_properties({
'name': 'foo.h',
'entry_type': 1
})))
assert_that(
include_cache._cache,
has_entry(
PathToTestFile('cache_test'),
has_entries({
'mtime':
mtime,
'includes':
contains_exactly(
has_properties({
'name': 'foo.h',
'entry_type': 1
}))
})))
def __init__(self, user_options):
super(ClangCompleter, self).__init__(user_options)
self._completer = ycm_core.ClangCompleter()
self._flags = Flags()
self._include_cache = IncludeCache()
self._diagnostic_store = None
self._files_being_compiled = EphemeralValuesSet()
def test_IncludeCache_Cached_NewMtime( self ):
with TemporaryTestDir() as tmp_dir:
include_cache = IncludeCache()
assert_that( include_cache._cache, equal_to( {} ) )
foo_path = os.path.join( tmp_dir, 'foo' )
with open( foo_path, 'w' ) as foo_file:
foo_file.write( 'foo' )
old_includes = include_cache.GetIncludes( tmp_dir )
old_mtime = os.path.getmtime( tmp_dir )
assert_that( old_includes, contains_exactly( has_properties( {
'name': 'foo',
'entry_type': 1
} ) ) )
assert_that( include_cache._cache,
has_entry( tmp_dir,
has_entries( {
'mtime': old_mtime,
'includes': contains_exactly( has_properties( {
'name': 'foo',
'entry_type': 1
} ) )
} ) ) )
sleep( 2 )
bar_path = os.path.join( tmp_dir, 'bar' )
with open( bar_path, 'w' ) as bar_file:
bar_file.write( 'bar' )
new_includes = include_cache.GetIncludes( tmp_dir )
new_mtime = os.path.getmtime( tmp_dir )
assert_that( old_mtime, not_( equal_to( new_mtime ) ) )
assert_that( new_includes, contains_inanyorder(
has_properties( {
'name': 'foo',
'entry_type': 1
} ),
has_properties( {
'name': 'bar',
'entry_type': 1
} )
) )
assert_that( include_cache._cache,
has_entry( tmp_dir, has_entries( {
'mtime': new_mtime,
'includes': contains_inanyorder(
has_properties( {
'name': 'foo',
'entry_type': 1
} ),
has_properties( {
'name': 'bar',
'entry_type': 1
} ) )
} ) ) )
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._flags = Flags()
self._include_cache = IncludeCache()
self._diagnostic_store = None
self._files_being_compiled = EphemeralValuesSet()
self._logger = logging.getLogger( __name__ )
def IncludeCache_Cached_NoNewMtime_test():
include_cache = IncludeCache()
eq_(include_cache._cache, {})
old_includes = include_cache.GetIncludes(PathToTestFile('cache_test'))
old_mtime = os.path.getmtime(PathToTestFile('cache_test'))
assert_that(old_includes,
contains(has_properties({
'name': 'foo.h',
'entry_type': 1
})))
assert_that(
include_cache._cache,
has_entry(
PathToTestFile('cache_test'),
has_entries({
'mtime':
old_mtime,
'includes':
contains(has_properties({
'name': 'foo.h',
'entry_type': 1
}))
})))
new_includes = include_cache.GetIncludes(PathToTestFile('cache_test'))
new_mtime = os.path.getmtime(PathToTestFile('cache_test'))
eq_(new_mtime, old_mtime)
assert_that(new_includes,
contains(has_properties({
'name': 'foo.h',
'entry_type': 1
})))
assert_that(
include_cache._cache,
has_entry(
PathToTestFile('cache_test'),
has_entries({
'mtime':
new_mtime,
'includes':
contains(has_properties({
'name': 'foo.h',
'entry_type': 1
}))
})))
def IncludeCache_NotCached_DirInaccessible_test():
include_cache = IncludeCache()
assert_that(include_cache._cache, equal_to({}))
includes = include_cache.GetIncludes(PathToTestFile('unknown_dir'))
assert_that(includes, equal_to([]))
assert_that(include_cache._cache, equal_to({}))
class ClangCompleter(Completer):
def __init__(self, user_options):
super(ClangCompleter, self).__init__(user_options)
self._completer = ycm_core.ClangCompleter()
self._flags = Flags()
self._include_cache = IncludeCache()
self._diagnostic_store = None
self._files_being_compiled = EphemeralValuesSet()
def SupportedFiletypes(self):
return CLANG_FILETYPES
def GetUnsavedFilesVector(self, request_data):
files = ycm_core.UnsavedFileVector()
for filename, file_data in iteritems(request_data['file_data']):
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 = ToCppStringCompatible(contents)
unsaved_file.contents_ = utf8_contents
unsaved_file.length_ = len(utf8_contents)
unsaved_file.filename_ = ToCppStringCompatible(filename)
files.append(unsaved_file)
return files
def ShouldCompleteIncludeStatement(self, request_data):
column_codepoint = request_data['column_codepoint'] - 1
current_line = request_data['line_value']
return INCLUDE_REGEX.match(current_line[:column_codepoint])
def ShouldUseNowInner(self, request_data):
if self.ShouldCompleteIncludeStatement(request_data):
return True
return super(ClangCompleter, self).ShouldUseNowInner(request_data)
def GetIncludePaths(self, request_data):
column_codepoint = request_data['column_codepoint'] - 1
current_line = request_data['line_value']
line = current_line[:column_codepoint]
path_dir, quoted_include, start_codepoint = (
GetIncompleteIncludeValue(line))
if start_codepoint is None:
return None
request_data['start_codepoint'] = start_codepoint
# We do what GCC does for <> versus "":
# http://gcc.gnu.org/onlinedocs/cpp/Include-Syntax.html
flags, filepath = self._FlagsForRequest(request_data)
(quoted_include_paths, include_paths,
framework_paths) = UserIncludePaths(flags, filepath)
if quoted_include:
include_paths.extend(quoted_include_paths)
includes = IncludeList()
for include_path in include_paths:
unicode_path = ToUnicode(os.path.join(include_path, path_dir))
includes.AddIncludes(self._include_cache.GetIncludes(unicode_path))
if framework_paths:
if path_dir:
head, tail = PathLeftSplit(path_dir)
path_dir = os.path.join(head + '.framework', 'Headers', tail)
for framework_path in framework_paths:
unicode_path = ToUnicode(os.path.join(framework_path,
path_dir))
includes.AddIncludes(
self._include_cache.GetIncludes(unicode_path,
is_framework=not path_dir))
return includes.GetIncludes()
def ComputeCandidatesInner(self, request_data):
flags, filename = self._FlagsForRequest(request_data)
if not flags:
raise RuntimeError(NO_COMPILE_FLAGS_MESSAGE)
includes = self.GetIncludePaths(request_data)
if includes is not None:
return includes
if self._completer.UpdatingTranslationUnit(
ToCppStringCompatible(filename)):
raise RuntimeError(PARSING_FILE_MESSAGE)
files = self.GetUnsavedFilesVector(request_data)
line = request_data['line_num']
column = request_data['start_column']
with self._files_being_compiled.GetExclusive(filename):
results = self._completer.CandidatesForLocationInFile(
ToCppStringCompatible(filename),
ToCppStringCompatible(request_data['filepath']), line, column,
files, flags)
if not results:
raise RuntimeError(NO_COMPLETIONS_MESSAGE)
return [ConvertCompletionData(x) for x in results]
def GetSubcommandsMap(self):
return {
'GoToDefinition': (lambda self, request_data, args: self.
_GoToDefinition(request_data)),
'GoToDeclaration': (lambda self, request_data, args: self.
_GoToDeclaration(request_data)),
'GoTo':
(lambda self, request_data, args: self._GoTo(request_data)),
'GoToImprecise':
(lambda self, request_data, args: self._GoToImprecise(request_data)
),
'GoToInclude':
(lambda self, request_data, args: self._GoToInclude(request_data)),
'ClearCompilationFlagCache': (lambda self, request_data, args: self
._ClearCompilationFlagCache()),
'GetType': (lambda self, request_data, args: self._GetSemanticInfo(
request_data, func='GetTypeAtLocation')),
'GetTypeImprecise':
(lambda self, request_data, args: self._GetSemanticInfo(
request_data, func='GetTypeAtLocation', reparse=False)),
'GetParent':
(lambda self, request_data, args: self._GetSemanticInfo(
request_data, func='GetEnclosingFunctionAtLocation')),
'FixIt':
(lambda self, request_data, args: self._FixIt(request_data)),
'GetDoc': (lambda self, request_data, args: self._GetSemanticInfo(
request_data,
reparse=True,
func='GetDocsForLocationInFile',
response_builder=_BuildGetDocResponse)),
'GetDocImprecise':
(lambda self, request_data, args: self._GetSemanticInfo(
request_data,
reparse=False,
func='GetDocsForLocationInFile',
response_builder=_BuildGetDocResponse)),
}
def _LocationForGoTo(self, goto_function, request_data, reparse=True):
flags, filename = self._FlagsForRequest(request_data)
if not flags:
raise ValueError(NO_COMPILE_FLAGS_MESSAGE)
if self._completer.UpdatingTranslationUnit(
ToCppStringCompatible(filename)):
raise RuntimeError(PARSING_FILE_MESSAGE)
files = self.GetUnsavedFilesVector(request_data)
line = request_data['line_num']
column = request_data['column_num']
return getattr(self._completer, goto_function)(
ToCppStringCompatible(filename),
ToCppStringCompatible(request_data['filepath']), line, column,
files, flags, reparse)
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 _ResponseForLocation(location)
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 _ResponseForLocation(location)
def _GoTo(self, request_data):
include_response = self._ResponseForInclude(request_data)
if include_response:
return include_response
location = self._LocationForGoTo('GetDefinitionOrDeclarationLocation',
request_data)
if not location or not location.IsValid():
raise RuntimeError('Can\'t jump to definition or declaration.')
return _ResponseForLocation(location)
def _GoToImprecise(self, request_data):
include_response = self._ResponseForInclude(request_data)
if include_response:
return include_response
location = self._LocationForGoTo('GetDefinitionOrDeclarationLocation',
request_data,
reparse=False)
if not location or not location.IsValid():
raise RuntimeError('Can\'t jump to definition or declaration.')
return _ResponseForLocation(location)
def _ResponseForInclude(self, request_data):
"""Returns response for include file location if cursor is on the
include statement, None otherwise.
Throws RuntimeError if cursor is on include statement and corresponding
include file not found."""
current_line = request_data['line_value']
include_file_name, quoted_include = GetFullIncludeValue(current_line)
if not include_file_name:
return None
flags, current_file_path = self._FlagsForRequest(request_data)
(quoted_include_paths, include_paths,
framework_paths) = UserIncludePaths(flags, current_file_path)
include_file_path = None
if quoted_include:
include_file_path = _GetAbsolutePath(include_file_name,
quoted_include_paths)
if not include_file_path:
include_file_path = _GetAbsolutePath(include_file_name,
include_paths)
if not include_file_path and framework_paths:
head, tail = PathLeftSplit(include_file_name)
include_file_name = os.path.join(head + '.framework', 'Headers',
tail)
include_file_path = _GetAbsolutePath(include_file_name,
framework_paths)
if include_file_path:
return responses.BuildGoToResponse(include_file_path,
line_num=1,
column_num=1)
raise RuntimeError('Include file not found.')
def _GoToInclude(self, request_data):
include_response = self._ResponseForInclude(request_data)
if not include_response:
raise RuntimeError('Not an include/import line.')
return include_response
def _GetSemanticInfo(
self,
request_data,
func,
response_builder=responses.BuildDisplayMessageResponse,
reparse=True):
flags, filename = self._FlagsForRequest(request_data)
if not flags:
raise ValueError(NO_COMPILE_FLAGS_MESSAGE)
if self._completer.UpdatingTranslationUnit(
ToCppStringCompatible(filename)):
raise RuntimeError(PARSING_FILE_MESSAGE)
files = self.GetUnsavedFilesVector(request_data)
line = request_data['line_num']
column = request_data['column_num']
message = getattr(self._completer, func)(
ToCppStringCompatible(filename),
ToCppStringCompatible(request_data['filepath']), line, column,
files, flags, reparse)
if not message:
message = "No semantic information available"
return response_builder(message)
def _ClearCompilationFlagCache(self):
self._flags.Clear()
def _FixIt(self, request_data):
flags, filename = self._FlagsForRequest(request_data)
if not flags:
raise ValueError(NO_COMPILE_FLAGS_MESSAGE)
if self._completer.UpdatingTranslationUnit(
ToCppStringCompatible(filename)):
raise RuntimeError(PARSING_FILE_MESSAGE)
files = self.GetUnsavedFilesVector(request_data)
line = request_data['line_num']
column = request_data['column_num']
fixits = getattr(self._completer, "GetFixItsForLocationInFile")(
ToCppStringCompatible(filename),
ToCppStringCompatible(request_data['filepath']), line, column,
files, flags, True)
# don't raise an error if not fixits: - leave that to the client to respond
# in a nice way
return responses.BuildFixItResponse(fixits)
def OnFileReadyToParse(self, request_data):
flags, filename = self._FlagsForRequest(request_data)
if not flags:
raise ValueError(NO_COMPILE_FLAGS_MESSAGE)
with self._files_being_compiled.GetExclusive(filename):
diagnostics = self._completer.UpdateTranslationUnit(
ToCppStringCompatible(filename),
self.GetUnsavedFilesVector(request_data), flags)
diagnostics = _FilterDiagnostics(diagnostics)
self._diagnostic_store = DiagnosticsToDiagStructure(diagnostics)
return responses.BuildDiagnosticResponse(
diagnostics, request_data['filepath'],
self.max_diagnostics_to_display)
def OnBufferUnload(self, request_data):
# FIXME: The filepath here is (possibly) wrong when overriding the
# translation unit filename. If the buffer that the user closed is not the
# "translation unit" filename, then we won't close the unit. It would
# require the user to open the translation unit file, and close that.
# Incidentally, doing so would flush the unit for any _other_ open files
# which use that translation unit.
#
# Solving this would require remembering the graph of files to translation
# units and only closing a unit when there are no files open which use it.
self._completer.DeleteCachesForFile(
ToCppStringCompatible(request_data['filepath']))
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.long_formatted_text_)
def DebugInfo(self, request_data):
try:
# Note that it only raises NoExtraConfDetected:
# - when extra_conf is None and,
# - there is no compilation database
flags, filename = self._FlagsForRequest(request_data) or []
except (NoExtraConfDetected, UnknownExtraConf):
# If _FlagsForRequest returns None or raises, we use an empty list in
# practice.
flags = []
filename = request_data['filepath']
database = self._flags.LoadCompilationDatabase(filename)
database_directory = database.database_directory if database else None
database_item = responses.DebugInfoItem(
key='compilation database path',
value='{0}'.format(database_directory))
flags_item = responses.DebugInfoItem(key='flags',
value='{0}'.format(list(flags)))
filename_item = responses.DebugInfoItem(key='translation unit',
value=filename)
return responses.BuildDebugInfoResponse(
name='C-family', items=[database_item, flags_item, filename_item])
def _FlagsForRequest(self, request_data):
filename = request_data['filepath']
if 'compilation_flags' in request_data:
# Not supporting specifying the translation unit using this method as it
# is only used by the tests.
return (PrepareFlagsForClang(request_data['compilation_flags'],
filename), filename)
client_data = request_data['extra_conf_data']
return self._flags.FlagsForFile(filename, client_data=client_data)
def IncludeCache_NotCached_DirInaccessible_test():
include_cache = IncludeCache()
eq_(include_cache._cache, {})
includes = include_cache.GetIncludes(PathToTestFile('unknown_dir'))
eq_(includes, [])
eq_(include_cache._cache, {})