性能优化, easycomplete#util#GetVimCompletionItems 用 lua 重写了 for #383

Author: jayli

autoload/easycomplete/action/completion.vim

@@ -3,6 +3,7 @@
 " 参考 vim-lsp 完全重构了，无须再安装外部依赖，这里的 LSP
 " 工具函数主要是给 easycomplete 的插件用的通用方法，内部使用方便
 " ----------------------------------------------------------------------
+let s:util_toolkit = has('nvim') ? v:lua.require("easycomplete.util") : v:null
 
 function! easycomplete#action#completion#do(opt, ctx)
   if empty(easycomplete#installer#GetCommand(a:opt['name']))
@@ -68,7 +69,11 @@ function! s:GetLspCompletionResult(server_name, data, plugin_name, word) abort
   " 这里包含了 info document 和 matches
   let g:xx = reltime()
   " 192 个元素，55 ms
-  let l:completion_result = easycomplete#util#GetVimCompletionItems(l:response, a:plugin_name, a:word)
+  if g:env_is_nvim
+    let l:completion_result = s:util_toolkit.get_vim_complete_items(l:response, a:plugin_name, a:word)
+  else
+    let l:completion_result = easycomplete#util#GetVimCompletionItems(l:response, a:plugin_name, a:word)
+  endif
   " call s:console('<--', 'TODOTODOTODO', reltimestr(reltime(g:xx)), len(l:completion_result['items']))
   return {'matches': l:completion_result['items'], 'incomplete': l:completion_result['incomplete'] }
 endfunction

autoload/easycomplete/util.vim

@@ -1697,6 +1697,18 @@ endfunction " }}}
 " {{{ BadBoy
 " 对 lsp response 的过滤，这个过滤本来应该 lsp 给做掉，但实际 lsp
 " 偷懒都给过来了, 导致渲染很慢, v:true === isBad
+function! easycomplete#util#BadBoy_Nim(item, typing_word)
+  return s:BadBoy.Nim(a:item, a:typing_word)
+endfunction
+
+function! easycomplete#util#BadBoy_Vim(item, typing_word)
+  return s:BadBoy.Vim(a:item, a:typing_word)
+endfunction
+
+function! easycomplete#util#BadBoy_Dart(item, typing_word)
+  return s:BadBoy.Dart(a:item, a:typing_word)
+endfunction
+
 let s:BadBoy = {}
 function! s:BadBoy.Nim(item, typing_word)
   if &filetype != "nim" | return v:false | endif
@@ -1825,6 +1837,10 @@ function! s:NormalizeFunctionalSnip(insertText)
   return ret_str
 endfunction
 
+function! easycomplete#util#NormalizeFunctionalSnip(insertText)
+  return s:NormalizeFunctionalSnip(a:insertText)
+endfunction
+
 " GetVimCompletionItems {{{
 function! easycomplete#util#GetVimCompletionItems(response, plugin_name, word)
   let l:result = a:response['result']
@@ -1865,13 +1881,6 @@ function! easycomplete#util#GetVimCompletionItems(response, plugin_name, word)
           \ 'lsp_item' : l:completion_item
           \ }
 
-    " 如果 label 中包含括号 且过长
-    " if l:completion_item['label'] =~ "(.\\+)" && strlen(l:completion_item['label']) > 40
-    "   if easycomplete#util#contains(l:completion_item['label'], ",") >= 2
-    "     let l:completion_item['label'] = substitute(l:completion_item['label'], "(.\\+)", "(...)", "g")
-    "   endif
-    " endif
-
     if has_key(l:completion_item, 'textEdit') && type(l:completion_item['textEdit']) == type({})
       if has_key(l:completion_item['textEdit'], 'nextText')
         let l:vim_complete_item['word'] = l:completion_item['textEdit']['nextText']
@@ -1973,6 +1982,7 @@ function! easycomplete#util#GetVimCompletionItems(response, plugin_name, word)
     if get(l:vim_complete_item, "word", "") != ""
       let l:vim_complete_items += [l:vim_complete_item]
     endif
+    "----------------------------------
   endfor
   return { 'items': l:vim_complete_items, 'incomplete': l:incomplete }
 endfunction

lua/easycomplete/util.lua

