Fix CompleteDone (#637)

* Move some codes to completion.vim that related to handling CompleteDone.

* Add abort

* Fix test

* Add l: prefix to self vars

* Disable unused vars

* Restore position

* Support snippet simple case and vim-lsp-snippets

* Support g:lsp_text_edit_enabled

* Fix for v:null results

* Fix multi-byte chars

* Add document

* Fix for vim-lsp-snippets for now

* Prepare to future improvements

* More clalify line comment

* User get_user_data instead of extract_user_data

* Always use [''] pattern for accessing dictionary property

* Fix misspelling

* More strict check for completionProvider.resolveProvider

* Fix obj.key to obj['key']

* Store completed_item id to the user_data

* Fix omni tests

* Apply for the review
- Rename expand_text_simply -> simple_expand_text
- to_col -> _lsp_to_vim
- Rename user_data key

* Add example tests

* Add timeout to completionItem/resolve in completion.vim

* Fix timeout feature

* Add timeout log

* Fix documents

Author: hrsh7th

autoload/lsp.vim

@@ -58,6 +58,7 @@ function! lsp#enable() abort
         if g:lsp_highlights_enabled | call lsp#ui#vim#highlights#enable() | endif
         if g:lsp_textprop_enabled | call lsp#ui#vim#diagnostics#textprop#enable() | endif
     endif
+    call lsp#ui#vim#completion#_setup()
     call s:register_events()
 endfunction
 

autoload/lsp/client.vim

@@ -247,7 +247,13 @@ function! s:lsp_send(id, opts, type) abort " opts = { id?, method?, result?, par
     if (a:type == s:send_type_request)
         let l:id = l:request['id']
         if get(a:opts, 'sync', 0) !=# 0
+            let l:start_time = reltime()
+
+            let l:timeout = get(a:opts, 'sync_timeout', -1)
             while has_key(l:ctx['requests'], l:request['id'])
+                if (reltimefloat(reltime(l:start_time)) * 1000) > l:timeout && l:timeout != -1
+                    throw 'lsp#client: timeout'
+                endif
                 sleep 1m
             endwhile
         endif

autoload/lsp/omni.vim

@@ -37,11 +37,8 @@ let s:completion_status_failed = 'failed'
 let s:completion_status_pending = 'pending'
 
 let s:is_user_data_support = has('patch-8.0.1493')
-let s:user_data_key = 'vim-lsp/textEdit'
-let s:user_data_additional_edits_key = 'vim-lsp/additionalTextEdits'
-let s:user_data_insert_start_key = 'vim-lsp/insertStart'
-let s:user_data_insert_format_key = 'vim-lsp/insertFormat'
-let s:user_data_filtertext_key = 'vim-lsp/filterText'
+let s:managed_user_data_key_base = 0
+let s:managed_user_data_map = {}
 
 " }}}
 
@@ -80,10 +77,11 @@ function! lsp#omni#complete(findstart, base) abort
 endfunction
 
 function! s:get_insertion_point(item, current_line, typed_pattern) abort
-    if !has_key(a:item, 'user_data')
-        let l:insert_start = -1
-    else
-        let l:insert_start = get(json_decode(a:item['user_data']), s:user_data_insert_start_key, -1)
+    let l:insert_start = -1
+
+    let l:user_data = lsp#omni#get_managed_user_data_from_completed_item(a:item)
+    if has_key(l:user_data, 'completion_item') && has_key(l:user_data['completion_item'], 'textEdit')
+        let l:insert_start = l:user_data['completion_item']['textEdit']['range']['start']['character']
     endif
 
     if l:insert_start >= 0
@@ -94,12 +92,11 @@ function! s:get_insertion_point(item, current_line, typed_pattern) abort
 endfunction
 
 function! s:get_filter_label(item) abort
-    if !has_key(a:item, 'user_data')
-        return trim(a:item['word'])
+    let l:user_data = lsp#omni#get_managed_user_data_from_completed_item(a:item)
+    if has_key(l:user_data, 'completion_item') && has_key(l:user_data['completion_item'], 'filterText')
+        return trim(l:user_data['completion_item']['filterText'])
     endif
-
-    let l:user_data = json_decode(a:item['user_data'])
-    return trim(get(l:user_data, s:user_data_filtertext_key, a:item['word']))
+    return trim(a:item['word'])
 endfunction
 
 function! s:prefix_filter(item, last_typed_word) abort
@@ -252,12 +249,6 @@ function! lsp#omni#default_get_vim_completion_item(item, ...) abort
         let l:abbr = a:item['label']
     endif
 
-    if has_key(a:item, 'insertTextFormat') && a:item['insertTextFormat'] == 2
-        let l:word = substitute(l:word, '\<\$[0-9]\+\|\${[^}]\+}\>', '', 'g')
-    endif
-
-    let l:kind = lsp#omni#get_kind_text(a:item, l:server_name)
-
     let l:completion = {
                 \ 'word': l:word,
                 \ 'abbr': l:abbr,
@@ -266,7 +257,8 @@ function! lsp#omni#default_get_vim_completion_item(item, ...) abort
                 \ 'icase': 1,
                 \ 'dup': 1,
                 \ 'empty': 1,
-                \ 'kind': l:kind}
+                \ 'kind': lsp#omni#get_kind_text(a:item, l:server_name)
+                \ }
 
     " check support user_data.
     " if not support but g:lsp_text_edit_enabled enabled,
