Conquer of Completion

CI (Linux, macOS)	Coverage	Gitter	Doc

Coc is an intellisense engine for vim8 & neovim.

It's a completion framework, language server client which support extension features of VSCode

True snippet and additional text edit support

Checkout doc/coc.txt for vim interface.

Why?

• 🚀 Fast: instant increment completion, increment buffer sync using buffer update events.
• 💎 Reliable: typed language, tested with CI.
• 🌟 Featured: full LSP support
• ❤️ Flexible: configured as VSCode, extensions works like VSCode

Completion experience

You might wondering why another completion engine since there're already widely used YouCompleteMe and deoplete.nvim.

Below is the reasons that lead to coc.nvim build it's own engine:

• Full LSP completion support, especially snippet and additionalTextEdit feature, you'll understand why it's awesome when you experience it with coc extension like coc-tsserver.
• Does completion resolve on completion item change. The detail from complete item is echoed after selected, we will have floating window for documentation when floating window is supported.
• Start completion without timer. The completion would start after you type first letter of word by default, and filtered with new input when completion finished, while some completion engine use timer to trigger completion and you always have to wait after type character.
• Realtime buffer keywords. Coc generate buffer keywords on buffer change in background (with debounce), while some completion engines use cache which could be wrong sometimes. And Locality bonus feature from VSCode is enabled by default.
• Filter completion items when possible. When your does fuzzy filter with completion items (which would trigger TextChangedI during completion), some completion engines would trigger new completion, but coc filter the items when possible which makes coc much faster. Filter completion items on backspace is also supported.

Table of contents

