[RFC|RDY] code actions (#162)

* WIP code actions

It was addded the code actions funcionality
https://microsoft.github.io/language-server-protocol/specification#textDocument_codeAction

Processing the result is not quite right, because it is always applying
the c (change) command, and it does not insert the new line (\n)
character

* WIP code actions

It was addded the code actions funcionality
https://microsoft.github.io/language-server-protocol/specification#textDocument_codeAction

Processing the result is not quite right, because it is always applying
the c (change) command, and it does not insert the new line (\n)
character

* Improved apply_text_edit

Now the function apply_text_edit insert texts as well, instead of only
replacing it.

Fixed some typos and broken links

* Added documentation and fixed code_action

Now lsp#ui#vim#code_action uses the diagnostic range instead of the
get_position

* Fixed code action

The code action had a problem when it needed to delete/replace some
text, and when the code was folded it did not work since to execute do
not seem to unfold the code

* Changed copy to deepcopy

Since we modifying nested objects we need to use deepcopy

* Fixed preprocessing and added sort to textedits

To perform an unfold it is necessary to check first if the line has
fold level, if the line has foldlevel = 0 and you try to unfold it will
cause and error.

Since LSP specification does not guarantee that text edits are ordered,
we needed to sort it so it will work on any valid LSP

* Fixed text edits sort

Removed stable_sort since it is not necessary

Now it sorts the text edits in a reverse order and merge text edits
that are inserts on the same place

* Fixed codeAction deleting lines

* Passing capability on initialization

* Added buffer validation before setting the sign

This validation is necessary since the documentation states that the
file {fname} must be already be loaded in a buffer.

* Changed msgpack_type to v:true

Msgpack_type does not work on vim

Author: augustomelo

README.md

@@ -51,6 +51,7 @@ Refer to docs on configuring omnifunc or [asyncomplete.vim](https://github.com/p
 
 | Command | Description|
 |--|--|
+|`:LspCodeAction`| Gets a list of possible commands that can be applied to a file so it can be fixed (quick fix) |
 |`:LspDocumentDiagnostics`| Get current document diagnostics information |
 |`:LspDefinition`| Go to definition |
 |`:LspDocumentFormat`| Format entire document |

autoload/lsp.vim

@@ -350,7 +350,11 @@ function! s:ensure_init(buf, server_name, cb) abort
     if has_key(l:server_info, 'capabilities')
         let l:capabilities = l:server_info['capabilities']
     else
-        let l:capabilities = {}
+        let l:capabilities = {
+        \   'workspace': {
+        \       'applyEdit ': v:true
+        \   }
+        \ }
     endif
 
     if has_key(l:server_info, 'initialization_options')

autoload/lsp/capabilities.vim

@@ -39,6 +39,10 @@ function! lsp#capabilities#has_implementation_provider(server_name) abort
     return s:has_bool_provider(a:server_name, 'implementationProvider')
 endfunction
 
+function! lsp#capabilities#has_code_action_provider(server_name) abort
+    return s:has_bool_provider(a:server_name, 'codeActionProvider')
+endfunction
+
 function! lsp#capabilities#has_type_definition_provider(server_name) abort
     return s:has_bool_provider(a:server_name, 'typeDefinitionProvider')
 endfunction

autoload/lsp/ui/vim.vim

@@ -259,6 +259,39 @@ function! lsp#ui#vim#document_symbol() abort
     echo 'Retrieving document symbols ...'
 endfunction
 
+" https://microsoft.github.io/language-server-protocol/specification#textDocument_codeAction
+function! lsp#ui#vim#code_action() abort
+    let l:servers = filter(lsp#get_whitelisted_servers(), 'lsp#capabilities#has_code_action_provider(v:val)')
+    let s:last_req_id = s:last_req_id + 1
+    let s:diagnostics = lsp#ui#vim#diagnostics#get_diagnostics_under_cursor()
+
+    if len(l:servers) == 0
+        call s:not_supported('Code action')
+        return
+    endif
+
+    if len(s:diagnostics) == 0
+        echo 'No diagnostics found under the cursors'
+        return
+    endif
+
+    for l:server in l:servers
+        call lsp#send_request(l:server, {
+            \ 'method': 'textDocument/codeAction',
+            \ 'params': {
+            \   'textDocument': lsp#get_text_document_identifier(),
+            \   'range': s:diagnostics['range'],
+            \   'context': {
+            \       'diagnostics' : [s:diagnostics],
+            \   },
+            \ },
+            \ 'on_notification': function('s:handle_code_action', [l:server, s:last_req_id, 'codeAction']),
+            \ })
+    endfor
+
+    echo 'Retrieving code actions ...'
+endfunction
+
 function! s:handle_symbol(server, last_req_id, type, data) abort
     if a:last_req_id != s:last_req_id
         return
@@ -344,8 +377,34 @@ function! s:handle_text_edit(server, last_req_id, type, data) abort
     echo 'Document formatted'
 endfunction
 
+function! s:handle_code_action(server, last_req_id, type, data) abort
+    let l:codeActions = a:data['response']['result']
+    let l:index = 0
+    let l:choices = []
+
+    call lsp#log('s:handle_code_action', l:codeActions)
+
+    if len(l:codeActions) == 0
+        echo 'No code actions found'
+        return
+    endif
+
+    while l:index < len(l:codeActions)
+        call add(l:choices, string(l:index + 1) . ' - ' . l:codeActions[index]['title'])
+
+        let l:index += 1
+    endwhile
+
+    let l:choice = inputlist(l:choices)
+
+    if l:choice > 0 && l:choice <= l:index
+        call lsp#log('s:handle_code_action', l:codeActions[l:choice - 1]['arguments'][0])
+        call s:apply_workspace_edits(l:codeActions[l:choice - 1]['arguments'][0])
+    endif
+endfunction
+
 " @params
-"   workspace_edits - https://github.com/Microsoft/language-server-protocol/blob/master/protocol.md#workspaceedit
+"   workspace_edits - https://microsoft.github.io/language-server-protocol/specification#workspaceedit
 function! s:apply_workspace_edits(workspace_edits) abort
     if has_key(a:workspace_edits, 'changes')
         let l:cur_buffer = bufnr('%')
@@ -371,36 +430,246 @@ function! s:apply_workspace_edits(workspace_edits) abort
     endif
 endfunction
 
-function! s:generate_move_cmd(line_pos, character_pos) abort
-    let l:result = printf("%dG0", a:line_pos) " move the line and set to the cursor at the beggining
-    if a:character_pos > 0
-        let l:result .= printf("%dl", a:character_pos) " Move right until the character
+function! s:apply_text_edits(uri, text_edits) abort
+    " https://microsoft.github.io/language-server-protocol/specification#textedit
+    " The order in the array defines the order in which the inserted string
+    " appear in the resulting text.
+    "
+    " The edits must be applied in the reverse order so the early edits will
+    " not interfere with the position of later edits, they need to be applied
+    " one at the time or put together as a single command.
+    "
+    " Example: {"range": {"end": {"character": 45, "line": 5}, "start":
+    " {"character": 45, "line": 5}}, "newText": "\n"}, {"range": {"end":
+    " {"character": 45, "line": 5}, "start": {"character": 45, "line": 5}},
+    " "newText": "import javax.ws.rs.Consumes;"}]}}
+    "
+    " If we apply the \n first we will need adjust the line range of the next
+    " command (so the import will be written on the next line) , but if we
+    " write the import first and then the \n everything will be fine.
+    " If you do not apply a command one at  time, you will need to adjust the
+    " range columns after which edit. You will get this (only one execution):
+    "
+    " execute 'keepjumps normal! 6G045laimport javax.ws.rs.Consumes;'" |
+    " execute 'keepjumps normal! 6G045la\n'
+    "
+    " resulting in this:
+    " import javax.servlet.http.HttpServletRequest;i
+    " mport javax.ws.rs.Consumes;
+    "
+    " instead of this (multiple executions):
+    " execute 'keepjumps normal! 6G045laimport javax.ws.rs.Consumes;'"
+    " execute 'keepjumps normal! 6G045li\n'
+    "
+    " resulting in this:
+    " import javax.servlet.http.HttpServletRequest;
+    " import javax.ws.rs.Consumes;
+    "
+    "
+    " The sort is also necessary since the LSP specification does not
+    " guarantee that text edits are sorted.
+    "
+    " Example:
+    " Initial text:  "abcdef"
+    " Edits:
+    " ((0,0), (0, 1), "") - remove first character 'a'
+    " ((0, 4), (0, 5), "") - remove fifth character 'e'
+    " ((0, 2), (0, 3), "") - remove third character 'c'
+    let l:text_edits = sort(deepcopy(a:text_edits), '<SID>sort_text_edit_desc')
+    let l:i = 0
+
+    while l:i < len(l:text_edits)
+        let l:merged_text_edit = s:merge_same_range(l:i, l:text_edits)
+        let l:cmd = s:build_cmd(a:uri, l:merged_text_edit['merged'])
+
+        try
+            let l:was_paste = &paste
+            set paste
+            execute l:cmd
+        finally
+            let &paste = l:was_paste
+        endtry
+
+        let l:i = l:merged_text_edit['end_index']
+    endwhile
+endfunction
+
+" Merge the edits on the same range so we do not have to reverse the
+" text_edits  that are inserts, also from the specification:
+" If multiple inserts have the same position, the order in the array
+" defines the order in which the inserted strings appear in the
+" resulting text
+function! s:merge_same_range(start_index, text_edits) abort
+    let l:i = a:start_index + 1
+    let l:merged = deepcopy(a:text_edits[a:start_index])
+
+    while l:i < len(a:text_edits) &&
+        \ s:is_same_range(l:merged['range'], a:text_edits[l:i]['range'])
+
+        let l:merged['newText'] .= a:text_edits[l:i]['newText']
+        let l:i += 1
+    endwhile
+
+    return {'merged': l:merged, 'end_index': l:i}
+endfunction
+
+function! s:is_same_range(range1, range2) abort
+    return a:range1['start']['line'] == a:range2['start']['line'] &&
+        \ a:range1['end']['line'] == a:range2['end']['line'] &&
+        \ a:range1['start']['character'] == a:range2['start']['character'] &&
+        \ a:range1['end']['character'] == a:range2['end']['character']
+endfunction
+
+" https://microsoft.github.io/language-server-protocol/specification#textedit
+function! s:is_insert(range) abort
+    return a:range['start']['line'] == a:range['end']['line'] &&
+        \ a:range['start']['character'] == a:range['end']['character']
+endfunction
+
+" Compares two text edits, based on the starting position of the range.
+" Assumes that edits have non-overlapping ranges.
+"
+" `text_edit1` and `text_edit2` are dictionaries and represent LSP TextEdit type.
+"
+" Returns 0 if both text edits starts at the same position (insert text),
+" positive value if `text_edit1` starts before `text_edit2` and negative value
+" otherwise.
+function! s:sort_text_edit_desc(text_edit1, text_edit2) abort
+    if a:text_edit1['range']['start']['line'] != a:text_edit2['range']['start']['line']
+        return a:text_edit2['range']['start']['line'] - a:text_edit1['range']['start']['line']
     endif
-    return l:result
+
+    if a:text_edit1['range']['start']['character'] != a:text_edit2['range']['start']['character']
+        return a:text_edit2['range']['start']['character'] - a:text_edit1['range']['start']['character']
+    endif
+
+    return !s:is_insert(a:text_edit1['range']) ? -1 :
+        \ s:is_insert(a:text_edit2['range']) ? 0 : 1
 endfunction
 
-function! s:apply_text_edits(uri, text_edits) abort
+function! s:build_cmd(uri, text_edit) abort
     let l:path = lsp#utils#uri_to_path(a:uri)
     let l:buffer = bufnr(l:path)
     let l:cmd = 'keepjumps keepalt ' . (l:buffer !=# -1 ? 'b ' . l:buffer : 'edit ' . l:path)
-    for l:text_edit in a:text_edits
-        let l:start_line = l:text_edit['range']['start']['line'] + 1
-        let l:start_character = l:text_edit['range']['start']['character']
-        let l:end_line = l:text_edit['range']['end']['line'] + 1
-        let l:end_character = l:text_edit['range']['end']['character'] - 1  " -1 since the last character is excluded
-        let l:new_text = l:text_edit['newText']
-        let l:sub_cmd = s:generate_move_cmd(l:start_line, l:start_character) " move to the first position 
-        let l:sub_cmd .= "v" " visual mode 
-        let l:sub_cmd .= s:generate_move_cmd(l:end_line, l:end_character) " move to the last position 
-        let l:sub_cmd .= printf("c%s", l:new_text) " change text
-        let l:escaped_sub_cmd = substitute(l:sub_cmd, '''', '''''', 'g')
-        let l:cmd = l:cmd . " | execute 'keepjumps normal! " . l:escaped_sub_cmd . "'"
-    endfor
-    call lsp#log('s:apply_text_edits', l:cmd)
-    try
-        set paste
-        execute l:cmd
-    finally
-        set nopaste
-    endtry
+    let s:text_edit = deepcopy(a:text_edit)
+
+    let s:text_edit['range'] = s:parse_range(s:text_edit['range'])
+    let l:sub_cmd = s:generate_sub_cmd(s:text_edit)
+    let l:escaped_sub_cmd = substitute(l:sub_cmd, '''', '''''', 'g')
+    let l:cmd = l:cmd . " | execute 'keepjumps normal! " . l:escaped_sub_cmd . "'"
+
+    call lsp#log('s:build_cmd', l:cmd)
+
+    return l:cmd
+endfunction
+
+function! s:generate_sub_cmd(text_edit) abort
+    if s:is_insert(a:text_edit['range'])
+        return s:generate_sub_cmd_insert(a:text_edit)
+    else
+        return s:generate_sub_cmd_replace(a:text_edit)
+    endif
+endfunction
+
+function! s:generate_sub_cmd_insert(text_edit) abort
+    let l:start_line = a:text_edit['range']['start']['line']
+    let l:start_character = a:text_edit['range']['start']['character']
+    let l:new_text = s:parse(a:text_edit['newText'])
+
+    let l:sub_cmd = s:preprocess_cmd(a:text_edit['range'])
+    let l:sub_cmd .= s:generate_move_cmd(l:start_line, l:start_character)
+
+    if len(l:new_text) == 0
+        let l:sub_cmd .= 'x'
+    else
+        if l:start_character >= len(getline(l:start_line))
+            let l:sub_cmd .= 'a'
+        else
+            let l:sub_cmd .= 'i'
+        endif
+    endif
+
+    let l:sub_cmd .= printf('%s', l:new_text)
+
+    return l:sub_cmd
+endfunction
+
+function! s:generate_sub_cmd_replace(text_edit) abort
+    let l:start_line = a:text_edit['range']['start']['line']
+    let l:start_character = a:text_edit['range']['start']['character']
+    let l:end_line = a:text_edit['range']['end']['line']
+    let l:end_character = a:text_edit['range']['end']['character']
+    let l:new_text = a:text_edit['newText']
+
+    " This is necessary since you are removing lines, because when in normal
+    " mode it cannot grab the last character + 1 (\n).
+    if l:start_character >= len(getline(l:start_line)) && l:end_character == 0
+        let l:start_line += 1
+        let l:start_character = 0
+
+    endif
+
+    " Since the columns in vim is one-based index, this validation is necessary as
+    " well
+    if l:end_character == 0
+        let l:end_line -= 1
+        let l:end_character = len(getline(l:end_line))
+    endif
+
+    let l:sub_cmd = s:preprocess_cmd(a:text_edit['range'])
+    let l:sub_cmd .= s:generate_move_cmd(l:start_line, l:start_character) " move to the first position
+    let l:sub_cmd .= 'v'
+    let l:sub_cmd .= s:generate_move_cmd(l:end_line, l:end_character) " move to the last position
+
+    if len(l:new_text) == 0
+        let l:sub_cmd .= 'x'
+    else
+        let l:sub_cmd .= 'c'
+        let l:sub_cmd .= printf('%s', l:new_text) " change text
+    endif
+
+    return l:sub_cmd
+endfunction
+
+function! s:generate_move_cmd(line_pos, character_pos) abort
+    let l:result = printf('%dG0', a:line_pos) " move the line and set to the cursor at the beginning
+    if a:character_pos > 0
+        let l:result .= printf('%dl', a:character_pos) " move right until the character
+    endif
+    return l:result
+endfunction
+
+function! s:parse(text) abort
+    " https://stackoverflow.com/questions/71417/why-is-r-a-newline-for-vim
+    return substitute(a:text, '\(^\n|\n$\|\r\n\)', '\r', 'g')
+endfunction
+
+function! s:preprocess_cmd(range) abort
+    " preprocess by opening the folds, this is needed because the line you are
+    " going might have a folding
+    let l:preprocess = ''
+
+    if foldlevel(a:range['start']['line']) > 0
+        let l:preprocess .= a:range['start']['line']
+        let l:preprocess .= 'GzO'
+    endif
+
+    if foldlevel(a:range['end']['line']) > 0
+        let l:preprocess .= a:range['end']['line']
+        let l:preprocess .= 'GzO'
+    endif
+
+    return l:preprocess
+endfunction
+
+" https://microsoft.github.io/language-server-protocol/specification#text-documents
+" Position in a text document expressed as zero-based line and zero-based
+" character offset, and since we are using the character as a offset position
+" we do not have to fix its position
+function! s:parse_range(range) abort
+    let s:range = deepcopy(a:range)
+    let s:range['start']['line'] =  a:range['start']['line'] + 1
+    let s:range['end']['line'] = a:range['end']['line'] + 1
+
+    return s:range
 endfunction

autoload/lsp/ui/vim/signs.vim

@@ -186,7 +186,8 @@ endfunction
 
 function! s:place_signs(server_name, path, diagnostics) abort
 	let s:err_loc = []
-    if !empty(a:diagnostics)
+
+    if !empty(a:diagnostics) && bufnr(a:path) >= 0
         for l:item in a:diagnostics
             let l:line = l:item['range']['start']['line'] + 1