@@ -277,38 +269,9 @@ function! lsp#omni#default_get_vim_completion_item(item, ...) abort
         call lsp#log(l:no_support_error_message)
     endif
 
-    let l:user_data = {}
-
-    " Use '-1' to signal "no specific insertion point" set.
-    let l:user_data[s:user_data_insert_start_key] = -1
-
-    " add user_data in completion item, when
-    "     1. provided user_data
-    "     2. provided textEdit or additionalTextEdits
-    "     3. textEdit value is Dictionary or additionalTextEdits is non-empty list
-    if g:lsp_text_edit_enabled
-        let l:text_edit = get(a:item, 'textEdit', v:null)
-        let l:additional_text_edits = get(a:item, 'additionalTextEdits', v:null)
-
-        " type check
-        if type(l:text_edit) == type({})
-            let l:user_data[s:user_data_key] = l:text_edit
-            let l:user_data[s:user_data_insert_start_key] = l:text_edit['range']['start']['character']
-            let l:user_data[s:user_data_insert_format_key] = get(a:item, 'insertTextFormat', 0)
-        endif
-
-        if type(l:additional_text_edits) == type([]) && !empty(l:additional_text_edits)
-            let l:user_data[s:user_data_additional_edits_key] = l:additional_text_edits
-        endif
-    endif
-
-    " Store filterText in user_data
-    if s:is_user_data_support && has_key(a:item, 'filterText')
-        let l:user_data[s:user_data_filtertext_key] = a:item['filterText']
-    endif
-
-    if !empty(l:user_data)
-        let l:completion['user_data'] = json_encode(l:user_data)
+    " Add user_data.
+    if s:is_user_data_support
+        let l:completion['user_data'] = s:create_user_data(a:item, l:server_name)
     endif
 
     if has_key(a:item, 'detail') && !empty(a:item['detail'])
@@ -332,139 +295,42 @@ function! lsp#omni#get_vim_completion_item(...) abort
     return call(g:lsp_get_vim_completion_item[0], a:000)
 endfunction
 
