mirror of
https://github.com/neovim/neovim.git
synced 2024-09-17 20:58:20 -04:00
Compare commits
29 Commits
7ac093abbc
...
b0fae12c71
Author | SHA1 | Date | |
---|---|---|---|
|
b0fae12c71 | ||
|
a0d8c2b86e | ||
|
549c00c791 | ||
|
23dcd7cd73 | ||
|
3f15e57b26 | ||
|
a9031cc4a6 | ||
|
5e7933693b | ||
|
f408603f4f | ||
|
78b8510933 | ||
|
057d27a9d6 | ||
|
5792546777 | ||
|
3b54adc6c6 | ||
|
325d349f9d | ||
|
5191a11d66 | ||
|
90585e47fe | ||
|
f2173b1aa2 | ||
|
67d6b6f27e | ||
|
8512f669f0 | ||
|
755512ed60 | ||
|
4c23b83456 | ||
|
5284a2a793 | ||
|
b9b408a56c | ||
|
8654a97006 | ||
|
057314345a | ||
|
d15d002bf4 | ||
|
2a56b563e5 | ||
|
07c0196300 | ||
|
750ec22474 | ||
|
60cdbf3f92 |
18
.github/workflows/backport.yml
vendored
18
.github/workflows/backport.yml
vendored
@ -26,3 +26,21 @@ jobs:
|
||||
pull_title: "${pull_title}"
|
||||
label_pattern: "^ci:backport ([^ ]+)$"
|
||||
github_token: ${{ steps.app-token.outputs.token }}
|
||||
|
||||
- name: Create failed backport label
|
||||
if: ${{ steps.backport.outputs.was_successful == 'false' }}
|
||||
uses: actions/github-script@v7
|
||||
with:
|
||||
script: |
|
||||
github.rest.issues.addLabels({
|
||||
issue_number: context.issue.number,
|
||||
owner: context.repo.owner,
|
||||
repo: context.repo.repo,
|
||||
labels: ['needs:backport']
|
||||
})
|
||||
|
||||
- name: Enable automerge
|
||||
if: ${{ steps.backport.outputs.was_successful == 'true' }}
|
||||
env:
|
||||
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
run: gh pr merge --rebase --auto ${{ steps.backport.outputs.created_pull_numbers }}
|
||||
|
2
.github/workflows/reviewers_add.yml
vendored
2
.github/workflows/reviewers_add.yml
vendored
@ -5,7 +5,7 @@ on:
|
||||
workflow_call:
|
||||
jobs:
|
||||
request-reviewer:
|
||||
if: github.event.pull_request.state == 'open' && github.event.pull_request.draft == false
|
||||
if: github.event.pull_request.state == 'open' && github.event.pull_request.draft == false && !endsWith(github.actor, '[bot]')
|
||||
runs-on: ubuntu-latest
|
||||
permissions:
|
||||
pull-requests: write
|
||||
|
@ -7,8 +7,8 @@ LUAJIT_SHA256 2b5514bd6a6573cb6111b43d013e952cbaf46762d14ebe26c872ddb80b5a84e0
|
||||
LUA_URL https://www.lua.org/ftp/lua-5.1.5.tar.gz
|
||||
LUA_SHA256 2640fc56a795f29d28ef15e13c34a47e223960b0240e8cb0a82d9b0738695333
|
||||
|
||||
UNIBILIUM_URL https://github.com/neovim/unibilium/archive/ab28a2ddb86a144194a798bcf1fef1ab4f981ab7.tar.gz
|
||||
UNIBILIUM_SHA256 7c0386fc48452632868e0dcb8e7ed140d67a3da79e39ceee54c1ba7a495ad625
|
||||
UNIBILIUM_URL https://github.com/neovim/unibilium/archive/v2.1.2.tar.gz
|
||||
UNIBILIUM_SHA256 370ecb07fbbc20d91d1b350c55f1c806b06bf86797e164081ccc977fc9b3af7a
|
||||
|
||||
LUV_URL https://github.com/luvit/luv/releases/download/1.48.0-2/luv-1.48.0-2.tar.gz
|
||||
LUV_SHA256 2c3a1ddfebb4f6550293a40ee789f7122e97647eede51511f57203de48c03b7a
|
||||
|
@ -23,6 +23,7 @@
|
||||
" 2024 Aug 15 by Vim Project: style changes, prevent E121 (#15501)
|
||||
" 2024 Aug 22 by Vim Project: fix mf-selection highlight (#15551)
|
||||
" 2024 Aug 22 by Vim Project: adjust echo output of mx command (#15550)
|
||||
" 2024 Sep 15 by Vim Project: more strict confirmation dialog (#15680)
|
||||
" }}}
|
||||
" Former Maintainer: Charles E Campbell
|
||||
" GetLatestVimScripts: 1075 1 :AutoInstall: netrw.vim
|
||||
@ -11275,7 +11276,7 @@ fun! s:NetrwLocalRm(path) range
|
||||
let ok= s:NetrwLocalRmFile(a:path,fname,all)
|
||||
if ok =~# 'q\%[uit]' || ok == "no"
|
||||
break
|
||||
elseif ok =~# 'a\%[ll]'
|
||||
elseif ok =~# '^a\%[ll]$'
|
||||
let all= 1
|
||||
endif
|
||||
endfor
|
||||
@ -11304,7 +11305,7 @@ fun! s:NetrwLocalRm(path) range
|
||||
let ok= s:NetrwLocalRmFile(a:path,curword,all)
|
||||
if ok =~# 'q\%[uit]' || ok == "no"
|
||||
break
|
||||
elseif ok =~# 'a\%[ll]'
|
||||
elseif ok =~# '^a\%[ll]$'
|
||||
let all= 1
|
||||
endif
|
||||
let ctr= ctr + 1
|
||||
@ -11351,12 +11352,12 @@ fun! s:NetrwLocalRmFile(path,fname,all)
|
||||
" call Decho("response: ok<".ok.">",'~'.expand("<slnum>"))
|
||||
let ok= substitute(ok,'\[{y(es)},n(o),a(ll),q(uit)]\s*','','e')
|
||||
" call Decho("response: ok<".ok."> (after sub)",'~'.expand("<slnum>"))
|
||||
if ok =~# 'a\%[ll]'
|
||||
if ok =~# '^a\%[ll]$'
|
||||
let all= 1
|
||||
endif
|
||||
endif
|
||||
|
||||
if all || ok =~# 'y\%[es]' || ok == ""
|
||||
if all || ok =~# '^y\%[es]$' || ok == ""
|
||||
let ret= s:NetrwDelete(rmfile)
|
||||
" call Decho("errcode=".v:shell_error." ret=".ret,'~'.expand("<slnum>"))
|
||||
endif
|
||||
@ -11372,13 +11373,13 @@ fun! s:NetrwLocalRmFile(path,fname,all)
|
||||
if ok == ""
|
||||
let ok="no"
|
||||
endif
|
||||
if ok =~# 'a\%[ll]'
|
||||
if ok =~# '^a\%[ll]$'
|
||||
let all= 1
|
||||
endif
|
||||
endif
|
||||
let rmfile= substitute(rmfile,'[\/]$','','e')
|
||||
|
||||
if all || ok =~# 'y\%[es]' || ok == ""
|
||||
if all || ok =~# '^y\%[es]$' || ok == ""
|
||||
if delete(rmfile,"rf")
|
||||
call netrw#ErrorMsg(s:ERROR,"unable to delete directory <".rmfile.">!",103)
|
||||
endif
|
||||
|
@ -2559,7 +2559,7 @@ vim.ui.input({opts}, {on_confirm}) *vim.ui.input()*
|
||||
typed (it might be an empty string if nothing was
|
||||
entered), or `nil` if the user aborted the dialog.
|
||||
|
||||
vim.ui.open({path}) *vim.ui.open()*
|
||||
vim.ui.open({path}, {opt}) *vim.ui.open()*
|
||||
Opens `path` with the system default handler (macOS `open`, Windows
|
||||
`explorer.exe`, Linux `xdg-open`, …), or returns (but does not show) an
|
||||
error message on failure.
|
||||
@ -2570,6 +2570,8 @@ vim.ui.open({path}) *vim.ui.open()*
|
||||
-- Asynchronous.
|
||||
vim.ui.open("https://neovim.io/")
|
||||
vim.ui.open("~/path/to/file")
|
||||
-- Use the "osurl" command to handle the path or URL.
|
||||
vim.ui.open("gh#neovim/neovim!29490", { cmd = { 'osurl' } })
|
||||
-- Synchronous (wait until the process exits).
|
||||
local cmd, err = vim.ui.open("$VIMRUNTIME")
|
||||
if cmd then
|
||||
@ -2579,6 +2581,8 @@ vim.ui.open({path}) *vim.ui.open()*
|
||||
|
||||
Parameters: ~
|
||||
• {path} (`string`) Path or URL to open
|
||||
• {opt} (`{ cmd?: string[] }?`) Options
|
||||
• cmd string[]|nil Command used to open the path or URL.
|
||||
|
||||
Return (multiple): ~
|
||||
(`vim.SystemObj?`) Command object, or nil if not found.
|
||||
|
@ -87,6 +87,9 @@ TREESITTER
|
||||
capture IDs to a list of nodes that need to be iterated over. For
|
||||
backwards compatibility, an option `all=false` (only return the last
|
||||
matching node) is provided that will be removed in a future release.
|
||||
• |LanguageTree:trees()| no longer guarantees that the returned table is
|
||||
list-like even after a full parse. Always use |next()| or |pairs()| to
|
||||
access it.
|
||||
|
||||
TUI
|
||||
|
||||
@ -186,6 +189,9 @@ TREESITTER
|
||||
• |LanguageTree:node_for_range()| gets anonymous and named nodes for a range
|
||||
• |vim.treesitter.get_node()| now takes an option `include_anonymous`, default
|
||||
false, which allows it to return anonymous nodes as well as named nodes.
|
||||
• |LanguageTree:parse()| runs injection query only on the provided list of
|
||||
ranges as long as the language does not have a combined injection,
|
||||
significantly improving |treesitter-highlight| performance.
|
||||
|
||||
TUI
|
||||
|
||||
@ -194,7 +200,10 @@ TUI
|
||||
|
||||
UI
|
||||
|
||||
• TODO
|
||||
• |vim.ui.open()| (by default bound to |gx|) accepts an `opt.cmd` parameter
|
||||
which controls the tool used to open the given path or URL. If you want to
|
||||
globally set this, you can override vim.ui.open using the same approach
|
||||
described at |vim.paste()|.
|
||||
|
||||
==============================================================================
|
||||
CHANGED FEATURES *news-changed*
|
||||
|
@ -1683,6 +1683,12 @@ In order to highlight nested parens with different colors, define colors for
|
||||
or >
|
||||
:hi javaParen ctermfg=blue guifg=#0000ff
|
||||
|
||||
Certain modifiers are incompatible with each other, e.g. `abstract` and
|
||||
`final`: >
|
||||
:syn list javaConceptKind
|
||||
and can be differently highlighted as a group than other modifiers with >
|
||||
:hi link javaConceptKind NonText
|
||||
|
||||
If you notice highlighting errors while scrolling backwards, which are fixed
|
||||
when redrawing with CTRL-L, try setting the "g:java_minlines" variable to
|
||||
a larger number: >
|
||||
|
@ -1343,7 +1343,7 @@ LanguageTree:invalidate({reload}) *LanguageTree:invalidate()*
|
||||
|
||||
Should only be called when the tracked state of the LanguageTree is not
|
||||
valid against the parse tree in treesitter. Doesn't clear filesystem
|
||||
cache. Called often, so needs to be fast.
|
||||
cache.
|
||||
|
||||
Parameters: ~
|
||||
• {reload} (`boolean?`)
|
||||
@ -1351,7 +1351,8 @@ LanguageTree:invalidate({reload}) *LanguageTree:invalidate()*
|
||||
LanguageTree:is_valid({exclude_children}) *LanguageTree:is_valid()*
|
||||
Returns whether this LanguageTree is valid, i.e., |LanguageTree:trees()|
|
||||
reflects the latest state of the source. If invalid, user should call
|
||||
|LanguageTree:parse()|.
|
||||
|LanguageTree:parse()|. `is_valid(false)` can be slow because it runs
|
||||
injection on the full source.
|
||||
|
||||
Parameters: ~
|
||||
• {exclude_children} (`boolean?`) whether to ignore the validity of
|
||||
@ -1411,7 +1412,7 @@ LanguageTree:node_for_range({range}, {opts})
|
||||
Return: ~
|
||||
(`TSNode?`)
|
||||
|
||||
LanguageTree:parse({range}) *LanguageTree:parse()*
|
||||
LanguageTree:parse({ranges}) *LanguageTree:parse()*
|
||||
Recursively parse all regions in the language tree using
|
||||
|treesitter-parsers| for the corresponding languages and run injection
|
||||
queries on the parsed trees to determine whether child trees should be
|
||||
@ -1422,11 +1423,11 @@ LanguageTree:parse({range}) *LanguageTree:parse()*
|
||||
if {range} is `true`).
|
||||
|
||||
Parameters: ~
|
||||
• {range} (`boolean|Range?`) Parse this range in the parser's source.
|
||||
Set to `true` to run a complete parse of the source (Note:
|
||||
Can be slow!) Set to `false|nil` to only parse regions with
|
||||
empty ranges (typically only the root tree without
|
||||
injections).
|
||||
• {ranges} (`boolean|Range|(Range)[]?`) Parse this range(s) in the
|
||||
parser's source. Set to `true` to run a complete parse of
|
||||
the source (Note: Can be slow!) Set to `false|nil` to only
|
||||
parse regions with empty ranges (typically only the root
|
||||
tree without injections).
|
||||
|
||||
Return: ~
|
||||
(`table<integer, TSTree>`)
|
||||
@ -1478,10 +1479,7 @@ LanguageTree:tree_for_range({range}, {opts})
|
||||
|
||||
LanguageTree:trees() *LanguageTree:trees()*
|
||||
Returns all trees of the regions parsed by this parser. Does not include
|
||||
child languages. The result is list-like if
|
||||
• this LanguageTree is the root, in which case the result is empty or a
|
||||
singleton list; or
|
||||
• the root LanguageTree is fully parsed.
|
||||
child languages.
|
||||
|
||||
Return: ~
|
||||
(`table<integer, TSTree>`)
|
||||
|
@ -9,8 +9,8 @@
|
||||
local function get_commentstring(ref_position)
|
||||
local buf_cs = vim.bo.commentstring
|
||||
|
||||
local has_ts_parser, ts_parser = pcall(vim.treesitter.get_parser)
|
||||
if not has_ts_parser then
|
||||
local ts_parser = vim.treesitter._get_parser()
|
||||
if not ts_parser then
|
||||
return buf_cs
|
||||
end
|
||||
|
||||
|
@ -213,23 +213,25 @@ end
|
||||
--- Default menus
|
||||
do
|
||||
--- Right click popup menu
|
||||
local function def_menu(ctx)
|
||||
vim.cmd([[
|
||||
anoremenu PopUp.Go\ to\ definition <Cmd>lua vim.lsp.buf.definition()<CR>
|
||||
amenu PopUp.Open\ in\ web\ browser gx
|
||||
anoremenu PopUp.Inspect <Cmd>Inspect<CR>
|
||||
anoremenu PopUp.-1- <Nop>
|
||||
vnoremenu PopUp.Cut "+x
|
||||
vnoremenu PopUp.Copy "+y
|
||||
anoremenu PopUp.Paste "+gP
|
||||
vnoremenu PopUp.Paste "+P
|
||||
vnoremenu PopUp.Delete "_x
|
||||
nnoremenu PopUp.Select\ All ggVG
|
||||
vnoremenu PopUp.Select\ All gg0oG$
|
||||
inoremenu PopUp.Select\ All <C-Home><C-O>VG
|
||||
anoremenu PopUp.-2- <Nop>
|
||||
anoremenu PopUp.How-to\ disable\ mouse <Cmd>help disable-mouse<CR>
|
||||
vim.cmd([[
|
||||
anoremenu PopUp.Go\ to\ definition <Cmd>lua vim.lsp.buf.definition()<CR>
|
||||
amenu PopUp.Open\ in\ web\ browser gx
|
||||
anoremenu PopUp.Inspect <Cmd>Inspect<CR>
|
||||
anoremenu PopUp.-1- <Nop>
|
||||
vnoremenu PopUp.Cut "+x
|
||||
vnoremenu PopUp.Copy "+y
|
||||
anoremenu PopUp.Paste "+gP
|
||||
vnoremenu PopUp.Paste "+P
|
||||
vnoremenu PopUp.Delete "_x
|
||||
nnoremenu PopUp.Select\ All ggVG
|
||||
vnoremenu PopUp.Select\ All gg0oG$
|
||||
inoremenu PopUp.Select\ All <C-Home><C-O>VG
|
||||
anoremenu PopUp.-2- <Nop>
|
||||
anoremenu PopUp.How-to\ disable\ mouse <Cmd>help disable-mouse<CR>
|
||||
]])
|
||||
|
||||
local function enable_ctx_menu(ctx)
|
||||
vim.cmd([[
|
||||
amenu disable PopUp.Go\ to\ definition
|
||||
amenu disable PopUp.Open\ in\ web\ browser
|
||||
]])
|
||||
@ -240,7 +242,6 @@ do
|
||||
vim.cmd([[anoremenu enable PopUp.Go\ to\ definition]])
|
||||
end
|
||||
end
|
||||
def_menu()
|
||||
|
||||
local nvim_popupmenu_augroup = vim.api.nvim_create_augroup('nvim_popupmenu', {})
|
||||
vim.api.nvim_create_autocmd('MenuPopup', {
|
||||
@ -252,7 +253,7 @@ do
|
||||
local urls = require('vim.ui')._get_urls()
|
||||
local url = vim.startswith(urls[1], 'http')
|
||||
local ctx = url and 'url' or (vim.lsp.get_clients({ bufnr = 0 })[1] and 'lsp' or nil)
|
||||
def_menu(ctx)
|
||||
enable_ctx_menu(ctx)
|
||||
end,
|
||||
})
|
||||
end
|
||||
|
14
runtime/lua/vim/_meta/vimfn.lua
generated
14
runtime/lua/vim/_meta/vimfn.lua
generated
@ -6703,7 +6703,7 @@ function vim.fn.printf(fmt, expr1) end
|
||||
--- If the buffer doesn't exist or isn't a prompt buffer, an empty
|
||||
--- string is returned.
|
||||
---
|
||||
--- @param buf any
|
||||
--- @param buf integer|string
|
||||
--- @return any
|
||||
function vim.fn.prompt_getprompt(buf) end
|
||||
|
||||
@ -6738,8 +6738,8 @@ function vim.fn.prompt_getprompt(buf) end
|
||||
--- endfunc
|
||||
--- call prompt_setcallback(bufnr(), function('s:TextEntered'))
|
||||
---
|
||||
--- @param buf any
|
||||
--- @param expr any
|
||||
--- @param buf integer|string
|
||||
--- @param expr string|function
|
||||
--- @return any
|
||||
function vim.fn.prompt_setcallback(buf, expr) end
|
||||
|
||||
@ -6751,8 +6751,8 @@ function vim.fn.prompt_setcallback(buf, expr) end
|
||||
--- mode. Without setting a callback Vim will exit Insert mode,
|
||||
--- as in any buffer.
|
||||
---
|
||||
--- @param buf any
|
||||
--- @param expr any
|
||||
--- @param buf integer|string
|
||||
--- @param expr string|function
|
||||
--- @return any
|
||||
function vim.fn.prompt_setinterrupt(buf, expr) end
|
||||
|
||||
@ -6763,8 +6763,8 @@ function vim.fn.prompt_setinterrupt(buf, expr) end
|
||||
--- call prompt_setprompt(bufnr(''), 'command: ')
|
||||
--- <
|
||||
---
|
||||
--- @param buf any
|
||||
--- @param text any
|
||||
--- @param buf integer|string
|
||||
--- @param text string
|
||||
--- @return any
|
||||
function vim.fn.prompt_setprompt(buf, text) end
|
||||
|
||||
|
@ -280,12 +280,7 @@ local extension = {
|
||||
cfi = 'cf',
|
||||
hgrc = 'cfg',
|
||||
cfg = detect.cfg,
|
||||
cfG = detect.cfg,
|
||||
cFg = detect.cfg,
|
||||
cFG = detect.cfg,
|
||||
Cfg = detect.cfg,
|
||||
CfG = detect.cfg,
|
||||
CFg = detect.cfg,
|
||||
CFG = detect.cfg,
|
||||
chf = 'ch',
|
||||
chai = 'chaiscript',
|
||||
@ -370,12 +365,7 @@ local extension = {
|
||||
drt = 'dart',
|
||||
ds = 'datascript',
|
||||
dat = detect.dat,
|
||||
daT = detect.dat,
|
||||
dAt = detect.dat,
|
||||
dAT = detect.dat,
|
||||
Dat = detect.dat,
|
||||
DaT = detect.dat,
|
||||
DAt = detect.dat,
|
||||
DAT = detect.dat,
|
||||
dcd = 'dcd',
|
||||
decl = detect.decl,
|
||||
@ -658,12 +648,7 @@ local extension = {
|
||||
kt = 'kotlin',
|
||||
ktm = 'kotlin',
|
||||
sub = 'krl',
|
||||
suB = 'krl',
|
||||
sUb = 'krl',
|
||||
sUB = 'krl',
|
||||
Sub = 'krl',
|
||||
SuB = 'krl',
|
||||
SUb = 'krl',
|
||||
SUB = 'krl',
|
||||
ks = 'kscript',
|
||||
k = 'kwt',
|
||||
@ -699,12 +684,7 @@ local extension = {
|
||||
lite = 'lite',
|
||||
livemd = 'livebook',
|
||||
log = detect.log,
|
||||
loG = detect.log,
|
||||
lOg = detect.log,
|
||||
lOG = detect.log,
|
||||
Log = detect.log,
|
||||
LoG = detect.log,
|
||||
LOg = detect.log,
|
||||
LOG = detect.log,
|
||||
lgt = 'logtalk',
|
||||
lotos = 'lotos',
|
||||
@ -773,12 +753,7 @@ local extension = {
|
||||
mmp = 'mmp',
|
||||
mms = detect.mms,
|
||||
mod = detect.mod,
|
||||
moD = detect.mod,
|
||||
mOd = detect.mod,
|
||||
mOD = detect.mod,
|
||||
Mod = detect.mod,
|
||||
MoD = detect.mod,
|
||||
MOd = detect.mod,
|
||||
MOD = detect.mod,
|
||||
DEF = 'modula2',
|
||||
m3 = 'modula3',
|
||||
@ -948,12 +923,7 @@ local extension = {
|
||||
ih = 'ppwiz',
|
||||
action = 'privoxy',
|
||||
prg = detect.prg,
|
||||
prG = detect.prg,
|
||||
pRg = detect.prg,
|
||||
pRG = detect.prg,
|
||||
Prg = detect.prg,
|
||||
PrG = detect.prg,
|
||||
PRg = detect.prg,
|
||||
PRG = detect.prg,
|
||||
pc = 'proc',
|
||||
pdb = 'prolog',
|
||||
@ -1133,12 +1103,7 @@ local extension = {
|
||||
sqr = 'sqr',
|
||||
nut = 'squirrel',
|
||||
src = detect.src,
|
||||
srC = detect.src,
|
||||
sRc = detect.src,
|
||||
sRC = detect.src,
|
||||
Src = detect.src,
|
||||
SrC = detect.src,
|
||||
SRc = detect.src,
|
||||
SRC = detect.src,
|
||||
s28 = 'srec',
|
||||
s37 = 'srec',
|
||||
@ -1168,12 +1133,7 @@ local extension = {
|
||||
swig = 'swig',
|
||||
swg = 'swig',
|
||||
sys = detect.sys,
|
||||
syS = detect.sys,
|
||||
sYs = detect.sys,
|
||||
sYS = detect.sys,
|
||||
Sys = detect.sys,
|
||||
SyS = detect.sys,
|
||||
SYs = detect.sys,
|
||||
SYS = detect.sys,
|
||||
svh = 'systemverilog',
|
||||
sv = 'systemverilog',
|
||||
|
@ -447,11 +447,9 @@ function M.document_symbol(opts)
|
||||
request_with_opts(ms.textDocument_documentSymbol, params, opts)
|
||||
end
|
||||
|
||||
--- @param call_hierarchy_items lsp.CallHierarchyItem[]?
|
||||
--- @param call_hierarchy_items lsp.CallHierarchyItem[]
|
||||
--- @return lsp.CallHierarchyItem?
|
||||
local function pick_call_hierarchy_item(call_hierarchy_items)
|
||||
if not call_hierarchy_items then
|
||||
return
|
||||
end
|
||||
if #call_hierarchy_items == 1 then
|
||||
return call_hierarchy_items[1]
|
||||
end
|
||||
@ -476,7 +474,7 @@ local function call_hierarchy(method)
|
||||
vim.notify(err.message, vim.log.levels.WARN)
|
||||
return
|
||||
end
|
||||
if not result then
|
||||
if not result or vim.tbl_isempty(result) then
|
||||
vim.notify('No item resolved', vim.log.levels.WARN)
|
||||
return
|
||||
end
|
||||
|
@ -154,7 +154,7 @@ end
|
||||
---@param encoding string utf-8|utf-16|utf-32| defaults to utf-16
|
||||
---@return integer byte (utf-8) index of `encoding` index `index` in `line`
|
||||
function M._str_byteindex_enc(line, index, encoding)
|
||||
local len = vim.fn.strlen(line)
|
||||
local len = #line
|
||||
if index > len then
|
||||
-- LSP spec: if character > line length, default to the line length.
|
||||
-- https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#position
|
||||
@ -167,7 +167,7 @@ function M._str_byteindex_enc(line, index, encoding)
|
||||
if index then
|
||||
return index
|
||||
else
|
||||
return #line
|
||||
return len
|
||||
end
|
||||
elseif encoding == 'utf-16' then
|
||||
return vim.str_byteindex(line, index, true)
|
||||
|
@ -74,14 +74,14 @@ end
|
||||
|
||||
--- Returns the parser for a specific buffer and attaches it to the buffer
|
||||
---
|
||||
--- If needed, this will create the parser.
|
||||
--- If needed, this will create the parser. If no parser can be found or created, returns `nil`.
|
||||
---
|
||||
---@param bufnr (integer|nil) Buffer the parser should be tied to (default: current buffer)
|
||||
---@param lang (string|nil) Language of this parser (default: from buffer filetype)
|
||||
---@param opts (table|nil) Options to pass to the created language tree
|
||||
---
|
||||
---@return vim.treesitter.LanguageTree object to use for parsing
|
||||
function M.get_parser(bufnr, lang, opts)
|
||||
---@return vim.treesitter.LanguageTree? object to use for parsing, or `nil` if not found
|
||||
function M._get_parser(bufnr, lang, opts)
|
||||
opts = opts or {}
|
||||
|
||||
if bufnr == nil or bufnr == 0 then
|
||||
@ -94,18 +94,14 @@ function M.get_parser(bufnr, lang, opts)
|
||||
|
||||
if not valid_lang(lang) then
|
||||
if not parsers[bufnr] then
|
||||
error(
|
||||
string.format(
|
||||
'There is no parser available for buffer %d and one could not be'
|
||||
.. ' created because lang could not be determined. Either pass lang'
|
||||
.. ' or set the buffer filetype',
|
||||
bufnr
|
||||
)
|
||||
)
|
||||
return nil
|
||||
end
|
||||
elseif parsers[bufnr] == nil or parsers[bufnr]:lang() ~= lang then
|
||||
assert(lang, 'lang should be valid')
|
||||
parsers[bufnr] = M._create_parser(bufnr, lang, opts)
|
||||
local parser = vim.F.npcall(M._create_parser, bufnr, lang, opts)
|
||||
if not parser then
|
||||
return nil
|
||||
end
|
||||
parsers[bufnr] = parser
|
||||
end
|
||||
|
||||
parsers[bufnr]:register_cbs(opts.buf_attach_cbs)
|
||||
@ -113,6 +109,29 @@ function M.get_parser(bufnr, lang, opts)
|
||||
return parsers[bufnr]
|
||||
end
|
||||
|
||||
--- Returns the parser for a specific buffer and attaches it to the buffer
|
||||
---
|
||||
--- If needed, this will create the parser.
|
||||
---
|
||||
---@param bufnr (integer|nil) Buffer the parser should be tied to (default: current buffer)
|
||||
---@param lang (string|nil) Language of this parser (default: from buffer filetype)
|
||||
---@param opts (table|nil) Options to pass to the created language tree
|
||||
---
|
||||
---@return vim.treesitter.LanguageTree object to use for parsing
|
||||
function M.get_parser(bufnr, lang, opts)
|
||||
-- TODO(ribru17): Remove _get_parser and move that logic back here once the breaking function
|
||||
-- signature change is acceptable.
|
||||
local parser = M._get_parser(bufnr, lang, opts)
|
||||
if not parser then
|
||||
vim.notify_once(
|
||||
'WARNING: vim.treesitter.get_parser will return nil instead of raising an error in Neovim 0.12',
|
||||
vim.log.levels.WARN
|
||||
)
|
||||
error('Parser not found.')
|
||||
end
|
||||
return parser
|
||||
end
|
||||
|
||||
--- Returns a string parser
|
||||
---
|
||||
---@param str string Text to parse
|
||||
@ -386,7 +405,7 @@ function M.get_node(opts)
|
||||
|
||||
local ts_range = { row, col, row, col }
|
||||
|
||||
local root_lang_tree = M.get_parser(bufnr, opts.lang)
|
||||
local root_lang_tree = M._get_parser(bufnr, opts.lang)
|
||||
if not root_lang_tree then
|
||||
return
|
||||
end
|
||||
@ -419,7 +438,11 @@ end
|
||||
---@param lang (string|nil) Language of the parser (default: from buffer filetype)
|
||||
function M.start(bufnr, lang)
|
||||
bufnr = bufnr or api.nvim_get_current_buf()
|
||||
local parser = M.get_parser(bufnr, lang)
|
||||
local parser = M._get_parser(bufnr, lang)
|
||||
if not parser then
|
||||
vim.notify('No parser for the given buffer.', vim.log.levels.WARN)
|
||||
return
|
||||
end
|
||||
M.highlighter.new(parser)
|
||||
end
|
||||
|
||||
|
@ -114,7 +114,7 @@ local function compute_folds_levels(bufnr, info, srow, erow, parse_injections)
|
||||
srow = srow or 0
|
||||
erow = erow or api.nvim_buf_line_count(bufnr)
|
||||
|
||||
local parser = ts.get_parser(bufnr)
|
||||
local parser = assert(ts._get_parser(bufnr))
|
||||
|
||||
parser:parse(parse_injections and { srow, erow } or nil)
|
||||
|
||||
@ -392,7 +392,7 @@ function M.foldexpr(lnum)
|
||||
lnum = lnum or vim.v.lnum
|
||||
local bufnr = api.nvim_get_current_buf()
|
||||
|
||||
local parser = vim.F.npcall(ts.get_parser, bufnr)
|
||||
local parser = ts._get_parser(bufnr)
|
||||
if not parser then
|
||||
return '0'
|
||||
end
|
||||
|
@ -172,7 +172,7 @@ function M.lint(buf, opts)
|
||||
--- @type (table|nil)
|
||||
local parser_info = vim.F.npcall(vim.treesitter.language.inspect, lang)
|
||||
|
||||
local parser = vim.treesitter.get_parser(buf)
|
||||
local parser = assert(vim.treesitter._get_parser(buf), 'query parser not found.')
|
||||
parser:parse()
|
||||
parser:for_each_tree(function(tree, ltree)
|
||||
if ltree:lang() == 'query' then
|
||||
|
@ -76,10 +76,9 @@ end
|
||||
---
|
||||
---@package
|
||||
function TSTreeView:new(bufnr, lang)
|
||||
local ok, parser = pcall(vim.treesitter.get_parser, bufnr or 0, lang)
|
||||
if not ok then
|
||||
local err = parser --[[ @as string ]]
|
||||
return nil, 'No parser available for the given buffer:\n' .. err
|
||||
local parser = vim.treesitter._get_parser(bufnr or 0, lang)
|
||||
if not parser then
|
||||
return nil, 'No parser available for the given buffer.'
|
||||
end
|
||||
|
||||
-- For each child tree (injected language), find the root of the tree and locate the node within
|
||||
@ -539,7 +538,7 @@ local edit_ns = api.nvim_create_namespace('treesitter/dev-edit')
|
||||
local function update_editor_highlights(query_win, base_win, lang)
|
||||
local base_buf = api.nvim_win_get_buf(base_win)
|
||||
local query_buf = api.nvim_win_get_buf(query_win)
|
||||
local parser = vim.treesitter.get_parser(base_buf, lang)
|
||||
local parser = assert(vim.treesitter._get_parser(base_buf, lang))
|
||||
api.nvim_buf_clear_namespace(base_buf, edit_ns, 0, -1)
|
||||
local query_content = table.concat(api.nvim_buf_get_lines(query_buf, 0, -1, false), '\n')
|
||||
|
||||
@ -556,7 +555,8 @@ local function update_editor_highlights(query_win, base_win, lang)
|
||||
-- Remove the '@' from the cursor word
|
||||
cursor_word = cursor_word:sub(2)
|
||||
local topline, botline = vim.fn.line('w0', base_win), vim.fn.line('w$', base_win)
|
||||
for id, node in query:iter_captures(parser:trees()[1]:root(), base_buf, topline - 1, botline) do
|
||||
local _, tree = next(parser:trees())
|
||||
for id, node in query:iter_captures(tree:root(), base_buf, topline - 1, botline) do
|
||||
local capture_name = query.captures[id]
|
||||
if capture_name == cursor_word then
|
||||
local lnum, col, end_lnum, end_col = node:range()
|
||||
@ -596,8 +596,8 @@ function M.edit_query(lang)
|
||||
end
|
||||
vim.cmd(cmd)
|
||||
|
||||
local ok, parser = pcall(vim.treesitter.get_parser, buf, lang)
|
||||
if not ok then
|
||||
local parser = vim.treesitter._get_parser(buf, lang)
|
||||
if not parser then
|
||||
return nil, 'No parser available for the given buffer'
|
||||
end
|
||||
lang = parser:lang()
|
||||
|
@ -391,6 +391,23 @@ function TSHighlighter._on_spell_nav(_, _, buf, srow, _, erow, _)
|
||||
self._highlight_states = highlight_states
|
||||
end
|
||||
|
||||
function TSHighlighter._on_start()
|
||||
local buf_ranges = {} ---@type table<integer, (Range)[]>
|
||||
for _, win in ipairs(api.nvim_tabpage_list_wins(0)) do
|
||||
local buf = api.nvim_win_get_buf(win)
|
||||
if TSHighlighter.active[buf] then
|
||||
if not buf_ranges[buf] then
|
||||
buf_ranges[buf] = {}
|
||||
end
|
||||
local topline, botline = vim.fn.line('w0', win) - 1, vim.fn.line('w$', win)
|
||||
table.insert(buf_ranges[buf], { topline, botline })
|
||||
end
|
||||
end
|
||||
for buf, ranges in pairs(buf_ranges) do
|
||||
TSHighlighter.active[buf].tree:parse(ranges)
|
||||
end
|
||||
end
|
||||
|
||||
---@private
|
||||
---@param _win integer
|
||||
---@param buf integer
|
||||
@ -401,13 +418,13 @@ function TSHighlighter._on_win(_, _win, buf, topline, botline)
|
||||
if not self then
|
||||
return false
|
||||
end
|
||||
self.tree:parse({ topline, botline + 1 })
|
||||
self:prepare_highlight_states(topline, botline + 1)
|
||||
self.redraw_count = self.redraw_count + 1
|
||||
return true
|
||||
end
|
||||
|
||||
api.nvim_set_decoration_provider(ns, {
|
||||
on_start = TSHighlighter._on_start,
|
||||
on_win = TSHighlighter._on_win,
|
||||
on_line = TSHighlighter._on_line,
|
||||
_on_spell_nav = TSHighlighter._on_spell_nav,
|
||||
|
@ -72,19 +72,35 @@ local TSCallbackNames = {
|
||||
---@field private _callbacks table<TSCallbackName,function[]> Callback handlers
|
||||
---@field package _callbacks_rec table<TSCallbackName,function[]> Callback handlers (recursive)
|
||||
---@field private _children table<string,vim.treesitter.LanguageTree> Injected languages
|
||||
---@field private _injection_query vim.treesitter.Query Queries defining injected languages
|
||||
---@field private _injection_query vim.treesitter.Query? Queries defining injected languages
|
||||
---
|
||||
---If `is_valid(true) and _injections_processed`, the set of children parsers and their sets of
|
||||
---regions are complete wrt. the full source, so that it's not necessary to execute injections.
|
||||
---@field private _injections_processed boolean
|
||||
---
|
||||
---@field private _opts table Options
|
||||
---@field private _parser TSParser Parser for language
|
||||
---@field private _has_regions boolean
|
||||
---@field private _regions table<integer, Range6[]>?
|
||||
---
|
||||
---List of regions this tree should manage and parse. If nil then regions are
|
||||
---taken from _trees. This is mostly a short-lived cache for included_regions()
|
||||
---@field private _regions table<integer, Range6[]>?
|
||||
---
|
||||
---Inverse region table, i.e., a (chaining) hash table from regions to their index in `_region`.
|
||||
---Used for checking if an added region is already managed by this parser, so that it can reuse
|
||||
---the existing tree for incremental parsing.
|
||||
---The hash function is simply `region[1][3]` (the start byte of its first range).
|
||||
---Each bucket has the shape of { region1, index of region1, region2, index of region2, ... }.
|
||||
---@field private _regions_inv table<integer, (Range6[]|integer)[]>?
|
||||
---
|
||||
---@field private _lang string Language name
|
||||
---@field private _parent? vim.treesitter.LanguageTree Parent LanguageTree
|
||||
---@field private _source (integer|string) Buffer or string to parse
|
||||
---@field private _trees table<integer, TSTree> Reference to parsed tree (one for each language).
|
||||
---
|
||||
---Reference to parsed tree (one for each language).
|
||||
---Each key is the index of region, which is synced with _regions and _valid.
|
||||
---@field private _trees table<integer, TSTree>
|
||||
---
|
||||
---@field private _valid boolean|table<integer,boolean> If the parsed tree is valid
|
||||
---@field private _logger? fun(logtype: string, msg: string)
|
||||
---@field private _logfile? file*
|
||||
@ -228,7 +244,7 @@ end
|
||||
--- Invalidates this parser and its children.
|
||||
---
|
||||
--- Should only be called when the tracked state of the LanguageTree is not valid against the parse
|
||||
--- tree in treesitter. Doesn't clear filesystem cache. Called often, so needs to be fast.
|
||||
--- tree in treesitter. Doesn't clear filesystem cache.
|
||||
---@param reload boolean|nil
|
||||
function LanguageTree:invalidate(reload)
|
||||
self._valid = false
|
||||
@ -248,9 +264,6 @@ end
|
||||
|
||||
--- Returns all trees of the regions parsed by this parser.
|
||||
--- Does not include child languages.
|
||||
--- The result is list-like if
|
||||
--- * this LanguageTree is the root, in which case the result is empty or a singleton list; or
|
||||
--- * the root LanguageTree is fully parsed.
|
||||
---
|
||||
---@return table<integer, TSTree>
|
||||
function LanguageTree:trees()
|
||||
@ -264,6 +277,7 @@ end
|
||||
|
||||
--- Returns whether this LanguageTree is valid, i.e., |LanguageTree:trees()| reflects the latest
|
||||
--- state of the source. If invalid, user should call |LanguageTree:parse()|.
|
||||
--- `is_valid(false)` can be slow because it runs injection on the full source.
|
||||
---@param exclude_children boolean|nil whether to ignore the validity of children (default `false`)
|
||||
---@return boolean
|
||||
function LanguageTree:is_valid(exclude_children)
|
||||
@ -278,8 +292,11 @@ function LanguageTree:is_valid(exclude_children)
|
||||
end
|
||||
|
||||
if not exclude_children then
|
||||
-- Run full injection to check if the current set of children and their regions are complete.
|
||||
-- Note that `set_included_regions` marks new regions invalid.
|
||||
if not self._injections_processed then
|
||||
return false
|
||||
self:_add_injections(true)
|
||||
self._injections_processed = true
|
||||
end
|
||||
|
||||
for _, child in pairs(self._children) do
|
||||
@ -308,24 +325,26 @@ function LanguageTree:source()
|
||||
end
|
||||
|
||||
--- @param region Range6[]
|
||||
--- @param range? boolean|Range
|
||||
--- @param ranges? boolean|(Range)[]
|
||||
--- @return boolean
|
||||
local function intercepts_region(region, range)
|
||||
local function intercepts_region(region, ranges)
|
||||
if #region == 0 then
|
||||
return true
|
||||
end
|
||||
|
||||
if range == nil then
|
||||
if ranges == nil then
|
||||
return false
|
||||
end
|
||||
|
||||
if type(range) == 'boolean' then
|
||||
return range
|
||||
if type(ranges) == 'boolean' then
|
||||
return ranges
|
||||
end
|
||||
|
||||
for _, r in ipairs(region) do
|
||||
if Range.intercepts(r, range) then
|
||||
return true
|
||||
for _, r1 in ipairs(region) do
|
||||
for _, r2 in ipairs(ranges) do
|
||||
if Range.intercepts(r1, r2) then
|
||||
return true
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
@ -333,11 +352,11 @@ local function intercepts_region(region, range)
|
||||
end
|
||||
|
||||
--- @private
|
||||
--- @param range boolean|Range?
|
||||
--- @param ranges boolean|(Range)[]?
|
||||
--- @return Range6[] changes
|
||||
--- @return integer no_regions_parsed
|
||||
--- @return number total_parse_time
|
||||
function LanguageTree:_parse_regions(range)
|
||||
function LanguageTree:_parse_regions(ranges)
|
||||
local changes = {}
|
||||
local no_regions_parsed = 0
|
||||
local total_parse_time = 0
|
||||
@ -346,17 +365,17 @@ function LanguageTree:_parse_regions(range)
|
||||
self._valid = {}
|
||||
end
|
||||
|
||||
-- If there are no ranges, set to an empty list
|
||||
-- If there is no region, set to an empty list
|
||||
-- so the included ranges in the parser are cleared.
|
||||
for i, ranges in pairs(self:included_regions()) do
|
||||
for i, region in pairs(self:included_regions()) do
|
||||
if
|
||||
not self._valid[i]
|
||||
and (
|
||||
intercepts_region(ranges, range)
|
||||
or (self._trees[i] and intercepts_region(self._trees[i]:included_ranges(false), range))
|
||||
intercepts_region(region, ranges)
|
||||
or (self._trees[i] and intercepts_region(self._trees[i]:included_ranges(false), ranges))
|
||||
)
|
||||
then
|
||||
self._parser:set_included_ranges(ranges)
|
||||
self._parser:set_included_ranges(region)
|
||||
local parse_time, tree, tree_changes =
|
||||
tcall(self._parser.parse, self._parser, self._trees[i], self._source, true)
|
||||
|
||||
@ -377,11 +396,12 @@ function LanguageTree:_parse_regions(range)
|
||||
end
|
||||
|
||||
--- @private
|
||||
--- @param ranges boolean|(Range)[]|nil
|
||||
--- @return number
|
||||
function LanguageTree:_add_injections()
|
||||
function LanguageTree:_add_injections(ranges)
|
||||
local seen_langs = {} ---@type table<string,boolean>
|
||||
|
||||
local query_time, injections_by_lang = tcall(self._get_injections, self)
|
||||
local query_time, injections_by_lang = tcall(self._get_injections, self, ranges)
|
||||
for lang, injection_regions in pairs(injections_by_lang) do
|
||||
local has_lang = pcall(language.add, lang)
|
||||
|
||||
@ -409,6 +429,14 @@ function LanguageTree:_add_injections()
|
||||
return query_time
|
||||
end
|
||||
|
||||
---@param region (Range)[]
|
||||
---@return Range4
|
||||
local function region_range(region)
|
||||
local srow, scol, _, _ = Range.unpack4(region[1])
|
||||
local _, _, erow, ecol = Range.unpack4(region[#region])
|
||||
return { srow, scol, erow, ecol }
|
||||
end
|
||||
|
||||
--- Recursively parse all regions in the language tree using |treesitter-parsers|
|
||||
--- for the corresponding languages and run injection queries on the parsed trees
|
||||
--- to determine whether child trees should be created and parsed.
|
||||
@ -416,16 +444,16 @@ end
|
||||
--- Any region with empty range (`{}`, typically only the root tree) is always parsed;
|
||||
--- otherwise (typically injections) only if it intersects {range} (or if {range} is `true`).
|
||||
---
|
||||
--- @param range boolean|Range|nil: Parse this range in the parser's source.
|
||||
--- @param ranges boolean|Range|(Range)[]|nil: Parse this range(s) in the parser's source.
|
||||
--- Set to `true` to run a complete parse of the source (Note: Can be slow!)
|
||||
--- Set to `false|nil` to only parse regions with empty ranges (typically
|
||||
--- only the root tree without injections).
|
||||
--- @return table<integer, TSTree>
|
||||
function LanguageTree:parse(range)
|
||||
if self:is_valid() then
|
||||
self:_log('valid')
|
||||
return self._trees
|
||||
function LanguageTree:parse(ranges)
|
||||
if type(ranges) == 'table' and #ranges > 0 and type(ranges[1]) == 'number' then
|
||||
ranges = { ranges }
|
||||
end
|
||||
---@cast ranges boolean|(Range)[]|nil
|
||||
|
||||
local changes --- @type Range6[]?
|
||||
|
||||
@ -436,16 +464,26 @@ function LanguageTree:parse(range)
|
||||
|
||||
-- At least 1 region is invalid
|
||||
if not self:is_valid(true) then
|
||||
changes, no_regions_parsed, total_parse_time = self:_parse_regions(range)
|
||||
changes, no_regions_parsed, total_parse_time = self:_parse_regions(ranges)
|
||||
-- Need to run injections when we parsed something
|
||||
if no_regions_parsed > 0 then
|
||||
self._injections_processed = false
|
||||
end
|
||||
end
|
||||
|
||||
if not self._injections_processed and range ~= false and range ~= nil then
|
||||
query_time = self:_add_injections()
|
||||
self._injections_processed = true
|
||||
-- NOTE: Trade-off in partial injection query execution
|
||||
-- * The good: Each `parse()` is faster.
|
||||
-- * The bad: `is_valid(false)` is more expensive, requiring a full injection query execution. To
|
||||
-- avoid this cost, each `parse()` always runs partial injection. However, this is not a big
|
||||
-- problem as partial injection is very cheap even on huge files.
|
||||
-- * A potential optimization: Track the ranges where the set of injected regions are known to be
|
||||
-- complete and valid, and run the injection query only on the intersection of requested ranges
|
||||
-- and the invalid ranges. This would be even more beneficial for combined injection.
|
||||
if self._injection_query and not self._injections_processed and ranges then
|
||||
query_time = self:_add_injections(ranges)
|
||||
if ranges == true or self._injection_query.has_combined_injection then
|
||||
self._injections_processed = true
|
||||
end
|
||||
end
|
||||
|
||||
self:_log({
|
||||
@ -453,11 +491,11 @@ function LanguageTree:parse(range)
|
||||
regions_parsed = no_regions_parsed,
|
||||
parse_time = total_parse_time,
|
||||
query_time = query_time,
|
||||
range = range,
|
||||
ranges = ranges,
|
||||
})
|
||||
|
||||
for _, child in pairs(self._children) do
|
||||
child:parse(range)
|
||||
child:parse(ranges)
|
||||
end
|
||||
|
||||
return self._trees
|
||||
@ -585,6 +623,125 @@ function LanguageTree:_iter_regions(fn)
|
||||
end
|
||||
end
|
||||
|
||||
---Add a region to the inverse region table.
|
||||
---@param regions_inv table<integer, (Range6[]|integer)[]>
|
||||
---@param i integer
|
||||
---@param region Range6[]
|
||||
local function regions_inv_insert(regions_inv, i, region)
|
||||
local start_byte = region[1][3]
|
||||
local bucket = regions_inv[start_byte]
|
||||
if not bucket then
|
||||
regions_inv[start_byte] = { region, i }
|
||||
else
|
||||
table.insert(bucket, region)
|
||||
table.insert(bucket, i)
|
||||
end
|
||||
end
|
||||
|
||||
---Remove a region from the inverse region table.
|
||||
---@param regions_inv table<integer, (Range6[]|integer)[]>
|
||||
---@param region Range6[]
|
||||
local function regions_inv_remove(regions_inv, region)
|
||||
local start_byte = region[1][3]
|
||||
local bucket = assert(regions_inv[start_byte])
|
||||
for e = 1, #bucket, 2 do
|
||||
if vim.deep_equal(bucket[e], region) then
|
||||
table.remove(bucket, e + 1)
|
||||
table.remove(bucket, e)
|
||||
if #bucket == 0 then
|
||||
regions_inv[start_byte] = nil
|
||||
end
|
||||
return
|
||||
end
|
||||
end
|
||||
error('region not found')
|
||||
end
|
||||
|
||||
---Whether two region values are approximately equal. Should be implied by equality.
|
||||
---See the comment in `set_included_regions` on why we use similarity.
|
||||
---For now it simply compares the last bytes of the first and the last regions.
|
||||
---@param region1 Range6[]
|
||||
---@param region2 Range6[]
|
||||
---@return boolean
|
||||
local function region_similar(region1, region2)
|
||||
return region1[1][6] == region2[1][6] or region1[#region1][6] == region2[#region2][6]
|
||||
end
|
||||
|
||||
---Find the given region from the inverse region table.
|
||||
---If there is no exact match, find an approximately matching region.
|
||||
---@param regions_inv table<integer, (Range6[]|integer)[]>
|
||||
---@param region Range6[]
|
||||
---@return integer?
|
||||
---@return boolean? exact
|
||||
local function regions_inv_lookup(regions_inv, region)
|
||||
local bucket = regions_inv[region[1][3]]
|
||||
if not bucket then
|
||||
return
|
||||
end
|
||||
|
||||
local i ---@type integer?
|
||||
for e = 1, #bucket, 2 do
|
||||
local old_region = bucket[e] --[[@as Range6[] ]]
|
||||
if region_similar(old_region, region) then
|
||||
i = bucket[e + 1] --[[@as integer]]
|
||||
if vim.deep_equal(old_region, region) then
|
||||
return i, true
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
return i, false
|
||||
end
|
||||
|
||||
---@param i integer
|
||||
function LanguageTree:_invalidate_region(i)
|
||||
if self._valid == true then
|
||||
self._valid = {}
|
||||
for j, _ in pairs(self._regions) do
|
||||
self._valid[j] = true
|
||||
end
|
||||
self._valid[i] = false
|
||||
elseif type(self._valid) == 'table' then
|
||||
self._valid[i] = false
|
||||
end
|
||||
end
|
||||
|
||||
---@param i integer
|
||||
function LanguageTree:_discard_region(i)
|
||||
if not self._has_regions then
|
||||
return
|
||||
end
|
||||
|
||||
if self._regions then
|
||||
regions_inv_remove(self._regions_inv, self._regions[i])
|
||||
self._regions[i] = nil
|
||||
end
|
||||
|
||||
if self._trees[i] then
|
||||
local region = self._trees[i]:included_ranges(true)
|
||||
self:_log(function()
|
||||
return 'discarding region', i, region_tostr(region)
|
||||
end)
|
||||
self:_do_callback('changedtree', region, self._trees[i])
|
||||
local discarded_range = region_range(region)
|
||||
self._trees[i] = nil
|
||||
-- Discard children's regions that are included in the discarded region. This is necessary
|
||||
-- because changes that only remove trees in this parser keep the children parsers untouched.
|
||||
for _, child in pairs(self._children) do
|
||||
for child_i, child_region in pairs(child:included_regions()) do
|
||||
if Range.contains(discarded_range, region_range(child_region)) then
|
||||
child:_discard_region(child_i)
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
-- If it's boolean (fully valid/invalid), deleting a region doesn't change its value.
|
||||
if type(self._valid) == 'table' then
|
||||
self._valid[i] = nil
|
||||
end
|
||||
end
|
||||
|
||||
--- Sets the included regions that should be parsed by this |LanguageTree|.
|
||||
--- A region is a set of nodes and/or ranges that will be parsed in the same context.
|
||||
---
|
||||
@ -604,7 +761,23 @@ end
|
||||
function LanguageTree:set_included_regions(new_regions)
|
||||
self._has_regions = true
|
||||
|
||||
-- Transform the tables from 4 element long to 6 element long (with byte offset)
|
||||
-- Refresh self._regions and self._regions_inv
|
||||
self:included_regions()
|
||||
|
||||
local touched = {} ---@type table<integer, true>
|
||||
|
||||
-- Check if the parser already has each region so that they can be parsed incrementally from an
|
||||
-- existing tree. We find the existing regions by "similarity" instead of the exact equality,
|
||||
-- because the values of an existing region and the matching region in `new_regions` may not be
|
||||
-- equal, in which case the existing tree can't be reused.
|
||||
--
|
||||
-- Inequality of matching regions happens because `_edit` does not accurately track changes in the
|
||||
-- existing regions. One (probably the only?) case is when a multi-range region created from a
|
||||
-- non-`include-children` injection or a combined injection is edited in a way that adds a range
|
||||
-- to the region, e.g., when adding a line in markdown fenced code block (with language).
|
||||
--
|
||||
-- Matching the regions doesn't need to precise: the consequence of false match and false
|
||||
-- non-match is just a minor loss in efficiency due to reparsing a region from scratch.
|
||||
for _, region in ipairs(new_regions) do
|
||||
for i, range in ipairs(region) do
|
||||
if type(range) == 'table' and #range == 4 then
|
||||
@ -613,26 +786,50 @@ function LanguageTree:set_included_regions(new_regions)
|
||||
region[i] = { range:range(true) }
|
||||
end
|
||||
end
|
||||
end
|
||||
---@cast region Range6[]
|
||||
|
||||
-- included_regions is not guaranteed to be list-like, but this is still sound, i.e. if
|
||||
-- new_regions is different from included_regions, then outdated regions in included_regions are
|
||||
-- invalidated. For example, if included_regions = new_regions ++ hole ++ outdated_regions, then
|
||||
-- outdated_regions is invalidated by _iter_regions in else branch.
|
||||
if #self:included_regions() ~= #new_regions then
|
||||
-- TODO(lewis6991): inefficient; invalidate trees incrementally
|
||||
for _, t in pairs(self._trees) do
|
||||
self:_do_callback('changedtree', t:included_ranges(true), t)
|
||||
local i, exact = regions_inv_lookup(self._regions_inv, region)
|
||||
|
||||
if not exact then
|
||||
if i then
|
||||
self:_log(function()
|
||||
return 'invalidating inexactly matched region', i, region_tostr(self._regions[i])
|
||||
end)
|
||||
regions_inv_remove(self._regions_inv, self._regions[i])
|
||||
else
|
||||
i = #self._regions + 1 -- this always gives an unoccupied index even if there are holes
|
||||
end
|
||||
self._regions[i] = region
|
||||
regions_inv_insert(self._regions_inv, i, region)
|
||||
self:_invalidate_region(i)
|
||||
end
|
||||
self._trees = {}
|
||||
self:invalidate()
|
||||
else
|
||||
self:_iter_regions(function(i, region)
|
||||
return vim.deep_equal(new_regions[i], region)
|
||||
end)
|
||||
---@cast i integer
|
||||
|
||||
touched[i] = true
|
||||
end
|
||||
|
||||
self._regions = new_regions
|
||||
-- Discard stale regions.
|
||||
for i, _ in pairs(self._regions) do
|
||||
if not touched[i] then
|
||||
self:_discard_region(i)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
--- @param region Range6[]
|
||||
local function prune_empty_ranges(region)
|
||||
local cur = 1
|
||||
for i, range in ipairs(region) do
|
||||
if range[3] ~= range[6] then
|
||||
if cur < i then
|
||||
region[cur] = range
|
||||
end
|
||||
cur = cur + 1
|
||||
end
|
||||
end
|
||||
for i = #region, cur, -1 do
|
||||
region[i] = nil
|
||||
end
|
||||
end
|
||||
|
||||
---Gets the set of included regions managed by this LanguageTree. This can be different from the
|
||||
@ -651,12 +848,27 @@ function LanguageTree:included_regions()
|
||||
return { {} }
|
||||
end
|
||||
|
||||
local regions = {} ---@type Range6[][]
|
||||
local regions = {} ---@type table<integer, Range6[]>
|
||||
local regions_inv = {} ---@type table<integer, (Range6[]|integer)[]>
|
||||
for i, _ in pairs(self._trees) do
|
||||
regions[i] = self._trees[i]:included_ranges(true)
|
||||
local region = self._trees[i]:included_ranges(true)
|
||||
-- If user deletes a range in a region, `tree:edit()` leaves an empty range instead of deleting
|
||||
-- it. This could be a bug in treesitter.
|
||||
prune_empty_ranges(region)
|
||||
if #region > 0 then
|
||||
regions[i] = region
|
||||
regions_inv_insert(regions_inv, i, region)
|
||||
else
|
||||
self._trees[i] = nil
|
||||
-- If it's boolean (fully valid/invalid), deleting a region doesn't change its value.
|
||||
if type(self._valid) == 'table' then
|
||||
self._valid[i] = nil
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
self._regions = regions
|
||||
self._regions_inv = regions_inv
|
||||
return regions
|
||||
end
|
||||
|
||||
@ -816,30 +1028,59 @@ end
|
||||
---
|
||||
--- This is where most of the injection processing occurs.
|
||||
---
|
||||
--- TODO: Allow for an offset predicate to tailor the injection range
|
||||
--- instead of using the entire nodes range.
|
||||
--- @param ranges boolean|(Range)[]|nil
|
||||
--- @private
|
||||
--- @return table<string, Range6[][]>
|
||||
function LanguageTree:_get_injections()
|
||||
if not self._injection_query then
|
||||
function LanguageTree:_get_injections(ranges)
|
||||
if not self._injection_query or not ranges then
|
||||
return {}
|
||||
end
|
||||
|
||||
---@type table<integer,vim.treesitter.languagetree.Injection>
|
||||
local injections = {}
|
||||
|
||||
-- Combined injection must be run on the full source, and currently there is no simply way to
|
||||
-- selectively match each pattern separately.
|
||||
if ranges == true or self._injection_query.has_combined_injection then
|
||||
ranges = { true } ---@diagnostic disable-line: assign-type-mismatch
|
||||
else
|
||||
for i, range in ipairs(ranges) do
|
||||
local sline, _, eline, _ = Range.unpack4(range)
|
||||
ranges[i] = { sline, eline }
|
||||
end
|
||||
end
|
||||
---@cast ranges (true|Range2)[]
|
||||
|
||||
for index, tree in pairs(self._trees) do
|
||||
local root_node = tree:root()
|
||||
local start_line, _, end_line, _ = root_node:range()
|
||||
local start_line, _, end_line, end_col = root_node:range()
|
||||
if end_col > 0 then
|
||||
end_line = end_line + 1
|
||||
end
|
||||
|
||||
for pattern, match, metadata in
|
||||
self._injection_query:iter_matches(root_node, self._source, start_line, end_line + 1)
|
||||
do
|
||||
local lang, combined, ranges = self:_get_injection(match, metadata)
|
||||
if lang then
|
||||
add_injection(injections, index, pattern, lang, combined, ranges)
|
||||
else
|
||||
self:_log('match from injection query failed for pattern', pattern)
|
||||
for _, range in ipairs(ranges) do
|
||||
local start_line_in_range, end_line_in_range = start_line, end_line
|
||||
if range ~= true then
|
||||
start_line_in_range = math.max(start_line, range[1])
|
||||
end_line_in_range = math.min(end_line, range[2])
|
||||
end
|
||||
-- Duplicates from overlapping ranges are handled by `set_included_ranges`.
|
||||
if start_line_in_range < end_line_in_range then
|
||||
for pattern, match, metadata in
|
||||
self._injection_query:iter_matches(
|
||||
root_node,
|
||||
self._source,
|
||||
start_line_in_range,
|
||||
end_line_in_range
|
||||
)
|
||||
do
|
||||
local lang, combined, inj_ranges = self:_get_injection(match, metadata)
|
||||
if lang then
|
||||
add_injection(injections, index, pattern, lang, combined, inj_ranges)
|
||||
else
|
||||
self:_log('match from injection query failed for pattern', pattern)
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@ -859,8 +1100,8 @@ function LanguageTree:_get_injections()
|
||||
if entry.combined then
|
||||
table.insert(result[lang], combine_regions(entry.regions))
|
||||
else
|
||||
for _, ranges in pairs(entry.regions) do
|
||||
table.insert(result[lang], ranges)
|
||||
for _, inj_ranges in pairs(entry.regions) do
|
||||
table.insert(result[lang], inj_ranges)
|
||||
end
|
||||
end
|
||||
end
|
||||
@ -908,6 +1149,7 @@ function LanguageTree:_edit(
|
||||
end
|
||||
|
||||
self._regions = nil
|
||||
self._regions_inv = nil
|
||||
|
||||
local changed_range = {
|
||||
start_row,
|
||||
@ -1071,14 +1313,7 @@ end
|
||||
---@param range Range
|
||||
---@return boolean
|
||||
local function tree_contains(tree, range)
|
||||
local tree_ranges = tree:included_ranges(false)
|
||||
|
||||
return Range.contains({
|
||||
tree_ranges[1][1],
|
||||
tree_ranges[1][2],
|
||||
tree_ranges[#tree_ranges][3],
|
||||
tree_ranges[#tree_ranges][4],
|
||||
}, range)
|
||||
return Range.contains(region_range(tree:included_ranges(false)), range)
|
||||
end
|
||||
|
||||
--- Determines whether {range} is contained in the |LanguageTree|.
|
||||
|
@ -11,6 +11,7 @@ local M = {}
|
||||
---@field lang string name of the language for this parser
|
||||
---@field captures string[] list of (unique) capture names defined in query
|
||||
---@field info vim.treesitter.QueryInfo contains information used in the query (e.g. captures, predicates, directives)
|
||||
---@field has_combined_injection true? whether this query has a combined injection pattern
|
||||
---@field query TSQuery userdata query object
|
||||
local Query = {}
|
||||
Query.__index = Query
|
||||
@ -30,6 +31,18 @@ function Query.new(lang, ts_query)
|
||||
patterns = query_info.patterns,
|
||||
}
|
||||
self.captures = self.info.captures
|
||||
|
||||
for _, preds in pairs(self.info.patterns) do
|
||||
if
|
||||
vim.tbl_contains(preds, function(pred)
|
||||
return vim.deep_equal(pred, { 'set!', 'injection.combined' })
|
||||
end, { predicate = true })
|
||||
then
|
||||
self.has_combined_injection = true
|
||||
break
|
||||
end
|
||||
end
|
||||
|
||||
return self
|
||||
end
|
||||
|
||||
|
@ -117,6 +117,8 @@ end
|
||||
--- -- Asynchronous.
|
||||
--- vim.ui.open("https://neovim.io/")
|
||||
--- vim.ui.open("~/path/to/file")
|
||||
--- -- Use the "osurl" command to handle the path or URL.
|
||||
--- vim.ui.open("gh#neovim/neovim!29490", { cmd = { 'osurl' } })
|
||||
--- -- Synchronous (wait until the process exits).
|
||||
--- local cmd, err = vim.ui.open("$VIMRUNTIME")
|
||||
--- if cmd then
|
||||
@ -125,12 +127,14 @@ end
|
||||
--- ```
|
||||
---
|
||||
---@param path string Path or URL to open
|
||||
---@param opt? { cmd?: string[] } Options
|
||||
--- - cmd string[]|nil Command used to open the path or URL.
|
||||
---
|
||||
---@return vim.SystemObj|nil # Command object, or nil if not found.
|
||||
---@return nil|string # Error message on failure, or nil on success.
|
||||
---
|
||||
---@see |vim.system()|
|
||||
function M.open(path)
|
||||
function M.open(path, opt)
|
||||
vim.validate({
|
||||
path = { path, 'string' },
|
||||
})
|
||||
@ -139,12 +143,13 @@ function M.open(path)
|
||||
path = vim.fs.normalize(path)
|
||||
end
|
||||
|
||||
local cmd --- @type string[]
|
||||
local opts --- @type vim.SystemOpts
|
||||
opt = opt or {}
|
||||
local cmd ---@type string[]
|
||||
local job_opt = { text = true, detach = true } --- @type vim.SystemOpts
|
||||
|
||||
opts = { text = true, detach = true }
|
||||
|
||||
if vim.fn.has('mac') == 1 then
|
||||
if opt.cmd then
|
||||
cmd = vim.list_extend(opt.cmd --[[@as string[] ]], { path })
|
||||
elseif vim.fn.has('mac') == 1 then
|
||||
cmd = { 'open', path }
|
||||
elseif vim.fn.has('win32') == 1 then
|
||||
if vim.fn.executable('rundll32') == 1 then
|
||||
@ -154,8 +159,8 @@ function M.open(path)
|
||||
end
|
||||
elseif vim.fn.executable('xdg-open') == 1 then
|
||||
cmd = { 'xdg-open', path }
|
||||
opts.stdout = false
|
||||
opts.stderr = false
|
||||
job_opt.stdout = false
|
||||
job_opt.stderr = false
|
||||
elseif vim.fn.executable('wslview') == 1 then
|
||||
cmd = { 'wslview', path }
|
||||
elseif vim.fn.executable('explorer.exe') == 1 then
|
||||
@ -164,7 +169,7 @@ function M.open(path)
|
||||
return nil, 'vim.ui.open: no handler found (tried: wslview, explorer.exe, xdg-open)'
|
||||
end
|
||||
|
||||
return vim.system(cmd, opts), nil
|
||||
return vim.system(cmd, job_opt), nil
|
||||
end
|
||||
|
||||
--- Returns all URLs at cursor, if any.
|
||||
|
@ -33,7 +33,7 @@ end
|
||||
--- Show a table of contents for the help buffer in a loclist
|
||||
function M.show_toc()
|
||||
local bufnr = vim.api.nvim_get_current_buf()
|
||||
local parser = vim.treesitter.get_parser(bufnr, 'vimdoc')
|
||||
local parser = assert(vim.treesitter._get_parser(bufnr, 'vimdoc'), 'vimdoc parser not found.')
|
||||
local query = vim.treesitter.query.parse(
|
||||
parser:lang(),
|
||||
[[
|
||||
|
@ -3,7 +3,7 @@
|
||||
" Maintainer: Aliaksei Budavei <0x000c70 AT gmail DOT com>
|
||||
" Former Maintainer: Claudio Fleiner <claudio@fleiner.com>
|
||||
" Repository: https://github.com/zzzyxwvut/java-vim.git
|
||||
" Last Change: 2024 Sep 10
|
||||
" Last Change: 2024 Sep 11
|
||||
|
||||
" Please check :help java.vim for comments on some of the options available.
|
||||
|
||||
@ -663,7 +663,7 @@ hi def link javaStorageClass StorageClass
|
||||
hi def link javaMethodDecl javaStorageClass
|
||||
hi def link javaClassDecl javaStorageClass
|
||||
hi def link javaScopeDecl javaStorageClass
|
||||
hi def link javaConceptKind NonText
|
||||
hi def link javaConceptKind javaStorageClass
|
||||
|
||||
hi def link javaBoolean Boolean
|
||||
hi def link javaSpecial Special
|
||||
|
@ -685,7 +685,7 @@ if !exists("g:vimsyn_noerror") && !exists("g:vimsyn_novimfunctionerror")
|
||||
syn match vimBufnrWarn /\<bufnr\s*(\s*["']\.['"]\s*)/
|
||||
endif
|
||||
|
||||
syn match vimNotFunc "\<if\>\|\<el\%[seif]\>\|\<retu\%[rn]\>\|\<while\>" skipwhite nextgroup=vimOper,vimOperParen,vimVar,vimFunc,vimNotation
|
||||
syn match vimNotFunc "\<if\>\|\<el\%[seif]\>\|\<retu\%[rn]\>\|\<while\>" skipwhite nextgroup=@vimExprList,vimNotation
|
||||
|
||||
" Match: {{{2
|
||||
" =====
|
||||
|
@ -786,7 +786,7 @@ local function parse_buf(fname, parser_path)
|
||||
if parser_path then
|
||||
vim.treesitter.language.add('vimdoc', { path = parser_path })
|
||||
end
|
||||
local lang_tree = vim.treesitter.get_parser(buf)
|
||||
local lang_tree = assert(vim.treesitter._get_parser(buf), 'vimdoc parser not found.')
|
||||
return lang_tree, buf
|
||||
end
|
||||
|
||||
@ -802,7 +802,7 @@ local function validate_one(fname, parser_path)
|
||||
parse_errors = {},
|
||||
}
|
||||
local lang_tree, buf = parse_buf(fname, parser_path)
|
||||
for _, tree in ipairs(lang_tree:trees()) do
|
||||
for _, tree in pairs(lang_tree:trees()) do
|
||||
visit_validate(tree:root(), 0, tree, { buf = buf, fname = fname }, stats)
|
||||
end
|
||||
lang_tree:destroy()
|
||||
@ -909,7 +909,7 @@ local function gen_one(fname, to_fname, old, commit, parser_path)
|
||||
]]
|
||||
|
||||
local main = ''
|
||||
for _, tree in ipairs(lang_tree:trees()) do
|
||||
for _, tree in pairs(lang_tree:trees()) do
|
||||
main = main
|
||||
.. (
|
||||
visit_node(
|
||||
|
@ -10,7 +10,7 @@
|
||||
Memcheck:Leak
|
||||
fun:malloc
|
||||
fun:uv_spawn
|
||||
fun:libuv_process_spawn
|
||||
fun:process_spawn
|
||||
fun:libuv_proc_spawn
|
||||
fun:proc_spawn
|
||||
fun:job_start
|
||||
}
|
||||
|
@ -848,7 +848,7 @@ def CheckIncludes(filename, lines, error):
|
||||
or filename.endswith('.in.h')
|
||||
or FileInfo(filename).RelativePath() in {
|
||||
'func_attr.h',
|
||||
'os/pty_process.h',
|
||||
'os/pty_proc.h',
|
||||
}):
|
||||
return
|
||||
|
||||
@ -869,7 +869,7 @@ def CheckIncludes(filename, lines, error):
|
||||
"src/nvim/msgpack_rpc/unpacker.h",
|
||||
"src/nvim/option.h",
|
||||
"src/nvim/os/pty_conpty_win.h",
|
||||
"src/nvim/os/pty_process_win.h",
|
||||
"src/nvim/os/pty_proc_win.h",
|
||||
]
|
||||
|
||||
skip_headers = [
|
||||
|
@ -417,10 +417,10 @@ list(SORT NVIM_HEADERS)
|
||||
|
||||
foreach(sfile ${NVIM_SOURCES})
|
||||
get_filename_component(f ${sfile} NAME)
|
||||
if(WIN32 AND ${f} MATCHES "^(pty_process_unix.c)$")
|
||||
if(WIN32 AND ${f} MATCHES "^(pty_proc_unix.c)$")
|
||||
list(REMOVE_ITEM NVIM_SOURCES ${sfile})
|
||||
endif()
|
||||
if(NOT WIN32 AND ${f} MATCHES "^(pty_process_win.c)$")
|
||||
if(NOT WIN32 AND ${f} MATCHES "^(pty_proc_win.c)$")
|
||||
list(REMOVE_ITEM NVIM_SOURCES ${sfile})
|
||||
endif()
|
||||
if(NOT WIN32 AND ${f} MATCHES "^(pty_conpty_win.c)$")
|
||||
@ -436,7 +436,7 @@ foreach(hfile ${NVIM_HEADERS})
|
||||
if(WIN32 AND ${f} MATCHES "^(unix_defs.h)$")
|
||||
list(REMOVE_ITEM NVIM_HEADERS ${hfile})
|
||||
endif()
|
||||
if(WIN32 AND ${f} MATCHES "^(pty_process_unix.h)$")
|
||||
if(WIN32 AND ${f} MATCHES "^(pty_proc_unix.h)$")
|
||||
list(REMOVE_ITEM NVIM_HEADERS ${hfile})
|
||||
endif()
|
||||
if(NOT WIN32 AND ${f} MATCHES "^(win_defs.h)$")
|
||||
@ -832,12 +832,12 @@ find_program(CLANG_TIDY_PRG clang-tidy)
|
||||
set(EXCLUDE_CLANG_TIDY typval_encode.c.h ui_events.in.h)
|
||||
if(WIN32)
|
||||
list(APPEND EXCLUDE_CLANG_TIDY
|
||||
os/pty_process_unix.h
|
||||
os/pty_proc_unix.h
|
||||
os/unix_defs.h)
|
||||
else()
|
||||
list(APPEND EXCLUDE_CLANG_TIDY
|
||||
os/win_defs.h
|
||||
os/pty_process_win.h
|
||||
os/pty_proc_win.h
|
||||
os/pty_conpty_win.h
|
||||
os/os_win_console.h)
|
||||
endif()
|
||||
|
@ -70,7 +70,7 @@
|
||||
#include "nvim/optionstr.h"
|
||||
#include "nvim/os/input.h"
|
||||
#include "nvim/os/os_defs.h"
|
||||
#include "nvim/os/process.h"
|
||||
#include "nvim/os/proc.h"
|
||||
#include "nvim/popupmenu.h"
|
||||
#include "nvim/pos_defs.h"
|
||||
#include "nvim/runtime.h"
|
||||
|
@ -19,7 +19,7 @@
|
||||
#include "nvim/eval/typval.h"
|
||||
#include "nvim/event/loop.h"
|
||||
#include "nvim/event/multiqueue.h"
|
||||
#include "nvim/event/process.h"
|
||||
#include "nvim/event/proc.h"
|
||||
#include "nvim/event/rstream.h"
|
||||
#include "nvim/event/socket.h"
|
||||
#include "nvim/event/stream.h"
|
||||
@ -88,7 +88,7 @@ void channel_free_all_mem(void)
|
||||
bool channel_close(uint64_t id, ChannelPart part, const char **error)
|
||||
{
|
||||
Channel *chan;
|
||||
Process *proc;
|
||||
Proc *proc;
|
||||
|
||||
const char *dummy;
|
||||
if (!error) {
|
||||
@ -139,8 +139,8 @@ bool channel_close(uint64_t id, ChannelPart part, const char **error)
|
||||
if (part == kChannelPartStderr || part == kChannelPartAll) {
|
||||
rstream_may_close(&proc->err);
|
||||
}
|
||||
if (proc->type == kProcessTypePty && part == kChannelPartAll) {
|
||||
pty_process_close_master(&chan->stream.pty);
|
||||
if (proc->type == kProcTypePty && part == kChannelPartAll) {
|
||||
pty_proc_close_master(&chan->stream.pty);
|
||||
}
|
||||
|
||||
break;
|
||||
@ -289,7 +289,7 @@ static void channel_destroy(Channel *chan)
|
||||
}
|
||||
|
||||
if (chan->streamtype == kChannelStreamProc) {
|
||||
process_free(&chan->stream.proc);
|
||||
proc_free(&chan->stream.proc);
|
||||
}
|
||||
|
||||
callback_reader_free(&chan->on_data);
|
||||
@ -376,7 +376,7 @@ Channel *channel_job_start(char **argv, const char *exepath, CallbackReader on_s
|
||||
*status_out = 0;
|
||||
return NULL;
|
||||
}
|
||||
chan->stream.pty = pty_process_init(&main_loop, chan);
|
||||
chan->stream.pty = pty_proc_init(&main_loop, chan);
|
||||
if (pty_width > 0) {
|
||||
chan->stream.pty.width = pty_width;
|
||||
}
|
||||
@ -384,22 +384,22 @@ Channel *channel_job_start(char **argv, const char *exepath, CallbackReader on_s
|
||||
chan->stream.pty.height = pty_height;
|
||||
}
|
||||
} else {
|
||||
chan->stream.uv = libuv_process_init(&main_loop, chan);
|
||||
chan->stream.uv = libuv_proc_init(&main_loop, chan);
|
||||
}
|
||||
|
||||
Process *proc = &chan->stream.proc;
|
||||
Proc *proc = &chan->stream.proc;
|
||||
proc->argv = argv;
|
||||
proc->exepath = exepath;
|
||||
proc->cb = channel_process_exit_cb;
|
||||
proc->cb = channel_proc_exit_cb;
|
||||
proc->events = chan->events;
|
||||
proc->detach = detach;
|
||||
proc->cwd = cwd;
|
||||
proc->env = env;
|
||||
proc->overlapped = overlapped;
|
||||
|
||||
char *cmd = xstrdup(process_get_exepath(proc));
|
||||
char *cmd = xstrdup(proc_get_exepath(proc));
|
||||
bool has_out, has_err;
|
||||
if (proc->type == kProcessTypePty) {
|
||||
if (proc->type == kProcTypePty) {
|
||||
has_out = true;
|
||||
has_err = false;
|
||||
} else {
|
||||
@ -410,7 +410,7 @@ Channel *channel_job_start(char **argv, const char *exepath, CallbackReader on_s
|
||||
|
||||
bool has_in = stdin_mode == kChannelStdinPipe;
|
||||
|
||||
int status = process_spawn(proc, has_in, has_out, has_err);
|
||||
int status = proc_spawn(proc, has_in, has_out, has_err);
|
||||
if (status) {
|
||||
semsg(_(e_jobspawn), os_strerror(status), cmd);
|
||||
xfree(cmd);
|
||||
@ -760,7 +760,7 @@ void channel_reader_callbacks(Channel *chan, CallbackReader *reader)
|
||||
}
|
||||
}
|
||||
|
||||
static void channel_process_exit_cb(Process *proc, int status, void *data)
|
||||
static void channel_proc_exit_cb(Proc *proc, int status, void *data)
|
||||
{
|
||||
Channel *chan = data;
|
||||
if (chan->term) {
|
||||
@ -847,7 +847,7 @@ static void term_write(const char *buf, size_t size, void *data)
|
||||
static void term_resize(uint16_t width, uint16_t height, void *data)
|
||||
{
|
||||
Channel *chan = data;
|
||||
pty_process_resize(&chan->stream.pty, width, height);
|
||||
pty_proc_resize(&chan->stream.pty, width, height);
|
||||
}
|
||||
|
||||
static inline void term_delayed_free(void **argv)
|
||||
@ -867,7 +867,7 @@ static inline void term_delayed_free(void **argv)
|
||||
static void term_close(void *data)
|
||||
{
|
||||
Channel *chan = data;
|
||||
process_stop(&chan->stream.proc);
|
||||
proc_stop(&chan->stream.proc);
|
||||
multiqueue_put(chan->events, term_delayed_free, data);
|
||||
}
|
||||
|
||||
@ -907,7 +907,7 @@ bool channel_job_running(uint64_t id)
|
||||
Channel *chan = find_channel(id);
|
||||
return (chan
|
||||
&& chan->streamtype == kChannelStreamProc
|
||||
&& !process_is_stopped(&chan->stream.proc));
|
||||
&& !proc_is_stopped(&chan->stream.proc));
|
||||
}
|
||||
|
||||
Dictionary channel_info(uint64_t id, Arena *arena)
|
||||
@ -924,8 +924,8 @@ Dictionary channel_info(uint64_t id, Arena *arena)
|
||||
switch (chan->streamtype) {
|
||||
case kChannelStreamProc: {
|
||||
stream_desc = "job";
|
||||
if (chan->stream.proc.type == kProcessTypePty) {
|
||||
const char *name = pty_process_tty_name(&chan->stream.pty);
|
||||
if (chan->stream.proc.type == kProcTypePty) {
|
||||
const char *name = pty_proc_tty_name(&chan->stream.pty);
|
||||
PUT_C(info, "pty", CSTR_TO_ARENA_OBJ(arena, name));
|
||||
}
|
||||
|
||||
|
@ -7,11 +7,11 @@
|
||||
#include "nvim/channel_defs.h" // IWYU pragma: keep
|
||||
#include "nvim/eval/typval_defs.h"
|
||||
#include "nvim/event/defs.h"
|
||||
#include "nvim/event/libuv_process.h"
|
||||
#include "nvim/event/libuv_proc.h"
|
||||
#include "nvim/macros_defs.h"
|
||||
#include "nvim/map_defs.h"
|
||||
#include "nvim/msgpack_rpc/channel_defs.h"
|
||||
#include "nvim/os/pty_process.h"
|
||||
#include "nvim/os/pty_proc.h"
|
||||
#include "nvim/types_defs.h"
|
||||
|
||||
struct Channel {
|
||||
@ -21,9 +21,9 @@ struct Channel {
|
||||
|
||||
ChannelStreamType streamtype;
|
||||
union {
|
||||
Process proc;
|
||||
LibuvProcess uv;
|
||||
PtyProcess pty;
|
||||
Proc proc;
|
||||
LibuvProc uv;
|
||||
PtyProc pty;
|
||||
RStream socket;
|
||||
StdioPair stdio;
|
||||
StderrState err;
|
||||
|
@ -170,28 +170,26 @@ static void margin_columns_win(win_T *wp, int *left_col, int *right_col)
|
||||
// cache previous calculations depending on w_virtcol
|
||||
static int saved_w_virtcol;
|
||||
static win_T *prev_wp;
|
||||
static int prev_width1;
|
||||
static int prev_width2;
|
||||
static int prev_left_col;
|
||||
static int prev_right_col;
|
||||
static int prev_col_off;
|
||||
|
||||
int cur_col_off = win_col_off(wp);
|
||||
int width1;
|
||||
int width2;
|
||||
int width1 = wp->w_width_inner - cur_col_off;
|
||||
int width2 = width1 + win_col_off2(wp);
|
||||
|
||||
if (saved_w_virtcol == wp->w_virtcol && prev_wp == wp
|
||||
&& prev_col_off == cur_col_off) {
|
||||
&& prev_width1 == width1 && prev_width2 == width2) {
|
||||
*right_col = prev_right_col;
|
||||
*left_col = prev_left_col;
|
||||
return;
|
||||
}
|
||||
|
||||
width1 = wp->w_width_inner - cur_col_off;
|
||||
width2 = width1 + win_col_off2(wp);
|
||||
|
||||
*left_col = 0;
|
||||
*right_col = width1;
|
||||
|
||||
if (wp->w_virtcol >= (colnr_T)width1) {
|
||||
if (wp->w_virtcol >= (colnr_T)width1 && width2 > 0) {
|
||||
*right_col = width1 + ((wp->w_virtcol - width1) / width2 + 1) * width2;
|
||||
}
|
||||
if (wp->w_virtcol >= (colnr_T)width1 && width2 > 0) {
|
||||
@ -202,8 +200,9 @@ static void margin_columns_win(win_T *wp, int *left_col, int *right_col)
|
||||
prev_left_col = *left_col;
|
||||
prev_right_col = *right_col;
|
||||
prev_wp = wp;
|
||||
prev_width1 = width1;
|
||||
prev_width2 = width2;
|
||||
saved_w_virtcol = wp->w_virtcol;
|
||||
prev_col_off = cur_col_off;
|
||||
}
|
||||
|
||||
/// Put a single char from an UTF-8 buffer into a line buffer.
|
||||
|
@ -32,7 +32,7 @@
|
||||
#include "nvim/eval/vars.h"
|
||||
#include "nvim/event/loop.h"
|
||||
#include "nvim/event/multiqueue.h"
|
||||
#include "nvim/event/process.h"
|
||||
#include "nvim/event/proc.h"
|
||||
#include "nvim/event/time.h"
|
||||
#include "nvim/ex_cmds.h"
|
||||
#include "nvim/ex_docmd.h"
|
||||
@ -8506,7 +8506,7 @@ Channel *find_job(uint64_t id, bool show_error)
|
||||
{
|
||||
Channel *data = find_channel(id);
|
||||
if (!data || data->streamtype != kChannelStreamProc
|
||||
|| process_is_stopped(&data->stream.proc)) {
|
||||
|| proc_is_stopped(&data->stream.proc)) {
|
||||
if (show_error) {
|
||||
if (data && data->streamtype != kChannelStreamProc) {
|
||||
emsg(_(e_invchanjob));
|
||||
|
@ -8044,7 +8044,7 @@ M.funcs = {
|
||||
|
||||
]=],
|
||||
name = 'prompt_getprompt',
|
||||
params = { { 'buf', 'any' } },
|
||||
params = { { 'buf', 'integer|string' } },
|
||||
signature = 'prompt_getprompt({buf})',
|
||||
},
|
||||
prompt_setcallback = {
|
||||
@ -8084,7 +8084,7 @@ M.funcs = {
|
||||
|
||||
]=],
|
||||
name = 'prompt_setcallback',
|
||||
params = { { 'buf', 'any' }, { 'expr', 'any' } },
|
||||
params = { { 'buf', 'integer|string' }, { 'expr', 'string|function' } },
|
||||
signature = 'prompt_setcallback({buf}, {expr})',
|
||||
},
|
||||
prompt_setinterrupt = {
|
||||
@ -8101,7 +8101,7 @@ M.funcs = {
|
||||
|
||||
]=],
|
||||
name = 'prompt_setinterrupt',
|
||||
params = { { 'buf', 'any' }, { 'expr', 'any' } },
|
||||
params = { { 'buf', 'integer|string' }, { 'expr', 'string|function' } },
|
||||
signature = 'prompt_setinterrupt({buf}, {expr})',
|
||||
},
|
||||
prompt_setprompt = {
|
||||
@ -8116,7 +8116,7 @@ M.funcs = {
|
||||
<
|
||||
]=],
|
||||
name = 'prompt_setprompt',
|
||||
params = { { 'buf', 'any' }, { 'text', 'any' } },
|
||||
params = { { 'buf', 'integer|string' }, { 'text', 'string' } },
|
||||
signature = 'prompt_setprompt({buf}, {text})',
|
||||
},
|
||||
pum_getpos = {
|
||||
|
@ -49,7 +49,7 @@
|
||||
#include "nvim/event/defs.h"
|
||||
#include "nvim/event/loop.h"
|
||||
#include "nvim/event/multiqueue.h"
|
||||
#include "nvim/event/process.h"
|
||||
#include "nvim/event/proc.h"
|
||||
#include "nvim/event/time.h"
|
||||
#include "nvim/ex_cmds.h"
|
||||
#include "nvim/ex_cmds_defs.h"
|
||||
@ -101,7 +101,7 @@
|
||||
#include "nvim/os/fs.h"
|
||||
#include "nvim/os/os.h"
|
||||
#include "nvim/os/os_defs.h"
|
||||
#include "nvim/os/pty_process.h"
|
||||
#include "nvim/os/pty_proc.h"
|
||||
#include "nvim/os/shell.h"
|
||||
#include "nvim/os/stdpaths_defs.h"
|
||||
#include "nvim/os/time.h"
|
||||
@ -3770,7 +3770,7 @@ static void f_jobpid(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
|
||||
return;
|
||||
}
|
||||
|
||||
Process *proc = &data->stream.proc;
|
||||
Proc *proc = &data->stream.proc;
|
||||
rettv->vval.v_number = proc->pid;
|
||||
}
|
||||
|
||||
@ -3796,13 +3796,13 @@ static void f_jobresize(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
|
||||
return;
|
||||
}
|
||||
|
||||
if (data->stream.proc.type != kProcessTypePty) {
|
||||
if (data->stream.proc.type != kProcTypePty) {
|
||||
emsg(_(e_channotpty));
|
||||
return;
|
||||
}
|
||||
|
||||
pty_process_resize(&data->stream.pty, (uint16_t)argvars[1].vval.v_number,
|
||||
(uint16_t)argvars[2].vval.v_number);
|
||||
pty_proc_resize(&data->stream.pty, (uint16_t)argvars[1].vval.v_number,
|
||||
(uint16_t)argvars[2].vval.v_number);
|
||||
rettv->vval.v_number = 1;
|
||||
}
|
||||
|
||||
@ -4077,7 +4077,7 @@ static void f_jobstop(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
|
||||
// Ignore return code, but show error later.
|
||||
channel_close(data->id, kChannelPartRpc, &error);
|
||||
}
|
||||
process_stop(&data->stream.proc);
|
||||
proc_stop(&data->stream.proc);
|
||||
rettv->vval.v_number = 1;
|
||||
if (error) {
|
||||
emsg(error);
|
||||
@ -4113,10 +4113,10 @@ static void f_jobwait(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
|
||||
|| !(chan = find_channel((uint64_t)TV_LIST_ITEM_TV(arg)->vval.v_number))
|
||||
|| chan->streamtype != kChannelStreamProc) {
|
||||
jobs[i] = NULL; // Invalid job.
|
||||
} else if (process_is_stopped(&chan->stream.proc)) {
|
||||
} else if (proc_is_stopped(&chan->stream.proc)) {
|
||||
// Job is stopped but not fully destroyed.
|
||||
// Ensure all callbacks on its event queue are executed. #15402
|
||||
process_wait(&chan->stream.proc, -1, NULL);
|
||||
proc_wait(&chan->stream.proc, -1, NULL);
|
||||
jobs[i] = NULL; // Invalid job.
|
||||
} else {
|
||||
jobs[i] = chan;
|
||||
@ -4144,8 +4144,8 @@ static void f_jobwait(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
|
||||
if (jobs[i] == NULL) {
|
||||
continue; // Invalid job, will assign status=-3 below.
|
||||
}
|
||||
int status = process_wait(&jobs[i]->stream.proc, remaining,
|
||||
waiting_jobs);
|
||||
int status = proc_wait(&jobs[i]->stream.proc, remaining,
|
||||
waiting_jobs);
|
||||
if (status < 0) {
|
||||
break; // Interrupted (CTRL-C) or timeout, skip remaining jobs.
|
||||
}
|
||||
@ -8207,7 +8207,7 @@ static void f_termopen(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
|
||||
return;
|
||||
}
|
||||
|
||||
int pid = chan->stream.pty.process.pid;
|
||||
int pid = chan->stream.pty.proc.pid;
|
||||
|
||||
// "./…" => "/home/foo/…"
|
||||
vim_FullName(cwd, NameBuff, sizeof(NameBuff), false);
|
||||
|
@ -142,30 +142,31 @@ struct socket_watcher {
|
||||
};
|
||||
|
||||
typedef enum {
|
||||
kProcessTypeUv,
|
||||
kProcessTypePty,
|
||||
} ProcessType;
|
||||
kProcTypeUv,
|
||||
kProcTypePty,
|
||||
} ProcType;
|
||||
|
||||
typedef struct process Process;
|
||||
typedef void (*process_exit_cb)(Process *proc, int status, void *data);
|
||||
typedef void (*internal_process_cb)(Process *proc);
|
||||
/// OS process
|
||||
typedef struct proc Proc;
|
||||
typedef void (*proc_exit_cb)(Proc *proc, int status, void *data);
|
||||
typedef void (*internal_proc_cb)(Proc *proc);
|
||||
|
||||
struct process {
|
||||
ProcessType type;
|
||||
struct proc {
|
||||
ProcType type;
|
||||
Loop *loop;
|
||||
void *data;
|
||||
int pid, status, refcount;
|
||||
uint8_t exit_signal; // Signal used when killing (on Windows).
|
||||
uint64_t stopped_time; // process_stop() timestamp
|
||||
uint64_t stopped_time; // proc_stop() timestamp
|
||||
const char *cwd;
|
||||
char **argv;
|
||||
const char *exepath;
|
||||
dict_T *env;
|
||||
Stream in;
|
||||
RStream out, err;
|
||||
/// Exit handler. If set, user must call process_free().
|
||||
process_exit_cb cb;
|
||||
internal_process_cb internal_exit_cb, internal_close_cb;
|
||||
/// Exit handler. If set, user must call proc_free().
|
||||
proc_exit_cb cb;
|
||||
internal_proc_cb internal_exit_cb, internal_close_cb;
|
||||
bool closed, detach, overlapped, fwd_err;
|
||||
MultiQueue *events;
|
||||
};
|
||||
|
@ -5,9 +5,9 @@
|
||||
|
||||
#include "nvim/eval/typval.h"
|
||||
#include "nvim/event/defs.h"
|
||||
#include "nvim/event/libuv_process.h"
|
||||
#include "nvim/event/libuv_proc.h"
|
||||
#include "nvim/event/loop.h"
|
||||
#include "nvim/event/process.h"
|
||||
#include "nvim/event/proc.h"
|
||||
#include "nvim/log.h"
|
||||
#include "nvim/os/os.h"
|
||||
#include "nvim/os/os_defs.h"
|
||||
@ -15,15 +15,15 @@
|
||||
#include "nvim/ui_client.h"
|
||||
|
||||
#ifdef INCLUDE_GENERATED_DECLARATIONS
|
||||
# include "event/libuv_process.c.generated.h"
|
||||
# include "event/libuv_proc.c.generated.h"
|
||||
#endif
|
||||
|
||||
/// @returns zero on success, or negative error code
|
||||
int libuv_process_spawn(LibuvProcess *uvproc)
|
||||
int libuv_proc_spawn(LibuvProc *uvproc)
|
||||
FUNC_ATTR_NONNULL_ALL
|
||||
{
|
||||
Process *proc = (Process *)uvproc;
|
||||
uvproc->uvopts.file = process_get_exepath(proc);
|
||||
Proc *proc = (Proc *)uvproc;
|
||||
uvproc->uvopts.file = proc_get_exepath(proc);
|
||||
uvproc->uvopts.args = proc->argv;
|
||||
uvproc->uvopts.flags = UV_PROCESS_WINDOWS_HIDE;
|
||||
#ifdef MSWIN
|
||||
@ -101,7 +101,7 @@ int libuv_process_spawn(LibuvProcess *uvproc)
|
||||
return status;
|
||||
}
|
||||
|
||||
void libuv_process_close(LibuvProcess *uvproc)
|
||||
void libuv_proc_close(LibuvProc *uvproc)
|
||||
FUNC_ATTR_NONNULL_ARG(1)
|
||||
{
|
||||
uv_close((uv_handle_t *)&uvproc->uv, close_cb);
|
||||
@ -109,11 +109,11 @@ void libuv_process_close(LibuvProcess *uvproc)
|
||||
|
||||
static void close_cb(uv_handle_t *handle)
|
||||
{
|
||||
Process *proc = handle->data;
|
||||
Proc *proc = handle->data;
|
||||
if (proc->internal_close_cb) {
|
||||
proc->internal_close_cb(proc);
|
||||
}
|
||||
LibuvProcess *uvproc = (LibuvProcess *)proc;
|
||||
LibuvProc *uvproc = (LibuvProc *)proc;
|
||||
if (uvproc->uvopts.env) {
|
||||
os_free_fullenv(uvproc->uvopts.env);
|
||||
}
|
||||
@ -121,7 +121,7 @@ static void close_cb(uv_handle_t *handle)
|
||||
|
||||
static void exit_cb(uv_process_t *handle, int64_t status, int term_signal)
|
||||
{
|
||||
Process *proc = handle->data;
|
||||
Proc *proc = handle->data;
|
||||
#if defined(MSWIN)
|
||||
// Use stored/expected signal.
|
||||
term_signal = proc->exit_signal;
|
||||
@ -130,10 +130,10 @@ static void exit_cb(uv_process_t *handle, int64_t status, int term_signal)
|
||||
proc->internal_exit_cb(proc);
|
||||
}
|
||||
|
||||
LibuvProcess libuv_process_init(Loop *loop, void *data)
|
||||
LibuvProc libuv_proc_init(Loop *loop, void *data)
|
||||
{
|
||||
LibuvProcess rv = {
|
||||
.process = process_init(loop, kProcessTypeUv, data)
|
||||
LibuvProc rv = {
|
||||
.proc = proc_init(loop, kProcTypeUv, data)
|
||||
};
|
||||
return rv;
|
||||
}
|
@ -5,12 +5,12 @@
|
||||
#include "nvim/event/defs.h"
|
||||
|
||||
typedef struct {
|
||||
Process process;
|
||||
Proc proc;
|
||||
uv_process_t uv;
|
||||
uv_process_options_t uvopts;
|
||||
uv_stdio_container_t uvstdio[4];
|
||||
} LibuvProcess;
|
||||
} LibuvProc;
|
||||
|
||||
#ifdef INCLUDE_GENERATED_DECLARATIONS
|
||||
# include "event/libuv_process.h.generated.h"
|
||||
# include "event/libuv_proc.h.generated.h"
|
||||
#endif
|
@ -4,24 +4,24 @@
|
||||
#include <uv.h>
|
||||
|
||||
#include "klib/klist.h"
|
||||
#include "nvim/event/libuv_process.h"
|
||||
#include "nvim/event/libuv_proc.h"
|
||||
#include "nvim/event/loop.h"
|
||||
#include "nvim/event/multiqueue.h"
|
||||
#include "nvim/event/process.h"
|
||||
#include "nvim/event/proc.h"
|
||||
#include "nvim/event/rstream.h"
|
||||
#include "nvim/event/stream.h"
|
||||
#include "nvim/event/wstream.h"
|
||||
#include "nvim/globals.h"
|
||||
#include "nvim/log.h"
|
||||
#include "nvim/main.h"
|
||||
#include "nvim/os/process.h"
|
||||
#include "nvim/os/pty_process.h"
|
||||
#include "nvim/os/proc.h"
|
||||
#include "nvim/os/pty_proc.h"
|
||||
#include "nvim/os/shell.h"
|
||||
#include "nvim/os/time.h"
|
||||
#include "nvim/ui_client.h"
|
||||
|
||||
#ifdef INCLUDE_GENERATED_DECLARATIONS
|
||||
# include "event/process.c.generated.h"
|
||||
# include "event/proc.c.generated.h"
|
||||
#endif
|
||||
|
||||
// Time for a process to exit cleanly before we send KILL.
|
||||
@ -33,13 +33,13 @@
|
||||
void __gcov_flush(void);
|
||||
#endif
|
||||
|
||||
static bool process_is_tearing_down = false;
|
||||
static bool proc_is_tearing_down = false;
|
||||
|
||||
// Delay exit until handles are closed, to avoid deadlocks
|
||||
static int exit_need_delay = 0;
|
||||
|
||||
/// @returns zero on success, or negative error code
|
||||
int process_spawn(Process *proc, bool in, bool out, bool err)
|
||||
int proc_spawn(Proc *proc, bool in, bool out, bool err)
|
||||
FUNC_ATTR_NONNULL_ALL
|
||||
{
|
||||
// forwarding stderr contradicts with processing it internally
|
||||
@ -70,11 +70,11 @@ int process_spawn(Process *proc, bool in, bool out, bool err)
|
||||
|
||||
int status;
|
||||
switch (proc->type) {
|
||||
case kProcessTypeUv:
|
||||
status = libuv_process_spawn((LibuvProcess *)proc);
|
||||
case kProcTypeUv:
|
||||
status = libuv_proc_spawn((LibuvProc *)proc);
|
||||
break;
|
||||
case kProcessTypePty:
|
||||
status = pty_process_spawn((PtyProcess *)proc);
|
||||
case kProcTypePty:
|
||||
status = pty_proc_spawn((PtyProc *)proc);
|
||||
break;
|
||||
}
|
||||
|
||||
@ -89,12 +89,12 @@ int process_spawn(Process *proc, bool in, bool out, bool err)
|
||||
uv_close((uv_handle_t *)&proc->err.s.uv.pipe, NULL);
|
||||
}
|
||||
|
||||
if (proc->type == kProcessTypeUv) {
|
||||
uv_close((uv_handle_t *)&(((LibuvProcess *)proc)->uv), NULL);
|
||||
if (proc->type == kProcTypeUv) {
|
||||
uv_close((uv_handle_t *)&(((LibuvProc *)proc)->uv), NULL);
|
||||
} else {
|
||||
process_close(proc);
|
||||
proc_close(proc);
|
||||
}
|
||||
process_free(proc);
|
||||
proc_free(proc);
|
||||
proc->status = -1;
|
||||
return status;
|
||||
}
|
||||
@ -102,52 +102,52 @@ int process_spawn(Process *proc, bool in, bool out, bool err)
|
||||
if (in) {
|
||||
stream_init(NULL, &proc->in, -1, (uv_stream_t *)&proc->in.uv.pipe);
|
||||
proc->in.internal_data = proc;
|
||||
proc->in.internal_close_cb = on_process_stream_close;
|
||||
proc->in.internal_close_cb = on_proc_stream_close;
|
||||
proc->refcount++;
|
||||
}
|
||||
|
||||
if (out) {
|
||||
stream_init(NULL, &proc->out.s, -1, (uv_stream_t *)&proc->out.s.uv.pipe);
|
||||
proc->out.s.internal_data = proc;
|
||||
proc->out.s.internal_close_cb = on_process_stream_close;
|
||||
proc->out.s.internal_close_cb = on_proc_stream_close;
|
||||
proc->refcount++;
|
||||
}
|
||||
|
||||
if (err) {
|
||||
stream_init(NULL, &proc->err.s, -1, (uv_stream_t *)&proc->err.s.uv.pipe);
|
||||
proc->err.s.internal_data = proc;
|
||||
proc->err.s.internal_close_cb = on_process_stream_close;
|
||||
proc->err.s.internal_close_cb = on_proc_stream_close;
|
||||
proc->refcount++;
|
||||
}
|
||||
|
||||
proc->internal_exit_cb = on_process_exit;
|
||||
proc->internal_exit_cb = on_proc_exit;
|
||||
proc->internal_close_cb = decref;
|
||||
proc->refcount++;
|
||||
kl_push(WatcherPtr, proc->loop->children, proc);
|
||||
DLOG("new: pid=%d exepath=[%s]", proc->pid, process_get_exepath(proc));
|
||||
DLOG("new: pid=%d exepath=[%s]", proc->pid, proc_get_exepath(proc));
|
||||
return 0;
|
||||
}
|
||||
|
||||
void process_teardown(Loop *loop) FUNC_ATTR_NONNULL_ALL
|
||||
void proc_teardown(Loop *loop) FUNC_ATTR_NONNULL_ALL
|
||||
{
|
||||
process_is_tearing_down = true;
|
||||
proc_is_tearing_down = true;
|
||||
kl_iter(WatcherPtr, loop->children, current) {
|
||||
Process *proc = (*current)->data;
|
||||
if (proc->detach || proc->type == kProcessTypePty) {
|
||||
Proc *proc = (*current)->data;
|
||||
if (proc->detach || proc->type == kProcTypePty) {
|
||||
// Close handles to process without killing it.
|
||||
CREATE_EVENT(loop->events, process_close_handles, proc);
|
||||
CREATE_EVENT(loop->events, proc_close_handles, proc);
|
||||
} else {
|
||||
process_stop(proc);
|
||||
proc_stop(proc);
|
||||
}
|
||||
}
|
||||
|
||||
// Wait until all children exit and all close events are processed.
|
||||
LOOP_PROCESS_EVENTS_UNTIL(loop, loop->events, -1,
|
||||
kl_empty(loop->children) && multiqueue_empty(loop->events));
|
||||
pty_process_teardown(loop);
|
||||
pty_proc_teardown(loop);
|
||||
}
|
||||
|
||||
void process_close_streams(Process *proc) FUNC_ATTR_NONNULL_ALL
|
||||
void proc_close_streams(Proc *proc) FUNC_ATTR_NONNULL_ALL
|
||||
{
|
||||
wstream_may_close(&proc->in);
|
||||
rstream_may_close(&proc->out);
|
||||
@ -162,7 +162,7 @@ void process_close_streams(Process *proc) FUNC_ATTR_NONNULL_ALL
|
||||
/// @return Exit code of the process. proc->status will have the same value.
|
||||
/// -1 if the timeout expired while the process is still running.
|
||||
/// -2 if the user interrupted the wait.
|
||||
int process_wait(Process *proc, int ms, MultiQueue *events)
|
||||
int proc_wait(Proc *proc, int ms, MultiQueue *events)
|
||||
FUNC_ATTR_NONNULL_ARG(1)
|
||||
{
|
||||
if (!proc->refcount) {
|
||||
@ -186,7 +186,7 @@ int process_wait(Process *proc, int ms, MultiQueue *events)
|
||||
// Assume that a user hitting CTRL-C does not like the current job. Kill it.
|
||||
if (got_int) {
|
||||
got_int = false;
|
||||
process_stop(proc);
|
||||
proc_stop(proc);
|
||||
if (ms == -1) {
|
||||
// We can only return if all streams/handles are closed and the job
|
||||
// exited.
|
||||
@ -214,7 +214,7 @@ int process_wait(Process *proc, int ms, MultiQueue *events)
|
||||
}
|
||||
|
||||
/// Ask a process to terminate and eventually kill if it doesn't respond
|
||||
void process_stop(Process *proc) FUNC_ATTR_NONNULL_ALL
|
||||
void proc_stop(Proc *proc) FUNC_ATTR_NONNULL_ALL
|
||||
{
|
||||
bool exited = (proc->status >= 0);
|
||||
if (exited || proc->stopped_time) {
|
||||
@ -224,13 +224,13 @@ void process_stop(Process *proc) FUNC_ATTR_NONNULL_ALL
|
||||
proc->exit_signal = SIGTERM;
|
||||
|
||||
switch (proc->type) {
|
||||
case kProcessTypeUv:
|
||||
case kProcTypeUv:
|
||||
os_proc_tree_kill(proc->pid, SIGTERM);
|
||||
break;
|
||||
case kProcessTypePty:
|
||||
case kProcTypePty:
|
||||
// close all streams for pty processes to send SIGHUP to the process
|
||||
process_close_streams(proc);
|
||||
pty_process_close_master((PtyProcess *)proc);
|
||||
proc_close_streams(proc);
|
||||
pty_proc_close_master((PtyProc *)proc);
|
||||
break;
|
||||
}
|
||||
|
||||
@ -240,7 +240,7 @@ void process_stop(Process *proc) FUNC_ATTR_NONNULL_ALL
|
||||
}
|
||||
|
||||
/// Frees process-owned resources.
|
||||
void process_free(Process *proc) FUNC_ATTR_NONNULL_ALL
|
||||
void proc_free(Proc *proc) FUNC_ATTR_NONNULL_ALL
|
||||
{
|
||||
if (proc->argv != NULL) {
|
||||
shell_free_argv(proc->argv);
|
||||
@ -249,19 +249,19 @@ void process_free(Process *proc) FUNC_ATTR_NONNULL_ALL
|
||||
}
|
||||
|
||||
/// Sends SIGKILL (or SIGTERM..SIGKILL for PTY jobs) to processes that did
|
||||
/// not terminate after process_stop().
|
||||
/// not terminate after proc_stop().
|
||||
static void children_kill_cb(uv_timer_t *handle)
|
||||
{
|
||||
Loop *loop = handle->loop->data;
|
||||
|
||||
kl_iter(WatcherPtr, loop->children, current) {
|
||||
Process *proc = (*current)->data;
|
||||
Proc *proc = (*current)->data;
|
||||
bool exited = (proc->status >= 0);
|
||||
if (exited || !proc->stopped_time) {
|
||||
continue;
|
||||
}
|
||||
uint64_t term_sent = UINT64_MAX == proc->stopped_time;
|
||||
if (kProcessTypePty != proc->type || term_sent) {
|
||||
if (kProcTypePty != proc->type || term_sent) {
|
||||
proc->exit_signal = SIGKILL;
|
||||
os_proc_tree_kill(proc->pid, SIGKILL);
|
||||
} else {
|
||||
@ -275,19 +275,19 @@ static void children_kill_cb(uv_timer_t *handle)
|
||||
}
|
||||
}
|
||||
|
||||
static void process_close_event(void **argv)
|
||||
static void proc_close_event(void **argv)
|
||||
{
|
||||
Process *proc = argv[0];
|
||||
Proc *proc = argv[0];
|
||||
if (proc->cb) {
|
||||
// User (hint: channel_job_start) is responsible for calling
|
||||
// process_free().
|
||||
// proc_free().
|
||||
proc->cb(proc, proc->status, proc->data);
|
||||
} else {
|
||||
process_free(proc);
|
||||
proc_free(proc);
|
||||
}
|
||||
}
|
||||
|
||||
static void decref(Process *proc)
|
||||
static void decref(Proc *proc)
|
||||
{
|
||||
if (--proc->refcount != 0) {
|
||||
return;
|
||||
@ -303,13 +303,13 @@ static void decref(Process *proc)
|
||||
}
|
||||
assert(node);
|
||||
kl_shift_at(WatcherPtr, loop->children, node);
|
||||
CREATE_EVENT(proc->events, process_close_event, proc);
|
||||
CREATE_EVENT(proc->events, proc_close_event, proc);
|
||||
}
|
||||
|
||||
static void process_close(Process *proc)
|
||||
static void proc_close(Proc *proc)
|
||||
FUNC_ATTR_NONNULL_ARG(1)
|
||||
{
|
||||
if (process_is_tearing_down && (proc->detach || proc->type == kProcessTypePty)
|
||||
if (proc_is_tearing_down && (proc->detach || proc->type == kProcTypePty)
|
||||
&& proc->closed) {
|
||||
// If a detached/pty process dies while tearing down it might get closed
|
||||
// twice.
|
||||
@ -319,17 +319,17 @@ static void process_close(Process *proc)
|
||||
proc->closed = true;
|
||||
|
||||
if (proc->detach) {
|
||||
if (proc->type == kProcessTypeUv) {
|
||||
uv_unref((uv_handle_t *)&(((LibuvProcess *)proc)->uv));
|
||||
if (proc->type == kProcTypeUv) {
|
||||
uv_unref((uv_handle_t *)&(((LibuvProc *)proc)->uv));
|
||||
}
|
||||
}
|
||||
|
||||
switch (proc->type) {
|
||||
case kProcessTypeUv:
|
||||
libuv_process_close((LibuvProcess *)proc);
|
||||
case kProcTypeUv:
|
||||
libuv_proc_close((LibuvProc *)proc);
|
||||
break;
|
||||
case kProcessTypePty:
|
||||
pty_process_close((PtyProcess *)proc);
|
||||
case kProcTypePty:
|
||||
pty_proc_close((PtyProc *)proc);
|
||||
break;
|
||||
}
|
||||
}
|
||||
@ -338,7 +338,7 @@ static void process_close(Process *proc)
|
||||
///
|
||||
/// @param proc Process, for which an output stream should be flushed.
|
||||
/// @param stream Stream to flush.
|
||||
static void flush_stream(Process *proc, RStream *stream)
|
||||
static void flush_stream(Proc *proc, RStream *stream)
|
||||
FUNC_ATTR_NONNULL_ARG(1)
|
||||
{
|
||||
if (!stream || stream->s.closed) {
|
||||
@ -382,16 +382,16 @@ static void flush_stream(Process *proc, RStream *stream)
|
||||
}
|
||||
}
|
||||
|
||||
static void process_close_handles(void **argv)
|
||||
static void proc_close_handles(void **argv)
|
||||
{
|
||||
Process *proc = argv[0];
|
||||
Proc *proc = argv[0];
|
||||
|
||||
exit_need_delay++;
|
||||
flush_stream(proc, &proc->out);
|
||||
flush_stream(proc, &proc->err);
|
||||
|
||||
process_close_streams(proc);
|
||||
process_close(proc);
|
||||
proc_close_streams(proc);
|
||||
proc_close(proc);
|
||||
exit_need_delay--;
|
||||
}
|
||||
|
||||
@ -426,7 +426,7 @@ void exit_from_channel(int status)
|
||||
multiqueue_put(main_loop.fast_events, exit_event, (void *)(intptr_t)status);
|
||||
}
|
||||
|
||||
static void on_process_exit(Process *proc)
|
||||
static void on_proc_exit(Proc *proc)
|
||||
{
|
||||
Loop *loop = proc->loop;
|
||||
ILOG("exited: pid=%d status=%d stoptime=%" PRIu64, proc->pid, proc->status,
|
||||
@ -439,13 +439,13 @@ static void on_process_exit(Process *proc)
|
||||
// Process has terminated, but there could still be data to be read from the
|
||||
// OS. We are still in the libuv loop, so we cannot call code that polls for
|
||||
// more data directly. Instead delay the reading after the libuv loop by
|
||||
// queueing process_close_handles() as an event.
|
||||
// queueing proc_close_handles() as an event.
|
||||
MultiQueue *queue = proc->events ? proc->events : loop->events;
|
||||
CREATE_EVENT(queue, process_close_handles, proc);
|
||||
CREATE_EVENT(queue, proc_close_handles, proc);
|
||||
}
|
||||
|
||||
static void on_process_stream_close(Stream *stream, void *data)
|
||||
static void on_proc_stream_close(Stream *stream, void *data)
|
||||
{
|
||||
Process *proc = data;
|
||||
Proc *proc = data;
|
||||
decref(proc);
|
||||
}
|
@ -6,9 +6,9 @@
|
||||
#include "nvim/event/defs.h" // IWYU pragma: keep
|
||||
#include "nvim/types_defs.h"
|
||||
|
||||
static inline Process process_init(Loop *loop, ProcessType type, void *data)
|
||||
static inline Proc proc_init(Loop *loop, ProcType type, void *data)
|
||||
{
|
||||
return (Process) {
|
||||
return (Proc) {
|
||||
.type = type,
|
||||
.data = data,
|
||||
.loop = loop,
|
||||
@ -33,17 +33,17 @@ static inline Process process_init(Loop *loop, ProcessType type, void *data)
|
||||
}
|
||||
|
||||
/// Get the path to the executable of the process.
|
||||
static inline const char *process_get_exepath(Process *proc)
|
||||
static inline const char *proc_get_exepath(Proc *proc)
|
||||
{
|
||||
return proc->exepath != NULL ? proc->exepath : proc->argv[0];
|
||||
}
|
||||
|
||||
static inline bool process_is_stopped(Process *proc)
|
||||
static inline bool proc_is_stopped(Proc *proc)
|
||||
{
|
||||
bool exited = (proc->status >= 0);
|
||||
return exited || (proc->stopped_time != 0);
|
||||
}
|
||||
|
||||
#ifdef INCLUDE_GENERATED_DECLARATIONS
|
||||
# include "event/process.h.generated.h"
|
||||
# include "event/proc.h.generated.h"
|
||||
#endif
|
@ -43,7 +43,7 @@
|
||||
#include "nvim/eval/userfunc.h"
|
||||
#include "nvim/event/loop.h"
|
||||
#include "nvim/event/multiqueue.h"
|
||||
#include "nvim/event/process.h"
|
||||
#include "nvim/event/proc.h"
|
||||
#include "nvim/event/stream.h"
|
||||
#include "nvim/ex_cmds.h"
|
||||
#include "nvim/ex_docmd.h"
|
||||
@ -174,7 +174,7 @@ bool event_teardown(void)
|
||||
loop_poll_events(&main_loop, 0); // Drain thread_events, fast_events.
|
||||
input_stop();
|
||||
channel_teardown();
|
||||
process_teardown(&main_loop);
|
||||
proc_teardown(&main_loop);
|
||||
timer_teardown();
|
||||
server_teardown();
|
||||
signal_teardown();
|
||||
@ -2207,7 +2207,7 @@ static void usage(void)
|
||||
printf(_(" --headless Don't start a user interface\n"));
|
||||
printf(_(" --listen <address> Serve RPC API from this address\n"));
|
||||
printf(_(" --remote[-subcommand] Execute commands remotely on a server\n"));
|
||||
printf(_(" --server <address> Specify RPC server to send commands to\n"));
|
||||
printf(_(" --server <address> Connect to this Nvim server\n"));
|
||||
printf(_(" --startuptime <file> Write startup timing messages to <file>\n"));
|
||||
printf(_("\nSee \":help startup-options\" for all options.\n"));
|
||||
}
|
||||
|
@ -84,7 +84,7 @@
|
||||
#include "nvim/os/input.h"
|
||||
#include "nvim/os/os.h"
|
||||
#include "nvim/os/os_defs.h"
|
||||
#include "nvim/os/process.h"
|
||||
#include "nvim/os/proc.h"
|
||||
#include "nvim/os/time.h"
|
||||
#include "nvim/os/time_defs.h"
|
||||
#include "nvim/path.h"
|
||||
@ -743,7 +743,7 @@ static void add_b0_fenc(ZeroBlock *b0p, buf_T *buf)
|
||||
/// @param swap_fname Name of the swapfile. If it's from before a reboot, the result is 0.
|
||||
///
|
||||
/// @return PID, or 0 if process is not running or the swapfile is from before a reboot.
|
||||
static int swapfile_process_running(const ZeroBlock *b0p, const char *swap_fname)
|
||||
static int swapfile_proc_running(const ZeroBlock *b0p, const char *swap_fname)
|
||||
{
|
||||
FileInfo st;
|
||||
double uptime;
|
||||
@ -1214,7 +1214,7 @@ void ml_recover(bool checkext)
|
||||
msg(_("Recovery completed. Buffer contents equals file contents."), 0);
|
||||
}
|
||||
msg_puts(_("\nYou may want to delete the .swp file now."));
|
||||
if (swapfile_process_running(b0p, fname_used)) {
|
||||
if (swapfile_proc_running(b0p, fname_used)) {
|
||||
// Warn there could be an active Vim on the same file, the user may
|
||||
// want to kill it.
|
||||
msg_puts(_("\nNote: process STILL RUNNING: "));
|
||||
@ -1462,7 +1462,7 @@ char *make_percent_swname(char *dir, char *dir_end, const char *name)
|
||||
}
|
||||
|
||||
// PID of swapfile owner, or zero if not running.
|
||||
static int process_running;
|
||||
static int proc_running;
|
||||
|
||||
/// For Vimscript "swapinfo()".
|
||||
///
|
||||
@ -1488,7 +1488,7 @@ void swapfile_dict(const char *fname, dict_T *d)
|
||||
tv_dict_add_str_len(d, S_LEN("fname"), b0.b0_fname,
|
||||
B0_FNAME_SIZE_ORG);
|
||||
|
||||
tv_dict_add_nr(d, S_LEN("pid"), swapfile_process_running(&b0, fname));
|
||||
tv_dict_add_nr(d, S_LEN("pid"), swapfile_proc_running(&b0, fname));
|
||||
tv_dict_add_nr(d, S_LEN("mtime"), char_to_long(b0.b0_mtime));
|
||||
tv_dict_add_nr(d, S_LEN("dirty"), b0.b0_dirty ? 1 : 0);
|
||||
tv_dict_add_nr(d, S_LEN("inode"), char_to_long(b0.b0_ino));
|
||||
@ -1572,7 +1572,7 @@ static time_t swapfile_info(char *fname)
|
||||
if (char_to_long(b0.b0_pid) != 0) {
|
||||
msg_puts(_("\n process ID: "));
|
||||
msg_outnum((int)char_to_long(b0.b0_pid));
|
||||
if ((process_running = swapfile_process_running(&b0, fname))) {
|
||||
if ((proc_running = swapfile_proc_running(&b0, fname))) {
|
||||
msg_puts(_(" (STILL RUNNING)"));
|
||||
}
|
||||
}
|
||||
@ -1640,7 +1640,7 @@ static bool swapfile_unchanged(char *fname)
|
||||
}
|
||||
|
||||
// process must be known and not running.
|
||||
if (char_to_long(b0.b0_pid) == 0 || swapfile_process_running(&b0, fname)) {
|
||||
if (char_to_long(b0.b0_pid) == 0 || swapfile_proc_running(&b0, fname)) {
|
||||
ret = false;
|
||||
}
|
||||
|
||||
@ -3399,7 +3399,7 @@ static char *findswapname(buf_T *buf, char **dirp, char *old_fname, bool *found_
|
||||
fd = os_open(fname, O_RDONLY, 0);
|
||||
if (fd >= 0) {
|
||||
if (read_eintr(fd, &b0, sizeof(b0)) == sizeof(b0)) {
|
||||
process_running = swapfile_process_running(&b0, fname);
|
||||
proc_running = swapfile_proc_running(&b0, fname);
|
||||
|
||||
// If the swapfile has the same directory as the
|
||||
// buffer don't compare the directory names, they can
|
||||
@ -3459,7 +3459,7 @@ static char *findswapname(buf_T *buf, char **dirp, char *old_fname, bool *found_
|
||||
choice = SEA_CHOICE_READONLY;
|
||||
}
|
||||
|
||||
process_running = 0; // Set by attention_message..swapfile_info.
|
||||
proc_running = 0; // Set by attention_message..swapfile_info.
|
||||
if (choice == SEA_CHOICE_NONE) {
|
||||
// Show info about the existing swapfile.
|
||||
attention_message(buf, fname);
|
||||
@ -3491,12 +3491,12 @@ static char *findswapname(buf_T *buf, char **dirp, char *old_fname, bool *found_
|
||||
= do_dialog(VIM_WARNING,
|
||||
_("VIM - ATTENTION"),
|
||||
name,
|
||||
process_running
|
||||
proc_running
|
||||
? _("&Open Read-Only\n&Edit anyway\n&Recover\n&Quit\n&Abort")
|
||||
: _("&Open Read-Only\n&Edit anyway\n&Recover\n&Delete it\n&Quit\n&Abort"),
|
||||
1, NULL, false);
|
||||
|
||||
if (process_running && dialog_result >= 4) {
|
||||
if (proc_running && dialog_result >= 4) {
|
||||
// compensate for missing "Delete it" button
|
||||
dialog_result++;
|
||||
}
|
||||
|
@ -14,7 +14,7 @@
|
||||
#include "nvim/event/defs.h"
|
||||
#include "nvim/event/loop.h"
|
||||
#include "nvim/event/multiqueue.h"
|
||||
#include "nvim/event/process.h"
|
||||
#include "nvim/event/proc.h"
|
||||
#include "nvim/event/rstream.h"
|
||||
#include "nvim/event/wstream.h"
|
||||
#include "nvim/globals.h"
|
||||
|
@ -344,7 +344,7 @@ char *os_getenvname_at_index(size_t index)
|
||||
#endif
|
||||
}
|
||||
|
||||
/// Get the process ID of the Neovim process.
|
||||
/// Get the process ID of the Nvim process.
|
||||
///
|
||||
/// @return the process ID.
|
||||
int64_t os_get_pid(void)
|
||||
|
@ -37,24 +37,24 @@
|
||||
|
||||
#include "nvim/log.h"
|
||||
#include "nvim/memory.h"
|
||||
#include "nvim/os/process.h"
|
||||
#include "nvim/os/proc.h"
|
||||
|
||||
#ifdef MSWIN
|
||||
# include "nvim/api/private/helpers.h"
|
||||
#endif
|
||||
|
||||
#ifdef INCLUDE_GENERATED_DECLARATIONS
|
||||
# include "os/process.c.generated.h"
|
||||
# include "os/proc.c.generated.h"
|
||||
#endif
|
||||
|
||||
#ifdef MSWIN
|
||||
static bool os_proc_tree_kill_rec(HANDLE process, int sig)
|
||||
static bool os_proc_tree_kill_rec(HANDLE proc, int sig)
|
||||
{
|
||||
if (process == NULL) {
|
||||
if (proc == NULL) {
|
||||
return false;
|
||||
}
|
||||
PROCESSENTRY32 pe;
|
||||
DWORD pid = GetProcessId(process);
|
||||
DWORD pid = GetProcessId(proc);
|
||||
|
||||
if (pid != 0) {
|
||||
HANDLE h = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
|
||||
@ -77,7 +77,7 @@ static bool os_proc_tree_kill_rec(HANDLE process, int sig)
|
||||
}
|
||||
|
||||
theend:
|
||||
return (bool)TerminateProcess(process, (unsigned)sig);
|
||||
return (bool)TerminateProcess(proc, (unsigned)sig);
|
||||
}
|
||||
/// Kills process `pid` and its descendants recursively.
|
||||
bool os_proc_tree_kill(int pid, int sig)
|
@ -7,5 +7,5 @@
|
||||
#endif
|
||||
|
||||
#ifdef INCLUDE_GENERATED_DECLARATIONS
|
||||
# include "os/process.h.generated.h"
|
||||
# include "os/proc.h.generated.h"
|
||||
#endif
|
@ -143,7 +143,7 @@ finished:
|
||||
return conpty_object;
|
||||
}
|
||||
|
||||
bool os_conpty_spawn(conpty_t *conpty_object, HANDLE *process_handle, wchar_t *name,
|
||||
bool os_conpty_spawn(conpty_t *conpty_object, HANDLE *proc_handle, wchar_t *name,
|
||||
wchar_t *cmd_line, wchar_t *cwd, wchar_t *env)
|
||||
{
|
||||
PROCESS_INFORMATION pi = { 0 };
|
||||
@ -159,7 +159,7 @@ bool os_conpty_spawn(conpty_t *conpty_object, HANDLE *process_handle, wchar_t *n
|
||||
&pi)) {
|
||||
return false;
|
||||
}
|
||||
*process_handle = pi.hProcess;
|
||||
*proc_handle = pi.hProcess;
|
||||
return true;
|
||||
}
|
||||
|
||||
|
7
src/nvim/os/pty_proc.h
Normal file
7
src/nvim/os/pty_proc.h
Normal file
@ -0,0 +1,7 @@
|
||||
#pragma once
|
||||
|
||||
#ifdef MSWIN
|
||||
# include "nvim/os/pty_proc_win.h"
|
||||
#else
|
||||
# include "nvim/os/pty_proc_unix.h"
|
||||
#endif
|
@ -34,16 +34,16 @@
|
||||
#include "nvim/eval/typval.h"
|
||||
#include "nvim/event/defs.h"
|
||||
#include "nvim/event/loop.h"
|
||||
#include "nvim/event/process.h"
|
||||
#include "nvim/event/proc.h"
|
||||
#include "nvim/log.h"
|
||||
#include "nvim/os/fs.h"
|
||||
#include "nvim/os/os_defs.h"
|
||||
#include "nvim/os/pty_process.h"
|
||||
#include "nvim/os/pty_process_unix.h"
|
||||
#include "nvim/os/pty_proc.h"
|
||||
#include "nvim/os/pty_proc_unix.h"
|
||||
#include "nvim/types_defs.h"
|
||||
|
||||
#ifdef INCLUDE_GENERATED_DECLARATIONS
|
||||
# include "os/pty_process_unix.c.generated.h"
|
||||
# include "os/pty_proc_unix.c.generated.h"
|
||||
#endif
|
||||
|
||||
#if defined(__sun) && !defined(HAVE_FORKPTY)
|
||||
@ -158,7 +158,7 @@ static pid_t forkpty(int *amaster, char *name, struct termios *termp, struct win
|
||||
#endif
|
||||
|
||||
/// @returns zero on success, or negative error code
|
||||
int pty_process_spawn(PtyProcess *ptyproc)
|
||||
int pty_proc_spawn(PtyProc *ptyproc)
|
||||
FUNC_ATTR_NONNULL_ALL
|
||||
{
|
||||
// termios initialized at first use
|
||||
@ -168,7 +168,7 @@ int pty_process_spawn(PtyProcess *ptyproc)
|
||||
}
|
||||
|
||||
int status = 0; // zero or negative error code (libuv convention)
|
||||
Process *proc = (Process *)ptyproc;
|
||||
Proc *proc = (Proc *)ptyproc;
|
||||
assert(proc->err.s.closed);
|
||||
uv_signal_start(&proc->loop->children_watcher, chld_handler, SIGCHLD);
|
||||
ptyproc->winsize = (struct winsize){ ptyproc->height, ptyproc->width, 0, 0 };
|
||||
@ -224,29 +224,29 @@ error:
|
||||
return status;
|
||||
}
|
||||
|
||||
const char *pty_process_tty_name(PtyProcess *ptyproc)
|
||||
const char *pty_proc_tty_name(PtyProc *ptyproc)
|
||||
{
|
||||
return ptsname(ptyproc->tty_fd);
|
||||
}
|
||||
|
||||
void pty_process_resize(PtyProcess *ptyproc, uint16_t width, uint16_t height)
|
||||
void pty_proc_resize(PtyProc *ptyproc, uint16_t width, uint16_t height)
|
||||
FUNC_ATTR_NONNULL_ALL
|
||||
{
|
||||
ptyproc->winsize = (struct winsize){ height, width, 0, 0 };
|
||||
ioctl(ptyproc->tty_fd, TIOCSWINSZ, &ptyproc->winsize);
|
||||
}
|
||||
|
||||
void pty_process_close(PtyProcess *ptyproc)
|
||||
void pty_proc_close(PtyProc *ptyproc)
|
||||
FUNC_ATTR_NONNULL_ALL
|
||||
{
|
||||
pty_process_close_master(ptyproc);
|
||||
Process *proc = (Process *)ptyproc;
|
||||
pty_proc_close_master(ptyproc);
|
||||
Proc *proc = (Proc *)ptyproc;
|
||||
if (proc->internal_close_cb) {
|
||||
proc->internal_close_cb(proc);
|
||||
}
|
||||
}
|
||||
|
||||
void pty_process_close_master(PtyProcess *ptyproc) FUNC_ATTR_NONNULL_ALL
|
||||
void pty_proc_close_master(PtyProc *ptyproc) FUNC_ATTR_NONNULL_ALL
|
||||
{
|
||||
if (ptyproc->tty_fd >= 0) {
|
||||
close(ptyproc->tty_fd);
|
||||
@ -254,12 +254,12 @@ void pty_process_close_master(PtyProcess *ptyproc) FUNC_ATTR_NONNULL_ALL
|
||||
}
|
||||
}
|
||||
|
||||
void pty_process_teardown(Loop *loop)
|
||||
void pty_proc_teardown(Loop *loop)
|
||||
{
|
||||
uv_signal_stop(&loop->children_watcher);
|
||||
}
|
||||
|
||||
static void init_child(PtyProcess *ptyproc)
|
||||
static void init_child(PtyProc *ptyproc)
|
||||
FUNC_ATTR_NONNULL_ALL
|
||||
{
|
||||
#if defined(HAVE__NSGETENVIRON)
|
||||
@ -277,13 +277,13 @@ static void init_child(PtyProcess *ptyproc)
|
||||
signal(SIGTERM, SIG_DFL);
|
||||
signal(SIGALRM, SIG_DFL);
|
||||
|
||||
Process *proc = (Process *)ptyproc;
|
||||
Proc *proc = (Proc *)ptyproc;
|
||||
if (proc->cwd && os_chdir(proc->cwd) != 0) {
|
||||
ELOG("chdir(%s) failed: %s", proc->cwd, strerror(errno));
|
||||
return;
|
||||
}
|
||||
|
||||
const char *prog = process_get_exepath(proc);
|
||||
const char *prog = proc_get_exepath(proc);
|
||||
|
||||
assert(proc->env);
|
||||
environ = tv_dict_to_env(proc->env);
|
||||
@ -388,7 +388,7 @@ static void chld_handler(uv_signal_t *handle, int signum)
|
||||
Loop *loop = handle->loop->data;
|
||||
|
||||
kl_iter(WatcherPtr, loop->children, current) {
|
||||
Process *proc = (*current)->data;
|
||||
Proc *proc = (*current)->data;
|
||||
do {
|
||||
pid = waitpid(proc->pid, &stat, WNOHANG);
|
||||
} while (pid < 0 && errno == EINTR);
|
||||
@ -406,10 +406,10 @@ static void chld_handler(uv_signal_t *handle, int signum)
|
||||
}
|
||||
}
|
||||
|
||||
PtyProcess pty_process_init(Loop *loop, void *data)
|
||||
PtyProc pty_proc_init(Loop *loop, void *data)
|
||||
{
|
||||
PtyProcess rv;
|
||||
rv.process = process_init(loop, kProcessTypePty, data);
|
||||
PtyProc rv;
|
||||
rv.proc = proc_init(loop, kProcTypePty, data);
|
||||
rv.width = 80;
|
||||
rv.height = 24;
|
||||
rv.tty_fd = -1;
|
@ -1,5 +1,5 @@
|
||||
#pragma once
|
||||
// IWYU pragma: private, include "nvim/os/pty_process.h"
|
||||
// IWYU pragma: private, include "nvim/os/pty_proc.h"
|
||||
|
||||
#include <stdint.h>
|
||||
#include <sys/ioctl.h>
|
||||
@ -7,12 +7,12 @@
|
||||
#include "nvim/event/defs.h"
|
||||
|
||||
typedef struct {
|
||||
Process process;
|
||||
Proc proc;
|
||||
uint16_t width, height;
|
||||
struct winsize winsize;
|
||||
int tty_fd;
|
||||
} PtyProcess;
|
||||
} PtyProc;
|
||||
|
||||
#ifdef INCLUDE_GENERATED_DECLARATIONS
|
||||
# include "os/pty_process_unix.h.generated.h"
|
||||
# include "os/pty_proc_unix.h.generated.h"
|
||||
#endif
|
@ -10,20 +10,20 @@
|
||||
#include "nvim/memory.h"
|
||||
#include "nvim/os/os.h"
|
||||
#include "nvim/os/pty_conpty_win.h"
|
||||
#include "nvim/os/pty_process_win.h"
|
||||
#include "nvim/os/pty_proc_win.h"
|
||||
|
||||
#ifdef INCLUDE_GENERATED_DECLARATIONS
|
||||
# include "os/pty_process_win.c.generated.h"
|
||||
# include "os/pty_proc_win.c.generated.h"
|
||||
#endif
|
||||
|
||||
static void CALLBACK pty_process_finish1(void *context, BOOLEAN unused)
|
||||
static void CALLBACK pty_proc_finish1(void *context, BOOLEAN unused)
|
||||
FUNC_ATTR_NONNULL_ALL
|
||||
{
|
||||
PtyProcess *ptyproc = (PtyProcess *)context;
|
||||
Process *proc = (Process *)ptyproc;
|
||||
PtyProc *ptyproc = (PtyProc *)context;
|
||||
Proc *proc = (Proc *)ptyproc;
|
||||
|
||||
os_conpty_free(ptyproc->conpty);
|
||||
// NB: pty_process_finish1() is called on a separate thread,
|
||||
// NB: pty_proc_finish1() is called on a separate thread,
|
||||
// but the timer only works properly if it's started by the main thread.
|
||||
loop_schedule_fast(proc->loop, event_create(start_wait_eof_timer, ptyproc));
|
||||
}
|
||||
@ -31,7 +31,7 @@ static void CALLBACK pty_process_finish1(void *context, BOOLEAN unused)
|
||||
static void start_wait_eof_timer(void **argv)
|
||||
FUNC_ATTR_NONNULL_ALL
|
||||
{
|
||||
PtyProcess *ptyproc = (PtyProcess *)argv[0];
|
||||
PtyProc *ptyproc = (PtyProc *)argv[0];
|
||||
|
||||
if (ptyproc->finish_wait != NULL) {
|
||||
uv_timer_start(&ptyproc->wait_eof_timer, wait_eof_timer_cb, 200, 200);
|
||||
@ -39,15 +39,15 @@ static void start_wait_eof_timer(void **argv)
|
||||
}
|
||||
|
||||
/// @returns zero on success, or negative error code.
|
||||
int pty_process_spawn(PtyProcess *ptyproc)
|
||||
int pty_proc_spawn(PtyProc *ptyproc)
|
||||
FUNC_ATTR_NONNULL_ALL
|
||||
{
|
||||
Process *proc = (Process *)ptyproc;
|
||||
Proc *proc = (Proc *)ptyproc;
|
||||
int status = 0;
|
||||
conpty_t *conpty_object = NULL;
|
||||
char *in_name = NULL;
|
||||
char *out_name = NULL;
|
||||
HANDLE process_handle = NULL;
|
||||
HANDLE proc_handle = NULL;
|
||||
uv_connect_t *in_req = NULL;
|
||||
uv_connect_t *out_req = NULL;
|
||||
wchar_t *cmd_line = NULL;
|
||||
@ -69,7 +69,7 @@ int pty_process_spawn(PtyProcess *ptyproc)
|
||||
uv_pipe_connect(in_req,
|
||||
&proc->in.uv.pipe,
|
||||
in_name,
|
||||
pty_process_connect_cb);
|
||||
pty_proc_connect_cb);
|
||||
}
|
||||
|
||||
if (!proc->out.s.closed) {
|
||||
@ -77,7 +77,7 @@ int pty_process_spawn(PtyProcess *ptyproc)
|
||||
uv_pipe_connect(out_req,
|
||||
&proc->out.s.uv.pipe,
|
||||
out_name,
|
||||
pty_process_connect_cb);
|
||||
pty_proc_connect_cb);
|
||||
}
|
||||
|
||||
if (proc->cwd != NULL) {
|
||||
@ -105,7 +105,7 @@ int pty_process_spawn(PtyProcess *ptyproc)
|
||||
}
|
||||
|
||||
if (!os_conpty_spawn(conpty_object,
|
||||
&process_handle,
|
||||
&proc_handle,
|
||||
NULL,
|
||||
cmd_line,
|
||||
cwd,
|
||||
@ -114,42 +114,42 @@ int pty_process_spawn(PtyProcess *ptyproc)
|
||||
status = (int)GetLastError();
|
||||
goto cleanup;
|
||||
}
|
||||
proc->pid = (int)GetProcessId(process_handle);
|
||||
proc->pid = (int)GetProcessId(proc_handle);
|
||||
|
||||
uv_timer_init(&proc->loop->uv, &ptyproc->wait_eof_timer);
|
||||
ptyproc->wait_eof_timer.data = (void *)ptyproc;
|
||||
if (!RegisterWaitForSingleObject(&ptyproc->finish_wait,
|
||||
process_handle,
|
||||
pty_process_finish1,
|
||||
proc_handle,
|
||||
pty_proc_finish1,
|
||||
ptyproc,
|
||||
INFINITE,
|
||||
WT_EXECUTEDEFAULT | WT_EXECUTEONLYONCE)) {
|
||||
abort();
|
||||
}
|
||||
|
||||
// Wait until pty_process_connect_cb is called.
|
||||
// Wait until pty_proc_connect_cb is called.
|
||||
while ((in_req != NULL && in_req->handle != NULL)
|
||||
|| (out_req != NULL && out_req->handle != NULL)) {
|
||||
uv_run(&proc->loop->uv, UV_RUN_ONCE);
|
||||
}
|
||||
|
||||
ptyproc->conpty = conpty_object;
|
||||
ptyproc->process_handle = process_handle;
|
||||
ptyproc->proc_handle = proc_handle;
|
||||
conpty_object = NULL;
|
||||
process_handle = NULL;
|
||||
proc_handle = NULL;
|
||||
|
||||
cleanup:
|
||||
if (status) {
|
||||
// In the case of an error of MultiByteToWideChar or CreateProcessW.
|
||||
ELOG("pty_process_spawn(%s): %s: error code: %d",
|
||||
ELOG("pty_proc_spawn(%s): %s: error code: %d",
|
||||
proc->argv[0], emsg, status);
|
||||
status = os_translate_sys_error(status);
|
||||
}
|
||||
os_conpty_free(conpty_object);
|
||||
xfree(in_name);
|
||||
xfree(out_name);
|
||||
if (process_handle != NULL) {
|
||||
CloseHandle(process_handle);
|
||||
if (proc_handle != NULL) {
|
||||
CloseHandle(proc_handle);
|
||||
}
|
||||
xfree(in_req);
|
||||
xfree(out_req);
|
||||
@ -159,32 +159,32 @@ cleanup:
|
||||
return status;
|
||||
}
|
||||
|
||||
const char *pty_process_tty_name(PtyProcess *ptyproc)
|
||||
const char *pty_proc_tty_name(PtyProc *ptyproc)
|
||||
{
|
||||
return "?";
|
||||
}
|
||||
|
||||
void pty_process_resize(PtyProcess *ptyproc, uint16_t width, uint16_t height)
|
||||
void pty_proc_resize(PtyProc *ptyproc, uint16_t width, uint16_t height)
|
||||
FUNC_ATTR_NONNULL_ALL
|
||||
{
|
||||
os_conpty_set_size(ptyproc->conpty, width, height);
|
||||
}
|
||||
|
||||
void pty_process_close(PtyProcess *ptyproc)
|
||||
void pty_proc_close(PtyProc *ptyproc)
|
||||
FUNC_ATTR_NONNULL_ALL
|
||||
{
|
||||
Process *proc = (Process *)ptyproc;
|
||||
Proc *proc = (Proc *)ptyproc;
|
||||
|
||||
pty_process_close_master(ptyproc);
|
||||
pty_proc_close_master(ptyproc);
|
||||
|
||||
if (ptyproc->finish_wait != NULL) {
|
||||
UnregisterWaitEx(ptyproc->finish_wait, NULL);
|
||||
ptyproc->finish_wait = NULL;
|
||||
uv_close((uv_handle_t *)&ptyproc->wait_eof_timer, NULL);
|
||||
}
|
||||
if (ptyproc->process_handle != NULL) {
|
||||
CloseHandle(ptyproc->process_handle);
|
||||
ptyproc->process_handle = NULL;
|
||||
if (ptyproc->proc_handle != NULL) {
|
||||
CloseHandle(ptyproc->proc_handle);
|
||||
ptyproc->proc_handle = NULL;
|
||||
}
|
||||
|
||||
if (proc->internal_close_cb) {
|
||||
@ -192,17 +192,17 @@ void pty_process_close(PtyProcess *ptyproc)
|
||||
}
|
||||
}
|
||||
|
||||
void pty_process_close_master(PtyProcess *ptyproc)
|
||||
void pty_proc_close_master(PtyProc *ptyproc)
|
||||
FUNC_ATTR_NONNULL_ALL
|
||||
{
|
||||
}
|
||||
|
||||
void pty_process_teardown(Loop *loop)
|
||||
void pty_proc_teardown(Loop *loop)
|
||||
FUNC_ATTR_NONNULL_ALL
|
||||
{
|
||||
}
|
||||
|
||||
static void pty_process_connect_cb(uv_connect_t *req, int status)
|
||||
static void pty_proc_connect_cb(uv_connect_t *req, int status)
|
||||
FUNC_ATTR_NONNULL_ALL
|
||||
{
|
||||
assert(status == 0);
|
||||
@ -212,23 +212,23 @@ static void pty_process_connect_cb(uv_connect_t *req, int status)
|
||||
static void wait_eof_timer_cb(uv_timer_t *wait_eof_timer)
|
||||
FUNC_ATTR_NONNULL_ALL
|
||||
{
|
||||
PtyProcess *ptyproc = wait_eof_timer->data;
|
||||
Process *proc = (Process *)ptyproc;
|
||||
PtyProc *ptyproc = wait_eof_timer->data;
|
||||
Proc *proc = (Proc *)ptyproc;
|
||||
|
||||
assert(ptyproc->finish_wait != NULL);
|
||||
if (proc->out.s.closed || proc->out.did_eof || !uv_is_readable(proc->out.s.uvstream)) {
|
||||
uv_timer_stop(&ptyproc->wait_eof_timer);
|
||||
pty_process_finish2(ptyproc);
|
||||
pty_proc_finish2(ptyproc);
|
||||
}
|
||||
}
|
||||
|
||||
static void pty_process_finish2(PtyProcess *ptyproc)
|
||||
static void pty_proc_finish2(PtyProc *ptyproc)
|
||||
FUNC_ATTR_NONNULL_ALL
|
||||
{
|
||||
Process *proc = (Process *)ptyproc;
|
||||
Proc *proc = (Proc *)ptyproc;
|
||||
|
||||
DWORD exit_code = 0;
|
||||
GetExitCodeProcess(ptyproc->process_handle, &exit_code);
|
||||
GetExitCodeProcess(ptyproc->proc_handle, &exit_code);
|
||||
proc->status = proc->exit_signal ? 128 + proc->exit_signal : (int)exit_code;
|
||||
|
||||
proc->internal_exit_cb(proc);
|
||||
@ -427,14 +427,14 @@ cleanup:
|
||||
return rc;
|
||||
}
|
||||
|
||||
PtyProcess pty_process_init(Loop *loop, void *data)
|
||||
PtyProc pty_proc_init(Loop *loop, void *data)
|
||||
{
|
||||
PtyProcess rv;
|
||||
rv.process = process_init(loop, kProcessTypePty, data);
|
||||
PtyProc rv;
|
||||
rv.proc = proc_init(loop, kProcTypePty, data);
|
||||
rv.width = 80;
|
||||
rv.height = 24;
|
||||
rv.conpty = NULL;
|
||||
rv.finish_wait = NULL;
|
||||
rv.process_handle = NULL;
|
||||
rv.proc_handle = NULL;
|
||||
return rv;
|
||||
}
|
@ -1,20 +1,20 @@
|
||||
#pragma once
|
||||
// IWYU pragma: private, include "nvim/os/pty_process.h"
|
||||
// IWYU pragma: private, include "nvim/os/pty_proc.h"
|
||||
|
||||
#include <uv.h>
|
||||
|
||||
#include "nvim/event/process.h"
|
||||
#include "nvim/event/proc.h"
|
||||
#include "nvim/lib/queue_defs.h"
|
||||
#include "nvim/os/pty_conpty_win.h"
|
||||
|
||||
typedef struct pty_process {
|
||||
Process process;
|
||||
Proc proc;
|
||||
uint16_t width, height;
|
||||
conpty_t *conpty;
|
||||
HANDLE finish_wait;
|
||||
HANDLE process_handle;
|
||||
HANDLE proc_handle;
|
||||
uv_timer_t wait_eof_timer;
|
||||
} PtyProcess;
|
||||
} PtyProc;
|
||||
|
||||
// Structure used by build_cmd_line()
|
||||
typedef struct arg_node {
|
||||
@ -23,5 +23,5 @@ typedef struct arg_node {
|
||||
} ArgNode;
|
||||
|
||||
#ifdef INCLUDE_GENERATED_DECLARATIONS
|
||||
# include "os/pty_process_win.h.generated.h"
|
||||
# include "os/pty_proc_win.h.generated.h"
|
||||
#endif
|
@ -1,7 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#ifdef MSWIN
|
||||
# include "nvim/os/pty_process_win.h"
|
||||
#else
|
||||
# include "nvim/os/pty_process_unix.h"
|
||||
#endif
|
@ -14,10 +14,10 @@
|
||||
#include "nvim/eval.h"
|
||||
#include "nvim/eval/typval_defs.h"
|
||||
#include "nvim/event/defs.h"
|
||||
#include "nvim/event/libuv_process.h"
|
||||
#include "nvim/event/libuv_proc.h"
|
||||
#include "nvim/event/loop.h"
|
||||
#include "nvim/event/multiqueue.h"
|
||||
#include "nvim/event/process.h"
|
||||
#include "nvim/event/proc.h"
|
||||
#include "nvim/event/rstream.h"
|
||||
#include "nvim/event/stream.h"
|
||||
#include "nvim/event/wstream.h"
|
||||
@ -872,12 +872,12 @@ static int do_os_system(char **argv, const char *input, size_t len, char **outpu
|
||||
char prog[MAXPATHL];
|
||||
xstrlcpy(prog, argv[0], MAXPATHL);
|
||||
|
||||
LibuvProcess uvproc = libuv_process_init(&main_loop, &buf);
|
||||
Process *proc = &uvproc.process;
|
||||
LibuvProc uvproc = libuv_proc_init(&main_loop, &buf);
|
||||
Proc *proc = &uvproc.proc;
|
||||
MultiQueue *events = multiqueue_new_child(main_loop.events);
|
||||
proc->events = events;
|
||||
proc->argv = argv;
|
||||
int status = process_spawn(proc, has_input, true, true);
|
||||
int status = proc_spawn(proc, has_input, true, true);
|
||||
if (status) {
|
||||
loop_poll_events(&main_loop, 0);
|
||||
// Failed, probably 'shell' is not executable.
|
||||
@ -910,7 +910,7 @@ static int do_os_system(char **argv, const char *input, size_t len, char **outpu
|
||||
|
||||
if (!wstream_write(&proc->in, input_buffer)) {
|
||||
// couldn't write, stop the process and tell the user about it
|
||||
process_stop(proc);
|
||||
proc_stop(proc);
|
||||
return -1;
|
||||
}
|
||||
// close the input stream after everything is written
|
||||
@ -927,7 +927,7 @@ static int do_os_system(char **argv, const char *input, size_t len, char **outpu
|
||||
msg_no_more = true;
|
||||
lines_left = -1;
|
||||
}
|
||||
int exitcode = process_wait(proc, -1, NULL);
|
||||
int exitcode = proc_wait(proc, -1, NULL);
|
||||
if (!got_int && out_data_decide_throttle(0)) {
|
||||
// Last chunk of output was skipped; display it now.
|
||||
out_data_ring(NULL, SIZE_MAX);
|
||||
|
@ -950,8 +950,8 @@ void time_msg(const char *mesg, const proftime_T *start)
|
||||
/// Initializes the `time_fd` stream for the --startuptime report.
|
||||
///
|
||||
/// @param fname startuptime report file path
|
||||
/// @param process_name name of the current Nvim process to write in the report.
|
||||
void time_init(const char *fname, const char *process_name)
|
||||
/// @param proc_name name of the current Nvim process to write in the report.
|
||||
void time_init(const char *fname, const char *proc_name)
|
||||
{
|
||||
const size_t bufsize = 8192; // Big enough for the entire --startuptime report.
|
||||
time_fd = fopen(fname, "a");
|
||||
@ -972,7 +972,7 @@ void time_init(const char *fname, const char *process_name)
|
||||
semsg("time_init: setvbuf failed: %d %s", r, uv_err_name(r));
|
||||
return;
|
||||
}
|
||||
fprintf(time_fd, "--- Startup times for process: %s ---\n", process_name);
|
||||
fprintf(time_fd, "--- Startup times for process: %s ---\n", proc_name);
|
||||
}
|
||||
|
||||
/// Flushes the startuptimes to disk for the current process
|
||||
|
@ -6875,7 +6875,8 @@ bool set_ref_in_quickfix(int copyID)
|
||||
// In a location list window and none of the other windows is
|
||||
// referring to this location list. Mark the location list
|
||||
// context as still in use.
|
||||
if (mark_quickfix_ctx(win->w_llist_ref, copyID)) {
|
||||
if (mark_quickfix_ctx(win->w_llist_ref, copyID)
|
||||
|| mark_quickfix_user_data(win->w_llist_ref, copyID)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
@ -103,7 +103,7 @@ Debugging tests
|
||||
DBG 2022-06-15T18:37:45.227 T57.58016.0/c UI: stop
|
||||
INF 2022-06-15T18:37:45.227 T57.58016.0/c os_exit:595: Nvim exit: 0
|
||||
DBG 2022-06-15T18:37:45.229 T57.58016.0 read_cb:118: closing Stream (0x7fd5d700ea18): EOF (end of file)
|
||||
INF 2022-06-15T18:37:45.229 T57.58016.0 on_process_exit:400: exited: pid=58017 status=0 stoptime=0
|
||||
INF 2022-06-15T18:37:45.229 T57.58016.0 on_proc_exit:400: exited: pid=58017 status=0 stoptime=0
|
||||
```
|
||||
- You can set `$GDB` to [run functional tests under gdbserver](https://github.com/neovim/neovim/pull/1527):
|
||||
|
||||
|
@ -114,6 +114,7 @@ function Session:request(method, ...)
|
||||
return true, result
|
||||
end
|
||||
|
||||
--- Runs the event loop.
|
||||
function Session:run(request_cb, notification_cb, setup_cb, timeout)
|
||||
local function on_request(method, args, response)
|
||||
coroutine_exec(request_cb, method, args, function(status, result, flag)
|
||||
|
@ -1,6 +1,6 @@
|
||||
local t = require('test.testutil')
|
||||
local n = require('test.functional.testnvim')()
|
||||
local tt = require('test.functional.terminal.testutil')
|
||||
local tt = require('test.functional.testterm')
|
||||
|
||||
local clear = n.clear
|
||||
local feed_command = n.feed_command
|
||||
|
@ -1,6 +1,6 @@
|
||||
local t = require('test.testutil')
|
||||
local n = require('test.functional.testnvim')()
|
||||
local tt = require('test.functional.terminal.testutil')
|
||||
local tt = require('test.functional.testterm')
|
||||
local uv = vim.uv
|
||||
|
||||
local clear, command, testprg = n.clear, n.command, n.testprg
|
||||
@ -199,7 +199,7 @@ end)
|
||||
|
||||
describe('autocmd TextChangedT', function()
|
||||
clear()
|
||||
local screen = tt.screen_setup()
|
||||
local screen = tt.setup_screen()
|
||||
|
||||
it('works', function()
|
||||
command('autocmd TextChangedT * ++once let g:called = 1')
|
||||
|
@ -1,7 +1,7 @@
|
||||
local t = require('test.testutil')
|
||||
local n = require('test.functional.testnvim')()
|
||||
local Screen = require('test.functional.ui.screen')
|
||||
local tt = require('test.functional.terminal.testutil')
|
||||
local tt = require('test.functional.testterm')
|
||||
|
||||
local clear = n.clear
|
||||
local eq = t.eq
|
||||
|
@ -1,6 +1,6 @@
|
||||
local t = require('test.testutil')
|
||||
local n = require('test.functional.testnvim')()
|
||||
local tt = require('test.functional.terminal.testutil')
|
||||
local tt = require('test.functional.testterm')
|
||||
|
||||
local assert_log = t.assert_log
|
||||
local clear = n.clear
|
||||
|
@ -157,5 +157,28 @@ describe('vim.ui', function()
|
||||
exec_lua [[local _, err = vim.ui.open('foo') ; return err]]
|
||||
)
|
||||
end)
|
||||
|
||||
it('opt.cmd #29490', function()
|
||||
t.matches(
|
||||
'ENOENT: no such file or directory',
|
||||
t.pcall_err(exec_lua, function()
|
||||
vim.ui.open('foo', { cmd = { 'non-existent-tool' } })
|
||||
end)
|
||||
)
|
||||
|
||||
eq(
|
||||
{
|
||||
code = 0,
|
||||
signal = 0,
|
||||
stderr = '',
|
||||
stdout = 'arg1=arg1;arg2=https://example.com;',
|
||||
},
|
||||
exec_lua(function(cmd_)
|
||||
local cmd, err = vim.ui.open('https://example.com', { cmd = cmd_ })
|
||||
assert(cmd and not err)
|
||||
return cmd:wait()
|
||||
end, { n.testprg('printargs-test'), 'arg1' })
|
||||
)
|
||||
end)
|
||||
end)
|
||||
end)
|
||||
|
@ -1,7 +1,7 @@
|
||||
local t = require('test.testutil')
|
||||
local n = require('test.functional.testnvim')()
|
||||
|
||||
local tt = require('test.functional.terminal.testutil')
|
||||
local tt = require('test.functional.testterm')
|
||||
local clear, eq, api = n.clear, t.eq, n.api
|
||||
local feed = n.feed
|
||||
local feed_data = tt.feed_data
|
||||
@ -17,7 +17,7 @@ describe(':terminal altscreen', function()
|
||||
|
||||
before_each(function()
|
||||
clear()
|
||||
screen = tt.screen_setup()
|
||||
screen = tt.setup_screen()
|
||||
feed_data({
|
||||
'line1',
|
||||
'line2',
|
||||
|
@ -1,7 +1,7 @@
|
||||
local t = require('test.testutil')
|
||||
local n = require('test.functional.testnvim')()
|
||||
|
||||
local tt = require('test.functional.terminal.testutil')
|
||||
local tt = require('test.functional.testterm')
|
||||
local ok = t.ok
|
||||
|
||||
if t.skip(t.is_os('win')) then
|
||||
|
@ -1,7 +1,7 @@
|
||||
local t = require('test.testutil')
|
||||
local n = require('test.functional.testnvim')()
|
||||
local Screen = require('test.functional.ui.screen')
|
||||
local tt = require('test.functional.terminal.testutil')
|
||||
local tt = require('test.functional.testterm')
|
||||
|
||||
local assert_alive = n.assert_alive
|
||||
local feed, clear = n.feed, n.clear
|
||||
@ -29,7 +29,7 @@ describe(':terminal buffer', function()
|
||||
before_each(function()
|
||||
clear()
|
||||
command('set modifiable swapfile undolevels=20')
|
||||
screen = tt.screen_setup()
|
||||
screen = tt.setup_screen()
|
||||
end)
|
||||
|
||||
it('terminal-mode forces various options', function()
|
||||
@ -574,7 +574,7 @@ if is_os('win') then
|
||||
feed_command('set modifiable swapfile undolevels=20')
|
||||
poke_eventloop()
|
||||
local cmd = { 'cmd.exe', '/K', 'PROMPT=$g$s' }
|
||||
screen = tt.screen_setup(nil, cmd)
|
||||
screen = tt.setup_screen(nil, cmd)
|
||||
end)
|
||||
|
||||
it('"put" operator sends data normally', function()
|
||||
|
@ -1,7 +1,7 @@
|
||||
local t = require('test.testutil')
|
||||
local n = require('test.functional.testnvim')()
|
||||
local Screen = require('test.functional.ui.screen')
|
||||
local tt = require('test.functional.terminal.testutil')
|
||||
local tt = require('test.functional.testterm')
|
||||
|
||||
local feed, clear = n.feed, n.clear
|
||||
local testprg, command = n.testprg, n.command
|
||||
@ -18,7 +18,7 @@ describe(':terminal cursor', function()
|
||||
|
||||
before_each(function()
|
||||
clear()
|
||||
screen = tt.screen_setup()
|
||||
screen = tt.setup_screen()
|
||||
end)
|
||||
|
||||
it('moves the screen cursor when focused', function()
|
||||
|
@ -1,7 +1,7 @@
|
||||
local t = require('test.testutil')
|
||||
local n = require('test.functional.testnvim')()
|
||||
local Screen = require('test.functional.ui.screen')
|
||||
local tt = require('test.functional.terminal.testutil')
|
||||
local tt = require('test.functional.testterm')
|
||||
|
||||
local feed, clear = n.feed, n.clear
|
||||
local api = n.api
|
||||
|
@ -1,7 +1,7 @@
|
||||
local t = require('test.testutil')
|
||||
local n = require('test.functional.testnvim')()
|
||||
|
||||
local tt = require('test.functional.terminal.testutil')
|
||||
local tt = require('test.functional.testterm')
|
||||
local clear, eq, eval = n.clear, t.eq, n.eval
|
||||
local feed, api, command = n.feed, n.api, n.command
|
||||
local feed_data = tt.feed_data
|
||||
@ -14,7 +14,7 @@ describe(':terminal mouse', function()
|
||||
before_each(function()
|
||||
clear()
|
||||
api.nvim_set_option_value('statusline', '==========', {})
|
||||
screen = tt.screen_setup()
|
||||
screen = tt.setup_screen()
|
||||
command('highlight StatusLine NONE')
|
||||
command('highlight StatusLineNC NONE')
|
||||
command('highlight StatusLineTerm NONE')
|
||||
|
@ -1,7 +1,7 @@
|
||||
local t = require('test.testutil')
|
||||
local n = require('test.functional.testnvim')()
|
||||
local Screen = require('test.functional.ui.screen')
|
||||
local tt = require('test.functional.terminal.testutil')
|
||||
local tt = require('test.functional.testterm')
|
||||
|
||||
local clear, eq = n.clear, t.eq
|
||||
local feed, testprg = n.feed, n.testprg
|
||||
@ -22,7 +22,7 @@ describe(':terminal scrollback', function()
|
||||
|
||||
before_each(function()
|
||||
clear()
|
||||
screen = tt.screen_setup(nil, nil, 30)
|
||||
screen = tt.setup_screen(nil, nil, 30)
|
||||
end)
|
||||
|
||||
describe('when the limit is exceeded', function()
|
||||
@ -399,9 +399,9 @@ describe("'scrollback' option", function()
|
||||
it('set to 0 behaves as 1', function()
|
||||
local screen
|
||||
if is_os('win') then
|
||||
screen = tt.screen_setup(nil, { 'cmd.exe' }, 30)
|
||||
screen = tt.setup_screen(nil, { 'cmd.exe' }, 30)
|
||||
else
|
||||
screen = tt.screen_setup(nil, { 'sh' }, 30)
|
||||
screen = tt.setup_screen(nil, { 'sh' }, 30)
|
||||
end
|
||||
|
||||
api.nvim_set_option_value('scrollback', 0, {})
|
||||
@ -416,10 +416,10 @@ describe("'scrollback' option", function()
|
||||
local screen
|
||||
if is_os('win') then
|
||||
command([[let $PROMPT='$$']])
|
||||
screen = tt.screen_setup(nil, { 'cmd.exe' }, 30)
|
||||
screen = tt.setup_screen(nil, { 'cmd.exe' }, 30)
|
||||
else
|
||||
command('let $PS1 = "$"')
|
||||
screen = tt.screen_setup(nil, { 'sh' }, 30)
|
||||
screen = tt.setup_screen(nil, { 'sh' }, 30)
|
||||
end
|
||||
|
||||
api.nvim_set_option_value('scrollback', 200, {})
|
||||
@ -480,8 +480,8 @@ describe("'scrollback' option", function()
|
||||
end)
|
||||
|
||||
it('deletes extra lines immediately', function()
|
||||
-- Scrollback is 10 on screen_setup
|
||||
local screen = tt.screen_setup(nil, nil, 30)
|
||||
-- Scrollback is 10 on setup_screen
|
||||
local screen = tt.setup_screen(nil, nil, 30)
|
||||
local lines = {}
|
||||
for i = 1, 30 do
|
||||
table.insert(lines, 'line' .. tostring(i))
|
||||
|
@ -7,7 +7,7 @@
|
||||
local t = require('test.testutil')
|
||||
local n = require('test.functional.testnvim')()
|
||||
local Screen = require('test.functional.ui.screen')
|
||||
local tt = require('test.functional.terminal.testutil')
|
||||
local tt = require('test.functional.testterm')
|
||||
|
||||
local eq = t.eq
|
||||
local feed_data = tt.feed_data
|
||||
@ -2111,7 +2111,7 @@ describe('TUI', function()
|
||||
finally(function()
|
||||
os.remove('testF')
|
||||
end)
|
||||
local screen = tt.screen_setup(
|
||||
local screen = tt.setup_screen(
|
||||
0,
|
||||
('"%s" -u NONE -i NONE --cmd "set noswapfile noshowcmd noruler" --cmd "normal iabc" > /dev/null 2>&1 && cat testF && rm testF'):format(
|
||||
nvim_prog
|
||||
|
@ -1,7 +1,7 @@
|
||||
local t = require('test.testutil')
|
||||
local n = require('test.functional.testnvim')()
|
||||
|
||||
local tt = require('test.functional.terminal.testutil')
|
||||
local tt = require('test.functional.testterm')
|
||||
local feed_data = tt.feed_data
|
||||
local feed, clear = n.feed, n.clear
|
||||
local poke_eventloop = n.poke_eventloop
|
||||
@ -37,7 +37,7 @@ describe(':terminal window', function()
|
||||
|
||||
before_each(function()
|
||||
clear()
|
||||
screen = tt.screen_setup()
|
||||
screen = tt.setup_screen()
|
||||
end)
|
||||
|
||||
it('sets topline correctly #8556', function()
|
||||
@ -198,7 +198,7 @@ describe(':terminal with multigrid', function()
|
||||
|
||||
before_each(function()
|
||||
clear()
|
||||
screen = tt.screen_setup(0, nil, 50, nil, { ext_multigrid = true })
|
||||
screen = tt.setup_screen(0, nil, 50, nil, { ext_multigrid = true })
|
||||
end)
|
||||
|
||||
it('resizes to requested size', function()
|
||||
|
@ -1,7 +1,7 @@
|
||||
local t = require('test.testutil')
|
||||
local n = require('test.functional.testnvim')()
|
||||
|
||||
local tt = require('test.functional.terminal.testutil')
|
||||
local tt = require('test.functional.testterm')
|
||||
local assert_alive = n.assert_alive
|
||||
local clear = n.clear
|
||||
local feed = n.feed
|
||||
@ -22,7 +22,7 @@ describe(':terminal', function()
|
||||
-- set the statusline to a constant value because of variables like pid
|
||||
-- and current directory and to improve visibility of splits
|
||||
api.nvim_set_option_value('statusline', '==========', {})
|
||||
screen = tt.screen_setup(3)
|
||||
screen = tt.setup_screen(3)
|
||||
command('highlight StatusLine NONE')
|
||||
command('highlight StatusLineNC NONE')
|
||||
command('highlight StatusLineTerm NONE')
|
||||
|
@ -250,6 +250,8 @@ function M.set_method_error(err)
|
||||
method_error = err
|
||||
end
|
||||
|
||||
--- Runs the event loop of the given session.
|
||||
---
|
||||
--- @param lsession test.Session
|
||||
--- @param request_cb function?
|
||||
--- @param notification_cb function?
|
||||
@ -296,6 +298,7 @@ function M.run_session(lsession, request_cb, notification_cb, setup_cb, timeout)
|
||||
return lsession.eof_err
|
||||
end
|
||||
|
||||
--- Runs the event loop of the current global session.
|
||||
function M.run(request_cb, notification_cb, setup_cb, timeout)
|
||||
assert(session)
|
||||
return M.run_session(session, request_cb, notification_cb, setup_cb, timeout)
|
||||
|
@ -1,6 +1,13 @@
|
||||
-- To test tui/input.c, this module spawns `nvim` inside :terminal and sends
|
||||
-- bytes via jobsend(). Note: the functional/testutil.lua test-session methods
|
||||
-- operate on the _host_ session, _not_ the child session.
|
||||
-- Functions to test :terminal and the Nvim TUI.
|
||||
-- Starts a child process in a `:terminal` and sends bytes to the child via nvim_chan_send().
|
||||
-- Note: the global functional/testutil.lua test-session is _host_ session, _not_
|
||||
-- the child session.
|
||||
--
|
||||
-- - Use `setup_screen()` to test `:terminal` behavior with an arbitrary command.
|
||||
-- - Use `setup_child_nvim()` to test the Nvim TUI.
|
||||
-- - NOTE: Only use this if your test actually needs the full lifecycle/capabilities of the
|
||||
-- builtin Nvim TUI. Most tests should just use `Screen.new()` directly, or plain old API calls.
|
||||
|
||||
local n = require('test.functional.testnvim')()
|
||||
local Screen = require('test.functional.ui.screen')
|
||||
|
||||
@ -9,18 +16,20 @@ local exec_lua = n.exec_lua
|
||||
local api = n.api
|
||||
local nvim_prog = n.nvim_prog
|
||||
|
||||
local function feed_data(data)
|
||||
local M = {}
|
||||
|
||||
function M.feed_data(data)
|
||||
if type(data) == 'table' then
|
||||
data = table.concat(data, '\n')
|
||||
end
|
||||
exec_lua('vim.api.nvim_chan_send(vim.b.terminal_job_id, ...)', data)
|
||||
end
|
||||
|
||||
local function feed_termcode(data)
|
||||
feed_data('\027' .. data)
|
||||
function M.feed_termcode(data)
|
||||
M.feed_data('\027' .. data)
|
||||
end
|
||||
|
||||
local function make_lua_executor(session)
|
||||
function M.make_lua_executor(session)
|
||||
return function(code, ...)
|
||||
local status, rv = session:request('nvim_exec_lua', code, { ... })
|
||||
if not status then
|
||||
@ -34,60 +43,68 @@ end
|
||||
-- some t for controlling the terminal. the codes were taken from
|
||||
-- infocmp xterm-256color which is less what libvterm understands
|
||||
-- civis/cnorm
|
||||
local function hide_cursor()
|
||||
feed_termcode('[?25l')
|
||||
function M.hide_cursor()
|
||||
M.feed_termcode('[?25l')
|
||||
end
|
||||
local function show_cursor()
|
||||
feed_termcode('[?25h')
|
||||
function M.show_cursor()
|
||||
M.feed_termcode('[?25h')
|
||||
end
|
||||
-- smcup/rmcup
|
||||
local function enter_altscreen()
|
||||
feed_termcode('[?1049h')
|
||||
function M.enter_altscreen()
|
||||
M.feed_termcode('[?1049h')
|
||||
end
|
||||
local function exit_altscreen()
|
||||
feed_termcode('[?1049l')
|
||||
function M.exit_altscreen()
|
||||
M.feed_termcode('[?1049l')
|
||||
end
|
||||
-- character attributes
|
||||
local function set_fg(num)
|
||||
feed_termcode('[38;5;' .. num .. 'm')
|
||||
function M.set_fg(num)
|
||||
M.feed_termcode('[38;5;' .. num .. 'm')
|
||||
end
|
||||
local function set_bg(num)
|
||||
feed_termcode('[48;5;' .. num .. 'm')
|
||||
function M.set_bg(num)
|
||||
M.feed_termcode('[48;5;' .. num .. 'm')
|
||||
end
|
||||
local function set_bold()
|
||||
feed_termcode('[1m')
|
||||
function M.set_bold()
|
||||
M.feed_termcode('[1m')
|
||||
end
|
||||
local function set_italic()
|
||||
feed_termcode('[3m')
|
||||
function M.set_italic()
|
||||
M.feed_termcode('[3m')
|
||||
end
|
||||
local function set_underline()
|
||||
feed_termcode('[4m')
|
||||
function M.set_underline()
|
||||
M.feed_termcode('[4m')
|
||||
end
|
||||
local function set_underdouble()
|
||||
feed_termcode('[4:2m')
|
||||
function M.set_underdouble()
|
||||
M.feed_termcode('[4:2m')
|
||||
end
|
||||
local function set_undercurl()
|
||||
feed_termcode('[4:3m')
|
||||
function M.set_undercurl()
|
||||
M.feed_termcode('[4:3m')
|
||||
end
|
||||
local function set_strikethrough()
|
||||
feed_termcode('[9m')
|
||||
function M.set_strikethrough()
|
||||
M.feed_termcode('[9m')
|
||||
end
|
||||
local function clear_attrs()
|
||||
feed_termcode('[0;10m')
|
||||
function M.clear_attrs()
|
||||
M.feed_termcode('[0;10m')
|
||||
end
|
||||
-- mouse
|
||||
local function enable_mouse()
|
||||
feed_termcode('[?1002h')
|
||||
function M.enable_mouse()
|
||||
M.feed_termcode('[?1002h')
|
||||
end
|
||||
local function disable_mouse()
|
||||
feed_termcode('[?1002l')
|
||||
function M.disable_mouse()
|
||||
M.feed_termcode('[?1002l')
|
||||
end
|
||||
|
||||
local default_command = { testprg('tty-test') }
|
||||
|
||||
local function screen_setup(extra_rows, command, cols, env, screen_opts)
|
||||
--- Runs `cmd` in a :terminal, and returns a `Screen` object.
|
||||
---
|
||||
---@param extra_rows? integer Extra rows to add to the default screen.
|
||||
---@param cmd? string|string[] Command to run in the terminal (default: `{ 'tty-test' }`)
|
||||
---@param cols? integer Create screen with this many columns (default: 50)
|
||||
---@param env? table Environment set on the `cmd` job.
|
||||
---@param screen_opts? table Options for `Screen.new()`.
|
||||
---@return test.functional.ui.screen # Screen attached to the global (not child) Nvim session.
|
||||
function M.setup_screen(extra_rows, cmd, cols, env, screen_opts)
|
||||
extra_rows = extra_rows and extra_rows or 0
|
||||
command = command and command or default_command
|
||||
cmd = cmd and cmd or default_command
|
||||
cols = cols and cols or 50
|
||||
|
||||
api.nvim_command('highlight TermCursor cterm=reverse')
|
||||
@ -120,7 +137,7 @@ local function screen_setup(extra_rows, command, cols, env, screen_opts)
|
||||
screen:attach(screen_opts or { rgb = false })
|
||||
|
||||
api.nvim_command('enew')
|
||||
api.nvim_call_function('termopen', { command, env and { env = env } or nil })
|
||||
api.nvim_call_function('termopen', { cmd, env and { env = env } or nil })
|
||||
api.nvim_input('<CR>')
|
||||
local vim_errmsg = api.nvim_eval('v:errmsg')
|
||||
if vim_errmsg and '' ~= vim_errmsg then
|
||||
@ -133,7 +150,7 @@ local function screen_setup(extra_rows, command, cols, env, screen_opts)
|
||||
|
||||
-- tty-test puts the terminal into raw mode and echoes input. Tests work by
|
||||
-- feeding termcodes to control the display and asserting by screen:expect.
|
||||
if command == default_command and screen_opts == nil then
|
||||
if cmd == default_command and screen_opts == nil then
|
||||
-- Wait for "tty ready" to be printed before each test or the terminal may
|
||||
-- still be in canonical mode (will echo characters for example).
|
||||
local empty_line = (' '):rep(cols)
|
||||
@ -160,37 +177,24 @@ local function screen_setup(extra_rows, command, cols, env, screen_opts)
|
||||
return screen
|
||||
end
|
||||
|
||||
local function setup_child_nvim(args, opts)
|
||||
--- Spawns Nvim with `args` in a :terminal, and returns a `Screen` object.
|
||||
---
|
||||
--- @note Only use this if you actually need the full lifecycle/capabilities of the builtin Nvim
|
||||
--- TUI. Most tests should just use `Screen.new()` directly, or plain old API calls.
|
||||
---
|
||||
---@param args? string[] Args passed to child Nvim.
|
||||
---@param opts? table Options
|
||||
---@return test.functional.ui.screen # Screen attached to the global (not child) Nvim session.
|
||||
function M.setup_child_nvim(args, opts)
|
||||
opts = opts or {}
|
||||
local argv = { nvim_prog, unpack(args) }
|
||||
local argv = { nvim_prog, unpack(args or {}) }
|
||||
|
||||
local env = opts.env or {}
|
||||
if not env.VIMRUNTIME then
|
||||
env.VIMRUNTIME = os.getenv('VIMRUNTIME')
|
||||
end
|
||||
|
||||
return screen_setup(opts.extra_rows, argv, opts.cols, env)
|
||||
return M.setup_screen(opts.extra_rows, argv, opts.cols, env)
|
||||
end
|
||||
|
||||
return {
|
||||
feed_data = feed_data,
|
||||
feed_termcode = feed_termcode,
|
||||
make_lua_executor = make_lua_executor,
|
||||
hide_cursor = hide_cursor,
|
||||
show_cursor = show_cursor,
|
||||
enter_altscreen = enter_altscreen,
|
||||
exit_altscreen = exit_altscreen,
|
||||
set_fg = set_fg,
|
||||
set_bg = set_bg,
|
||||
set_bold = set_bold,
|
||||
set_italic = set_italic,
|
||||
set_underline = set_underline,
|
||||
set_underdouble = set_underdouble,
|
||||
set_undercurl = set_undercurl,
|
||||
set_strikethrough = set_strikethrough,
|
||||
clear_attrs = clear_attrs,
|
||||
enable_mouse = enable_mouse,
|
||||
disable_mouse = disable_mouse,
|
||||
screen_setup = screen_setup,
|
||||
setup_child_nvim = setup_child_nvim,
|
||||
}
|
||||
return M
|
@ -8,6 +8,7 @@ local exec_lua = n.exec_lua
|
||||
local pcall_err = t.pcall_err
|
||||
local matches = t.matches
|
||||
local insert = n.insert
|
||||
local NIL = vim.NIL
|
||||
|
||||
before_each(clear)
|
||||
|
||||
@ -15,10 +16,12 @@ describe('treesitter language API', function()
|
||||
-- error tests not requiring a parser library
|
||||
it('handles missing language', function()
|
||||
eq(
|
||||
".../language.lua:0: no parser for 'borklang' language, see :help treesitter-parsers",
|
||||
'.../treesitter.lua:0: Parser not found.',
|
||||
pcall_err(exec_lua, "parser = vim.treesitter.get_parser(0, 'borklang')")
|
||||
)
|
||||
|
||||
eq(NIL, exec_lua("return vim.treesitter._get_parser(0, 'borklang')"))
|
||||
|
||||
-- actual message depends on platform
|
||||
matches(
|
||||
"Failed to load parser for language 'borklang': uv_dlopen: .+",
|
||||
@ -105,9 +108,10 @@ describe('treesitter language API', function()
|
||||
command('set filetype=borklang')
|
||||
-- Should throw an error when filetype changes to borklang
|
||||
eq(
|
||||
".../language.lua:0: no parser for 'borklang' language, see :help treesitter-parsers",
|
||||
'.../treesitter.lua:0: Parser not found.',
|
||||
pcall_err(exec_lua, "new_parser = vim.treesitter.get_parser(0, 'borklang')")
|
||||
)
|
||||
eq(NIL, exec_lua("return vim.treesitter._get_parser(0, 'borklang')"))
|
||||
end
|
||||
)
|
||||
|
||||
|
@ -135,9 +135,7 @@ void ui_refresh(void)
|
||||
insert(test_text)
|
||||
|
||||
eq(
|
||||
'.../treesitter.lua:0: There is no parser available for buffer 1 and one'
|
||||
.. ' could not be created because lang could not be determined. Either'
|
||||
.. ' pass lang or set the buffer filetype',
|
||||
'.../treesitter.lua:0: Parser not found.',
|
||||
pcall_err(exec_lua, 'vim.treesitter.get_parser(0)')
|
||||
)
|
||||
|
||||
@ -253,20 +251,25 @@ end]]
|
||||
local root = _G.parser:parse()[1]:root()
|
||||
_G.parser:set_included_regions({ { root:child(0) } })
|
||||
_G.parser:invalidate()
|
||||
return { _G.parser:parse(true)[1]:root():range() }
|
||||
local _, tree = next(_G.parser:parse(true))
|
||||
return { tree:root():range() }
|
||||
end)
|
||||
|
||||
eq({ 0, 0, 18, 1 }, res2)
|
||||
|
||||
eq({ { { 0, 0, 0, 18, 1, 512 } } }, exec_lua [[ return parser:included_regions() ]])
|
||||
eq(
|
||||
{ { { 0, 0, 0, 18, 1, 512 } } },
|
||||
exec_lua [[return vim.tbl_values(_G.parser:included_regions())]]
|
||||
)
|
||||
|
||||
local range_tbl = exec_lua(function()
|
||||
_G.parser:set_included_regions { { { 0, 0, 17, 1 } } }
|
||||
_G.parser:parse()
|
||||
return _G.parser:included_regions()
|
||||
end)
|
||||
|
||||
eq({ { { 0, 0, 0, 17, 1, 508 } } }, range_tbl)
|
||||
eq(
|
||||
{ { { 0, 0, 0, 17, 1, 508 } } },
|
||||
exec_lua(function()
|
||||
_G.parser:set_included_regions { { { 0, 0, 17, 1 } } }
|
||||
_G.parser:parse()
|
||||
return vim.tbl_values(_G.parser:included_regions())
|
||||
end)
|
||||
)
|
||||
end)
|
||||
|
||||
it('allows to set complex ranges', function()
|
||||
@ -283,7 +286,8 @@ end]]
|
||||
|
||||
parser:set_included_regions({ nodes })
|
||||
|
||||
local root = parser:parse(true)[1]:root()
|
||||
local _, tree = next(parser:parse(true))
|
||||
local root = tree:root()
|
||||
|
||||
local res = {}
|
||||
for i = 0, (root:named_child_count() - 1) do
|
||||
@ -826,27 +830,140 @@ print()
|
||||
1,
|
||||
exec_lua(function()
|
||||
_G.parser:parse({ 0, 2 })
|
||||
return #_G.parser:children().lua:trees()
|
||||
return vim.tbl_count(_G.parser:children().lua:trees())
|
||||
end)
|
||||
)
|
||||
|
||||
-- Regions outside the given range are discarded.
|
||||
eq(
|
||||
1,
|
||||
exec_lua(function()
|
||||
_G.parser:parse({ 2, 6 })
|
||||
return vim.tbl_count(_G.parser:children().lua:trees())
|
||||
end)
|
||||
)
|
||||
|
||||
eq(
|
||||
2,
|
||||
exec_lua(function()
|
||||
_G.parser:parse({ 2, 6 })
|
||||
return #_G.parser:children().lua:trees()
|
||||
end)
|
||||
exec_lua [[
|
||||
parser:invalidate()
|
||||
parser:parse({{0, 2}, {2,6}})
|
||||
return vim.tbl_count(parser:children().lua:trees())
|
||||
]]
|
||||
)
|
||||
|
||||
eq(
|
||||
2,
|
||||
exec_lua [[
|
||||
parser:parse({{0, 5}, {2, 6}})
|
||||
return vim.tbl_count(parser:children().lua:trees())
|
||||
]]
|
||||
)
|
||||
|
||||
eq(
|
||||
7,
|
||||
exec_lua(function()
|
||||
_G.parser:parse(true)
|
||||
return #_G.parser:children().lua:trees()
|
||||
return vim.tbl_count(_G.parser:children().lua:trees())
|
||||
end)
|
||||
)
|
||||
end)
|
||||
|
||||
it('reuses similar existing regions', function()
|
||||
insert(dedent [[
|
||||
* line1
|
||||
line2]])
|
||||
|
||||
exec_lua(function()
|
||||
_G.parser = vim.treesitter.get_parser(0, 'markdown', {
|
||||
injections = {
|
||||
markdown = '((inline) @injection.content (#set! injection.language "markdown_inline"))',
|
||||
},
|
||||
})
|
||||
end)
|
||||
|
||||
local function get_regions()
|
||||
return exec_lua(function()
|
||||
_G.parser:parse(true)
|
||||
local result = {}
|
||||
for i, tree in pairs(_G.parser:children().markdown_inline:trees()) do
|
||||
result[i] = tree:included_ranges()
|
||||
end
|
||||
return result
|
||||
end)
|
||||
end
|
||||
|
||||
eq({
|
||||
[1] = { { 0, 2, 1, 0 }, { 1, 2, 1, 7 } },
|
||||
}, get_regions())
|
||||
|
||||
feed('2ggyyp')
|
||||
-- region index does not change
|
||||
eq({
|
||||
[1] = { { 0, 2, 1, 0 }, { 1, 2, 2, 0 }, { 2, 2, 2, 7 } },
|
||||
}, get_regions())
|
||||
|
||||
feed('2ggdd')
|
||||
eq({
|
||||
[1] = { { 0, 2, 1, 0 }, { 1, 2, 1, 7 } },
|
||||
}, get_regions())
|
||||
|
||||
feed('ggyGP')
|
||||
-- the old region moves while maintaining its index
|
||||
eq({
|
||||
[1] = { { 2, 2, 3, 0 }, { 3, 2, 3, 7 } },
|
||||
[2] = { { 0, 2, 1, 0 }, { 1, 2, 1, 7 } },
|
||||
}, get_regions())
|
||||
end)
|
||||
|
||||
it("recursively discards children's regions contained in a parent's discarded region", function()
|
||||
insert(dedent [[
|
||||
`return`
|
||||
|
||||
```
|
||||
line 4
|
||||
```
|
||||
line 6 `return`
|
||||
```]])
|
||||
|
||||
exec_lua(function()
|
||||
_G.parser = vim.treesitter.get_parser(0, 'markdown', {
|
||||
injections = {
|
||||
-- inject code span to lua
|
||||
markdown_inline = '((code_span) @injection.content (#offset! @injection.content 0 1 0 -1) (#set! injection.language "lua"))',
|
||||
},
|
||||
})
|
||||
end)
|
||||
|
||||
local function get_regions()
|
||||
return exec_lua(function()
|
||||
_G.parser:parse(true)
|
||||
local result = {}
|
||||
for i, tree in pairs(_G.parser:children().markdown_inline:children().lua:trees()) do
|
||||
result[i] = tree:included_ranges()
|
||||
end
|
||||
return result
|
||||
end)
|
||||
end
|
||||
|
||||
-- Initially, "line 4" is in the fenced code block, and "line 6 `return`" is a normal paragraph
|
||||
-- with a inline code span.
|
||||
eq({
|
||||
[1] = { { 0, 1, 0, 7 } },
|
||||
[2] = { { 5, 8, 5, 14 } },
|
||||
}, get_regions())
|
||||
|
||||
-- Extend the code block to "line 6 `return`". Note that the only effect to markdown_inline
|
||||
-- parser is removing a region, so it does not parse anything in markdown_inline parser.
|
||||
feed('5ggD')
|
||||
-- Despite not parsing at the parent (markdown_inline) parser, the regions in children (lua)
|
||||
-- parser that are included in the parent's removed region should be removed as well.
|
||||
-- The "`return`" at the first line is just for preventing the lua parser from being removed.
|
||||
eq({
|
||||
[1] = { { 0, 1, 0, 7 } },
|
||||
}, get_regions())
|
||||
end)
|
||||
|
||||
describe('languagetree is_valid()', function()
|
||||
before_each(function()
|
||||
insert(dedent [[
|
||||
@ -857,10 +974,8 @@ print()
|
||||
|
||||
]])
|
||||
|
||||
feed(':set ft=help<cr>')
|
||||
|
||||
exec_lua(function()
|
||||
vim.treesitter.get_parser(0, 'vimdoc', {
|
||||
_G.parser = vim.treesitter.get_parser(0, 'vimdoc', {
|
||||
injections = {
|
||||
vimdoc = '((codeblock (language) @injection.language (code) @injection.content) (#set! injection.include-children))',
|
||||
},
|
||||
@ -868,21 +983,22 @@ print()
|
||||
end)
|
||||
end)
|
||||
|
||||
it('is valid excluding, invalid including children initially', function()
|
||||
eq(true, exec_lua('return vim.treesitter.get_parser():is_valid(true)'))
|
||||
eq(false, exec_lua('return vim.treesitter.get_parser():is_valid()'))
|
||||
end)
|
||||
local function get_regions()
|
||||
return exec_lua(function()
|
||||
if not _G.parser:children().lua then
|
||||
return nil
|
||||
end
|
||||
local result = {}
|
||||
for i, tree in pairs(_G.parser:children().lua:trees()) do
|
||||
result[i] = tree:included_ranges()
|
||||
end
|
||||
return result
|
||||
end)
|
||||
end
|
||||
|
||||
it('is fully valid after a full parse', function()
|
||||
exec_lua('vim.treesitter.get_parser():parse(true)')
|
||||
eq(true, exec_lua('return vim.treesitter.get_parser():is_valid(true)'))
|
||||
eq(true, exec_lua('return vim.treesitter.get_parser():is_valid()'))
|
||||
end)
|
||||
|
||||
it('is fully valid after a parsing a range on parsed tree', function()
|
||||
exec_lua('vim.treesitter.get_parser():parse({5, 7})')
|
||||
eq(true, exec_lua('return vim.treesitter.get_parser():is_valid(true)'))
|
||||
eq(true, exec_lua('return vim.treesitter.get_parser():is_valid()'))
|
||||
it('is valid including children since it does not have one', function()
|
||||
eq(true, exec_lua('return parser:is_valid(true)'))
|
||||
eq(true, exec_lua('return parser:is_valid()'))
|
||||
end)
|
||||
|
||||
describe('when adding content with injections', function()
|
||||
@ -897,36 +1013,36 @@ print()
|
||||
end)
|
||||
|
||||
it('is fully invalid after changes', function()
|
||||
eq(false, exec_lua('return vim.treesitter.get_parser():is_valid(true)'))
|
||||
eq(false, exec_lua('return vim.treesitter.get_parser():is_valid()'))
|
||||
eq(false, exec_lua('return parser:is_valid(true)'))
|
||||
eq(false, exec_lua('return parser:is_valid()'))
|
||||
end)
|
||||
|
||||
it('is valid excluding, invalid including children after a rangeless parse', function()
|
||||
exec_lua('vim.treesitter.get_parser():parse()')
|
||||
eq(true, exec_lua('return vim.treesitter.get_parser():is_valid(true)'))
|
||||
eq(false, exec_lua('return vim.treesitter.get_parser():is_valid()'))
|
||||
exec_lua('parser:parse()')
|
||||
eq(true, exec_lua('return parser:is_valid(true)'))
|
||||
eq(false, exec_lua('return parser:is_valid()'))
|
||||
end)
|
||||
|
||||
it(
|
||||
'is fully valid after a range parse that leads to parsing not parsed injections',
|
||||
function()
|
||||
exec_lua('vim.treesitter.get_parser():parse({5, 7})')
|
||||
eq(true, exec_lua('return vim.treesitter.get_parser():is_valid(true)'))
|
||||
eq(true, exec_lua('return vim.treesitter.get_parser():is_valid()'))
|
||||
exec_lua('parser:parse({5, 7})')
|
||||
eq(true, exec_lua('return parser:is_valid(true)'))
|
||||
eq(true, exec_lua('return parser:is_valid()'))
|
||||
end
|
||||
)
|
||||
|
||||
it(
|
||||
'is valid excluding, invalid including children after a range parse that does not lead to parsing not parsed injections',
|
||||
function()
|
||||
exec_lua('vim.treesitter.get_parser():parse({2, 4})')
|
||||
eq(true, exec_lua('return vim.treesitter.get_parser():is_valid(true)'))
|
||||
eq(false, exec_lua('return vim.treesitter.get_parser():is_valid()'))
|
||||
exec_lua('parser:parse({2, 4})')
|
||||
eq(true, exec_lua('return parser:is_valid(true)'))
|
||||
eq(false, exec_lua('return parser:is_valid()'))
|
||||
end
|
||||
)
|
||||
end)
|
||||
|
||||
describe('when removing content with injections', function()
|
||||
describe('when removing an injection region', function()
|
||||
before_each(function()
|
||||
feed('G')
|
||||
insert(dedent [[
|
||||
@ -935,41 +1051,80 @@ print()
|
||||
<
|
||||
|
||||
>lua
|
||||
local a = {}
|
||||
local b = {}
|
||||
<
|
||||
|
||||
]])
|
||||
|
||||
exec_lua('vim.treesitter.get_parser():parse(true)')
|
||||
exec_lua('parser:parse(true)')
|
||||
eq({ [1] = { { 6, 0, 7, 0 } }, [2] = { { 10, 0, 11, 0 } } }, get_regions())
|
||||
|
||||
feed('Gd3k')
|
||||
-- the empty region is pruned
|
||||
eq({ [1] = { { 6, 0, 7, 0 } } }, get_regions())
|
||||
end)
|
||||
|
||||
it('is fully invalid after changes', function()
|
||||
eq(false, exec_lua('return vim.treesitter.get_parser():is_valid(true)'))
|
||||
eq(false, exec_lua('return vim.treesitter.get_parser():is_valid()'))
|
||||
end)
|
||||
|
||||
it('is valid excluding, invalid including children after a rangeless parse', function()
|
||||
exec_lua('vim.treesitter.get_parser():parse()')
|
||||
eq(true, exec_lua('return vim.treesitter.get_parser():is_valid(true)'))
|
||||
eq(false, exec_lua('return vim.treesitter.get_parser():is_valid()'))
|
||||
end)
|
||||
|
||||
it('is fully valid after a range parse that leads to parsing modified child tree', function()
|
||||
exec_lua('vim.treesitter.get_parser():parse({5, 7})')
|
||||
eq(true, exec_lua('return vim.treesitter.get_parser():is_valid(true)'))
|
||||
eq(true, exec_lua('return vim.treesitter.get_parser():is_valid()'))
|
||||
eq(false, exec_lua('return parser:is_valid(true)'))
|
||||
eq(false, exec_lua('return parser:is_valid()'))
|
||||
end)
|
||||
|
||||
it(
|
||||
'is valid excluding, invalid including children after a range parse that does not lead to parsing modified child tree',
|
||||
'is fully valid after a rangeless parse, since the only change to the children was removing a region',
|
||||
function()
|
||||
exec_lua('vim.treesitter.get_parser():parse({2, 4})')
|
||||
eq(true, exec_lua('return vim.treesitter.get_parser():is_valid(true)'))
|
||||
eq(false, exec_lua('return vim.treesitter.get_parser():is_valid()'))
|
||||
exec_lua('parser:parse()')
|
||||
eq(true, exec_lua('return parser:is_valid(true)'))
|
||||
eq(true, exec_lua('return parser:is_valid()'))
|
||||
end
|
||||
)
|
||||
|
||||
it('is fully valid after a range parse that includes injection region', function()
|
||||
exec_lua('parser:parse({5, 7})')
|
||||
eq(true, exec_lua('return parser:is_valid(true)'))
|
||||
eq(true, exec_lua('return parser:is_valid()'))
|
||||
end)
|
||||
|
||||
it(
|
||||
'is valid excluding, invalid including children after a range parse that does not include injection region',
|
||||
function()
|
||||
exec_lua('parser:parse({2, 4})')
|
||||
eq(vim.NIL, get_regions())
|
||||
eq(true, exec_lua('return parser:is_valid(true)'))
|
||||
eq(false, exec_lua('return parser:is_valid()'))
|
||||
end
|
||||
)
|
||||
end)
|
||||
|
||||
describe('when editing an injection region', function()
|
||||
before_each(function()
|
||||
feed('G')
|
||||
insert(dedent [[
|
||||
>lua
|
||||
local a = 1
|
||||
<
|
||||
]])
|
||||
|
||||
exec_lua('parser:parse(true)')
|
||||
|
||||
feed('G2kA<BS>2<ESC>') -- 1 → 2
|
||||
end)
|
||||
|
||||
it('is fully invalid after changes', function()
|
||||
eq(false, exec_lua('return parser:is_valid(true)'))
|
||||
eq(false, exec_lua('return parser:is_valid()'))
|
||||
end)
|
||||
|
||||
it('is valid excluding, invalid including children after a rangeless parse', function()
|
||||
exec_lua('parser:parse()')
|
||||
eq(true, exec_lua('return parser:is_valid(true)'))
|
||||
eq(false, exec_lua('return parser:is_valid()'))
|
||||
end)
|
||||
|
||||
it('is fully valid after a range parse that includes modified region', function()
|
||||
exec_lua('parser:parse({5, 7})')
|
||||
eq(true, exec_lua('return parser:is_valid(true)'))
|
||||
eq(true, exec_lua('return parser:is_valid()'))
|
||||
end)
|
||||
end)
|
||||
end)
|
||||
end)
|
||||
|
@ -1078,6 +1078,44 @@ describe('CursorLine and CursorLineNr highlights', function()
|
||||
]])
|
||||
end)
|
||||
|
||||
-- oldtest: Test_cursorline_screenline_resize()
|
||||
it("'cursorlineopt' screenline is updated on window resize", function()
|
||||
local screen = Screen.new(75, 8)
|
||||
screen:attach()
|
||||
exec([[
|
||||
50vnew
|
||||
call setline(1, repeat('xyz ', 30))
|
||||
setlocal number cursorline cursorlineopt=screenline
|
||||
normal! $
|
||||
]])
|
||||
screen:expect([[
|
||||
{8: 1 }xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xy│ |
|
||||
{8: }z xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz │{1:~ }|
|
||||
{8: }{21:xyz xyz xyz xyz xyz xyz xyz^ }│{1:~ }|
|
||||
{1:~ }│{1:~ }|*3
|
||||
{3:[No Name] [+] }{2:[No Name] }|
|
||||
|
|
||||
]])
|
||||
command('vertical resize -4')
|
||||
screen:expect([[
|
||||
{8: 1 }xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xy│ |
|
||||
{8: }z xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz │{1:~ }|
|
||||
{8: }{21:xyz xyz xyz xyz xyz xyz xyz xyz xyz^ }│{1:~ }|
|
||||
{1:~ }│{1:~ }|*3
|
||||
{3:[No Name] [+] }{2:[No Name] }|
|
||||
|
|
||||
]])
|
||||
command('set cpoptions+=n')
|
||||
screen:expect([[
|
||||
{8: 1 }xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xy│ |
|
||||
z xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz │{1:~ }|
|
||||
{21:xyz xyz xyz xyz xyz xyz xyz xyz^ }│{1:~ }|
|
||||
{1:~ }│{1:~ }|*3
|
||||
{3:[No Name] [+] }{2:[No Name] }|
|
||||
|
|
||||
]])
|
||||
end)
|
||||
|
||||
-- oldtest: Test_cursorline_after_yank()
|
||||
it('always updated. vim-patch:8.1.0849', function()
|
||||
local screen = Screen.new(50, 5)
|
||||
|
@ -1,7 +1,7 @@
|
||||
local t = require('test.testutil')
|
||||
local n = require('test.functional.testnvim')()
|
||||
local Screen = require('test.functional.ui.screen')
|
||||
local tt = require('test.functional.terminal.testutil')
|
||||
local tt = require('test.functional.testterm')
|
||||
|
||||
local clear, insert = n.clear, n.insert
|
||||
local command = n.command
|
||||
|
@ -1,7 +1,7 @@
|
||||
local t = require('test.testutil')
|
||||
local n = require('test.functional.testnvim')()
|
||||
local Screen = require('test.functional.ui.screen')
|
||||
local tt = require('test.functional.terminal.testutil')
|
||||
local tt = require('test.functional.testterm')
|
||||
|
||||
local assert_alive = n.assert_alive
|
||||
local mkdir, write_file, rmdir = t.mkdir, t.write_file, n.rmdir
|
||||
|
@ -262,14 +262,34 @@ func Test_cursorline_callback()
|
||||
|
||||
call timer_start(300, 'Func')
|
||||
END
|
||||
call writefile(lines, 'Xcul_timer')
|
||||
call writefile(lines, 'Xcul_timer', 'D')
|
||||
|
||||
let buf = RunVimInTerminal('-S Xcul_timer', #{rows: 8})
|
||||
call TermWait(buf, 310)
|
||||
call VerifyScreenDump(buf, 'Test_cursorline_callback_1', {})
|
||||
|
||||
call StopVimInTerminal(buf)
|
||||
call delete('Xcul_timer')
|
||||
endfunc
|
||||
|
||||
func Test_cursorline_screenline_resize()
|
||||
CheckScreendump
|
||||
|
||||
let lines =<< trim END
|
||||
50vnew
|
||||
call setline(1, repeat('xyz ', 30))
|
||||
setlocal number cursorline cursorlineopt=screenline
|
||||
normal! $
|
||||
END
|
||||
call writefile(lines, 'Xcul_screenline_resize', 'D')
|
||||
|
||||
let buf = RunVimInTerminal('-S Xcul_screenline_resize', #{rows: 8})
|
||||
call VerifyScreenDump(buf, 'Test_cursorline_screenline_resize_1', {})
|
||||
call term_sendkeys(buf, ":vertical resize -4\<CR>")
|
||||
call VerifyScreenDump(buf, 'Test_cursorline_screenline_resize_2', {})
|
||||
call term_sendkeys(buf, ":set cpoptions+=n\<CR>")
|
||||
call VerifyScreenDump(buf, 'Test_cursorline_screenline_resize_3', {})
|
||||
|
||||
call StopVimInTerminal(buf)
|
||||
endfunc
|
||||
|
||||
func Test_cursorline_screenline_update()
|
||||
@ -280,7 +300,7 @@ func Test_cursorline_screenline_update()
|
||||
set cursorline cursorlineopt=screenline
|
||||
inoremap <F2> <Cmd>call cursor(1, 1)<CR>
|
||||
END
|
||||
call writefile(lines, 'Xcul_screenline')
|
||||
call writefile(lines, 'Xcul_screenline', 'D')
|
||||
|
||||
let buf = RunVimInTerminal('-S Xcul_screenline', #{rows: 8})
|
||||
call term_sendkeys(buf, "A")
|
||||
@ -290,7 +310,17 @@ func Test_cursorline_screenline_update()
|
||||
call term_sendkeys(buf, "\<Esc>")
|
||||
|
||||
call StopVimInTerminal(buf)
|
||||
call delete('Xcul_screenline')
|
||||
endfunc
|
||||
|
||||
func Test_cursorline_screenline_zero_width()
|
||||
CheckOption foldcolumn
|
||||
|
||||
set cursorline culopt=screenline winminwidth=1 foldcolumn=1
|
||||
" This used to crash Vim
|
||||
1vnew | redraw
|
||||
|
||||
bwipe!
|
||||
set cursorline& culopt& winminwidth& foldcolumn&
|
||||
endfunc
|
||||
|
||||
func Test_cursorline_cursorbind_horizontal_scroll()
|
||||
|
@ -1150,15 +1150,14 @@ func Test_cfg_file()
|
||||
unlet g:filetype_cfg
|
||||
|
||||
" RAPID cfg
|
||||
let ext = 'cfg'
|
||||
for i in ['EIO', 'MMC', 'MOC', 'PROC', 'SIO', 'SYS']
|
||||
call writefile([i .. ':CFG'], 'cfgfile.' .. ext)
|
||||
execute "split cfgfile." .. ext
|
||||
call assert_equal('rapid', &filetype)
|
||||
bwipe!
|
||||
call delete('cfgfile.' .. ext)
|
||||
" check different case of file extension
|
||||
let ext = substitute(ext, '\(\l\)', '\u\1', '')
|
||||
for ext in ['cfg', 'Cfg', 'CFG']
|
||||
call writefile([i .. ':CFG'], 'cfgfile.' .. ext)
|
||||
execute "split cfgfile." .. ext
|
||||
call assert_equal('rapid', &filetype)
|
||||
bwipe!
|
||||
call delete('cfgfile.' .. ext)
|
||||
endfor
|
||||
endfor
|
||||
|
||||
" clean up
|
||||
|
@ -4071,11 +4071,23 @@ func Test_ll_window_ctx()
|
||||
enew | only
|
||||
endfunc
|
||||
|
||||
" Similar to the problem above, but for user data.
|
||||
func Test_ll_window_user_data()
|
||||
call setloclist(0, [#{bufnr: bufnr(), user_data: {}}])
|
||||
lopen
|
||||
wincmd t
|
||||
close
|
||||
call test_garbagecollect_now()
|
||||
call feedkeys("\<CR>", 'tx')
|
||||
call test_garbagecollect_now()
|
||||
%bwipe!
|
||||
endfunc
|
||||
|
||||
" The following test used to crash vim
|
||||
func Test_lfile_crash()
|
||||
sp Xtest
|
||||
au QuickFixCmdPre * bw
|
||||
call assert_fails('lfile', 'E40')
|
||||
call assert_fails('lfile', 'E40:')
|
||||
au! QuickFixCmdPre
|
||||
endfunc
|
||||
|
||||
|
Loading…
Reference in New Issue
Block a user