jonhoo/coc.nvim

Make your vim/neovim as smart as VSCode.

Coc is an intellisense engine for vim8 & neovim.

It works on vim >= 8.0 and neovim >= 0.3.1.

It's a completion framework and language server client which supports extension features of VSCode.

True snippet and additional text editing support

Floating windows require the nightly build of vim >= 8.1.1522, follow steps in the faq. Floating windows are supported in neovim >= 0.4.0.

Check out doc/coc.txt for the 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 like VSCode, extensions work like in VSCode

Completion experience

You might be wondering why yet another completion engine since there is the already widely used YouCompleteMe and deoplete.nvim.

Below are the reasons that led coc.nvim to build its own engine:

Full LSP completion support, especially snippet and additionalTextEdit feature, you'll understand why it's awesome when you experience it with a coc extension like coc-tsserver.
Asynchronous and parallel completion request, unless using vim sources, your vim will never be blocked.
Does completion resolving on completion item change. The details from completion items are echoed after being selected, this feature requires the CompleteChanged autocmd to work.
Incomplete request and cancel request support, only incomplete completion requests would be triggered on filtering completion items and cancellation requests are sent to servers only when necessary.
Start completion without timer. The completion will start after you type the first letter of a word by default and is filtered with new input after the completion has finished. Other completion engines use a timer to trigger completion so you always have to wait after the typed character.
Realtime buffer keywords. Coc will generate buffer keywords on buffer change in the background (with debounce), while some completion engines use a cache which isn't always correct. Plus, Locality bonus feature from VSCode is enabled by default.
Filter completion items when possible. When you do a fuzzy filter with completion items, some completion engines will trigger a new completion, but coc.nvim will filter the items when possible which makes it much faster. Filtering completion items on backspace is also supported.

Installation

Install nodejs when necessary:
```
curl -sL install-node.now.sh/lts | bash
```
For vim-plug users:
```
" Use release branch
Plug 'neoclide/coc.nvim', {'branch': 'release'}
" Or latest tag
Plug 'neoclide/coc.nvim', {'tag': '*', 'branch': 'release'}
" Or build from source code by use yarn: https://yarnpkg.com
Plug 'neoclide/coc.nvim', {'do': 'yarn install --frozen-lockfile'}
```
in your .vimrc or init.vim, then restart vim and run :PlugInstall.

For other plugin managers, make sure use release branch.

Note: The first time building from source code may be slow.

Note: NixOS users must follow these steps:
1. Install nodejs and yarn via nix-env or put them in /etc/nixos/configuration.nix
2. sudo nixos-rebuild switch
3. Plug 'neoclide/coc.nvim', {'do': 'yarn install --frozen-lockfile'}
4. Don't forget to put: set shell=/bin/sh in your init.vim.
Completion with sources
Using snippets
Using extensions
Using list
Using configuration file
Using workspaceFolders
Using multiple cursors
Language servers
- Supported features
- Register custom language servers
  - Dart
  - C/C++/Objective-C
  - Rust
  - Go
  - PHP
  - Dockerfile
  - Bash
  - Lua
  - OCaml and ReasonML
  - PureScript
  - Flow
  - Haskell
  - vim/erb/markdown
  - Elixir
  - Python
  - Ruby
  - Scala
  - Latex
  - Elm
  - Fortran
  - Clojure
  - Julia
  - Dhall

Completion sources

Completion from words in buffers and file paths completions are supported by default.

For other completion sources, check out:

coc-sources: includes some common completion source extensions.
coc-neco: viml completion support.
coc-vimtex: vimtex integration.
coc-neoinclude: neoinclude integration.
coc-lbdbq: email address completion.
coc-browser: web browser words completion.

Or you can create a custom source.

Extensions