-augroup lsp_completion_item_text_edit
-    autocmd!
-    autocmd CompleteDone * call <SID>apply_text_edits()
-augroup END
-
-function! s:apply_text_edits() abort
-    " textEdit support function(callin from CompleteDone).
-    "
-    " expected user_data structure:
-    "     v:completed_item['user_data']: {
-    "       'vim-lsp/textEdit': {
-    "         'range': { ...(snip) },
-    "         'newText': 'yyy'
-    "       },
-    "       'vim-lsp/additionalTextEdits': [
-    "         {
-    "           'range': { ...(snip) },
-    "           'newText': 'yyy'
-    "         },
-    "         ...
-    "       ],
-    "     }
-    if !g:lsp_text_edit_enabled
-        doautocmd User lsp_complete_done
-        return
-    endif
-
-    " completion faild or not select complete item
-    if empty(v:completed_item)
-        doautocmd User lsp_complete_done
-        return
-    endif
-
-    " check user_data
-    if !has_key(v:completed_item, 'user_data')
-        doautocmd User lsp_complete_done
-        return
-    endif
-
-    " check user_data type is Dictionary and user_data['vim-lsp/textEdit']
-    try
-        let l:user_data = json_decode(v:completed_item['user_data'])
-    catch
-        " do nothing if user_data is not json type string.
-        doautocmd User lsp_complete_done
-        return
-    endtry
-
-    if type(l:user_data) != type({})
-        doautocmd User lsp_complete_done
-        return
-    endif
-
-    let l:all_text_edits = []
-
-    " if newText contains snippet markers, remove all them.
-    let l:snippet_marker_pos = -1
-
-    " expand textEdit range, for omni complet inserted text.
-    let l:text_edit = get(l:user_data, s:user_data_key, {})
-    if !empty(l:text_edit)
-        let l:expanded_text_edit = s:expand_range(l:text_edit, strchars(v:completed_item['word']))
-        " InsertTextFormat:Snippet
-        if get(l:user_data, s:user_data_insert_format_key, 0) == 2
-            let l:new_text = l:expanded_text_edit['newText']
-            let l:marker_pattern = '\<\$[0-9]\+\|\${[^}]\+}\>'
-            let l:snippet_marker_pos = matchstrpos(l:new_text, l:marker_pattern)[1] - 1
-            let l:expanded_text_edit['newText'] = substitute(l:new_text, l:marker_pattern, '', 'g')
-        endif
-        call add(l:all_text_edits, l:expanded_text_edit)
-    endif
-
-    if has_key(l:user_data, s:user_data_additional_edits_key)
-        let l:all_text_edits += l:user_data[s:user_data_additional_edits_key]
-    endif
-
-    " save cursor position in a mark, vim will move it appropriately when
-    " applying edits
-    let l:saved_mark = getpos("'a")
-    " move to end of newText but in two steps (as column may not exist yet)
-    let [l:pos, l:col_offset] = s:get_cursor_pos_and_edit_length(l:text_edit)
-    call setpos("'a", l:pos)
-
-    " apply textEdits
-    if !empty(l:all_text_edits)
-        call lsp#utils#text_edit#apply_text_edits(lsp#utils#get_buffer_uri(), l:all_text_edits)
-        " When user typed something character while popup menu is shwon, vim
-        " insert typed-character after CompleteDone occured. but the character
-        " should not be duplicated since the textEdit include the character.
-        " this remove the following character.
-        if l:snippet_marker_pos != -1
-            let l:oldpos = line('.')
-            let l:oldline = getline('.')
-            call timer_start(1, {_-> [
-        \    setline(l:oldpos, l:oldline),
-        \    execute('redraw', 1),
-        \    execute('doautocmd User lsp_complete_done', 1),
-        \] })
-        endif
-        return
-    endif
-
-    let l:pos = getpos("'a")
-    if l:snippet_marker_pos >= 0
-        let l:pos[2] += l:snippet_marker_pos
-    else
-        let l:pos[2] += l:col_offset
-    endif
-    call setpos("'a", l:saved_mark)
-    call setpos('.', l:pos)
-
-    doautocmd User lsp_complete_done
+"
+" Clear internal user_data map.
+"
+" This function should call at `CompleteDone` only if not empty `v:completed_item`.
+"
+function! lsp#omni#_clear_managed_user_data_map() abort
+    let s:managed_user_data_key_base = 0
+    let s:managed_user_data_map = {}
 endfunction
 
-function! s:expand_range(text_edit, expand_length) abort
-    let l:expanded_text_edit = a:text_edit
-    let l:expanded_text_edit['range']['end']['character'] += a:expand_length
-
-    return l:expanded_text_edit
+"
+" create item's user_data.
+"
+function! s:create_user_data(completion_item, server_name) abort
+    let l:user_data_key = 'vim-lsp/key/' . string(s:managed_user_data_key_base)
+    let s:managed_user_data_map[l:user_data_key] = {
+                \   'server_name': a:server_name,
+                \   'completion_item': a:completion_item
+                \ }
+    let s:managed_user_data_key_base += 1
+    return l:user_data_key
 endfunction
 
-function! s:get_cursor_pos_and_edit_length(text_edit) abort
-    if !empty(a:text_edit)
-        let l:start = a:text_edit['range']['start']
-        let [l:line, l:col] = lsp#utils#position#_lsp_to_vim('%', l:start)
-        let l:length = len(a:text_edit['newText'])
-        let l:pos = [0, l:line, l:col, 0]
-    else
-        let l:length = 0
-        let l:pos = getpos('.')
+function! lsp#omni#get_managed_user_data_from_completed_item(completed_item) abort
+    " the item has no user_data.
+    if !has_key(a:completed_item, 'user_data')
+        return {}
+    endif
+
+    " Check managed user_data.
+    let l:user_data_key = get(a:completed_item, 'user_data', '')
+    if !has_key(s:managed_user_data_map, l:user_data_key)
+        return {}
     endif
 
-    return [l:pos, l:length]
+    return s:managed_user_data_map[l:user_data_key]
 endfunction
 
 function! lsp#omni#get_completion_item_kinds() abort