4d97437872
Moved File parse request handling and diagnostic extraction flow into python to simplify flow and allow easier addition of new parse request handlers such as semantic highlighter. Refactored base_test to patch separate vimsupport functions instead of the whole module, and interfering the test results afterwards. Added new tests for diagnostic sign place/unplace and error/warning count extraction API.
864 lines
26 KiB
VimL
864 lines
26 KiB
VimL
" Copyright (C) 2011, 2012 Google Inc.
|
|
"
|
|
" 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/>.
|
|
|
|
" This is basic vim plugin boilerplate
|
|
let s:save_cpo = &cpo
|
|
set cpo&vim
|
|
|
|
" This needs to be called outside of a function
|
|
let s:script_folder_path = escape( expand( '<sfile>:p:h' ), '\' )
|
|
let s:omnifunc_mode = 0
|
|
let s:defer_omnifunc = 1
|
|
|
|
let s:old_cursor_position = []
|
|
let s:cursor_moved = 0
|
|
let s:moved_vertically_in_insert_mode = 0
|
|
let s:previous_num_chars_on_current_line = strlen( getline('.') )
|
|
|
|
|
|
function! youcompleteme#Enable()
|
|
" When vim is in diff mode, don't run
|
|
if &diff
|
|
return
|
|
endif
|
|
|
|
call s:SetUpBackwardsCompatibility()
|
|
|
|
" This can be 0 if YCM libs are old or -1 if an exception occured while
|
|
" executing the function.
|
|
if s:SetUpPython() != 1
|
|
return
|
|
endif
|
|
|
|
call s:SetUpCommands()
|
|
call s:SetUpCpoptions()
|
|
call s:SetUpCompleteopt()
|
|
call s:SetUpKeyMappings()
|
|
|
|
if g:ycm_show_diagnostics_ui
|
|
call s:TurnOffSyntasticForCFamily()
|
|
endif
|
|
|
|
call s:SetUpSigns()
|
|
call s:SetUpSyntaxHighlighting()
|
|
|
|
if g:ycm_allow_changing_updatetime && &updatetime > 2000
|
|
set ut=2000
|
|
endif
|
|
|
|
call youcompleteme#EnableCursorMovedAutocommands()
|
|
augroup youcompleteme
|
|
autocmd!
|
|
" Note that these events will NOT trigger for the file vim is started with;
|
|
" so if you do "vim foo.cc", these events will not trigger when that buffer
|
|
" is read. This is because youcompleteme#Enable() is called on VimEnter and
|
|
" that happens *after" BufRead/BufEnter has already triggered for the
|
|
" initial file.
|
|
" We also need to trigger buf init code on the FileType event because when
|
|
" the user does :enew and then :set ft=something, we need to run buf init
|
|
" code again.
|
|
autocmd BufReadPre * call s:OnBufferReadPre( expand( '<afile>:p' ) )
|
|
autocmd BufRead,BufEnter,FileType * call s:OnBufferVisit()
|
|
autocmd BufUnload * call s:OnBufferUnload( expand( '<afile>:p' ) )
|
|
autocmd CursorHold,CursorHoldI * call s:OnCursorHold()
|
|
autocmd InsertLeave * call s:OnInsertLeave()
|
|
autocmd InsertEnter * call s:OnInsertEnter()
|
|
autocmd VimLeave * call s:OnVimLeave()
|
|
autocmd CompleteDone * call s:OnCompleteDone()
|
|
augroup END
|
|
|
|
" Setting the omnifunc require us to ask the server if it has a Native
|
|
" Semantic Completer for the current buffer's filetype. When vim first start
|
|
" this mean that we have to wait for the server to be up and running which
|
|
" would block vim's GUI. To avoid this we defer setting the omnifunc the
|
|
" first time to when we enter Insert mode and then update it on every
|
|
" BufferVisit as normal.
|
|
if s:defer_omnifunc
|
|
augroup ycm_defer_omnifunc
|
|
autocmd!
|
|
autocmd InsertEnter * call s:SetOmnicompleteFunc()
|
|
\ | let s:defer_omnifunc = 0
|
|
\ | autocmd! ycm_defer_omnifunc
|
|
augroup END
|
|
endif
|
|
|
|
" Calling these once solves the problem of BufReadPre/BufRead/BufEnter not
|
|
" triggering for the first loaded file. This should be the last commands
|
|
" executed in this function!
|
|
call s:OnBufferReadPre( expand( '<afile>:p' ) )
|
|
call s:OnBufferVisit()
|
|
endfunction
|
|
|
|
|
|
function! youcompleteme#EnableCursorMovedAutocommands()
|
|
augroup ycmcompletemecursormove
|
|
autocmd!
|
|
autocmd CursorMovedI * call s:OnCursorMovedInsertMode()
|
|
autocmd CursorMoved * call s:OnCursorMovedNormalMode()
|
|
augroup END
|
|
endfunction
|
|
|
|
|
|
function! youcompleteme#DisableCursorMovedAutocommands()
|
|
autocmd! ycmcompletemecursormove CursorMoved *
|
|
autocmd! ycmcompletemecursormove CursorMovedI *
|
|
endfunction
|
|
|
|
|
|
function! youcompleteme#GetErrorCount()
|
|
return pyeval( 'ycm_state.GetErrorCount()' )
|
|
endfunction
|
|
|
|
|
|
function! youcompleteme#GetWarningCount()
|
|
return pyeval( 'ycm_state.GetWarningCount()' )
|
|
endfunction
|
|
|
|
|
|
function! s:SetUpPython() abort
|
|
python << EOF
|
|
import sys
|
|
import vim
|
|
import os
|
|
import subprocess
|
|
|
|
script_folder = vim.eval( 's:script_folder_path' )
|
|
sys.path.insert( 0, os.path.join( script_folder, '../python' ) )
|
|
sys.path.insert( 0, os.path.join( script_folder, '../third_party/ycmd' ) )
|
|
from ycmd import utils
|
|
utils.AddNearestThirdPartyFoldersToSysPath( script_folder )
|
|
|
|
# We need to import ycmd's third_party folders as well since we import and
|
|
# use ycmd code in the client.
|
|
utils.AddNearestThirdPartyFoldersToSysPath( utils.__file__ )
|
|
from ycm import base
|
|
base.LoadJsonDefaultsIntoVim()
|
|
from ycmd import user_options_store
|
|
user_options_store.SetAll( base.BuildServerConf() )
|
|
from ycm import paths, vimsupport
|
|
|
|
popen_args = [ paths.PathToPythonInterpreter(),
|
|
paths.PathToCheckCoreVersion() ]
|
|
|
|
if utils.SafePopen( popen_args ).wait() == 2:
|
|
vimsupport.PostVimMessage(
|
|
'YouCompleteMe unavailable: YCM support libs too old, PLEASE RECOMPILE' )
|
|
vim.command( 'return 0' )
|
|
|
|
from ycm.youcompleteme import YouCompleteMe
|
|
ycm_state = YouCompleteMe( user_options_store.GetAll() )
|
|
vim.command( 'return 1' )
|
|
EOF
|
|
endfunction
|
|
|
|
|
|
function! s:SetUpKeyMappings()
|
|
" The g:ycm_key_select_completion and g:ycm_key_previous_completion used to
|
|
" exist and are now here purely for the sake of backwards compatibility; we
|
|
" don't want to break users if we can avoid it.
|
|
|
|
if exists('g:ycm_key_select_completion') &&
|
|
\ index(g:ycm_key_list_select_completion,
|
|
\ g:ycm_key_select_completion) == -1
|
|
call add(g:ycm_key_list_select_completion, g:ycm_key_select_completion)
|
|
endif
|
|
|
|
if exists('g:ycm_key_previous_completion') &&
|
|
\ index(g:ycm_key_list_previous_completion,
|
|
\ g:ycm_key_previous_completion) == -1
|
|
call add(g:ycm_key_list_previous_completion, g:ycm_key_previous_completion)
|
|
endif
|
|
|
|
for key in g:ycm_key_list_select_completion
|
|
" With this command, when the completion window is visible, the tab key
|
|
" (default) will select the next candidate in the window. In vim, this also
|
|
" changes the typed-in text to that of the candidate completion.
|
|
exe 'inoremap <expr>' . key .
|
|
\ ' pumvisible() ? "\<C-n>" : "\' . key .'"'
|
|
endfor
|
|
|
|
|
|
for key in g:ycm_key_list_previous_completion
|
|
" This selects the previous candidate for shift-tab (default)
|
|
exe 'inoremap <expr>' . key .
|
|
\ ' pumvisible() ? "\<C-p>" : "\' . key .'"'
|
|
endfor
|
|
|
|
if !empty( g:ycm_key_invoke_completion )
|
|
let invoke_key = g:ycm_key_invoke_completion
|
|
|
|
" Inside the console, <C-Space> is passed as <Nul> to Vim
|
|
if invoke_key ==# '<C-Space>'
|
|
imap <Nul> <C-Space>
|
|
endif
|
|
|
|
" <c-x><c-o> trigger omni completion, <c-p> deselects the first completion
|
|
" candidate that vim selects by default
|
|
silent! exe 'inoremap <unique> ' . invoke_key . ' <C-X><C-O><C-P>'
|
|
endif
|
|
|
|
if !empty( g:ycm_key_detailed_diagnostics )
|
|
silent! exe 'nnoremap <unique> ' . g:ycm_key_detailed_diagnostics .
|
|
\ ' :YcmShowDetailedDiagnostic<cr>'
|
|
endif
|
|
endfunction
|
|
|
|
|
|
function! s:SetUpSigns()
|
|
" We try to ensure backwards compatibility with Syntastic if the user has
|
|
" already defined styling for Syntastic highlight groups.
|
|
|
|
if !hlexists( 'YcmErrorSign' )
|
|
if hlexists( 'SyntasticErrorSign')
|
|
highlight link YcmErrorSign SyntasticErrorSign
|
|
else
|
|
highlight link YcmErrorSign error
|
|
endif
|
|
endif
|
|
|
|
if !hlexists( 'YcmWarningSign' )
|
|
if hlexists( 'SyntasticWarningSign')
|
|
highlight link YcmWarningSign SyntasticWarningSign
|
|
else
|
|
highlight link YcmWarningSign todo
|
|
endif
|
|
endif
|
|
|
|
if !hlexists( 'YcmErrorLine' )
|
|
highlight link YcmErrorLine SyntasticErrorLine
|
|
endif
|
|
|
|
if !hlexists( 'YcmWarningLine' )
|
|
highlight link YcmWarningLine SyntasticWarningLine
|
|
endif
|
|
|
|
exe 'sign define YcmError text=' . g:ycm_error_symbol .
|
|
\ ' texthl=YcmErrorSign linehl=YcmErrorLine'
|
|
exe 'sign define YcmWarning text=' . g:ycm_warning_symbol .
|
|
\ ' texthl=YcmWarningSign linehl=YcmWarningLine'
|
|
endfunction
|
|
|
|
|
|
function! s:SetUpSyntaxHighlighting()
|
|
" We try to ensure backwards compatibility with Syntastic if the user has
|
|
" already defined styling for Syntastic highlight groups.
|
|
|
|
if !hlexists( 'YcmErrorSection' )
|
|
if hlexists( 'SyntasticError' )
|
|
highlight link YcmErrorSection SyntasticError
|
|
else
|
|
highlight link YcmErrorSection SpellBad
|
|
endif
|
|
endif
|
|
|
|
if !hlexists( 'YcmWarningSection' )
|
|
if hlexists( 'SyntasticWarning' )
|
|
highlight link YcmWarningSection SyntasticWarning
|
|
else
|
|
highlight link YcmWarningSection SpellCap
|
|
endif
|
|
endif
|
|
endfunction
|
|
|
|
|
|
function! s:SetUpBackwardsCompatibility()
|
|
let complete_in_comments_and_strings =
|
|
\ get( g:, 'ycm_complete_in_comments_and_strings', 0 )
|
|
|
|
if complete_in_comments_and_strings
|
|
let g:ycm_complete_in_strings = 1
|
|
let g:ycm_complete_in_comments = 1
|
|
endif
|
|
|
|
" ycm_filetypes_to_completely_ignore is the old name for fileype_blacklist
|
|
if has_key( g:, 'ycm_filetypes_to_completely_ignore' )
|
|
let g:filetype_blacklist = g:ycm_filetypes_to_completely_ignore
|
|
endif
|
|
endfunction
|
|
|
|
|
|
" Needed so that YCM is used instead of Syntastic
|
|
function! s:TurnOffSyntasticForCFamily()
|
|
let g:syntastic_cpp_checkers = []
|
|
let g:syntastic_c_checkers = []
|
|
let g:syntastic_objc_checkers = []
|
|
let g:syntastic_objcpp_checkers = []
|
|
endfunction
|
|
|
|
|
|
function! s:AllowedToCompleteInCurrentFile()
|
|
if empty( &filetype ) ||
|
|
\ getbufvar( winbufnr( winnr() ), "&buftype" ) ==# 'nofile' ||
|
|
\ &filetype ==# 'qf'
|
|
return 0
|
|
endif
|
|
|
|
if exists( 'b:ycm_largefile' )
|
|
return 0
|
|
endif
|
|
|
|
let whitelist_allows = has_key( g:ycm_filetype_whitelist, '*' ) ||
|
|
\ has_key( g:ycm_filetype_whitelist, &filetype )
|
|
let blacklist_allows = !has_key( g:ycm_filetype_blacklist, &filetype )
|
|
|
|
return whitelist_allows && blacklist_allows
|
|
endfunction
|
|
|
|
|
|
function! s:SetUpCommands()
|
|
command! YcmRestartServer call s:RestartServer()
|
|
command! YcmShowDetailedDiagnostic call s:ShowDetailedDiagnostic()
|
|
command! YcmDebugInfo call s:DebugInfo()
|
|
command! -nargs=? -complete=custom,youcompleteme#LogsComplete
|
|
\ YcmToggleLogs call s:ToggleLogs(<f-args>)
|
|
command! -nargs=* -complete=custom,youcompleteme#SubCommandsComplete
|
|
\ YcmCompleter call s:CompleterCommand(<f-args>)
|
|
command! YcmForceCompileAndDiagnostics call s:ForceCompileAndDiagnostics()
|
|
command! YcmDiags call s:ShowDiagnostics()
|
|
endfunction
|
|
|
|
|
|
function! s:SetUpCpoptions()
|
|
" Without this flag in cpoptions, critical YCM mappings do not work. There's
|
|
" no way to not have this and have YCM working, so force the flag.
|
|
set cpoptions+=B
|
|
|
|
" This prevents the display of "Pattern not found" & similar messages during
|
|
" completion. This is only available since Vim 7.4.314
|
|
if pyeval( 'vimsupport.VimVersionAtLeast("7.4.314")' )
|
|
set shortmess+=c
|
|
endif
|
|
endfunction
|
|
|
|
|
|
function! s:SetUpCompleteopt()
|
|
" Some plugins (I'm looking at you, vim-notes) change completeopt by for
|
|
" instance adding 'longest'. This breaks YCM. So we force our settings.
|
|
" There's no two ways about this: if you want to use YCM then you have to
|
|
" have these completeopt settings, otherwise YCM won't work at all.
|
|
|
|
" We need menuone in completeopt, otherwise when there's only one candidate
|
|
" for completion, the menu doesn't show up.
|
|
set completeopt-=menu
|
|
set completeopt+=menuone
|
|
|
|
" This is unnecessary with our features. People use this option to insert
|
|
" the common prefix of all the matches and then add more differentiating chars
|
|
" so that they can select a more specific match. With our features, they
|
|
" don't need to insert the prefix; they just type the differentiating chars.
|
|
" Also, having this option set breaks the plugin.
|
|
set completeopt-=longest
|
|
|
|
if g:ycm_add_preview_to_completeopt
|
|
set completeopt+=preview
|
|
endif
|
|
endfunction
|
|
|
|
|
|
" For various functions/use-cases, we want to keep track of whether the buffer
|
|
" has changed since the last time they were invoked. We keep the state of
|
|
" b:changedtick of the last time the specific function was called in
|
|
" b:ycm_changedtick.
|
|
function! s:SetUpYcmChangedTick()
|
|
let b:ycm_changedtick =
|
|
\ get( b:, 'ycm_changedtick', {
|
|
\ 'file_ready_to_parse' : -1,
|
|
\ } )
|
|
endfunction
|
|
|
|
|
|
function! s:OnVimLeave()
|
|
py ycm_state.OnVimLeave()
|
|
endfunction
|
|
|
|
|
|
function! s:OnCompleteDone()
|
|
py ycm_state.OnCompleteDone()
|
|
endfunction
|
|
|
|
|
|
function! s:OnBufferReadPre(filename)
|
|
let threshold = g:ycm_disable_for_files_larger_than_kb * 1024
|
|
|
|
if threshold > 0 && getfsize( a:filename ) > threshold
|
|
echohl WarningMsg |
|
|
\ echomsg "YouCompleteMe is disabled in this buffer; " .
|
|
\ "the file exceeded the max size (see YCM options)." |
|
|
\ echohl None
|
|
let b:ycm_largefile = 1
|
|
endif
|
|
endfunction
|
|
|
|
function! s:OnBufferVisit()
|
|
" We need to do this even when we are not allowed to complete in the current
|
|
" file because we might be allowed to complete in the future! The canonical
|
|
" example is creating a new buffer with :enew and then setting a filetype.
|
|
call s:SetUpYcmChangedTick()
|
|
|
|
if !s:AllowedToCompleteInCurrentFile()
|
|
return
|
|
endif
|
|
|
|
call s:SetUpCompleteopt()
|
|
call s:SetCompleteFunc()
|
|
|
|
if !s:defer_omnifunc
|
|
call s:SetOmnicompleteFunc()
|
|
endif
|
|
|
|
py ycm_state.OnBufferVisit()
|
|
call s:OnFileReadyToParse()
|
|
endfunction
|
|
|
|
|
|
function! s:OnBufferUnload( deleted_buffer_file )
|
|
if !s:AllowedToCompleteInCurrentFile() || empty( a:deleted_buffer_file )
|
|
return
|
|
endif
|
|
|
|
py ycm_state.OnBufferUnload( vim.eval( 'a:deleted_buffer_file' ) )
|
|
endfunction
|
|
|
|
|
|
function! s:OnCursorHold()
|
|
if !s:AllowedToCompleteInCurrentFile()
|
|
return
|
|
endif
|
|
|
|
call s:SetUpCompleteopt()
|
|
call s:OnFileReadyToParse()
|
|
endfunction
|
|
|
|
|
|
function! s:OnFileReadyToParse()
|
|
" We need to call this just in case there is no b:ycm_changetick; this can
|
|
" happen for special buffers.
|
|
call s:SetUpYcmChangedTick()
|
|
|
|
" Order is important here; we need to extract any information before
|
|
" reparsing the file again. If we sent the new parse request first, then
|
|
" the response would always be pending when we called
|
|
" HandleFileParseRequest.
|
|
py ycm_state.HandleFileParseRequest()
|
|
|
|
let buffer_changed = b:changedtick != b:ycm_changedtick.file_ready_to_parse
|
|
if buffer_changed
|
|
py ycm_state.OnFileReadyToParse()
|
|
endif
|
|
let b:ycm_changedtick.file_ready_to_parse = b:changedtick
|
|
endfunction
|
|
|
|
|
|
function! s:SetCompleteFunc()
|
|
let &completefunc = 'youcompleteme#Complete'
|
|
let &l:completefunc = 'youcompleteme#Complete'
|
|
endfunction
|
|
|
|
|
|
function! s:SetOmnicompleteFunc()
|
|
if pyeval( 'ycm_state.NativeFiletypeCompletionUsable()' )
|
|
let &omnifunc = 'youcompleteme#OmniComplete'
|
|
let &l:omnifunc = 'youcompleteme#OmniComplete'
|
|
|
|
" If we don't have native filetype support but the omnifunc is set to YCM's
|
|
" omnifunc because the previous file the user was editing DID have native
|
|
" support, we remove our omnifunc.
|
|
elseif &omnifunc == 'youcompleteme#OmniComplete'
|
|
let &omnifunc = ''
|
|
let &l:omnifunc = ''
|
|
endif
|
|
endfunction
|
|
|
|
function! s:OnCursorMovedInsertMode()
|
|
if !s:AllowedToCompleteInCurrentFile()
|
|
return
|
|
endif
|
|
|
|
py ycm_state.OnCursorMoved()
|
|
call s:UpdateCursorMoved()
|
|
|
|
" Basically, we need to only trigger the completion menu when the user has
|
|
" inserted or deleted a character, NOT just when the user moves in insert mode
|
|
" (with, say, the arrow keys). If we trigger the menu even on pure moves, then
|
|
" it's impossible to move in insert mode since the up/down arrows start moving
|
|
" the selected completion in the completion menu. Yeah, people shouldn't be
|
|
" moving in insert mode at all (that's what normal mode is for) but explain
|
|
" that to the users who complain...
|
|
if !s:BufferTextChangedSinceLastMoveInInsertMode()
|
|
return
|
|
endif
|
|
|
|
call s:IdentifierFinishedOperations()
|
|
if g:ycm_autoclose_preview_window_after_completion
|
|
call s:ClosePreviewWindowIfNeeded()
|
|
endif
|
|
|
|
if g:ycm_auto_trigger || s:omnifunc_mode
|
|
call s:InvokeCompletion()
|
|
endif
|
|
|
|
" We have to make sure we correctly leave omnifunc mode even when the user
|
|
" inserts something like a "operator[]" candidate string which fails
|
|
" CurrentIdentifierFinished check.
|
|
if s:omnifunc_mode && !pyeval( 'base.LastEnteredCharIsIdentifierChar()')
|
|
let s:omnifunc_mode = 0
|
|
endif
|
|
endfunction
|
|
|
|
|
|
function! s:OnCursorMovedNormalMode()
|
|
if !s:AllowedToCompleteInCurrentFile()
|
|
return
|
|
endif
|
|
|
|
call s:OnFileReadyToParse()
|
|
py ycm_state.OnCursorMoved()
|
|
endfunction
|
|
|
|
|
|
function! s:OnInsertLeave()
|
|
if !s:AllowedToCompleteInCurrentFile()
|
|
return
|
|
endif
|
|
|
|
let s:omnifunc_mode = 0
|
|
call s:OnFileReadyToParse()
|
|
py ycm_state.OnInsertLeave()
|
|
if g:ycm_autoclose_preview_window_after_completion ||
|
|
\ g:ycm_autoclose_preview_window_after_insertion
|
|
call s:ClosePreviewWindowIfNeeded()
|
|
endif
|
|
endfunction
|
|
|
|
|
|
function! s:OnInsertEnter()
|
|
let s:previous_num_chars_on_current_line = strlen( getline('.') )
|
|
|
|
if !s:AllowedToCompleteInCurrentFile()
|
|
return
|
|
endif
|
|
|
|
let s:old_cursor_position = []
|
|
endfunction
|
|
|
|
|
|
function! s:UpdateCursorMoved()
|
|
let current_position = getpos('.')
|
|
let s:cursor_moved = current_position != s:old_cursor_position
|
|
|
|
let s:moved_vertically_in_insert_mode = s:old_cursor_position != [] &&
|
|
\ current_position[ 1 ] != s:old_cursor_position[ 1 ]
|
|
|
|
let s:old_cursor_position = current_position
|
|
endfunction
|
|
|
|
|
|
function! s:BufferTextChangedSinceLastMoveInInsertMode()
|
|
let num_chars_in_current_cursor_line = strlen( getline('.') )
|
|
|
|
if s:moved_vertically_in_insert_mode
|
|
let s:previous_num_chars_on_current_line = num_chars_in_current_cursor_line
|
|
return 0
|
|
endif
|
|
|
|
let changed_text_on_current_line = num_chars_in_current_cursor_line !=
|
|
\ s:previous_num_chars_on_current_line
|
|
let s:previous_num_chars_on_current_line = num_chars_in_current_cursor_line
|
|
|
|
return changed_text_on_current_line
|
|
endfunction
|
|
|
|
|
|
function! s:ClosePreviewWindowIfNeeded()
|
|
let current_buffer_name = bufname('')
|
|
|
|
" We don't want to try to close the preview window in special buffers like
|
|
" "[Command Line]"; if we do, Vim goes bonkers. Special buffers always start
|
|
" with '['.
|
|
if current_buffer_name[ 0 ] == '['
|
|
return
|
|
endif
|
|
|
|
" This command does the actual closing of the preview window. If no preview
|
|
" window is shown, nothing happens.
|
|
pclose
|
|
endfunction
|
|
|
|
|
|
function! s:IdentifierFinishedOperations()
|
|
if !pyeval( 'base.CurrentIdentifierFinished()' )
|
|
return
|
|
endif
|
|
py ycm_state.OnCurrentIdentifierFinished()
|
|
let s:omnifunc_mode = 0
|
|
endfunction
|
|
|
|
|
|
" Returns 1 when inside comment and 2 when inside string
|
|
function! s:InsideCommentOrString()
|
|
" Has to be col('.') -1 because col('.') doesn't exist at this point. We are
|
|
" in insert mode when this func is called.
|
|
let syntax_group = synIDattr( synIDtrans( synID( line( '.' ), col( '.' ) - 1, 1 ) ), 'name')
|
|
|
|
if stridx(syntax_group, 'Comment') > -1
|
|
return 1
|
|
endif
|
|
|
|
if stridx(syntax_group, 'String') > -1
|
|
return 2
|
|
endif
|
|
|
|
return 0
|
|
endfunction
|
|
|
|
|
|
function! s:InsideCommentOrStringAndShouldStop()
|
|
let retval = s:InsideCommentOrString()
|
|
let inside_comment = retval == 1
|
|
let inside_string = retval == 2
|
|
|
|
if inside_comment && g:ycm_complete_in_comments ||
|
|
\ inside_string && g:ycm_complete_in_strings
|
|
return 0
|
|
endif
|
|
|
|
return retval
|
|
endfunction
|
|
|
|
|
|
function! s:OnBlankLine()
|
|
return pyeval( 'not vim.current.line or vim.current.line.isspace()' )
|
|
endfunction
|
|
|
|
|
|
function! s:InvokeCompletion()
|
|
if &completefunc != "youcompleteme#Complete"
|
|
return
|
|
endif
|
|
|
|
if s:InsideCommentOrStringAndShouldStop() || s:OnBlankLine()
|
|
return
|
|
endif
|
|
|
|
" This is tricky. First, having 'refresh' set to 'always' in the dictionary
|
|
" that our completion function returns makes sure that our completion function
|
|
" is called on every keystroke. Second, when the sequence of characters the
|
|
" user typed produces no results in our search an infinite loop can occur. The
|
|
" problem is that our feedkeys call triggers the OnCursorMovedI event which we
|
|
" are tied to. We prevent this infinite loop from starting by making sure that
|
|
" the user has moved the cursor since the last time we provided completion
|
|
" results.
|
|
if !s:cursor_moved
|
|
return
|
|
endif
|
|
|
|
" <c-x><c-u> invokes the user's completion function (which we have set to
|
|
" youcompleteme#Complete), and <c-p> tells Vim to select the previous
|
|
" completion candidate. This is necessary because by default, Vim selects the
|
|
" first candidate when completion is invoked, and selecting a candidate
|
|
" automatically replaces the current text with it. Calling <c-p> forces Vim to
|
|
" deselect the first candidate and in turn preserve the user's current text
|
|
" until he explicitly chooses to replace it with a completion.
|
|
call feedkeys( "\<C-X>\<C-U>\<C-P>", 'n' )
|
|
endfunction
|
|
|
|
|
|
python << EOF
|
|
def GetCompletionsInner():
|
|
request = ycm_state.GetCurrentCompletionRequest()
|
|
request.Start()
|
|
while not request.Done():
|
|
if bool( int( vim.eval( 'complete_check()' ) ) ):
|
|
return { 'words' : [], 'refresh' : 'always'}
|
|
|
|
results = base.AdjustCandidateInsertionText( request.Response() )
|
|
return { 'words' : results, 'refresh' : 'always' }
|
|
EOF
|
|
|
|
|
|
function! s:GetCompletions()
|
|
py results = GetCompletionsInner()
|
|
let results = pyeval( 'results' )
|
|
return results
|
|
endfunction
|
|
|
|
|
|
" This is our main entry point. This is what vim calls to get completions.
|
|
function! youcompleteme#Complete( findstart, base )
|
|
" After the user types one character after the call to the omnifunc, the
|
|
" completefunc will be called because of our mapping that calls the
|
|
" completefunc on every keystroke. Therefore we need to delegate the call we
|
|
" 'stole' back to the omnifunc
|
|
if s:omnifunc_mode
|
|
return youcompleteme#OmniComplete( a:findstart, a:base )
|
|
endif
|
|
|
|
if a:findstart
|
|
" InvokeCompletion has this check but we also need it here because of random
|
|
" Vim bugs and unfortunate interactions with the autocommands of other
|
|
" plugins
|
|
if !s:cursor_moved
|
|
" for vim, -2 means not found but don't trigger an error message
|
|
" see :h complete-functions
|
|
return -2
|
|
endif
|
|
|
|
if !pyeval( 'ycm_state.IsServerAlive()' )
|
|
return -2
|
|
endif
|
|
py ycm_state.CreateCompletionRequest()
|
|
return pyeval( 'base.CompletionStartColumn()' )
|
|
else
|
|
return s:GetCompletions()
|
|
endif
|
|
endfunction
|
|
|
|
|
|
function! youcompleteme#OmniComplete( findstart, base )
|
|
if a:findstart
|
|
if !pyeval( 'ycm_state.IsServerAlive()' )
|
|
return -2
|
|
endif
|
|
let s:omnifunc_mode = 1
|
|
py ycm_state.CreateCompletionRequest( force_semantic = True )
|
|
return pyeval( 'base.CompletionStartColumn()' )
|
|
else
|
|
return s:GetCompletions()
|
|
endif
|
|
endfunction
|
|
|
|
|
|
function! youcompleteme#ServerPid()
|
|
return pyeval( 'ycm_state.ServerPid()' )
|
|
endfunction
|
|
|
|
|
|
function! s:RestartServer()
|
|
py ycm_state.RestartServer()
|
|
endfunction
|
|
|
|
|
|
function! s:ShowDetailedDiagnostic()
|
|
py ycm_state.ShowDetailedDiagnostic()
|
|
endfunction
|
|
|
|
|
|
function! s:DebugInfo()
|
|
echom "Printing YouCompleteMe debug information..."
|
|
let debug_info = pyeval( 'ycm_state.DebugInfo()' )
|
|
for line in split( debug_info, "\n" )
|
|
echom '-- ' . line
|
|
endfor
|
|
endfunction
|
|
|
|
|
|
function! s:ToggleLogs(...)
|
|
let stderr = a:0 == 0 || a:1 !=? 'stdout'
|
|
let stdout = a:0 == 0 || a:1 !=? 'stderr'
|
|
py ycm_state.ToggleLogs( stdout = vimsupport.GetBoolValue( 'l:stdout' ),
|
|
\ stderr = vimsupport.GetBoolValue( 'l:stderr' ) )
|
|
endfunction
|
|
|
|
|
|
function! s:CompleterCommand(...)
|
|
" CompleterCommand will call the OnUserCommand function of a completer.
|
|
" If the first arguments is of the form "ft=..." it can be used to specify the
|
|
" completer to use (for example "ft=cpp"). Else the native filetype completer
|
|
" of the current buffer is used. If no native filetype completer is found and
|
|
" no completer was specified this throws an error. You can use
|
|
" "ft=ycm:ident" to select the identifier completer.
|
|
" The remaining arguments will be passed to the completer.
|
|
let arguments = copy(a:000)
|
|
let completer = ''
|
|
|
|
if a:0 > 0 && strpart(a:1, 0, 3) == 'ft='
|
|
if a:1 == 'ft=ycm:ident'
|
|
let completer = 'identifier'
|
|
endif
|
|
let arguments = arguments[1:]
|
|
endif
|
|
|
|
py ycm_state.SendCommandRequest( vim.eval( 'l:arguments' ),
|
|
\ vim.eval( 'l:completer' ) )
|
|
endfunction
|
|
|
|
|
|
function! youcompleteme#OpenGoToList()
|
|
set lazyredraw
|
|
cclose
|
|
execute 'belowright copen 3'
|
|
set nolazyredraw
|
|
au WinLeave <buffer> q " automatically leave, if an option is chosen
|
|
redraw!
|
|
endfunction
|
|
|
|
|
|
function! youcompleteme#LogsComplete( arglead, cmdline, cursorpos )
|
|
return "stdout\nstderr"
|
|
endfunction
|
|
|
|
|
|
function! youcompleteme#SubCommandsComplete( arglead, cmdline, cursorpos )
|
|
return join( pyeval( 'ycm_state.GetDefinedSubcommands()' ),
|
|
\ "\n")
|
|
endfunction
|
|
|
|
|
|
function! s:ForceCompile()
|
|
if !pyeval( 'ycm_state.NativeFiletypeCompletionUsable()' )
|
|
echom "Native filetype completion not supported for current file, "
|
|
\ . "cannot force recompilation."
|
|
return 0
|
|
endif
|
|
|
|
echom "Forcing compilation, this will block Vim until done."
|
|
py ycm_state.OnFileReadyToParse()
|
|
py ycm_state.HandleFileParseRequest( True )
|
|
|
|
return 1
|
|
endfunction
|
|
|
|
|
|
function! s:ForceCompileAndDiagnostics()
|
|
let compilation_succeeded = s:ForceCompile()
|
|
if !compilation_succeeded
|
|
return
|
|
endif
|
|
echom "Diagnostics refreshed."
|
|
endfunction
|
|
|
|
|
|
function! s:ShowDiagnostics()
|
|
let compilation_succeeded = s:ForceCompile()
|
|
if !compilation_succeeded
|
|
return
|
|
endif
|
|
|
|
if pyeval( 'ycm_state.PopulateLocationListWithLatestDiagnostics()' )
|
|
if g:ycm_open_loclist_on_ycm_diags
|
|
lopen
|
|
endif
|
|
else
|
|
echom "No warnings or errors detected"
|
|
endif
|
|
endfunction
|
|
|
|
|
|
" This is basic vim plugin boilerplate
|
|
let &cpo = s:save_cpo
|
|
unlet s:save_cpo
|