Extensions are more powerful than a configured language server. Check out 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-ember for ember projects.
coc-vetur for vue, use vetur.
coc-phpls for php, use intelephense-docs.
coc-java for java, use eclipse.jdt.ls.
coc-solargraph for ruby, use solargraph.
coc-rls for rust, use Rust Language Server
coc-rust-analyzer for rust, use rust-analyzer
coc-r-lsp for r, use R languageserver.
coc-yaml for yaml
coc-python for python, extension forked from vscode-python.
coc-highlight provides default document symbol highlighting and color support.
coc-emmet provides emmet suggestions in completion list.
coc-snippets provides snippets solution.
coc-lists provides some basic lists like fzf.vim.
coc-git provides git integration.
coc-yank provides yank highlights & history.
coc-fsharp for fsharp.
coc-svg for svg.
coc-tailwindcss for tailwindcss.
coc-angular for angular.
coc-vimlsp for viml.
coc-xml for xml, use lsp4xml.
coc-elixir for elixir, based on elixir-ls.
coc-erlang_ls for erlang, based on erlang_ls
coc-tabnine for tabnine.
coc-powershell for PowerShellEditorService integration.
coc-omnisharp for csharp and visualbasic.
coc-texlab for LaTex using TexLab.
coc-lsp-wl for wolfram mathematica, fork of vscode-lsp-wl.
coc-flow for flow
coc-reason for reasonml

Plus more! To get a full list of coc extensions, search coc.nvim on npm, or use coc-marketplace, which can search and install extensions in coc.nvim directly.

Note: use :CocConfig to edit the configuration file. Completion & validation are supported after coc-json is installed.

Example vim configuration

Configuration is required to make coc.nvim easier to work with, since it doesn't change your key-mappings or vim options. This is done as much as possible to avoid conflict with your other plugins.

❗️Important: some vim plugins could change keymappings. Use a command like :verbose imap <tab> to make sure that your keymap has taken effect.

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

" Some servers have issues with backup files, see #649
set nobackup
set nowritebackup

" Better display for messages
set cmdheight=2

" You will have bad experience for diagnostic messages when it's default 4000.
set updatetime=300

" don't give |ins-completion-menu| messages.
set shortmess+=c

" 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> to trigger completion.
inoremap <silent><expr> <c-space> coc#refresh()

" Use <cr> to 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>"
" Or use `complete_info` if your vim support it, like:
" inoremap <expr> <cr> complete_info()["selected"] != "-1" ? "\<C-y>" : "\<C-g>u\<CR>"

" Use `[g` and `]g` to navigate diagnostics
nmap <silent> [g <Plug>(coc-diagnostic-prev)
nmap <silent> ]g <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 to show documentation in preview window
nnoremap <silent> K :call <SID>show_documentation()<CR>

function! s:show_documentation()
  if (index(['vim','help'], &filetype) >= 0)
    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
xmap <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
xmap <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)

" Create mappings for function text object, requires document symbols feature of languageserver.
xmap if <Plug>(coc-funcobj-i)
xmap af <Plug>(coc-funcobj-a)
omap if <Plug>(coc-funcobj-i)
omap af <Plug>(coc-funcobj-a)

" Use <C-d> for select selections ranges, needs server support, like: coc-tsserver, coc-python
nmap <silent> <C-d> <Plug>(coc-range-select)
xmap <silent> <C-d> <Plug>(coc-range-select)

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

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

" use `:OR` for organize import of current buffer
command! -nargs=0 OR   :call     CocAction('runCommand', 'editor.action.organizeImport')

" Add status line support, for integration with other plugin, checkout `:h coc-status`
set statusline^=%{coc#status()}%{get(b:,'coc_current_function','')}

" Using CocList
" Show all diagnostics
nnoremap <silent> <space>a  :<C-u>CocList diagnostics<cr>
" Manage extensions
nnoremap <silent> <space>e  :<C-u>CocList extensions<cr>
" Show commands
nnoremap <silent> <space>c  :<C-u>CocList commands<cr>
" Find symbol of current document
nnoremap <silent> <space>o  :<C-u>CocList outline<cr>
" Search workspace symbols
nnoremap <silent> <space>s  :<C-u>CocList -I symbols<cr>
" Do default action for next item.
nnoremap <silent> <space>j  :<C-u>CocNext<CR>
" Do default action for previous item.
nnoremap <silent> <space>k  :<C-u>CocPrev<CR>
" Resume latest coc list
nnoremap <silent> <space>p  :<C-u>CocListResume<CR>

Articles

Trouble shooting

Try these steps when you have problem with coc.nvim.

Make sure your vim version >= 8.0 by command :version.
If service failed to start, use command :CocInfo or :checkhealth on neovim.
Checkout the log of coc.nvim by command :CocOpenLog.
When you have issue with a languageserver, it's recommended to checkout the output