@@ -142,6 +142,173 @@ function util.complete_menu_filter(matching_res, word)
   return filtered_menu
 end
 
+-- easycomplete#util#GetVimCompletionItems 的 lua 实现
+function util.get_vim_complete_items(response, plugin_name, word)
+  local l_result = response["result"]
+  local l_items = {}
+  local l_incomplete = 0
+  if type(l_result) == type({}) and l_result["items"] == nil then
+    l_items = l_result
+    l_incomplete = 0
+  elseif type(l_result) == type({}) and l_result["items"] ~= nil then
+    l_items = l_result["items"]
+    if l_result["isIncomplete"] ~= nil then
+      l_incomplete = l_result["isIncomplete"]
+    else
+      l_incomplete = 0
+    end
+  else
+    l_items = {}
+    l_incomplete = 0
+  end
+
+  local l_vim_complete_items = {}
+  local l_items_length = #l_items
+  local typing_word = word
+
+  for _, l_completion_item in ipairs(l_items) do
+    if vim.o.filetype == "nim" and vim.fn['easycomplete#util#BadBoy_Nim'](l_completion_item, typing_word) then
+      goto continue
+    end
+    if vim.o.filetype == "vim" and vim.fn['easycomplete#util#BadBoy_Vim'](l_completion_item, typing_word) then
+      goto continue
+    end
+    if vim.o.filetype == 'dart' and vim.fn['easycomplete#util#BadBoy_Dart'](l_completion_item, typing_word) then
+      goto continue
+    end
+    
+    local l_expandable = false
+    if l_completion_item["insertTextFormat"] == 2 then
+      l_expandable = true
+    end
+
+    local l_lsp_type_obj = {}
+    local l_kind = 0
+    if l_completion_item["kind"] ~= nil then
+      l_lsp_type_obj = vim.fn["easycomplete#util#LspType"](l_completion_item["kind"])
+      l_kind = l_completion_item["kind"]
+    else
+      l_lsp_type_obj = vim.fn["easycomplete#util#LspType"](0)
+      l_kind = 0
+    end
+
+    local l_menu_str = ""
+    if vim.g.easycomplete_menu_abbr == 1 then
+      l_menu_str = "[" .. string.upper(plugin_name) .. "]"
+    else
+      l_menu_str = l_lsp_type_obj["fullname"]
+    end
+    local l_vim_complete_item = {
+      kind = l_lsp_type_obj["symble"],
+      dup = 1,
+      kind_number = l_kind,
+      menu = l_menu_str,
+      empty = 1,
+      icase = 1,
+      lsp_item = l_completion_item
+    }
+    if l_completion_item["textEdit"] ~= nil and type(l_completion_item['textEdit']) == type({}) then
+      if l_completion_item['textEdit']['nextText'] ~= nil then
+        l_vim_complete_item["word"] = l_completion_item['textEdit']['nextText']
+      end
+      if l_completion_item['textEdit']['newText'] ~= nil then
+        l_vim_complete_item["word"] = l_completion_item['textEdit']['newText']
+      end
+    elseif l_completion_item["insertText"] ~= nil and l_completion_item['insertText'] ~= "" then
+      l_vim_complete_item["word"] = l_completion_item['insertText']
+    else
+      l_vim_complete_item["word"] = l_completion_item['label']
+    end
+    if plugin_name == "cpp" and string.find(l_completion_item['label'], "^[•%s]") then
+      l_vim_complete_item["word"] = string.gsub(l_completion_item['label'], "^[•%s]", "")
+      l_completion_item["label"] = l_vim_complete_item["word"]
+    end
+    
+    if l_expandable == true then
+      local l_origin_word = l_vim_complete_item['word']
+      local l_placeholder_regex = [[\$[0-9]\+\|\${\%(\\.\|[^}]\)\+}]]
+      l_vim_complete_item['word'] = vim.fn['easycomplete#lsp#utils#make_valid_word'](
+            vim.fn.substitute(l_vim_complete_item['word'], l_placeholder_regex, "", "g"))
+      local l_placeholder_position = vim.fn.match(l_origin_word, l_placeholder_regex)
+      local l_cursor_backing_steps = string.len(string.sub(l_vim_complete_item['word'], l_placeholder_position + 1))
+      l_vim_complete_item['abbr'] = l_completion_item['label'] .. '~'
+      if string.len(l_origin_word) > string.len(l_vim_complete_item['word']) then
+        local l_user_data_json = {
+          expandable = 1,
+          placeholder_position = l_placeholder_position,
+          cursor_backing_steps = l_cursor_backing_steps
+        }
+        l_vim_complete_item['user_data'] = vim.fn.json_encode(l_user_data_json)
+        l_vim_complete_item['user_data_json'] = l_user_data_json
+      end
+      local l_user_data_json_l = vim.fn.extend(vim.fn["easycomplete#util#GetUserData"](l_vim_complete_item), {
+          expandable = 1
+        })
+      l_vim_complete_item['user_data'] = vim.fn.json_encode(l_user_data_json_l)
+      l_vim_complete_item['user_data_json'] = l_user_data_json_l
+    elseif string.find(l_completion_item['label'], ".+%(.*%)") then
+      l_vim_complete_item['abbr'] = l_completion_item['label']
+      if vim.fn['easycomplete#SnipExpandSupport']() then
+        l_vim_complete_item['word'] = l_completion_item['label']
+      else
+        -- 如果不支持snipexpand，则只做简易展开
+        l_vim_complete_item['word'] = string.gsub(l_completion_item['label'], "%(.*%)","") .. "()"
+      end
+      l_vim_complete_item['user_data_json'] = {
+        expandable = 1,
+        placeholder_position = string.len(l_vim_complete_item['word']) - 1,
+        cursor_backing_steps = 1
+      }
+      if vim.fn['easycomplete#SnipExpandSupport']() then
+        if string.find(l_completion_item["insertText"], "%${%d") then
+          -- 原本就是 snippet 形式
+          -- Do nothing
+        elseif string.find(l_completion_item["insertText"], ".+%(.*%)$") then
+          l_completion_item["insertText"] = vim.fn["easycomplete#util#NormalizeFunctionalSnip"](l_completion_item["insertText"])
+        elseif string.find(l_vim_complete_item["word"], ".+%(.*%)$") then
+          l_completion_item["insertText"] = vim.fn["easycomplete#util#NormalizeFunctionalSnip"](l_vim_complete_item["word"])
+        else
+          -- 不是函数形式，do nogthing
+        end
+      else
+        l_vim_complete_item['user_data_json']["custom_expand"] = 1
+      end
+      l_vim_complete_item["user_data"] = vim.fn.json_encode(l_vim_complete_item['user_data_json'])
+    else
+      l_vim_complete_item['abbr'] = l_completion_item['label']
+    end
+    local l_t_info = {}
+    if l_completion_item["documentation"] ~= nil then
+      l_t_info = vim.fn['easycomplete#util#NormalizeLspInfo'](l_completion_item["documentation"])
+    else
+      l_t_info = {}
+    end
+    if l_completion_item["detail"] == nil or l_completion_item["detail"] == "" then
+      l_vim_complete_item['info'] = l_t_info
+    else
+      l_vim_complete_item['info'] = {l_completion_item["detail"]}
+      for _, v in ipairs(l_t_info) do table.insert(l_vim_complete_item['info'], v) end
+    end
+
+    local sha256_str_o = vim.fn['easycomplete#util#Sha256'](l_vim_complete_item['word'] .. tostring(l_vim_complete_item['info']))
+    local sha256_str = string.sub(sha256_str_o, 1, 16)
+    local user_data_json = vim.fn.extend(vim.fn['easycomplete#util#GetUserData'](l_vim_complete_item), {
+             plugin_name = plugin_name,
+             sha256 = sha256_str,
+             lsp_item = l_completion_item
+           })
+    l_vim_complete_item['user_data'] = vim.fn.json_encode(user_data_json)
+    l_vim_complete_item["user_data_json"] = user_data_json
+
+    if l_vim_complete_item["word"] ~= "" then
+      table.insert(l_vim_complete_items, l_vim_complete_item)
+    end
+
+    ::continue::
+  end -- endfor
+  return { items = l_vim_complete_items, incomplete = l_incomplete }
+end -- endfunction
+
 -- TODO 需要再测试一下这个函数
 function util.get(a, ...)
   local args = {...}