• Installation

  For vim-plug user. Add:

  Plug 'neoclide/coc.nvim', {'tag': '*', 'do': { -> coc#util#install()}}

  Or build from source code by install nodejs and yarn

  curl -sL install-node.now.sh/lts | sh
  curl --compressed -o- -L https://yarnpkg.com/install.sh | bash

  And add:

  Plug 'neoclide/coc.nvim', {'do': 'yarn install'}

  to your .vimrc or init.vim, restart vim and run :PlugInstall.

  For other plugin manager, run command :call coc#util#install() to download binary after coc is installed.

  Note: neovim >= 0.3.0 or vim >= 8.1 is required.

  Note: for vim user, global installed vim-node-rpc module required.

• Completion with sources

  • Trigger mode of completion
  • Use <Tab> or custom key for trigger completion
  • Improve completion experience
  • Completion sources

• Using snippets

• Using extensions

  • Manage extensions

• Using configuration file

  • Configuration file resolve
  • Default COC preferences
  • Configuration for sources
  • Extension configuration

• Language servers

  • Supported features

  • Register custom language servers

    • Dart
    • Flow
    • C/C++/Objective-C
    • Go
    • PHP
    • Dockerfile
    • Bash
    • Lua
    • OCaml and ReasonML

• Statusline integration

• Debug language server

• F.A.Q

Completion sources

Completion for words of buffers and file path are supported by default.

For other completion sources, check out:

• coc-sources: includes some common completion source extensions.
• coc-neco: viml completion support.

Or you can create custom source.

Extensions

Extension are powerful than configured language server. Checkout Using coc extensions.

• coc-json for json.
• coc-tsserver for javascript and typescript.
• coc-html for html, handlebars and razor.
• coc-css for css, scss and less.
• coc-vetur for vue, use vetur.
• coc-java for java, use eclipse.jdt.ls.
• coc-solargraph for ruby, use solargraph.
• coc-rls for rust, use Rust Language Server
• coc-yaml for yaml
• coc-pyls for python, use Python Language Server
• coc-highlight provide default document symbol highlight and colors support.
• coc-emmet provide emmet suggest in completion list.

And more, to get full list of coc extensions, search coc.nvim on npm.

Note: use :CocConfig to edit configuration file, auto completion is supported after coc-json installed.

Example vim configuration

" if hidden not set, TextEdit might fail.
set hidden

" Better display for messages
set cmdheight=2

" Smaller updatetime for CursorHold & CursorHoldI
set updatetime=300

" always show signcolumns
set signcolumn=yes

" Use tab for trigger completion with characters ahead and navigate.
" Use command ':verbose imap <tab>' to make sure tab is not mapped by other plugin.
inoremap <silent><expr> <TAB>
      \ pumvisible() ? "\<C-n>" :
      \ <SID>check_back_space() ? "\<TAB>" :
      \ coc#refresh()
inoremap <expr><S-TAB> pumvisible() ? "\<C-p>" : "\<C-h>"

function! s:check_back_space() abort
  let col = col('.') - 1
  return !col || getline('.')[col - 1]  =~# '\s'
endfunction

" Use <c-space> for trigger completion.
inoremap <silent><expr> <c-space> coc#refresh()

" Use <cr> for confirm completion, `<C-g>u` means break undo chain at current position.
" Coc only does snippet and additional edit on confirm.
inoremap <expr> <cr> pumvisible() ? "\<C-y>" : "\<C-g>u\<CR>"

" Use `[c` and `]c` for navigate diagnostics
nmap <silent> [c <Plug>(coc-diagnostic-prev)
nmap <silent> ]c <Plug>(coc-diagnostic-next)

" Remap keys for gotos
nmap <silent> gd <Plug>(coc-definition)
nmap <silent> gy <Plug>(coc-type-definition)
nmap <silent> gi <Plug>(coc-implementation)
nmap <silent> gr <Plug>(coc-references)

" Use K for show documentation in preview window
nnoremap <silent> K :call <SID>show_documentation()<CR>

function! s:show_documentation()
  if &filetype == 'vim'
    execute 'h '.expand('<cword>')
  else
    call CocAction('doHover')
  endif
endfunction

" Highlight symbol under cursor on CursorHold
autocmd CursorHold * silent call CocActionAsync('highlight')

" Remap for rename current word
nmap <leader>rn <Plug>(coc-rename)

" Remap for format selected region
vmap <leader>f  <Plug>(coc-format-selected)
nmap <leader>f  <Plug>(coc-format-selected)

augroup mygroup
  autocmd!
  " Setup formatexpr specified filetype(s).
  autocmd FileType typescript,json setl formatexpr=CocAction('formatSelected')
  " Update signature help on jump placeholder
  autocmd User CocJumpPlaceholder call CocActionAsync('showSignatureHelp')
augroup end

" Remap for do codeAction of selected region, ex: `<leader>aap` for current paragraph
vmap <leader>a  <Plug>(coc-codeaction-selected)
nmap <leader>a  <Plug>(coc-codeaction-selected)

" Remap for do codeAction of current line
nmap <leader>ac  <Plug>(coc-codeaction)
" Fix autofix problem of current line
nmap <leader>qf  <Plug>(coc-fix-current)

" Use `:Format` for format current buffer
command! -nargs=0 Format :call CocAction('format')

" Use `:Fold` for fold current buffer
command! -nargs=? Fold :call     CocAction('fold', <f-args>)


" Add diagnostic info for https://github.com/itchyny/lightline.vim
let g:lightline = {
      \ 'colorscheme': 'wombat',
      \ 'active': {
      \   'left': [ [ 'mode', 'paste' ],
      \             [ 'cocstatus', 'readonly', 'filename', 'modified' ] ]
      \ },
      \ 'component_function': {
      \   'cocstatus': 'coc#status'
      \ },
      \ }



" Shortcuts for denite interface
" Show extension list
nnoremap <silent> <space>e  :<C-u>Denite coc-extension<cr>
" Show symbols of current buffer
nnoremap <silent> <space>o  :<C-u>Denite coc-symbols<cr>
" Search symbols of current workspace
nnoremap <silent> <space>t  :<C-u>Denite coc-workspace<cr>
" Show diagnostics of current workspace
nnoremap <silent> <space>a  :<C-u>Denite coc-diagnostic<cr>
" Show available commands
nnoremap <silent> <space>c  :<C-u>Denite coc-command<cr>
" Show available services
nnoremap <silent> <space>s  :<C-u>Denite coc-service<cr>
" Show links of current buffer
nnoremap <silent> <space>l  :<C-u>Denite coc-link<cr>

Feedback

If you like this plugin, star it! It's a great way of getting feedback. The same goes for reporting issues or feature requests.

Contact: Gitter Twitter

LICENSE