" don't spam the user when Vim is started in Vi compatibility mode
let s:cpo_save = &cpo
set cpo&vim
scriptencoding utf-8
if !exists('s:state')
let s:state = {
\ 'rpcid': 1,
\ 'running': 0,
\ 'currentThread': {},
\ 'localVars': {},
\ 'functionArgs': {},
\ 'registers': {},
\ 'message': [],
\ 'resultHandlers': {},
\ 'kill_on_detach': v:true,
\ }
if go#util#HasDebug('debugger-state')
call go#config#SetDebugDiag(s:state)
endif
endif
if !exists('s:start_args')
let s:start_args = []
endif
if !exists('s:mapargs')
let s:mapargs = {}
endif
function! s:goroutineID() abort
return s:state['currentThread'].goroutineID
endfunction
function! s:complete(job, exit_status, data) abort
let l:gotready = get(s:state, 'ready', 0)
" copy messages to a:data _only_ when dlv exited non-zero and it was never
" detected as ready (e.g. there was a compiler error).
if a:exit_status > 0 && !l:gotready
" copy messages to data so that vim-go's usual handling of errors from
" async jobs will occur.
call extend(a:data, s:state['message'])
endif
" return early instead of clearing any variables when the current job is not
" a:job
if has_key(s:state, 'job') && s:state['job'] != a:job
return
endif
if has_key(s:state, 'job')
call remove(s:state, 'job')
endif
if has_key(s:state, 'ready')
call remove(s:state, 'ready')
endif
if has_key(s:state, 'ch')
call remove(s:state, 'ch')
endif
call s:clearState()
endfunction
function! s:logger(prefix, ch, msg) abort
let l:cur_win = bufwinnr('')
let l:log_win = bufwinnr(bufnr('__GODEBUG_OUTPUT__'))
if l:log_win == -1
return
endif
exe l:log_win 'wincmd w'
try
setlocal modifiable
if getline(1) == ''
call setline('$', a:prefix . a:msg)
else
call append('$', a:prefix . a:msg)
endif
normal! G
setlocal nomodifiable
finally
exe l:cur_win 'wincmd w'
endtry
endfunction
" s:call_jsonrpc will call method, passing all of s:call_jsonrpc's optional
" arguments in the rpc request's params field.
" The first argument to s:call_jsonrpc should be a function that takes two
" arguments. The first argument will be a function that takes no arguments and will
" throw an exception if the response to the request is an error response. The
" second argument is the response itself.
function! s:call_jsonrpc(handle_result, method, ...) abort
if go#util#HasDebug('debugger-commands')
call go#util#EchoInfo('sending to dlv ' . a:method)
endif
let l:args = a:000
let s:state['rpcid'] += 1
let l:reqid = s:state['rpcid']
let l:req_json = json_encode({
\ 'id': l:reqid,
\ 'method': a:method,
\ 'params': l:args,
\})
try
let l:ch = s:state['ch']
if has('nvim')
call chansend(l:ch, l:req_json)
else
call ch_sendraw(l:ch, req_json)
endif
let s:state.resultHandlers[l:reqid] = a:handle_result
if go#util#HasDebug('debugger-commands')
let g:go_debug_commands = add(go#config#DebugCommands(), {
\ 'request': l:req_json,
\ })
endif
redraw
catch
throw substitute(v:exception, '^Vim', '', '')
endtry
endfunction
function! s:exited(res) abort
if type(a:res) ==# type(v:null)
return 0
endif
let state = a:res.result.State
return state.exited == v:true
endfunction
" Update the location of the current breakpoint or line we're halted on based on
" response from dlv.
function! s:update_breakpoint(res) abort
if type(a:res) ==# type(v:null)
return
endif
let state = a:res.result.State
if !has_key(state, 'currentThread')
return
endif
let s:state['currentThread'] = state.currentThread
let bufs = filter(map(range(1, winnr('$')), '[v:val,bufname(winbufnr(v:val))]'), 'v:val[1]=~"\.go$"')
if len(bufs) == 0
return
endif
exe bufs[0][0] 'wincmd w'
let filename = s:substituteRemotePath(state.currentThread.file)
let linenr = state.currentThread.line
let oldfile = fnamemodify(expand('%'), ':p:gs!\\!/!')
if oldfile != filename
silent! exe 'edit' filename
endif
silent! exe 'norm!' linenr.'G'
silent! normal! zvzz
" TODO(bc): convert to use s:sign_unplace()
silent! sign unplace 9999
" TODO(bc): convert to use s:sign_place()
silent! exe 'sign place 9999 line=' . linenr . ' name=godebugcurline file=' . filename
call s:warn_when_stale(fnamemodify(l:filename, ':p'))
endfunction
" Populate the stacktrace window.
function! s:show_stacktrace(check_errors, res) abort
try
call a:check_errors()
catch
call go#util#EchoError(printf('could not update stack: %s', v:exception))
return
endtry
if type(a:res) isnot type({}) || !has_key(a:res, 'result') || empty(a:res.result)
return
endif
let l:stack_win = bufwinnr(bufnr('__GODEBUG_STACKTRACE__'))
if l:stack_win == -1
return
endif
let l:cur_win = bufwinnr('')
exe l:stack_win 'wincmd w'
try
setlocal modifiable
silent %delete _
for i in range(len(a:res.result.Locations))
let loc = a:res.result.Locations[i]
if loc.file is# '?' || !has_key(loc, 'function')
continue
endif
call setline(i+1, printf('%s - %s:%d', loc.function.name, s:substituteRemotePath(fnamemodify(loc.file, ':p')), loc.line))
endfor
finally
setlocal nomodifiable
exe l:cur_win 'wincmd w'
endtry
endfunction
" Populate the variable window.
function! s:show_variables() abort
let l:var_win = bufwinnr(bufnr('__GODEBUG_VARIABLES__'))
if l:var_win == -1
return
endif
let l:cur_win = bufwinnr('')
exe l:var_win 'wincmd w'
try
setlocal modifiable
silent %delete _
let v = []
let v += ['# Local Variables']
if type(get(s:state, 'localVars', [])) is type([])
for c in s:state['localVars']
let v += split(s:eval_tree(c, 0, 0), "\n")
endfor
endif
let v += ['']
let v += ['# Function Arguments']
if type(get(s:state, 'functionArgs', [])) is type([])
for c in s:state['functionArgs']
let v += split(s:eval_tree(c, 0, 0), "\n")
endfor
endif
let v += ['']
let v += ['# Registers']
if type(get(s:state, 'registers', [])) is type([])
for c in s:state['registers']
let v += [printf("%s = %s", c.Name, c.Value)]
endfor
endif
call setline(1, v)
finally
setlocal nomodifiable
exe l:cur_win 'wincmd w'
endtry
endfunction
function! s:clearState() abort
let s:state['running'] = 0
let s:state['currentThread'] = {}
let s:state['localVars'] = {}
let s:state['functionArgs'] = {}
let s:state['registers'] = {}
let s:state['message'] = []
silent! sign unplace 9999
endfunction
function! s:stop() abort
call s:call_jsonrpc(function('s:noop'), 'RPCServer.Detach', {'kill': s:state['kill_on_detach']})
if has_key(s:state, 'job')
call go#job#Wait(s:state['job'])
" while waiting, the s:complete may have already removed job from s:state.
if has_key(s:state, 'job')
call remove(s:state, 'job')
endif
endif
if has_key(s:state, 'ready')
call remove(s:state, 'ready')
endif
if has_key(s:state, 'ch')
call remove(s:state, 'ch')
endif
call s:clearState()
endfunction
function! go#debug#Stop() abort
" Remove all commands and add back the default commands.
for k in map(split(execute('command GoDebug'), "\n")[1:], 'matchstr(v:val, "^\\s*\\zs\\S\\+")')
exe 'delcommand' k
endfor
command! -nargs=* -complete=customlist,go#package#Complete GoDebugStart call go#debug#Start('debug', <f-args>)
command! -nargs=* -complete=customlist,go#package#Complete GoDebugTest call go#debug#Start('test', <f-args>)
command! -nargs=? GoDebugConnect call go#debug#Start('connect', <f-args>)
command! -nargs=* GoDebugTestFunc call go#debug#TestFunc(<f-args>)
command! -nargs=1 GoDebugAttach call go#debug#Start('attach', <f-args>)
command! -nargs=? GoDebugBreakpoint call go#debug#Breakpoint(<f-args>)
" Restore mappings configured prior to debugging.
call s:restoreMappings()
" remove plug mappings
for k in map(split(execute('nmap <Plug>(go-debug-'), "\n"), 'matchstr(v:val, "^n\\s\\+\\zs\\S\\+")')
execute(printf('nunmap %s', k))
endfor
call s:stop()
let bufs = filter(map(range(1, winnr('$')), '[v:val,bufname(winbufnr(v:val))]'), 'v:val[1]=~"\.go$"')
if len(bufs) > 0
exe bufs[0][0] 'wincmd w'
else
wincmd p
endif
let stackbufnr = bufnr('__GODEBUG_STACKTRACE__')
if stackbufnr != -1
silent! exe bufwinnr(stackbufnr) 'wincmd c'
endif
let varbufnr = bufnr('__GODEBUG_VARIABLES__')
if varbufnr != -1
silent! exe bufwinnr(varbufnr) 'wincmd c'
endif
let outbufnr = bufnr('__GODEBUG_OUTPUT__')
if outbufnr != -1
silent! exe bufwinnr(outbufnr) 'wincmd c'
endif
let gorobufnr = bufnr('__GODEBUG_GOROUTINES__')
if gorobufnr != -1
silent! exe bufwinnr(gorobufnr) 'wincmd c'
endif
if has('balloon_eval')
let &ballooneval=s:ballooneval
let &balloonexpr=s:balloonexpr
endif
augroup vim-go-debug
autocmd!
augroup END
augroup! vim-go-debug
endfunction
function! s:goto_file() abort
let m = matchlist(getline('.'), ' - \(.*\):\([0-9]\+\)$')
if m[1] == ''
return
endif
let bufs = filter(map(range(1, winnr('$')), '[v:val,bufname(winbufnr(v:val))]'), 'v:val[1]=~"\.go$"')
if len(bufs) == 0
return
endif
exe bufs[0][0] 'wincmd w'
let filename = s:substituteLocalPath(m[1])
let linenr = m[2]
let oldfile = fnamemodify(expand('%'), ':p:gs!\\!/!')
if oldfile != filename
silent! exe 'edit' filename
endif
silent! exe 'norm!' linenr.'G'
silent! normal! zvzz
endfunction
function! s:delete_expands()
let nr = line('.')
while 1
let l = getline(nr+1)
if empty(l) || l =~ '^\S'
return
endif
silent! exe (nr+1) . 'd _'
endwhile
silent! exe 'norm!' nr.'G'
endfunction
function! s:expand_var() abort
" Get name from struct line.
let name = matchstr(getline('.'), '^[^:]\+\ze: \*\?[a-zA-Z0-9-_/\.]\+\({\.\.\.}\)\?$')
" Anonymous struct
if name == ''
let name = matchstr(getline('.'), '^[^:]\+\ze: \*\?struct {.\{-}}$')
endif
if name != ''
setlocal modifiable
let not_open = getline(line('.')+1) !~ '^ '
let l = line('.')
call s:delete_expands()
if not_open
call append(l, split(s:eval(name), "\n")[1:])
endif
silent! exe 'norm!' l.'G'
setlocal nomodifiable
return
endif
" Expand maps
let m = matchlist(getline('.'), '^[^:]\+\ze: map.\{-}\[\(\d\+\)\]$')
if len(m) > 0 && m[1] != ''
setlocal modifiable
let not_open = getline(line('.')+1) !~ '^ '
let l = line('.')
call s:delete_expands()
if not_open
" TODO: Not sure how to do this yet... Need to get keys of the map.
" let vs = ''
" for i in range(0, min([10, m[1]-1]))
" let vs .= ' ' . s:eval(printf("%s[%s]", m[0], ))
" endfor
" call append(l, split(vs, "\n"))
endif
silent! exe 'norm!' l.'G'
setlocal nomodifiable
return
endif
" Expand string.
let m = matchlist(getline('.'), '^\([^:]\+\)\ze: \(string\)\[\([0-9]\+\)\]\(: .\{-}\)\?$')
if len(m) > 0 && m[1] != ''
setlocal modifiable
let not_open = getline(line('.')+1) !~ '^ '
let l = line('.')
call s:delete_expands()
if not_open
let vs = ''
for i in range(0, min([10, m[3]-1]))
let vs .= ' ' . s:eval(m[1] . '[' . i . ']')
endfor
call append(l, split(vs, "\n"))
endif
silent! exe 'norm!' l.'G'
setlocal nomodifiable
return
endif
" Expand slice.
let m = matchlist(getline('.'), '^\([^:]\+\)\ze: \(\[\]\w\{-}\)\[\([0-9]\+\)\]$')
if len(m) > 0 && m[1] != ''
setlocal modifiable
let not_open = getline(line('.')+1) !~ '^ '
let l = line('.')
call s:delete_expands()
if not_open
let vs = ''
for i in range(0, min([10, m[3]-1]))
let vs .= ' ' . s:eval(m[1] . '[' . i . ']')
endfor
call append(l, split(vs, "\n"))
endif
silent! exe 'norm!' l.'G'
setlocal nomodifiable
return
endif
endfunction
function! s:start_cb() abort
let l:winid = win_getid()
let l:debugwindows = go#config#DebugWindows()
let l:debugpreservelayout = go#config#DebugPreserveLayout()
if !(empty(l:debugwindows) || l:debugpreservelayout)
silent! only!
endif
let winnum = bufwinnr(bufnr('__GODEBUG_STACKTRACE__'))
if winnum != -1
return
endif
if has_key(l:debugwindows, "vars") && l:debugwindows['vars'] != ''
exe 'silent ' . l:debugwindows['vars']
silent file `='__GODEBUG_VARIABLES__'`
setlocal buftype=nofile bufhidden=wipe nomodified nobuflisted noswapfile nowrap nonumber nocursorline
setlocal filetype=godebugvariables
call append(0, ["# Local Variables", "", "# Function Arguments", "", "# Registers"])
nmap <buffer> <silent> <cr> :<c-u>call <SID>expand_var()<cr>
nmap <buffer> q <Plug>(go-debug-stop)
endif
if has_key(l:debugwindows, "stack") && l:debugwindows['stack'] != ''
exe 'silent ' . l:debugwindows['stack']
silent file `='__GODEBUG_STACKTRACE__'`
setlocal buftype=nofile bufhidden=wipe nomodified nobuflisted noswapfile nowrap nonumber nocursorline
setlocal filetype=godebugstacktrace
nmap <buffer> <cr> :<c-u>call <SID>goto_file()<cr>
nmap <buffer> q <Plug>(go-debug-stop)
endif
if has_key(l:debugwindows, "goroutines") && l:debugwindows['goroutines'] != ''
exe 'silent ' . l:debugwindows['goroutines']
silent file `='__GODEBUG_GOROUTINES__'`
setlocal buftype=nofile bufhidden=wipe nomodified nobuflisted noswapfile nowrap nonumber nocursorline
setlocal filetype=godebugvariables
call append(0, ["# Goroutines"])
nmap <buffer> <silent> <cr> :<c-u>call go#debug#Goroutine()<cr>
endif
if has_key(l:debugwindows, "out") && l:debugwindows['out'] != ''
exe 'silent ' . l:debugwindows['out']
silent file `='__GODEBUG_OUTPUT__'`
setlocal buftype=nofile bufhidden=wipe nomodified nobuflisted noswapfile nowrap nonumber nocursorline
setlocal filetype=godebugoutput
nmap <buffer> q <Plug>(go-debug-stop)
endif
call win_gotoid(l:winid)
silent! delcommand GoDebugStart
silent! delcommand GoDebugTest
silent! delcommand GoDebugTestFunc
silent! delcommand GoDebugAttach
silent! delcommand GoDebugConnect
command! -nargs=0 GoDebugContinue call go#debug#Stack('continue')
command! -nargs=0 GoDebugStop call go#debug#Stop()
nnoremap <silent> <Plug>(go-debug-breakpoint) :<C-u>call go#debug#Breakpoint()<CR>
nnoremap <silent> <Plug>(go-debug-continue) :<C-u>call go#debug#Stack('continue')<CR>
nnoremap <silent> <Plug>(go-debug-stop) :<C-u>call go#debug#Stop()<CR>
augroup vim-go-debug
autocmd! *
call s:configureMappings('(go-debug-breakpoint)', '(go-debug-continue)')
augroup END
doautocmd vim-go-debug BufWinEnter *.go
endfunction
function! s:continue()
command! -nargs=0 GoDebugNext call go#debug#Stack('next')
command! -nargs=0 GoDebugStep call go#debug#Stack('step')
command! -nargs=0 GoDebugStepOut call go#debug#Stack('stepOut')
command! -nargs=0 GoDebugRestart call go#debug#Restart()
command! -nargs=* GoDebugSet call go#debug#Set(<f-args>)
command! -nargs=1 GoDebugPrint call go#debug#Print(<q-args>)
command! -nargs=0 GoDebugHalt call go#debug#Stack('halt')
nnoremap <silent> <Plug>(go-debug-next) :<C-u>call go#debug#Stack('next')<CR>
nnoremap <silent> <Plug>(go-debug-step) :<C-u>call go#debug#Stack('step')<CR>
nnoremap <silent> <Plug>(go-debug-stepout) :<C-u>call go#debug#Stack('stepOut')<CR>
nnoremap <silent> <Plug>(go-debug-print) :<C-u>call go#debug#Print(expand('<cword>'))<CR>
nnoremap <silent> <Plug>(go-debug-halt) :<C-u>call go#debug#Stack('halt')<CR>
if has('balloon_eval')
let s:balloonexpr=&balloonexpr
let s:ballooneval=&ballooneval
set balloonexpr=go#debug#BalloonExpr()
set ballooneval
endif
" Some debug mappings were already added. Restore any mappings the user had
" before the complete mappings are configured so that the mappings are
" returned to the user's original state after the debugger is stopped.
call s:restoreMappings()
augroup vim-go-debug
autocmd! *
call s:configureMappings('(go-debug-breakpoint)', '(go-debug-continue)', '(go-debug-halt)', '(go-debug-next)', '(go-debug-print)', '(go-debug-step)', '(go-debug-stepout)')
augroup END
doautocmd vim-go-debug BufWinEnter *.go
endfunction
function! s:err_cb(ch, msg) abort
if get(s:state, 'ready', 0) != 0
call s:logger('ERR: ', a:ch, a:msg)
return
endif
let s:state['message'] += [a:msg]
endfunction
function! s:out_cb(ch, msg) abort
if get(s:state, 'ready', 0) != 0
call s:logger('OUT: ', a:ch, a:msg)
return
endif
let s:state['message'] += [a:msg]
if stridx(a:msg, go#config#DebugAddress()) != -1
call s:connect(go#config#DebugAddress())
endif
endfunction
function! s:connect(addr) abort
let s:state['data'] = []
let l:state = {'databuf': ''}
" explicitly bind callback to state so that within it, self will
" always refer to state. See :help Partial for more information.
let l:state.on_data = function('s:on_data', [], l:state)
if has('nvim')
let l:ch = sockconnect('tcp', a:addr, {'on_data': l:state.on_data, 'state': l:state})
if l:ch == 0
call go#util#EchoError("could not connect to debugger")
if has_key(s:state, 'job')
call go#job#Stop(s:state['job'])
endif
return
endif
else
let l:ch = ch_open(a:addr, {'mode': 'raw', 'waittime': 5000, 'timeout': 20000, 'callback': l:state.on_data})
if ch_status(l:ch) !=# 'open'
call go#util#EchoError("could not connect to debugger")
if has_key(s:state, 'job')
call go#job#Stop(s:state['job'])
endif
return
endif
endif
let s:state['ch'] = l:ch
" After this block executes, Delve will be running with all the
" breakpoints setup, so this callback doesn't have to run again; just log
" future messages.
let s:state['ready'] = 1
" replace all the breakpoints set before delve started so that the ids won't overlap.
for l:bt in s:list_breakpoints()
call s:sign_unplace(l:bt.id, l:bt.file)
call go#debug#Breakpoint(l:bt.line, l:bt.file)
endfor
call s:start_cb()
endfunction
" s:on_data's third optional argument is provided, but not used, so that the
" same function can be used for Vim's 'callback' and Neovim's 'data'.
function! s:on_data(ch, data, ...) dict abort
let l:data = s:message(self.databuf, a:data)
let l:messages = split(l:data, "\n")
for l:msg in l:messages
let l:data = l:messages[0]
try
let l:res = json_decode(l:data)
" remove the decoded message
call remove(l:messages, 0)
catch
return
finally
" Rejoin messages and assign to databuf so that any messages that come
" in if s:handleRPCResult sleeps will be appended correctly.
"
" Because the current message is removed in the try immediately after
" decoding, that l:messages contains all the messages that have not
" yet been decoded including the current message if decoding it
" failed.
let self.databuf = join(l:messages, "\n")
endtry
if go#util#HasDebug('debugger-commands')
let g:go_debug_commands = add(go#config#DebugCommands(), {
\ 'response': l:data,
\ })
endif
call s:handleRPCResult(l:res)
endfor
endfunction
function! s:message(buf, data) abort
if has('nvim')
" dealing with the channel lines of Neovim is awful. The docs (:help
" channel-lines) say:
" stream event handlers may receive partial (incomplete) lines. For a
" given invocation of on_stdout etc, `a:data` is not guaranteed to end
" with a newline.
" - `abcdefg` may arrive as `['abc']`, `['defg']`.
" - `abc\nefg` may arrive as `['abc', '']`, `['efg']` or `['abc']`,
" `['','efg']`, or even `['ab']`, `['c','efg']`.
"
" Thankfully, though, this is explained a bit better in an issue:
" https://github.com/neovim/neovim/issues/3555. Specifically in these two
" comments:
" * https://github.com/neovim/neovim/issues/3555#issuecomment-152290804
" * https://github.com/neovim/neovim/issues/3555#issuecomment-152588749
"
" The key is
" Every item in the list passed to job control callbacks represents a
" string after a newline(Except the first, of course). If the program
" outputs: "hello\nworld" the corresponding list is ["hello", "world"].
" If the program outputs "hello\nworld\n", the corresponding list is
" ["hello", "world", ""]. In other words, you can always determine if
" the last line received is complete or not.
" and
" for every list you receive in a callback, all items except the first
" represent newlines.
let l:data = printf('%s%s', a:buf, a:data[0])
for l:msg in a:data[1:]
let l:data = printf("%s\n%s", l:data, l:msg)
endfor
return l:data
endif
return printf('%s%s', a:buf, a:data)
endfunction
" s:check_errors will be curried and injected into rpc result handlers so that
" those result handlers can consistently check for errors in the response by
" catching exceptions and handling the error appropriately.
function! s:check_errors(resp_json) abort
if type(a:resp_json) == v:t_dict && has_key(a:resp_json, 'error') && !empty(a:resp_json.error)
throw a:resp_json.error
endif
endfunction
function! s:handleRPCResult(resp) abort
try
let l:id = a:resp.id
" call the result handler with its first argument set to a curried
" s:check_errors value so that the result handler can call s:check_errors
" without passing any arguments to check whether the response is an error
" response.
call call(s:state.resultHandlers[l:id], [function('s:check_errors', [a:resp]), a:resp])
catch
throw v:exception
finally
if has_key(s:state.resultHandlers, l:id)
call remove(s:state.resultHandlers, l:id)
endif
endtry
endfunction
function! go#debug#TestFunc(...) abort
let l:test = go#util#TestName()
if l:test is ''
call go#util#Warn("vim-go: [debug] no test found immediate to cursor")
return
endif
call call('go#debug#Start', extend(['test', '.', '-test.run', printf('%s$', l:test)], a:000))
endfunction
" Start the debug mode. The first variadic argument is the package name to
" compile and debug, anything else will be passed to the running program.
function! go#debug#Start(mode, ...) abort
call go#cmd#autowrite()
if !go#util#has_job()
call go#util#EchoError('This feature requires either Vim 8.0.0087 or newer with +job or Neovim.')
return
endif
" It's already running.
if has_key(s:state, 'job')
return s:state['job']
endif
let s:start_args = [a:mode] + a:000
if go#util#HasDebug('debugger-state')
call go#config#SetDebugDiag(s:state)
endif
let dlv = go#path#CheckBinPath("dlv")
if empty(dlv)
return
endif
try
if a:mode is 'connect'
let l:addr = go#config#DebugAddress()
if a:0 > 0
let l:addr = a:1
endif
let s:state['kill_on_detach'] = v:false
call s:connect(l:addr)
else
let l:cmd = [dlv, a:mode]
let s:state['kill_on_detach'] = v:true
if a:mode is 'debug' || a:mode is 'test'
let l:cmd = extend(l:cmd, s:package(a:000))
let l:cmd = extend(l:cmd, ['--output', tempname()])
elseif a:mode is 'attach'
let l:cmd = add(l:cmd, a:1)
let s:state['kill_on_detach'] = v:false
else
call go#util#EchoError('Unknown dlv command')
endif
let l:cmd += [
\ '--headless',
\ '--api-version', '2',
\ '--listen', go#config#DebugAddress(),
\]
let l:debugLogOutput = go#config#DebugLogOutput()
if l:debugLogOutput != ''
let cmd += ['--log', '--log-output', l:debugLogOutput]
endif
let l:buildtags = go#config#BuildTags()
if buildtags isnot ''
let l:cmd += ['--build-flags', '--tags=' . buildtags]
endif
if len(a:000) > 1
let l:cmd += ['--'] + a:000[1:]
endif
let s:state['message'] = []
let l:opts = {
\ 'for': 'GoDebug',
\ 'statustype': 'debug',
\ 'complete': function('s:complete'),
\ }
let l:opts = go#job#Options(l:opts)
let l:opts.out_cb = function('s:out_cb')
let l:opts.err_cb = function('s:err_cb')
let l:opts.stoponexit = 'kill'
let s:state['job'] = go#job#Start(l:cmd, l:opts)
return s:state['job']
endif
catch
call go#util#EchoError(printf('could not start debugger: %s', v:exception))
endtry
endfunction
" s:package returns the import path of package name of a :GoDebug(Start|Test)
" call as a list so that the package can be appended to a command list using
" extend(). args is expected to be a (potentially empty) list. The first
" element in args (if there are any) is expected to be a package path. An
" empty list is returned when either args is an empty list or the import path
" cannot be determined.
function! s:package(args)
if len(a:args) == 0
return []
endif
" append the package when it's given.
let l:pkgname = a:args[0]
if l:pkgname[0] == '.'
let l:pkgabspath = fnamemodify(l:pkgname, ':p')
let l:dir = go#util#Chdir(expand('%:p:h'))
try
let l:pkgname = go#package#FromPath(l:pkgabspath)
if type(l:pkgname) == type(0)
call go#util#EchoError('could not determine package name')
return []
endif
finally
call go#util#Chdir(l:dir)
endtry
endif
return [l:pkgname]
endfunction
" Translate a reflect kind constant to a human string.
function! s:reflect_kind(k)
" Kind constants from Go's reflect package.
return [
\ 'Invalid Kind',
\ 'Bool',
\ 'Int',
\ 'Int8',
\ 'Int16',
\ 'Int32',
\ 'Int64',
\ 'Uint',
\ 'Uint8',
\ 'Uint16',
\ 'Uint32',
\ 'Uint64',
\ 'Uintptr',
\ 'Float32',
\ 'Float64',
\ 'Complex64',
\ 'Complex128',
\ 'Array',
\ 'Chan',
\ 'Func',
\ 'Interface',
\ 'Map',
\ 'Ptr',
\ 'Slice',
\ 'String',
\ 'Struct',
\ 'UnsafePointer',
\ ][a:k]
endfunction
function! s:eval_tree(var, nest, isMapOrSliceChild) abort
if a:var.name =~ '^\~'
return ''
endif
let nest = a:nest
let v = ''
let kind = s:reflect_kind(a:var.kind)
if !empty(a:var.name) || a:isMapOrSliceChild is 1
if a:isMapOrSliceChild == 0
let v .= repeat(' ', nest) . a:var.name . ': '
endif
if kind == 'Bool'
let v .= printf("%s", a:var.value)
elseif kind == 'Struct'
" Anonymous struct
if a:var.type[:8] == 'struct { '
let v .= printf("%s", a:var.type)
else
let v .= printf("%s{...}", a:var.type)
endif
elseif kind == 'String'
let v .= printf("%s[%d]%s", a:var.type, a:var.len,
\ len(a:var.value) > 0 ? ': ' . a:var.value : '')
elseif kind == 'Slice' || kind == 'String' || kind == 'Map' || kind == 'Array'
let v .= printf("%s[%d]", a:var.type, a:var.len)
elseif kind == 'Chan' || kind == 'Func' || kind == 'Interface'
let v .= printf("%s", a:var.type)
elseif kind == 'Ptr'
" TODO: We can do something more useful here.
let v .= printf("%s", a:var.type)
elseif kind == 'Complex64' || kind == 'Complex128'
let v .= printf("%s%s", a:var.type, a:var.value)
" Int, Float
else
let v .= printf("%s(%s)", a:var.type, a:var.value)
endif
if a:isMapOrSliceChild == 0
let v = printf("%s\n", v)
endif
else
let nest -= 1
endif
if index(['Chan', 'Complex64', 'Complex128'], kind) == -1 && a:var.type != 'error'
let l:idx = 0
for c in a:var.children
if kind == 'Map'
" Maps alternate children between keys and values. Keys will be even
" number indexes.
let l:isMapKey = (l:idx % 2) is 0
if l:isMapKey == 1
let v .= printf("%s%s:\n", repeat(' ', nest + 1), s:eval_tree(c, 0, 1))
else
let v .= printf("%s%s\n", repeat(' ', nest + 2), s:eval_tree(c, 0, 1))
endif
elseif kind == 'Slice'
let v .= printf("%d: %s\n", l:idx, s:eval_tree(c, nest + 1, 1))
else
let v .= s:eval_tree(c, nest + 1, 0)
endif
let l:idx += 1
endfor
endif
return v
endfunction
function! s:eval(arg) abort
try
let l:promise = go#promise#New(function('s:rpc_response'), 20000, {})
call s:call_jsonrpc(l:promise.wrapper, 'RPCServer.State')
let l:res = l:promise.await()
let l:cmd = 'RPCServer.Eval'
let l:args = {
\ 'expr': a:arg,
\ 'scope': {'GoroutineID': l:res.result.State.currentThread.goroutineID}
\ }
let l:ResultFn = funcref('s:evalResult', [])
if a:arg =~ '^call '
let l:cmd = 'RPCServer.Command'
let l:args = {
\ 'name': 'call',
\ 'Expr': a:arg[5:],
\ 'ReturnInfoLoadConfig': {
\ 'FollowPointers': v:false,
\ 'MaxVariableRecurse': 10,
\ 'MaxStringLen': 80,
\ 'MaxArrayValues': 10,
\ 'MaxStructFields': 10,
\ },
\ }
let l:ResultFn = funcref('s:callResult', [])
endif
let l:promise = go#promise#New(function('s:rpc_response'), 20000, {})
call s:call_jsonrpc(l:promise.wrapper, l:cmd, l:args)
let l:res = l:promise.await()
let l:result = call(l:ResultFn, [l:res.result])
" l:result will be a list when evaluating a call expression.
if type(l:result) is type([])
let l:result = map(l:result, funcref('s:renameEvalReturnValue'))
if len(l:result) isnot 1
return map(l:result, 's:eval_tree(v:val, 0, 0)')
endif
let l:result = l:result[0]
endif
return s:eval_tree(l:result, 0, 0)
catch
call go#util#EchoError(printf('evaluation failed: %s', v:exception))
return ''
endtry
endfunction
function! s:callResult(res) abort
return a:res.State.currentThread.ReturnValues
endfunction
function! s:evalResult(res) abort
return a:res.Variable
endfunction
function! s:renameEvalReturnValue(key, val) abort
let a:val.name = printf('[%s]', string(a:key))
return a:val
endfunction
function! go#debug#BalloonExpr() abort
silent! let l:v = s:eval(v:beval_text)
return l:v
endfunction
function! go#debug#Print(arg) abort
try
let l:result = s:eval(a:arg)
if type(l:result) is type([])
echo join(map(l:result, 'substitute(v:val, "\n$", "", '''')'), "\n")
return
elseif type(l:result) isnot type('')
throw 'unexpected result'
endif
echo substitute(l:result, "\n$", "", '')
catch
call go#util#EchoError(printf('could not print: %s', v:exception))
endtry
endfunction
function! s:update_goroutines() abort
call s:call_jsonrpc(function('s:update_goroutines_state_handler'), 'RPCServer.State')
endfunction
function! s:update_goroutines_state_handler(check_errors, res) abort
try
call a:check_errors()
let l:currentGoroutineID = 0
try
if type(a:res) is type({}) && has_key(a:res, 'result') && !empty(a:res['result'])
let l:currentGoroutineID = a:res["result"]["State"]["currentGoroutine"]["id"]
endif
catch
call go#util#EchoWarning("current goroutine not found...")
endtry
call s:call_jsonrpc(function('s:list_goroutines_handler', [l:currentGoroutineID]), 'RPCServer.ListGoroutines')
catch
call go#util#EchoError(printf('could not list goroutines: %s', v:exception))
endtry
endfunction
function s:list_goroutines_handler(currentGoroutineID, check_errors, res) abort
try
call a:check_errors()
call s:show_goroutines(a:currentGoroutineID, a:res)
catch
call go#util#EchoError(printf('could not show goroutines: %s', v:exception))
endtry
endfunction
function! s:show_goroutines(currentGoroutineID, res) abort
let l:goroutines_winid = bufwinid('__GODEBUG_GOROUTINES__')
if l:goroutines_winid == -1
return
endif
let l:winid = win_getid()
call win_gotoid(l:goroutines_winid)
try
setlocal modifiable
silent %delete _
let v = []
if type(a:res) isnot type({}) || !has_key(a:res, 'result') || empty(a:res['result'])
call setline(1, v)
return
endif
let l:goroutines = a:res["result"]["Goroutines"]
if len(l:goroutines) == 0
call go#util#EchoWarning("No Goroutines Running Now...")
call setline(1, v)
return
endif
for l:idx in range(len(l:goroutines))
let l:goroutine = l:goroutines[l:idx]
let l:goroutineType = ""
let l:loc = 0
if l:goroutine.startLoc.file != ""
let l:loc = l:goroutine.startLoc
let l:goroutineType = "Start"
endif
if l:goroutine.goStatementLoc.file != ""
let l:loc = l:goroutine.goStatementLoc
let l:goroutineType = "Go"
endif
if l:goroutine.currentLoc.file != ""
let l:loc = l:goroutine.currentLoc
let l:goroutineType = "Runtime"
endif
if l:goroutine.userCurrentLoc.file != ""
let l:loc=l:goroutine.userCurrentLoc
let l:goroutineType = "User"
endif
" The current goroutine can be changed by pressing enter on one of the
" lines listing a non-active goroutine. If the format of either of these
" lines is modified, then make sure that go#debug#Goroutine is also
" changed if needed.
if l:goroutine.id == a:currentGoroutineID
let l:g = printf("* Goroutine %s - %s: %s:%s %s (thread: %s)", l:goroutine.id, l:goroutineType, s:substituteRemotePath(l:loc.file), l:loc.line, l:loc.function.name, l:goroutine.threadID)
let l:currentGoroutine = [l:g]
continue
else
let l:g = printf(" Goroutine %s - %s: %s:%s %s (thread: %s)", l:goroutine.id, l:goroutineType, s:substituteRemotePath(l:loc.file), l:loc.line, l:loc.function.name, l:goroutine.threadID)
endif
let v += [l:g]
endfor
let v = ['# Goroutines'] + l:currentGoroutine + v
call setline(1, v)
finally
setlocal nomodifiable
call win_gotoid(l:winid)
endtry
endfunction
function! s:update_variables() abort
" FollowPointers requests pointers to be automatically dereferenced.
" MaxVariableRecurse is how far to recurse when evaluating nested types.
" MaxStringLen is the maximum number of bytes read from a string
" MaxArrayValues is the maximum number of elements read from an array, a slice or a map.
" MaxStructFields is the maximum number of fields read from a struct, -1 will read all fields.
let l:cfg = {
\ 'scope': {'GoroutineID': s:goroutineID()},
\ 'cfg': {'MaxStringLen': 20, 'MaxArrayValues': 20, 'MaxVariableRecurse': 10}
\ }
try
call s:call_jsonrpc(function('s:handle_list_local_vars'), 'RPCServer.ListLocalVars', l:cfg)
catch
call go#util#EchoError(printf('could not list variables: %s', v:exception))
endtry
try
call s:call_jsonrpc(function('s:handle_list_function_args'), 'RPCServer.ListFunctionArgs', l:cfg)
catch
call go#util#EchoError(printf('could not list function arguments: %s', v:exception))
endtry
try
call s:call_jsonrpc(function('s:handle_list_registers'), 'RPCServer.ListRegisters', l:cfg)
catch
call go#util#EchoError(printf('could not list registers: %s', v:exception))
endtry
endfunction
function! s:handle_list_local_vars(check_errors, res) abort
let s:state['localVars'] = {}
try
call a:check_errors()
if type(a:res) is type({}) && has_key(a:res, 'result') && !empty(a:res.result)
let s:state['localVars'] = a:res.result['Variables']
endif
catch
call go#util#EchoWarning(printf('could not list variables: %s', v:exception))
endtry
call s:show_variables()
endfunction
function! s:handle_list_function_args(check_errors, res) abort
let s:state['functionArgs'] = {}
try
call a:check_errors()
if type(a:res) is type({}) && has_key(a:res, 'result') && !empty(a:res.result)
let s:state['functionArgs'] = a:res.result['Args']
endif
catch
call go#util#EchoWarning(printf('could not list function arguments: %s', v:exception))
endtry
call s:show_variables()
endfunction
function! s:handle_list_registers(check_errors, res) abort
let s:state['registers'] = {}
try
call a:check_errors()
if type(a:res) is type({}) && has_key(a:res, 'result') && !empty(a:res.result)
let s:state['registers'] = a:res.result['Regs']
endif
catch
call go#util#EchoWarning(printf('could not list registers: %s', v:exception))
endtry
call s:show_variables()
endfunction
function! go#debug#Set(symbol, value) abort
try
let l:promise = go#promise#New(function('s:rpc_response'), 20000, {})
call s:call_jsonrpc(l:promise.wrapper, 'RPCServer.State')
let l:res = l:promise.await()
call s:call_jsonrpc(function('s:handle_set'), 'RPCServer.Set', {
\ 'symbol': a:symbol,
\ 'value': a:value,
\ 'scope': {'GoroutineID': l:res.result.State.currentThread.goroutineID}
\ })
catch
call go#util#EchoError(printf('could not set symbol value: %s', v:exception))
endtry
call s:update_variables()
endfunction
function! s:handle_set(check_errors, res) abort
try
call a:check_errors()
catch
call go#util#EchoError(printf('could not set symbol value: %s', v:exception))
endtry
call s:update_variables()
endfunction
function! s:update_stacktrace() abort
try
call s:call_jsonrpc(function('s:show_stacktrace'), 'RPCServer.Stacktrace', {'id': s:goroutineID(), 'depth': 5})
catch
call go#util#EchoError(printf('could not update stack: %s', v:exception))
endtry
endfunction
function! s:stack_cb(res) abort
let s:stack_name = ''
if type(a:res) isnot type({}) || !has_key(a:res, 'result') || empty(a:res.result)
return
endif
if s:exited(a:res)
call go#debug#Stop()
return
endif
call s:update_breakpoint(a:res)
call s:update_goroutines()
call s:update_stacktrace()
call s:update_variables()
endfunction
" Send a command to change the cursor location to Delve.
"
" a:name must be one of continue, next, step, or stepOut.
function! go#debug#Stack(name) abort
let l:name = a:name
" Run continue if the program hasn't started yet.
if s:state.running is 0
let s:state.running = 1
let l:name = 'continue'
call s:continue()
endif
" Add a breakpoint to the main.Main if the user didn't define any.
" TODO(bc): actually set the breakpoint in main.Main
if len(s:list_breakpoints()) is 0
if go#debug#Breakpoint() isnot 0
let s:state.running = 0
return
endif
endif
try
" s:stack_name is reset in s:stack_cb(). While its value is 'next', the
" current operation being performed by delve is a next operation and it
" must be cancelled before another next operation can start. See
" https://github.com/go-delve/delve/blob/ab5713d3ec5d12754f4b2edf85e4b36a08b67c48/Documentation/api/ClientHowto.md#special-continue-commands-and-asynchronous-breakpoints
" for more information.
if l:name is# 'next' && get(s:, 'stack_name', '') is# 'next'
" use s:rpc_response so that the any errors will be checked instead of
" completely discarding the result with s:noop.
let l:promise = go#promise#New(function('s:rpc_response'), 20000, {})
call s:call_jsonrpc(l:promise.wrapper, 'RPCServer.CancelNext')
call l:promise.await()
endif
let s:stack_name = l:name
try
silent! sign unplace 9999
call s:call_jsonrpc(function('s:handle_stack_response', [l:name]), 'RPCServer.Command', {'name': l:name})
catch
call go#util#EchoError(printf('rpc failure: %s', v:exception))
call s:clearState()
call go#util#EchoInfo('restarting debugger')
call go#debug#Restart()
endtry
catch
call go#util#EchoError(printf('CancelNext RPC call failed: %s', v:exception))
endtry
endfunction
function! s:handle_stack_response(command, check_errors, res) abort
try
call a:check_errors()
if a:command is# 'next'
call s:handleNextInProgress(a:res)
endif
call s:stack_cb(a:res)
catch
call go#util#EchoError(printf('rpc failure: %s', v:exception))
call s:clearState()
call go#util#EchoInfo('restarting debugger')
call go#debug#Restart()
endtry
endfunction
function! s:handleNextInProgress(res)
try
let l:res = a:res
let l:w = 0
while l:w < 1
if l:res.result.State.NextInProgress == v:true
" TODO(bc): message the user that a breakpoint was hit in a different
" goroutine while trying to resume.
let l:promise = go#promise#New(function('s:rpc_response'), 20000, {})
call s:call_jsonrpc(l:promise.wrapper, 'RPCServer.Command', {'name': 'continue'})
let l:res = l:promise.await()
else
return
endif
endwhile
catch
throw v:exception
endtry
endfunction
function! go#debug#Restart() abort
call go#cmd#autowrite()
try
call s:restoreMappings()
call s:stop()
let s:state = {
\ 'rpcid': 1,
\ 'running': 0,
\ 'currentThread': {},
\ 'localVars': {},
\ 'functionArgs': {},
\ 'registers': {},
\ 'message': [],
\ 'resultHandlers': {},
\ 'kill_on_detach': s:state['kill_on_detach'],
\ }
call call('go#debug#Start', s:start_args)
catch
call go#util#EchoError(printf('restart failed: %s', v:exception))
endtry
endfunction
" Report if debugger mode is ready.
function! s:isReady()
return get(s:state, 'ready', 0) != 0
endfunction
" Change Goroutine
function! go#debug#Goroutine() abort
let l:goroutineID = str2nr(substitute(getline('.'), '^ Goroutine \(.\{-1,\}\) - .*', '\1', 'g'))
if l:goroutineID <= 0
return
endif
try
let l:promise = go#promise#New(function('s:rpc_response'), 20000, {})
call s:call_jsonrpc(l:promise.wrapper, 'RPCServer.Command', {'Name': 'switchGoroutine', 'GoroutineID': l:goroutineID})
let l:res = l:promise.await()
call s:stack_cb(l:res)
call go#util#EchoInfo("Switched goroutine to: " . l:goroutineID)
catch
call go#util#EchoError(printf('could not switch goroutine: %s', v:exception))
endtry
endfunction
" Toggle breakpoint. Returns 0 on success and 1 on failure.
function! go#debug#Breakpoint(...) abort
let l:filename = fnamemodify(expand('%'), ':p:gs!\\!/!')
let l:linenr = line('.')
" Get line number from argument.
if len(a:000) > 0
let l:linenr = str2nr(a:1)
if l:linenr is 0
call go#util#EchoError('not a number: ' . a:1)
return 0
endif
if len(a:000) > 1
let l:filename = a:2
endif
endif
try
" Check if we already have a breakpoint for this line.
let l:found = {}
for l:bt in s:list_breakpoints()
if l:bt.file is# l:filename && l:bt.line is# l:linenr
let l:found = l:bt
break
endif
endfor
" Remove breakpoint.
if type(l:found) == v:t_dict && !empty(l:found)
call s:sign_unplace(l:found.id, l:found.file)
if s:isReady()
let l:promise = go#promise#New(function('s:rpc_response'), 20000, {})
call s:call_jsonrpc(l:promise.wrapper, 'RPCServer.ClearBreakpoint', {'id': l:found.id})
let res = l:promise.await()
endif
else " Add breakpoint
if s:isReady()
let l:promise = go#promise#New(function('s:rpc_response'), 20000, {})
call s:call_jsonrpc(l:promise.wrapper, 'RPCServer.CreateBreakpoint', {'Breakpoint': {'file': s:substituteLocalPath(l:filename), 'line': l:linenr}})
let l:res = l:promise.await()
let l:bt = l:res.result.Breakpoint
call s:sign_place(l:bt.id, s:substituteRemotePath(l:bt.file), l:bt.line)
else
let l:id = len(s:list_breakpoints()) + 1
call s:sign_place(l:id, l:filename, l:linenr)
endif
endif
catch
call go#util#EchoError(printf('could not toggle breakpoint: %s', v:exception))
return 1
endtry
return 0
endfunction
function! s:sign_unplace(id, file) abort
if !exists('*sign_unplace')
exe 'sign unplace ' . a:id .' file=' . a:file
return
endif
call sign_unplace('vim-go-debug', {'buffer': a:file, 'id': a:id})
endfunction
function! s:sign_place(id, expr, lnum) abort
if !exists('*sign_place')
exe 'sign place ' . a:id . ' line=' . a:lnum . ' name=godebugbreakpoint file=' . a:expr
return
endif
call sign_place(a:id, 'vim-go-debug', 'godebugbreakpoint', a:expr, {'lnum': a:lnum})
endfunction
function! s:list_breakpoints()
let l:breakpoints = []
let l:signs = s:sign_getplaced()
for l:item in l:signs
let l:file = fnamemodify(bufname(l:item.bufnr), ':p')
for l:sign in l:item.signs
call add(l:breakpoints, {
\ 'id': l:sign.id,
\ 'file': l:file,
\ 'line': l:sign.lnum,
\ })
endfor
endfor
return l:breakpoints
endfunction
function! s:sign_getplaced() abort
if !exists('*sign_getplaced') " sign_getplaced was introduced in Vim 8.1.0614
" :sign place
" --- Signs ---
" Signs for a.go:
" line=15 id=2 name=godebugbreakpoint
" line=16 id=1 name=godebugbreakpoint
" Signs for a_test.go:
" line=6 id=3 name=godebugbreakpoint
" l:signs should be the same sam form as the return value for
" sign_getplaced(), a list with the following entries:
" * bufnr - number of the buffer with the sign
" * signs = list of signs placed in bufnr
let l:signs = []
let l:file = ''
for l:line in split(execute('sign place'), '\n')[1:]
if l:line =~# '^Signs for '
let l:file = l:line[10:-2]
continue
else
" sign place's output may end with Signs instead of starting with Signs.
" See
" https://github.com/fatih/vim-go/issues/2920#issuecomment-644885774.
let l:idx = match(l:line, '\.go .* Signs:$')
if l:idx >= 0
let l:file = l:line[0:l:idx+2]
continue
endif
endif
if l:line !~# 'name=godebugbreakpoint'
continue
endif
let l:sign = matchlist(l:line, '\vline\=(\d+) +id\=(\d+)')
call add(l:signs, {
\ 'bufnr': bufnr(l:file),
\ 'signs': [{
\ 'id': str2nr(l:sign[2]),
\ 'lnum': str2nr(l:sign[1]),
\ }],
\ })
endfor
return l:signs
endif
" it would be nice to use lambda's here, but vim-vimparser currently fails
" to parse lamdas as map() arguments.
" TODO(bc): return flatten(map(filter(copy(getbufinfo()), { _, val -> val.listed }), { _, val -> sign_getplaced(val.bufnr, {'group': 'vim-go-debug', 'name': 'godebugbreakpoint'})}))
let l:bufinfo = getbufinfo()
let l:listed = []
for l:info in l:bufinfo
if l:info.listed
let l:listed = add(l:listed, l:info)
endif
endfor
let l:signs = []
for l:buf in l:listed
let l:signs = add(l:signs, sign_getplaced(l:buf.bufnr, {'group': 'vim-go-debug', 'name': 'godebugbreakpoint'})[0])
endfor
return l:signs
endfunction
exe 'sign define godebugbreakpoint text='.go#config#DebugBreakpointSignText().' texthl=GoDebugBreakpoint'
sign define godebugcurline text== texthl=GoDebugCurrent linehl=GoDebugCurrent
" s:rpc_response is a convenience function to check for errors and return
" a:res when a:res is not an error response.
function! s:rpc_response(check_errors, res) abort
call a:check_errors()
return a:res
endfunction
" s:noop is a noop function. It takes any number of arguments and does
" nothing.
function s:noop(...) abort
endfunction
function! s:warn_when_stale(filename) abort
let l:bufinfo = getbufinfo(a:filename)
if len(l:bufinfo) == 0
return
endif
if l:bufinfo[0].changed
call s:warn_stale()
return
endif
call s:call_jsonrpc(function('s:handle_staleness_check_response', [fnamemodify(a:filename, ':p')]), 'RPCServer.LastModified')
endfunction
function! s:handle_staleness_check_response(filename, check_errors, res) abort
try
call a:check_errors()
catch
" swallow any errors
return
endtry
let l:ftime = strftime('%Y-%m-%dT%H:%M:%S', getftime(a:filename))
if l:ftime < a:res.result.Time[0:(len(l:ftime) - 1)]
return
endif
call s:warn_stale(a:filename)
endfunction
function! s:warn_stale(filename) abort
call go#util#EchoWarning(printf('file locations may be incorrect, because %s has changed since debugging started', a:filename))
endfunction
function! s:configureMappings(...) abort
if a:0 == 0
return
endif
let l:debug_mappings = go#config#DebugMappings()
for l:arg in a:000
if !has_key(l:debug_mappings, l:arg)
continue
endif
let l:config = l:debug_mappings[l:arg]
" do not attempt to apply the mapping when the key is empty or missing.
if get(l:config, 'key', '') == ''
continue
endif
let l:lhs = l:config.key
try
call execute(printf('autocmd BufWinEnter *.go call s:save_maparg_for(expand(''%%''), ''%s'')', l:lhs))
call execute('autocmd BufWinLeave *.go call s:restoreMappings()')
let l:mapping = 'autocmd BufWinEnter *.go nmap <buffer>'
if has_key(l:config, 'arguments')
let l:mapping = printf('%s %s', l:mapping, l:config.arguments)
endif
let l:mapping = printf('%s %s <Plug>%s', l:mapping, l:lhs, l:arg)
call execute(l:mapping)
catch
call go#util#EchoError(printf('could not configure mapping for %s: %s', l:lhs, v:exception))
endtry
endfor
endfunction
function! s:save_maparg_for(bufname, lhs) abort
" make sure bufname is the active buffer.
if fnamemodify(a:bufname, ':p') isnot expand('%:p')
call go#util#EchoWarning('buffer must be active to save its mappings')
return
endif
" only normal-mode buffer-local mappings are needed, because all
" vim-go-debug mappings are normal-mode buffer-local mappings. Therefore,
" we only need to retrieve normal mode mappings that need to be saved.
let l:maparg = maparg(a:lhs, 'n', 0, 1)
if empty(l:maparg)
return
endif
if l:maparg.buffer
let l:bufmapargs = get(s:mapargs, a:bufname, [])
let l:bufmapargs = add(l:bufmapargs, l:maparg)
let s:mapargs[a:bufname] = l:bufmapargs
endif
endfunction
function! s:restoreMappings() abort
" Remove all debugging mappings.
for l:mapping in values(go#config#DebugMappings())
let l:lhs = get(l:mapping, 'key', '')
if l:lhs == ''
continue
endif
let l:maparg = maparg(l:lhs, 'n', 0, 1)
if empty(l:maparg)
continue
endif
if l:maparg.buffer
call execute(printf('nunmap <buffer> %s', l:lhs))
endif
endfor
call s:restoremappingfor(bufname(''))
endfunction
function! s:restoremappingfor(bufname) abort
if !has_key(s:mapargs, a:bufname)
return
endif
for l:maparg in s:mapargs[a:bufname]
call s:restore_mapping(l:maparg)
endfor
call remove(s:mapargs, a:bufname)
endfunction
function! s:restore_mapping(maparg)
if empty(a:maparg)
return
endif
if !exists('*mapset')
" see :h :map-arguments
let l:silent_attr = get(a:maparg, 'silent', 0) ? '<silent>' : ''
let l:nowait_attr = get(a:maparg, 'no_wait', 0) ? '<nowait>' : ''
let l:buffer_attr = get(a:maparg, 'buffer', 0) ? '<buffer>' : ''
let l:expr_attr = get(a:maparg, 'expr', 0) ? '<expr>' : ''
let l:unique_attr = get(a:maparg, 'unique', 0) ? '<unique>' : ''
let l:script_attr = get(a:maparg, 'script', 0) ? '<script>' : ''
let l:command = [a:maparg['mode'], (get(a:maparg, 'noremap', 0) ? 'nore' : ''), 'map']
let l:command = join(filter(l:command, '!empty(v:val)'), '')
let l:rhs = a:maparg['rhs']
let l:lhs = a:maparg['lhs']
" NOTE: most likely <buffer> should be first
let l:mapping = join(filter([l:command, l:buffer_attr, l:silent_attr, l:nowait_attr, l:expr_attr, l:unique_attr, l:script_attr, l:lhs, l:rhs], '!empty(v:val)'))
call execute(l:mapping)
return
endif
call mapset('n', 0, a:maparg)
return
endfunction
function! s:substituteRemotePath(path) abort
return s:substitutePath(a:path, go#config#DebugSubstitutePaths())
endfunction
function! s:substituteLocalPath(path) abort
return s:substitutePath(a:path, map(deepcopy(go#config#DebugSubstitutePaths()), '[v:val[1], v:val[0]]'))
endfunction
function! s:substitutePath(path, substitutions) abort
for [l:from, l:to] in a:substitutions
if len(a:path) < len(l:from)
continue
endif
if a:path[0:len(l:from)-1] != l:from
continue
endif
return printf('%s%s', l:to, a:path[len(l:from):-1])
endfor
return a:path
endfunction
" restore Vi compatibility settings
let &cpo = s:cpo_save
unlet s:cpo_save
" vim: sw=2 ts=2 et