412 lines
15 KiB
VimL
412 lines
15 KiB
VimL
let s:use_vim_textprops = lsp#utils#_has_textprops() && !has('nvim')
|
|
let s:use_nvim_highlight = lsp#utils#_has_nvim_buf_highlight()
|
|
let s:textprop_cache = 'vim-lsp-semantic-cache'
|
|
|
|
if s:use_nvim_highlight
|
|
let s:namespace_id = nvim_create_namespace('vim-lsp-semantic')
|
|
endif
|
|
|
|
" Global functions {{{1
|
|
function! lsp#internal#semantic#is_enabled() abort
|
|
return g:lsp_semantic_enabled && (s:use_vim_textprops || s:use_nvim_highlight) ? v:true : v:false
|
|
endfunction
|
|
|
|
function! lsp#internal#semantic#_enable() abort
|
|
if !lsp#internal#semantic#is_enabled() | return | endif
|
|
|
|
augroup lsp#internal#semantic
|
|
autocmd!
|
|
au User lsp_buffer_enabled call s:on_lsp_buffer_enabled()
|
|
augroup END
|
|
|
|
let l:events = [['User', 'lsp_buffer_enabled'], 'TextChanged', 'TextChangedI']
|
|
if exists('##TextChangedP')
|
|
call add(l:events, 'TextChangedP')
|
|
endif
|
|
let s:Dispose = lsp#callbag#pipe(
|
|
\ lsp#callbag#fromEvent(l:events),
|
|
\ lsp#callbag#filter({_->lsp#internal#semantic#is_enabled()}),
|
|
\ lsp#callbag#debounceTime(g:lsp_semantic_delay),
|
|
\ lsp#callbag#filter({_->index(['help', 'terminal', 'prompt', 'popup'], getbufvar(bufnr('%'), '&buftype')) ==# -1}),
|
|
\ lsp#callbag#filter({_->!lsp#utils#is_large_window(win_getid())}),
|
|
\ lsp#callbag#switchMap({_->
|
|
\ lsp#callbag#pipe(
|
|
\ s:semantic_request(),
|
|
\ lsp#callbag#materialize(),
|
|
\ lsp#callbag#filter({x->lsp#callbag#isNextNotification(x)}),
|
|
\ lsp#callbag#map({x->x['value']})
|
|
\ )
|
|
\ }),
|
|
\ lsp#callbag#subscribe({x->s:handle_semantic_request(x)})
|
|
\ )
|
|
endfunction
|
|
|
|
function! lsp#internal#semantic#_disable() abort
|
|
augroup lsp#internal#semantic
|
|
autocmd!
|
|
augroup END
|
|
|
|
if exists('s:Dispose')
|
|
call s:Dispose()
|
|
unlet s:Dispose
|
|
endif
|
|
endfunction
|
|
|
|
function! lsp#internal#semantic#get_legend(server) abort
|
|
if !lsp#capabilities#has_semantic_tokens(a:server)
|
|
return {'tokenTypes': [], 'tokenModifiers': []}
|
|
endif
|
|
|
|
let l:capabilities = lsp#get_server_capabilities(a:server)
|
|
return l:capabilities['semanticTokensProvider']['legend']
|
|
endfunction
|
|
|
|
function! lsp#internal#semantic#get_token_types() abort
|
|
let l:capability = 'lsp#capabilities#has_semantic_tokens(v:val)'
|
|
let l:servers = filter(lsp#get_allowed_servers(), l:capability)
|
|
|
|
if empty(l:servers)
|
|
return []
|
|
endif
|
|
|
|
let l:legend = lsp#internal#semantic#get_legend(l:servers[0])
|
|
let l:token_types = l:legend['tokenTypes']
|
|
call map(l:token_types, {_, type -> toupper(type[0]) . type[1:]})
|
|
return l:token_types
|
|
endfunction
|
|
|
|
function! lsp#internal#semantic#get_token_modifiers() abort
|
|
let l:capability = 'lsp#capabilities#has_semantic_tokens(v:val)'
|
|
let l:servers = filter(lsp#get_allowed_servers(), l:capability)
|
|
|
|
if empty(l:servers)
|
|
return []
|
|
endif
|
|
|
|
let l:legend = lsp#internal#semantic#get_legend(l:servers[0])
|
|
let l:token_modifiers = l:legend['tokenModifiers']
|
|
call map(l:token_modifiers, {_, modifier -> toupper(modifier[0]) . modifier[1:]})
|
|
return l:token_modifiers
|
|
endfunction
|
|
|
|
function! s:on_lsp_buffer_enabled() abort
|
|
augroup lsp#internal#semantic
|
|
if !exists('#BufUnload#<buffer>')
|
|
execute 'au BufUnload <buffer> call setbufvar(' . bufnr() . ', ''lsp_semantic_previous_result_id'', '''')'
|
|
endif
|
|
augroup END
|
|
endfunction
|
|
|
|
function! s:supports_full_semantic_request(server) abort
|
|
if !lsp#capabilities#has_semantic_tokens(a:server)
|
|
return v:false
|
|
endif
|
|
|
|
let l:capabilities = lsp#get_server_capabilities(a:server)['semanticTokensProvider']
|
|
if !has_key(l:capabilities, 'full')
|
|
return v:false
|
|
endif
|
|
|
|
if type(l:capabilities['full']) ==# v:t_dict
|
|
return v:true
|
|
endif
|
|
|
|
return l:capabilities['full']
|
|
endfunction
|
|
|
|
function! s:supports_delta_semantic_request(server) abort
|
|
if !lsp#capabilities#has_semantic_tokens(a:server)
|
|
return v:false
|
|
endif
|
|
|
|
let l:capabilities = lsp#get_server_capabilities(a:server)['semanticTokensProvider']
|
|
if !has_key(l:capabilities, 'full')
|
|
return v:false
|
|
endif
|
|
|
|
if type(l:capabilities['full']) !=# v:t_dict
|
|
return v:false
|
|
endif
|
|
|
|
if !has_key(l:capabilities['full'], 'delta')
|
|
return v:false
|
|
endif
|
|
|
|
return l:capabilities['full']['delta']
|
|
endfunction
|
|
|
|
function! s:get_server() abort
|
|
let l:capability = 's:supports_delta_semantic_request(v:val)'
|
|
let l:servers = filter(lsp#get_allowed_servers(), l:capability)
|
|
if empty(l:servers)
|
|
let l:capability = 's:supports_full_semantic_request(v:val)'
|
|
let l:servers = filter(lsp#get_allowed_servers(), l:capability)
|
|
endif
|
|
if empty(l:servers)
|
|
return ''
|
|
endif
|
|
return l:servers[0]
|
|
endfunction
|
|
|
|
function! s:semantic_request() abort
|
|
let l:server = s:get_server()
|
|
if l:server ==# ''
|
|
return lsp#callbag#empty()
|
|
endif
|
|
|
|
if (s:supports_delta_semantic_request(l:server)
|
|
\ && getbufvar(bufnr(), 'lsp_semantic_previous_result_id') !=# '')
|
|
return s:delta_semantic_request(l:server)
|
|
else
|
|
return s:full_semantic_request(l:server)
|
|
endif
|
|
endfunction
|
|
|
|
function! s:full_semantic_request(server) abort
|
|
return lsp#request(a:server, {
|
|
\ 'method': 'textDocument/semanticTokens/full',
|
|
\ 'params': {
|
|
\ 'textDocument': lsp#get_text_document_identifier()
|
|
\ }})
|
|
endfunction
|
|
|
|
function! s:delta_semantic_request(server) abort
|
|
return lsp#request(a:server, {
|
|
\ 'method': 'textDocument/semanticTokens/full/delta',
|
|
\ 'params': {
|
|
\ 'textDocument': lsp#get_text_document_identifier(),
|
|
\ 'previousResultId': getbufvar(bufname(), 'lsp_semantic_previous_result_id', 0)
|
|
\ }})
|
|
endfunction
|
|
|
|
" Highlight helper functions {{{1
|
|
function! s:handle_semantic_request(data) abort
|
|
if lsp#client#is_error(a:data['response'])
|
|
call lsp#log('Skipping semantic highlight: response is invalid')
|
|
return
|
|
endif
|
|
|
|
let l:server = a:data['server_name']
|
|
let l:uri = a:data['request']['params']['textDocument']['uri']
|
|
let l:path = lsp#utils#uri_to_path(l:uri)
|
|
let l:bufnr = bufnr(l:path)
|
|
|
|
" Skip if the buffer doesn't exist. This might happen when a buffer is
|
|
" opened and quickly deleted.
|
|
if !bufloaded(l:bufnr) | return | endif
|
|
|
|
if has_key(a:data['response']['result'], 'data')
|
|
call s:handle_semantic_tokens_response(l:server, l:bufnr, a:data['response']['result'])
|
|
elseif has_key(a:data['response']['result'], 'edits')
|
|
call s:handle_semantic_tokens_delta_response(l:server, l:bufnr, a:data['response']['result'])
|
|
else
|
|
" Don't update previous result ID if we could not update local copy
|
|
call lsp#log('SemanticHighlight: unsupported semanticTokens method')
|
|
return
|
|
endif
|
|
|
|
if has_key(a:data['response']['result'], 'resultId')
|
|
call setbufvar(l:bufnr, 'lsp_semantic_previous_result_id', a:data['response']['result']['resultId'])
|
|
endif
|
|
endfunction
|
|
|
|
function! s:handle_semantic_tokens_response(server, buf, result) abort
|
|
let l:highlights = {}
|
|
let l:legend = lsp#internal#semantic#get_legend(a:server)
|
|
for l:token in s:decode_tokens(a:result['data'])
|
|
let [l:key, l:value] = s:add_highlight(a:server, l:legend, a:buf, l:token)
|
|
let l:highlights[l:key] = get(l:highlights, l:key, []) + l:value
|
|
endfor
|
|
call s:apply_highlights(a:server, a:buf, l:highlights)
|
|
|
|
call setbufvar(a:buf, 'lsp_semantic_local_data', a:result['data'])
|
|
endfunction
|
|
|
|
function! s:startpos_compare(edit1, edit2) abort
|
|
return a:edit1[0] == a:edit2[0] ? 0 : a:edit1[0] > a:edit2[0] ? -1 : 1
|
|
endfunction
|
|
|
|
function! s:handle_semantic_tokens_delta_response(server, buf, result) abort
|
|
" The locations given in the edit are all referenced to the state before
|
|
" any are applied and sorting is not required from the server,
|
|
" therefore the edits must be sorted before applying.
|
|
let l:edits = a:result['edits']
|
|
call sort(l:edits, function('s:startpos_compare'))
|
|
|
|
let l:localdata = getbufvar(a:buf, 'lsp_semantic_local_data')
|
|
for l:edit in l:edits
|
|
let l:insertdata = get(l:edit, 'data', [])
|
|
let l:localdata = l:localdata[:l:edit['start'] - 1]
|
|
\ + l:insertdata
|
|
\ + l:localdata[l:edit['start'] + l:edit['deleteCount']:]
|
|
endfor
|
|
call setbufvar(a:buf, 'lsp_semantic_local_data', l:localdata)
|
|
|
|
let l:highlights = {}
|
|
let l:legend = lsp#internal#semantic#get_legend(a:server)
|
|
for l:token in s:decode_tokens(l:localdata)
|
|
let [l:key, l:value] = s:add_highlight(a:server, l:legend, a:buf, l:token)
|
|
let l:highlights[l:key] = get(l:highlights, l:key, []) + l:value
|
|
endfor
|
|
call s:apply_highlights(a:server, a:buf, l:highlights)
|
|
endfunction
|
|
|
|
function! s:decode_tokens(data) abort
|
|
let l:tokens = []
|
|
|
|
let l:i = 0
|
|
let l:line = 0
|
|
let l:char = 0
|
|
while l:i < len(a:data)
|
|
let l:line = l:line + a:data[l:i]
|
|
if a:data[l:i] > 0
|
|
let l:char = 0
|
|
endif
|
|
let l:char = l:char + a:data[l:i + 1]
|
|
|
|
call add(l:tokens, {
|
|
\ 'pos': {'line': l:line, 'character': l:char},
|
|
\ 'length': a:data[l:i + 2],
|
|
\ 'token_idx': a:data[l:i + 3],
|
|
\ 'token_modifiers': a:data[l:i + 4]
|
|
\ })
|
|
|
|
let l:i = l:i + 5
|
|
endwhile
|
|
|
|
return l:tokens
|
|
endfunction
|
|
|
|
function! s:clear_highlights(server, buf) abort
|
|
if s:use_vim_textprops
|
|
let l:BeginsWith = {str, prefix -> str[0:len(prefix) - 1] ==# prefix}
|
|
let l:IsSemanticTextprop = {_, textprop -> l:BeginsWith(textprop, s:textprop_type_prefix)}
|
|
let l:textprop_types = prop_type_list()
|
|
call filter(l:textprop_types, l:IsSemanticTextprop)
|
|
for l:textprop_type in l:textprop_types
|
|
silent! call prop_remove({'type': l:textprop_type, 'bufnr': a:buf, 'all': v:true})
|
|
endfor
|
|
elseif s:use_nvim_highlight
|
|
call nvim_buf_clear_namespace(a:buf, s:namespace_id, 0, line('$'))
|
|
endif
|
|
endfunction
|
|
|
|
function! s:add_highlight(server, legend, buf, token) abort
|
|
let l:startpos = lsp#utils#position#lsp_to_vim(a:buf, a:token['pos'])
|
|
let l:endpos = a:token['pos']
|
|
let l:endpos['character'] = l:endpos['character'] + a:token['length']
|
|
let l:endpos = lsp#utils#position#lsp_to_vim(a:buf, l:endpos)
|
|
|
|
if s:use_vim_textprops
|
|
let l:textprop_name = s:get_textprop_type(a:server, a:legend, a:token['token_idx'], a:token['token_modifiers'])
|
|
return [l:textprop_name, [[l:startpos[0], l:startpos[1], l:endpos[0], l:endpos[1]]]]
|
|
elseif s:use_nvim_highlight
|
|
let l:char = a:token['pos']['character']
|
|
let l:hl_name = s:get_hl_group(a:server, a:legend, a:token['token_idx'], a:token['token_modifiers'])
|
|
return [l:hl_name, [[l:startpos[0] - 1, l:startpos[1] - 1, l:endpos[1] - 1]]]
|
|
endif
|
|
endfunction
|
|
|
|
function! s:apply_highlights(server, buf, highlights) abort
|
|
call s:clear_highlights(a:server, a:buf)
|
|
|
|
if s:use_vim_textprops
|
|
for [l:type, l:prop_list] in items(a:highlights)
|
|
call prop_add_list({'type': l:type, 'bufnr': a:buf}, l:prop_list)
|
|
endfor
|
|
elseif s:use_nvim_highlight
|
|
call lsp#log(a:highlights)
|
|
for [l:hl_name, l:instances] in items(a:highlights)
|
|
for l:instance in l:instances
|
|
let [l:line, l:startcol, l:endcol] = l:instance
|
|
try
|
|
call nvim_buf_add_highlight(a:buf, s:namespace_id, l:hl_name, l:line, l:startcol, l:endcol)
|
|
catch
|
|
call lsp#log('SemanticHighlight: error while adding ' . l:hl_name . ' highlight on line ' . l:line)
|
|
endtry
|
|
endfor
|
|
endfor
|
|
end
|
|
endfunction
|
|
|
|
let s:hl_group_prefix = 'LspSemantic'
|
|
|
|
let s:default_highlight_groups = {
|
|
\ s:hl_group_prefix . 'Type': 'Type',
|
|
\ s:hl_group_prefix . 'Class': 'Type',
|
|
\ s:hl_group_prefix . 'Enum': 'Type',
|
|
\ s:hl_group_prefix . 'Interface': 'TypeDef',
|
|
\ s:hl_group_prefix . 'Struct': 'Type',
|
|
\ s:hl_group_prefix . 'TypeParameter': 'Type',
|
|
\ s:hl_group_prefix . 'Parameter': 'Identifier',
|
|
\ s:hl_group_prefix . 'Variable': 'Identifier',
|
|
\ s:hl_group_prefix . 'Property': 'Identifier',
|
|
\ s:hl_group_prefix . 'EnumMember': 'Constant',
|
|
\ s:hl_group_prefix . 'Event': 'Identifier',
|
|
\ s:hl_group_prefix . 'Function': 'Function',
|
|
\ s:hl_group_prefix . 'Method': 'Function',
|
|
\ s:hl_group_prefix . 'Macro': 'Macro',
|
|
\ s:hl_group_prefix . 'Keyword': 'Keyword',
|
|
\ s:hl_group_prefix . 'Modifier': 'Type',
|
|
\ s:hl_group_prefix . 'Comment': 'Comment',
|
|
\ s:hl_group_prefix . 'String': 'String',
|
|
\ s:hl_group_prefix . 'Number': 'Number',
|
|
\ s:hl_group_prefix . 'Regexp': 'String',
|
|
\ s:hl_group_prefix . 'Operator': 'Operator',
|
|
\ s:hl_group_prefix . 'Decorator': 'Macro'
|
|
\ }
|
|
|
|
function! s:get_hl_group(server, legend, token_idx, token_modifiers) abort
|
|
" get highlight group name
|
|
let l:Capitalise = {str -> toupper(str[0]) . str[1:]}
|
|
let l:token_name = l:Capitalise(a:legend['tokenTypes'][a:token_idx])
|
|
let l:token_modifiers = []
|
|
for l:modifier_idx in range(len(a:legend['tokenModifiers']))
|
|
" float2nr(pow(2, a)) is 1 << a
|
|
if and(a:token_modifiers, float2nr(pow(2, l:modifier_idx)))
|
|
let l:modifier_name = a:legend['tokenModifiers'][l:modifier_idx]
|
|
call add(l:token_modifiers, l:Capitalise(l:modifier_name))
|
|
endif
|
|
endfor
|
|
call sort(l:token_modifiers)
|
|
let l:hl_group = s:hl_group_prefix
|
|
\ . reduce(l:token_modifiers, {acc, val -> acc . val}, '')
|
|
\ . l:token_name
|
|
|
|
" create the highlight group if it does not already exist
|
|
if !hlexists(l:hl_group)
|
|
if has_key(s:default_highlight_groups, l:hl_group)
|
|
exec 'highlight link' l:hl_group s:default_highlight_groups[l:hl_group]
|
|
else
|
|
if a:token_modifiers != 0
|
|
let l:base_hl_group = s:get_hl_group(a:server, a:legend, a:token_idx, 0)
|
|
exec 'highlight link' l:hl_group l:base_hl_group
|
|
else
|
|
exec 'highlight link' l:hl_group 'Normal'
|
|
endif
|
|
endif
|
|
endif
|
|
|
|
return l:hl_group
|
|
endfunction
|
|
|
|
let s:textprop_type_prefix = 'vim-lsp-semantic-'
|
|
|
|
function! s:get_textprop_type(server, legend, token_idx, token_modifiers) abort
|
|
" get textprop type name
|
|
let l:textprop_type = s:textprop_type_prefix . a:server . '-' . a:token_idx . '-' . a:token_modifiers
|
|
|
|
" create the textprop type if it does not already exist
|
|
if prop_type_get(l:textprop_type) ==# {}
|
|
let l:hl_group = s:get_hl_group(a:server, a:legend, a:token_idx, a:token_modifiers)
|
|
silent! call prop_type_add(l:textprop_type, {
|
|
\ 'highlight': l:hl_group,
|
|
\ 'combine': v:true,
|
|
\ 'priority': lsp#internal#textprop#priority('semantic')})
|
|
endif
|
|
|
|
return l:textprop_type
|
|
endfunction
|
|
|
|
" vim: fdm=marker
|