mirror of
https://github.com/neovim/neovim.git
synced 2024-12-20 19:25:11 -07:00
vim-patch:8.2.3788: lambda for option that is a function may be freed
Problem: Lambda for option that is a function may be garbage collected.
Solution: Set a reference in the funcref. (Yegappan Lakshmanan,
closes vim/vim#9330)
6ae8fae869
Co-authored-by: Yegappan Lakshmanan <yegappan@yahoo.com>
This commit is contained in:
zeertzjq
parent
8f9ae52784
commit
c00d241981
@ -30,6 +30,7 @@
|
||||
#include "nvim/ex_session.h"
|
||||
#include "nvim/getchar.h"
|
||||
#include "nvim/highlight_group.h"
|
||||
#include "nvim/insexpand.h"
|
||||
#include "nvim/locale.h"
|
||||
#include "nvim/lua/executor.h"
|
||||
#include "nvim/mark.h"
|
||||
@ -49,6 +50,7 @@
|
||||
#include "nvim/search.h"
|
||||
#include "nvim/sign.h"
|
||||
#include "nvim/syntax.h"
|
||||
#include "nvim/tag.h"
|
||||
#include "nvim/ui.h"
|
||||
#include "nvim/ui_compositor.h"
|
||||
#include "nvim/undo.h"
|
||||
@ -4168,10 +4170,23 @@ bool garbage_collect(bool testing)
|
||||
ABORTING(set_ref_dict)(buf->additional_data, copyID);
|
||||
|
||||
// buffer callback functions
|
||||
set_ref_in_callback(&buf->b_prompt_callback, copyID, NULL, NULL);
|
||||
set_ref_in_callback(&buf->b_prompt_interrupt, copyID, NULL, NULL);
|
||||
ABORTING(set_ref_in_callback)(&buf->b_prompt_callback, copyID, NULL, NULL);
|
||||
ABORTING(set_ref_in_callback)(&buf->b_prompt_interrupt, copyID, NULL, NULL);
|
||||
ABORTING(set_ref_in_callback)(&buf->b_cfu_cb, copyID, NULL, NULL);
|
||||
ABORTING(set_ref_in_callback)(&buf->b_ofu_cb, copyID, NULL, NULL);
|
||||
ABORTING(set_ref_in_callback)(&buf->b_tsrfu_cb, copyID, NULL, NULL);
|
||||
ABORTING(set_ref_in_callback)(&buf->b_tfu_cb, copyID, NULL, NULL);
|
||||
}
|
||||
|
||||
// 'completefunc', 'omnifunc' and 'thesaurusfunc' callbacks
|
||||
ABORTING(set_ref_in_insexpand_funcs)(copyID);
|
||||
|
||||
// 'operatorfunc' callback
|
||||
ABORTING(set_ref_in_opfunc)(copyID);
|
||||
|
||||
// 'tagfunc' callback
|
||||
ABORTING(set_ref_in_tagfunc)(copyID);
|
||||
|
||||
FOR_ALL_TAB_WINDOWS(tp, wp) {
|
||||
// window-local variables
|
||||
ABORTING(set_ref_in_item)(&wp->w_winvar.di_tv, copyID, NULL, NULL);
|
||||
@ -5910,8 +5925,8 @@ bool callback_call(Callback *const callback, const int argcount_in, typval_T *co
|
||||
return call_func(name, -1, rettv, argcount_in, argvars_in, &funcexe);
|
||||
}
|
||||
|
||||
static bool set_ref_in_callback(Callback *callback, int copyID, ht_stack_T **ht_stack,
|
||||
list_stack_T **list_stack)
|
||||
bool set_ref_in_callback(Callback *callback, int copyID, ht_stack_T **ht_stack,
|
||||
list_stack_T **list_stack)
|
||||
{
|
||||
typval_T tv;
|
||||
switch (callback->type) {
|
||||
|
||||
@ -2299,6 +2299,17 @@ int set_thesaurusfunc_option(void)
|
||||
return retval;
|
||||
}
|
||||
|
||||
/// Mark the global 'completefunc' 'omnifunc' and 'thesaurusfunc' callbacks with
|
||||
/// "copyID" so that they are not garbage collected.
|
||||
bool set_ref_in_insexpand_funcs(int copyID)
|
||||
{
|
||||
bool abort = set_ref_in_callback(&cfu_cb, copyID, NULL, NULL);
|
||||
abort = abort || set_ref_in_callback(&ofu_cb, copyID, NULL, NULL);
|
||||
abort = abort || set_ref_in_callback(&tsrfu_cb, copyID, NULL, NULL);
|
||||
|
||||
return abort;
|
||||
}
|
||||
|
||||
/// Get the user-defined completion function name for completion "type"
|
||||
static char_u *get_complete_funcname(int type)
|
||||
{
|
||||
|
||||
@ -5606,6 +5606,13 @@ void free_operatorfunc_option(void)
|
||||
}
|
||||
#endif
|
||||
|
||||
/// Mark the global 'operatorfunc' callback with "copyID" so that it is not
|
||||
/// garbage collected.
|
||||
bool set_ref_in_opfunc(int copyID)
|
||||
{
|
||||
return set_ref_in_callback(&opfunc_cb, copyID, NULL, NULL);
|
||||
}
|
||||
|
||||
/// Handle the "g@" operator: call 'operatorfunc'.
|
||||
static void op_function(const oparg_T *oap)
|
||||
FUNC_ATTR_NONNULL_ALL
|
||||
|
||||
@ -6686,7 +6686,8 @@ int set_errorlist(win_T *wp, list_T *list, int action, char *title, dict_T *what
|
||||
return retval;
|
||||
}
|
||||
|
||||
/// Mark the context as in use for all the lists in a quickfix stack.
|
||||
/// Mark the quickfix context and callback function as in use for all the lists
|
||||
/// in a quickfix stack.
|
||||
static bool mark_quickfix_ctx(qf_info_T *qi, int copyID)
|
||||
{
|
||||
bool abort = false;
|
||||
@ -6695,8 +6696,11 @@ static bool mark_quickfix_ctx(qf_info_T *qi, int copyID)
|
||||
typval_T *ctx = qi->qf_lists[i].qf_ctx;
|
||||
if (ctx != NULL && ctx->v_type != VAR_NUMBER
|
||||
&& ctx->v_type != VAR_STRING && ctx->v_type != VAR_FLOAT) {
|
||||
abort = set_ref_in_item(ctx, copyID, NULL, NULL);
|
||||
abort = abort || set_ref_in_item(ctx, copyID, NULL, NULL);
|
||||
}
|
||||
|
||||
Callback *cb = &qi->qf_lists[i].qf_qftf_cb;
|
||||
abort = abort || set_ref_in_callback(cb, copyID, NULL, NULL);
|
||||
}
|
||||
|
||||
return abort;
|
||||
@ -6711,6 +6715,11 @@ bool set_ref_in_quickfix(int copyID)
|
||||
return abort;
|
||||
}
|
||||
|
||||
abort = set_ref_in_callback(&qftf_cb, copyID, NULL, NULL);
|
||||
if (abort) {
|
||||
return abort;
|
||||
}
|
||||
|
||||
FOR_ALL_TAB_WINDOWS(tp, win) {
|
||||
if (win->w_llist != NULL) {
|
||||
abort = mark_quickfix_ctx(win->w_llist, copyID);
|
||||
|
||||
@ -149,6 +149,13 @@ void free_tagfunc_option(void)
|
||||
}
|
||||
#endif
|
||||
|
||||
/// Mark the global 'tagfunc' callback with "copyID" so that it is not garbage
|
||||
/// collected.
|
||||
bool set_ref_in_tagfunc(int copyID)
|
||||
{
|
||||
return set_ref_in_callback(&tfu_cb, copyID, NULL, NULL);
|
||||
}
|
||||
|
||||
/// Copy the global 'tagfunc' callback function to the buffer-local 'tagfunc'
|
||||
/// callback for 'buf'.
|
||||
void set_buflocal_tfu_callback(buf_T *buf)
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -3,6 +3,7 @@
|
||||
source shared.vim
|
||||
source check.vim
|
||||
source view_util.vim
|
||||
source vim9.vim
|
||||
source screendump.vim
|
||||
|
||||
func Setup_NewWindow()
|
||||
@ -463,110 +464,122 @@ func Test_opfunc_callback()
|
||||
let g:OpFuncArgs = [a:val, a:type]
|
||||
endfunc
|
||||
|
||||
" Test for using a function()
|
||||
set opfunc=function('MyopFunc',\ [11])
|
||||
let g:OpFuncArgs = []
|
||||
normal! g@l
|
||||
call assert_equal([11, 'char'], g:OpFuncArgs)
|
||||
let lines =<< trim END
|
||||
#" Test for using a function()
|
||||
set opfunc=function('g:MyopFunc',\ [10])
|
||||
LET g:OpFuncArgs = []
|
||||
normal! g@l
|
||||
call assert_equal([10, 'char'], g:OpFuncArgs)
|
||||
|
||||
" Using a funcref variable to set 'operatorfunc'
|
||||
let Fn = function('MyopFunc', [12])
|
||||
let &opfunc = Fn
|
||||
let g:OpFuncArgs = []
|
||||
normal! g@l
|
||||
call assert_equal([12, 'char'], g:OpFuncArgs)
|
||||
#" Using a funcref variable to set 'operatorfunc'
|
||||
VAR Fn = function('g:MyopFunc', [11])
|
||||
LET &opfunc = Fn
|
||||
LET g:OpFuncArgs = []
|
||||
normal! g@l
|
||||
call assert_equal([11, 'char'], g:OpFuncArgs)
|
||||
|
||||
" Using a string(funcref_variable) to set 'operatorfunc'
|
||||
let Fn = function('MyopFunc', [13])
|
||||
let &operatorfunc = string(Fn)
|
||||
let g:OpFuncArgs = []
|
||||
normal! g@l
|
||||
call assert_equal([13, 'char'], g:OpFuncArgs)
|
||||
#" Using a string(funcref_variable) to set 'operatorfunc'
|
||||
LET Fn = function('g:MyopFunc', [12])
|
||||
LET &operatorfunc = string(Fn)
|
||||
LET g:OpFuncArgs = []
|
||||
normal! g@l
|
||||
call assert_equal([12, 'char'], g:OpFuncArgs)
|
||||
|
||||
" Test for using a funcref()
|
||||
set operatorfunc=funcref('MyopFunc',\ [14])
|
||||
let g:OpFuncArgs = []
|
||||
normal! g@l
|
||||
call assert_equal([14, 'char'], g:OpFuncArgs)
|
||||
#" Test for using a funcref()
|
||||
set operatorfunc=funcref('g:MyopFunc',\ [13])
|
||||
LET g:OpFuncArgs = []
|
||||
normal! g@l
|
||||
call assert_equal([13, 'char'], g:OpFuncArgs)
|
||||
|
||||
" Using a funcref variable to set 'operatorfunc'
|
||||
let Fn = funcref('MyopFunc', [15])
|
||||
let &opfunc = Fn
|
||||
let g:OpFuncArgs = []
|
||||
normal! g@l
|
||||
call assert_equal([15, 'char'], g:OpFuncArgs)
|
||||
#" Using a funcref variable to set 'operatorfunc'
|
||||
LET Fn = funcref('g:MyopFunc', [14])
|
||||
LET &opfunc = Fn
|
||||
LET g:OpFuncArgs = []
|
||||
normal! g@l
|
||||
call assert_equal([14, 'char'], g:OpFuncArgs)
|
||||
|
||||
" Using a string(funcref_variable) to set 'operatorfunc'
|
||||
let Fn = funcref('MyopFunc', [16])
|
||||
let &opfunc = string(Fn)
|
||||
let g:OpFuncArgs = []
|
||||
normal! g@l
|
||||
call assert_equal([16, 'char'], g:OpFuncArgs)
|
||||
#" Using a string(funcref_variable) to set 'operatorfunc'
|
||||
LET Fn = funcref('g:MyopFunc', [15])
|
||||
LET &opfunc = string(Fn)
|
||||
LET g:OpFuncArgs = []
|
||||
normal! g@l
|
||||
call assert_equal([15, 'char'], g:OpFuncArgs)
|
||||
|
||||
" Test for using a lambda function using set
|
||||
set opfunc={a\ ->\ MyopFunc(17,\ a)}
|
||||
let g:OpFuncArgs = []
|
||||
normal! g@l
|
||||
call assert_equal([17, 'char'], g:OpFuncArgs)
|
||||
#" Test for using a lambda function using set
|
||||
VAR optval = "LSTART a LMIDDLE MyopFunc(16, a) LEND"
|
||||
LET optval = substitute(optval, ' ', '\\ ', 'g')
|
||||
exe "set opfunc=" .. optval
|
||||
LET g:OpFuncArgs = []
|
||||
normal! g@l
|
||||
call assert_equal([16, 'char'], g:OpFuncArgs)
|
||||
|
||||
" Test for using a lambda function using let
|
||||
let &opfunc = {a -> MyopFunc(18, a)}
|
||||
let g:OpFuncArgs = []
|
||||
normal! g@l
|
||||
call assert_equal([18, 'char'], g:OpFuncArgs)
|
||||
#" Test for using a lambda function using LET
|
||||
LET &opfunc = LSTART a LMIDDLE MyopFunc(17, a) LEND
|
||||
LET g:OpFuncArgs = []
|
||||
normal! g@l
|
||||
call assert_equal([17, 'char'], g:OpFuncArgs)
|
||||
|
||||
" Set 'operatorfunc' to a string(lambda expression)
|
||||
let &opfunc = '{a -> MyopFunc(19, a)}'
|
||||
let g:OpFuncArgs = []
|
||||
normal! g@l
|
||||
call assert_equal([19, 'char'], g:OpFuncArgs)
|
||||
#" Set 'operatorfunc' to a string(lambda expression)
|
||||
LET &opfunc = 'LSTART a LMIDDLE MyopFunc(18, a) LEND'
|
||||
LET g:OpFuncArgs = []
|
||||
normal! g@l
|
||||
call assert_equal([18, 'char'], g:OpFuncArgs)
|
||||
|
||||
" Set 'operatorfunc' to a variable with a lambda expression
|
||||
let Lambda = {a -> MyopFunc(20, a)}
|
||||
let &opfunc = Lambda
|
||||
let g:OpFuncArgs = []
|
||||
normal! g@l
|
||||
call assert_equal([20, 'char'], g:OpFuncArgs)
|
||||
#" Set 'operatorfunc' to a variable with a lambda expression
|
||||
VAR Lambda = LSTART a LMIDDLE MyopFunc(19, a) LEND
|
||||
LET &opfunc = Lambda
|
||||
LET g:OpFuncArgs = []
|
||||
normal! g@l
|
||||
call assert_equal([19, 'char'], g:OpFuncArgs)
|
||||
|
||||
" Set 'operatorfunc' to a string(variable with a lambda expression)
|
||||
let Lambda = {a -> MyopFunc(21, a)}
|
||||
let &opfunc = string(Lambda)
|
||||
let g:OpFuncArgs = []
|
||||
normal! g@l
|
||||
call assert_equal([21, 'char'], g:OpFuncArgs)
|
||||
#" Set 'operatorfunc' to a string(variable with a lambda expression)
|
||||
LET Lambda = LSTART a LMIDDLE MyopFunc(20, a) LEND
|
||||
LET &opfunc = string(Lambda)
|
||||
LET g:OpFuncArgs = []
|
||||
normal! g@l
|
||||
call assert_equal([20, 'char'], g:OpFuncArgs)
|
||||
|
||||
" Try to use 'operatorfunc' after the function is deleted
|
||||
func TmpOpFunc(type)
|
||||
let g:OpFuncArgs = [22, a:type]
|
||||
endfunc
|
||||
let &opfunc = function('TmpOpFunc')
|
||||
delfunc TmpOpFunc
|
||||
call test_garbagecollect_now()
|
||||
let g:OpFuncArgs = []
|
||||
call assert_fails('normal! g@l', 'E117:')
|
||||
call assert_equal([], g:OpFuncArgs)
|
||||
#" Try to use 'operatorfunc' after the function is deleted
|
||||
func g:TmpOpFunc(type)
|
||||
LET g:OpFuncArgs = [21, a:type]
|
||||
endfunc
|
||||
LET &opfunc = function('g:TmpOpFunc')
|
||||
delfunc g:TmpOpFunc
|
||||
call test_garbagecollect_now()
|
||||
LET g:OpFuncArgs = []
|
||||
call assert_fails('normal! g@l', 'E117:')
|
||||
call assert_equal([], g:OpFuncArgs)
|
||||
|
||||
" Try to use a function with two arguments for 'operatorfunc'
|
||||
func! MyopFunc2(x, y)
|
||||
let g:OpFuncArgs = [a:x, a:y]
|
||||
endfunc
|
||||
set opfunc=MyopFunc2
|
||||
let g:OpFuncArgs = []
|
||||
call assert_fails('normal! g@l', 'E119:')
|
||||
call assert_equal([], g:OpFuncArgs)
|
||||
#" Try to use a function with two arguments for 'operatorfunc'
|
||||
func MyopFunc2(x, y)
|
||||
LET g:OpFuncArgs = [a:x, a:y]
|
||||
endfunc
|
||||
set opfunc=MyopFunc2
|
||||
LET g:OpFuncArgs = []
|
||||
call assert_fails('normal! g@l', 'E119:')
|
||||
call assert_equal([], g:OpFuncArgs)
|
||||
|
||||
" Try to use a lambda function with two arguments for 'operatorfunc'
|
||||
let &opfunc = {a, b -> MyopFunc(23, b)}
|
||||
let g:OpFuncArgs = []
|
||||
call assert_fails('normal! g@l', 'E119:')
|
||||
call assert_equal([], g:OpFuncArgs)
|
||||
#" Try to use a lambda function with two arguments for 'operatorfunc'
|
||||
LET &opfunc = LSTART a, b LMIDDLE MyopFunc(22, b) LEND
|
||||
LET g:OpFuncArgs = []
|
||||
call assert_fails('normal! g@l', 'E119:')
|
||||
call assert_equal([], g:OpFuncArgs)
|
||||
|
||||
" Test for clearing the 'operatorfunc' option
|
||||
set opfunc=''
|
||||
set opfunc&
|
||||
#" Test for clearing the 'operatorfunc' option
|
||||
set opfunc=''
|
||||
set opfunc&
|
||||
call assert_fails("set opfunc=function('abc')", "E700:")
|
||||
call assert_fails("set opfunc=funcref('abc')", "E700:")
|
||||
|
||||
call assert_fails("set opfunc=function('abc')", "E700:")
|
||||
call assert_fails("set opfunc=funcref('abc')", "E700:")
|
||||
#" set 'operatorfunc' to a non-existing function
|
||||
LET &opfunc = function('g:MyopFunc', [23])
|
||||
call assert_fails("set opfunc=function('NonExistingFunc')", 'E700:')
|
||||
call assert_fails("LET &opfunc = function('NonExistingFunc')", 'E700:')
|
||||
LET g:OpFuncArgs = []
|
||||
normal! g@l
|
||||
call assert_equal([23, 'char'], g:OpFuncArgs)
|
||||
END
|
||||
call CheckTransLegacySuccess(lines)
|
||||
|
||||
" Using Vim9 lambda expression in legacy context should fail
|
||||
" set opfunc=(a)\ =>\ MyopFunc(24,\ a)
|
||||
@ -574,19 +587,24 @@ func Test_opfunc_callback()
|
||||
" call assert_fails('normal! g@l', 'E117:')
|
||||
call assert_equal([], g:OpFuncArgs)
|
||||
|
||||
" set 'operatorfunc' to a non-existing function
|
||||
let &opfunc = function('MyopFunc', [25])
|
||||
call assert_fails("set opfunc=function('NonExistingFunc')", 'E700:')
|
||||
call assert_fails("let &opfunc = function('NonExistingFunc')", 'E700:')
|
||||
let g:OpFuncArgs = []
|
||||
normal! g@l
|
||||
call assert_equal([25, 'char'], g:OpFuncArgs)
|
||||
" set 'operatorfunc' to a partial with dict. This used to cause a crash.
|
||||
func SetOpFunc()
|
||||
let operator = {'execute': function('OperatorExecute')}
|
||||
let &opfunc = operator.execute
|
||||
endfunc
|
||||
func OperatorExecute(_) dict
|
||||
endfunc
|
||||
call SetOpFunc()
|
||||
call test_garbagecollect_now()
|
||||
set operatorfunc=
|
||||
delfunc SetOpFunc
|
||||
delfunc OperatorExecute
|
||||
|
||||
" Vim9 tests
|
||||
let lines =<< trim END
|
||||
vim9script
|
||||
|
||||
# Test for using function()
|
||||
# Test for using a def function with opfunc
|
||||
def g:Vim9opFunc(val: number, type: string): void
|
||||
g:OpFuncArgs = [val, type]
|
||||
enddef
|
||||
@ -594,33 +612,6 @@ func Test_opfunc_callback()
|
||||
g:OpFuncArgs = []
|
||||
normal! g@l
|
||||
assert_equal([60, 'char'], g:OpFuncArgs)
|
||||
|
||||
# Test for using a lambda
|
||||
&opfunc = (a) => Vim9opFunc(61, a)
|
||||
g:OpFuncArgs = []
|
||||
normal! g@l
|
||||
assert_equal([61, 'char'], g:OpFuncArgs)
|
||||
|
||||
# Test for using a string(lambda)
|
||||
&opfunc = '(a) => Vim9opFunc(62, a)'
|
||||
g:OpFuncArgs = []
|
||||
normal! g@l
|
||||
assert_equal([62, 'char'], g:OpFuncArgs)
|
||||
|
||||
# Test for using a variable with a lambda expression
|
||||
var Fn: func = (a) => Vim9opFunc(63, a)
|
||||
&opfunc = Fn
|
||||
g:OpFuncArgs = []
|
||||
normal! g@l
|
||||
assert_equal([63, 'char'], g:OpFuncArgs)
|
||||
|
||||
# Test for using a string(variable with a lambda expression)
|
||||
Fn = (a) => Vim9opFunc(64, a)
|
||||
&opfunc = string(Fn)
|
||||
g:OpFuncArgs = []
|
||||
normal! g@l
|
||||
assert_equal([64, 'char'], g:OpFuncArgs)
|
||||
bw!
|
||||
END
|
||||
" call CheckScriptSuccess(lines)
|
||||
|
||||
|
||||
@ -1,6 +1,7 @@
|
||||
" Test for the quickfix feature.
|
||||
|
||||
source check.vim
|
||||
source vim9.vim
|
||||
CheckFeature quickfix
|
||||
|
||||
source screendump.vim
|
||||
@ -5690,6 +5691,131 @@ func Test_qftextfunc()
|
||||
call Xtest_qftextfunc('l')
|
||||
endfunc
|
||||
|
||||
func Test_qftextfunc_callback()
|
||||
let lines =<< trim END
|
||||
set efm=%f:%l:%c:%m
|
||||
|
||||
#" Test for using a function()
|
||||
set qftf=function('g:Tqfexpr')
|
||||
cexpr "F1:1:1:L1"
|
||||
copen
|
||||
call assert_equal('F1-L1C1-L1', getline(1))
|
||||
cclose
|
||||
|
||||
#" Using a funcref variable to set 'quickfixtextfunc'
|
||||
VAR Fn = function('g:Tqfexpr')
|
||||
LET &qftf = Fn
|
||||
cexpr "F2:2:2:L2"
|
||||
copen
|
||||
call assert_equal('F2-L2C2-L2', getline(1))
|
||||
cclose
|
||||
|
||||
#" Using string(funcref_variable) to set 'quickfixtextfunc'
|
||||
LET Fn = function('g:Tqfexpr')
|
||||
LET &qftf = string(Fn)
|
||||
cexpr "F3:3:3:L3"
|
||||
copen
|
||||
call assert_equal('F3-L3C3-L3', getline(1))
|
||||
cclose
|
||||
|
||||
#" Test for using a funcref()
|
||||
set qftf=funcref('g:Tqfexpr')
|
||||
cexpr "F4:4:4:L4"
|
||||
copen
|
||||
call assert_equal('F4-L4C4-L4', getline(1))
|
||||
cclose
|
||||
|
||||
#" Using a funcref variable to set 'quickfixtextfunc'
|
||||
LET Fn = funcref('g:Tqfexpr')
|
||||
LET &qftf = Fn
|
||||
cexpr "F5:5:5:L5"
|
||||
copen
|
||||
call assert_equal('F5-L5C5-L5', getline(1))
|
||||
cclose
|
||||
|
||||
#" Using a string(funcref_variable) to set 'quickfixtextfunc'
|
||||
LET Fn = funcref('g:Tqfexpr')
|
||||
LET &qftf = string(Fn)
|
||||
cexpr "F5:5:5:L5"
|
||||
copen
|
||||
call assert_equal('F5-L5C5-L5', getline(1))
|
||||
cclose
|
||||
|
||||
#" Test for using a lambda function with set
|
||||
VAR optval = "LSTART a LMIDDLE Tqfexpr(a) LEND"
|
||||
LET optval = substitute(optval, ' ', '\\ ', 'g')
|
||||
exe "set qftf=" .. optval
|
||||
cexpr "F6:6:6:L6"
|
||||
copen
|
||||
call assert_equal('F6-L6C6-L6', getline(1))
|
||||
cclose
|
||||
|
||||
#" Set 'quickfixtextfunc' to a lambda expression
|
||||
LET &qftf = LSTART a LMIDDLE Tqfexpr(a) LEND
|
||||
cexpr "F7:7:7:L7"
|
||||
copen
|
||||
call assert_equal('F7-L7C7-L7', getline(1))
|
||||
cclose
|
||||
|
||||
#" Set 'quickfixtextfunc' to string(lambda_expression)
|
||||
LET &qftf = "LSTART a LMIDDLE Tqfexpr(a) LEND"
|
||||
cexpr "F8:8:8:L8"
|
||||
copen
|
||||
call assert_equal('F8-L8C8-L8', getline(1))
|
||||
cclose
|
||||
|
||||
#" Set 'quickfixtextfunc' to a variable with a lambda expression
|
||||
VAR Lambda = LSTART a LMIDDLE Tqfexpr(a) LEND
|
||||
LET &qftf = Lambda
|
||||
cexpr "F9:9:9:L9"
|
||||
copen
|
||||
call assert_equal('F9-L9C9-L9', getline(1))
|
||||
cclose
|
||||
|
||||
#" Set 'quickfixtextfunc' to a string(variable with a lambda expression)
|
||||
LET Lambda = LSTART a LMIDDLE Tqfexpr(a) LEND
|
||||
LET &qftf = string(Lambda)
|
||||
cexpr "F9:9:9:L9"
|
||||
copen
|
||||
call assert_equal('F9-L9C9-L9', getline(1))
|
||||
cclose
|
||||
END
|
||||
call CheckLegacyAndVim9Success(lines)
|
||||
|
||||
" set 'quickfixtextfunc' to a partial with dict. This used to cause a crash.
|
||||
func SetQftfFunc()
|
||||
let params = {'qftf': function('g:DictQftfFunc')}
|
||||
let &quickfixtextfunc = params.qftf
|
||||
endfunc
|
||||
func g:DictQftfFunc(_) dict
|
||||
endfunc
|
||||
call SetQftfFunc()
|
||||
new
|
||||
call SetQftfFunc()
|
||||
bw
|
||||
call test_garbagecollect_now()
|
||||
new
|
||||
set qftf=
|
||||
wincmd w
|
||||
set qftf=
|
||||
:%bw!
|
||||
|
||||
" set per-quickfix list 'quickfixtextfunc' to a partial with dict. This used
|
||||
" to cause a crash.
|
||||
let &qftf = ''
|
||||
func SetLocalQftfFunc()
|
||||
let params = {'qftf': function('g:DictQftfFunc')}
|
||||
call setqflist([], 'a', {'quickfixtextfunc' : params.qftf})
|
||||
endfunc
|
||||
call SetLocalQftfFunc()
|
||||
call test_garbagecollect_now()
|
||||
call setqflist([], 'a', {'quickfixtextfunc' : ''})
|
||||
delfunc g:DictQftfFunc
|
||||
delfunc SetQftfFunc
|
||||
delfunc SetLocalQftfFunc
|
||||
set efm&
|
||||
endfunc
|
||||
|
||||
" Test for updating a location list for some other window and check that
|
||||
" 'qftextfunc' uses the correct location list.
|
||||
func Test_qftextfunc_other_loclist()
|
||||
|
||||
@ -1,5 +1,7 @@
|
||||
" Test 'tagfunc'
|
||||
|
||||
source vim9.vim
|
||||
|
||||
func TagFunc(pat, flag, info)
|
||||
let g:tagfunc_args = [a:pat, a:flag, a:info]
|
||||
let tags = []
|
||||
@ -130,55 +132,121 @@ func Test_tagfunc_callback()
|
||||
return v:null
|
||||
endfunc
|
||||
|
||||
" Test for using a function()
|
||||
set tagfunc=function('MytagFunc1',[10])
|
||||
new | only
|
||||
let g:MytagFunc1_args = []
|
||||
call assert_fails('tag a11', 'E433:')
|
||||
call assert_equal([10, 'a11', '', {}], g:MytagFunc1_args)
|
||||
let lines =<< trim END
|
||||
#" Test for using a function()
|
||||
set tagfunc=function('g:MytagFunc1',\ [10])
|
||||
new | only
|
||||
LET g:MytagFunc1_args = []
|
||||
call assert_fails('tag a11', 'E433:')
|
||||
call assert_equal([10, 'a11', '', {}], g:MytagFunc1_args)
|
||||
|
||||
" Using a funcref variable to set 'tagfunc'
|
||||
let Fn = function('MytagFunc1', [11])
|
||||
let &tagfunc = Fn
|
||||
new | only
|
||||
let g:MytagFunc1_args = []
|
||||
call assert_fails('tag a12', 'E433:')
|
||||
call assert_equal([11, 'a12', '', {}], g:MytagFunc1_args)
|
||||
#" Using a funcref variable to set 'tagfunc'
|
||||
VAR Fn = function('g:MytagFunc1', [11])
|
||||
LET &tagfunc = Fn
|
||||
new | only
|
||||
LET g:MytagFunc1_args = []
|
||||
call assert_fails('tag a12', 'E433:')
|
||||
call assert_equal([11, 'a12', '', {}], g:MytagFunc1_args)
|
||||
|
||||
" Using a string(funcref_variable) to set 'tagfunc'
|
||||
let Fn = function('MytagFunc1', [12])
|
||||
let &tagfunc = string(Fn)
|
||||
new | only
|
||||
let g:MytagFunc1_args = []
|
||||
call assert_fails('tag a12', 'E433:')
|
||||
call assert_equal([12, 'a12', '', {}], g:MytagFunc1_args)
|
||||
#" Using a string(funcref_variable) to set 'tagfunc'
|
||||
LET Fn = function('g:MytagFunc1', [12])
|
||||
LET &tagfunc = string(Fn)
|
||||
new | only
|
||||
LET g:MytagFunc1_args = []
|
||||
call assert_fails('tag a12', 'E433:')
|
||||
call assert_equal([12, 'a12', '', {}], g:MytagFunc1_args)
|
||||
|
||||
" Test for using a funcref()
|
||||
func MytagFunc2(pat, flags, info)
|
||||
let g:MytagFunc2_args = [a:pat, a:flags, a:info]
|
||||
return v:null
|
||||
endfunc
|
||||
set tagfunc=funcref('MytagFunc1',[13])
|
||||
new | only
|
||||
let g:MytagFunc1_args = []
|
||||
call assert_fails('tag a13', 'E433:')
|
||||
call assert_equal([13, 'a13', '', {}], g:MytagFunc1_args)
|
||||
#" Test for using a funcref()
|
||||
set tagfunc=funcref('g:MytagFunc1',\ [13])
|
||||
new | only
|
||||
LET g:MytagFunc1_args = []
|
||||
call assert_fails('tag a13', 'E433:')
|
||||
call assert_equal([13, 'a13', '', {}], g:MytagFunc1_args)
|
||||
|
||||
" Using a funcref variable to set 'tagfunc'
|
||||
let Fn = funcref('MytagFunc1', [14])
|
||||
let &tagfunc = Fn
|
||||
new | only
|
||||
let g:MytagFunc1_args = []
|
||||
call assert_fails('tag a14', 'E433:')
|
||||
call assert_equal([14, 'a14', '', {}], g:MytagFunc1_args)
|
||||
#" Using a funcref variable to set 'tagfunc'
|
||||
LET Fn = funcref('g:MytagFunc1', [14])
|
||||
LET &tagfunc = Fn
|
||||
new | only
|
||||
LET g:MytagFunc1_args = []
|
||||
call assert_fails('tag a14', 'E433:')
|
||||
call assert_equal([14, 'a14', '', {}], g:MytagFunc1_args)
|
||||
|
||||
" Using a string(funcref_variable) to set 'tagfunc'
|
||||
let Fn = funcref('MytagFunc1', [15])
|
||||
let &tagfunc = string(Fn)
|
||||
#" Using a string(funcref_variable) to set 'tagfunc'
|
||||
LET Fn = funcref('g:MytagFunc1', [15])
|
||||
LET &tagfunc = string(Fn)
|
||||
new | only
|
||||
LET g:MytagFunc1_args = []
|
||||
call assert_fails('tag a14', 'E433:')
|
||||
call assert_equal([15, 'a14', '', {}], g:MytagFunc1_args)
|
||||
|
||||
#" Test for using a lambda function
|
||||
VAR optval = "LSTART a, b, c LMIDDLE MytagFunc1(16, a, b, c) LEND"
|
||||
LET optval = substitute(optval, ' ', '\\ ', 'g')
|
||||
exe "set tagfunc=" .. optval
|
||||
new | only
|
||||
LET g:MytagFunc1_args = []
|
||||
call assert_fails('tag a17', 'E433:')
|
||||
call assert_equal([16, 'a17', '', {}], g:MytagFunc1_args)
|
||||
|
||||
#" Set 'tagfunc' to a lambda expression
|
||||
LET &tagfunc = LSTART a, b, c LMIDDLE MytagFunc1(17, a, b, c) LEND
|
||||
new | only
|
||||
LET g:MytagFunc1_args = []
|
||||
call assert_fails('tag a18', 'E433:')
|
||||
call assert_equal([17, 'a18', '', {}], g:MytagFunc1_args)
|
||||
|
||||
#" Set 'tagfunc' to a string(lambda expression)
|
||||
LET &tagfunc = 'LSTART a, b, c LMIDDLE MytagFunc1(18, a, b, c) LEND'
|
||||
new | only
|
||||
LET g:MytagFunc1_args = []
|
||||
call assert_fails('tag a18', 'E433:')
|
||||
call assert_equal([18, 'a18', '', {}], g:MytagFunc1_args)
|
||||
|
||||
#" Set 'tagfunc' to a variable with a lambda expression
|
||||
VAR Lambda = LSTART a, b, c LMIDDLE MytagFunc1(19, a, b, c) LEND
|
||||
LET &tagfunc = Lambda
|
||||
new | only
|
||||
LET g:MytagFunc1_args = []
|
||||
call assert_fails("tag a19", "E433:")
|
||||
call assert_equal([19, 'a19', '', {}], g:MytagFunc1_args)
|
||||
|
||||
#" Set 'tagfunc' to a string(variable with a lambda expression)
|
||||
LET Lambda = LSTART a, b, c LMIDDLE MytagFunc1(20, a, b, c) LEND
|
||||
LET &tagfunc = string(Lambda)
|
||||
new | only
|
||||
LET g:MytagFunc1_args = []
|
||||
call assert_fails("tag a19", "E433:")
|
||||
call assert_equal([20, 'a19', '', {}], g:MytagFunc1_args)
|
||||
|
||||
#" Test for using a lambda function with incorrect return value
|
||||
LET Lambda = LSTART a, b, c LMIDDLE strlen(a) LEND
|
||||
LET &tagfunc = string(Lambda)
|
||||
new | only
|
||||
call assert_fails("tag a20", "E987:")
|
||||
|
||||
#" Test for clearing the 'tagfunc' option
|
||||
set tagfunc=''
|
||||
set tagfunc&
|
||||
call assert_fails("set tagfunc=function('abc')", "E700:")
|
||||
call assert_fails("set tagfunc=funcref('abc')", "E700:")
|
||||
|
||||
#" set 'tagfunc' to a non-existing function
|
||||
LET &tagfunc = function('g:MytagFunc1', [21])
|
||||
call assert_fails("set tagfunc=function('NonExistingFunc')", 'E700:')
|
||||
call assert_fails("LET &tagfunc = function('NonExistingFunc')", 'E700:')
|
||||
call assert_fails("tag axb123", 'E426:')
|
||||
END
|
||||
call CheckLegacyAndVim9Success(lines)
|
||||
|
||||
let &tagfunc = "{a -> 'abc'}"
|
||||
call assert_fails("echo taglist('a')", "E987:")
|
||||
|
||||
" Using Vim9 lambda expression in legacy context should fail
|
||||
" set tagfunc=(a,\ b,\ c)\ =>\ g:MytagFunc1(21,\ a,\ b,\ c)
|
||||
new | only
|
||||
let g:MytagFunc1_args = []
|
||||
call assert_fails('tag a14', 'E433:')
|
||||
call assert_equal([15, 'a14', '', {}], g:MytagFunc1_args)
|
||||
" call assert_fails("tag a17", "E117:")
|
||||
call assert_equal([], g:MytagFunc1_args)
|
||||
|
||||
" Test for using a script local function
|
||||
set tagfunc=<SID>ScriptLocalTagFunc
|
||||
@ -203,70 +271,25 @@ func Test_tagfunc_callback()
|
||||
call assert_fails('tag a16', 'E433:')
|
||||
call assert_equal(['a16', '', {}], g:ScriptLocalFuncArgs)
|
||||
|
||||
" Test for using a lambda function
|
||||
set tagfunc={a,\ b,\ c\ ->\ MytagFunc1(16,\ a,\ b,\ c)}
|
||||
new | only
|
||||
let g:MytagFunc1_args = []
|
||||
call assert_fails('tag a17', 'E433:')
|
||||
call assert_equal([16, 'a17', '', {}], g:MytagFunc1_args)
|
||||
|
||||
" Set 'tagfunc' to a lambda expression
|
||||
let &tagfunc = {a, b, c -> MytagFunc1(17, a, b, c)}
|
||||
new | only
|
||||
let g:MytagFunc1_args = []
|
||||
call assert_fails('tag a18', 'E433:')
|
||||
call assert_equal([17, 'a18', '', {}], g:MytagFunc1_args)
|
||||
|
||||
" Set 'tagfunc' to a string(lambda expression)
|
||||
let &tagfunc = '{a, b, c -> MytagFunc1(18, a, b, c)}'
|
||||
new | only
|
||||
let g:MytagFunc1_args = []
|
||||
call assert_fails('tag a18', 'E433:')
|
||||
call assert_equal([18, 'a18', '', {}], g:MytagFunc1_args)
|
||||
|
||||
" Set 'tagfunc' to a variable with a lambda expression
|
||||
let Lambda = {a, b, c -> MytagFunc1(19, a, b, c)}
|
||||
let &tagfunc = Lambda
|
||||
new | only
|
||||
let g:MytagFunc1_args = []
|
||||
call assert_fails("tag a19", "E433:")
|
||||
call assert_equal([19, 'a19', '', {}], g:MytagFunc1_args)
|
||||
|
||||
" Set 'tagfunc' to a string(variable with a lambda expression)
|
||||
let Lambda = {a, b, c -> MytagFunc1(20, a, b, c)}
|
||||
let &tagfunc = string(Lambda)
|
||||
new | only
|
||||
let g:MytagFunc1_args = []
|
||||
call assert_fails("tag a19", "E433:")
|
||||
call assert_equal([20, 'a19', '', {}], g:MytagFunc1_args)
|
||||
|
||||
" Test for using a lambda function with incorrect return value
|
||||
let Lambda = {s -> strlen(s)}
|
||||
let &tagfunc = string(Lambda)
|
||||
new | only
|
||||
call assert_fails("tag a20", "E987:")
|
||||
|
||||
" Test for clearing the 'tagfunc' option
|
||||
set tagfunc=''
|
||||
set tagfunc&
|
||||
|
||||
call assert_fails("set tagfunc=function('abc')", "E700:")
|
||||
call assert_fails("set tagfunc=funcref('abc')", "E700:")
|
||||
let &tagfunc = "{a -> 'abc'}"
|
||||
call assert_fails("echo taglist('a')", "E987:")
|
||||
|
||||
" Using Vim9 lambda expression in legacy context should fail
|
||||
" set tagfunc=(a,\ b,\ c)\ =>\ g:MytagFunc1(21,\ a,\ b,\ c)
|
||||
new | only
|
||||
let g:MytagFunc1_args = []
|
||||
" call assert_fails("tag a17", "E117:")
|
||||
call assert_equal([], g:MytagFunc1_args)
|
||||
|
||||
" set 'tagfunc' to a non-existing function
|
||||
call assert_fails("set tagfunc=function('NonExistingFunc')", 'E700:')
|
||||
call assert_fails("let &tagfunc = function('NonExistingFunc')", 'E700:')
|
||||
call assert_fails("tag axb123", 'E426:')
|
||||
bw!
|
||||
" set 'tagfunc' to a partial with dict. This used to cause a crash.
|
||||
func SetTagFunc()
|
||||
let params = {'tagfn': function('g:DictTagFunc')}
|
||||
let &tagfunc = params.tagfn
|
||||
endfunc
|
||||
func g:DictTagFunc(_) dict
|
||||
endfunc
|
||||
call SetTagFunc()
|
||||
new
|
||||
call SetTagFunc()
|
||||
bw
|
||||
call test_garbagecollect_now()
|
||||
new
|
||||
set tagfunc=
|
||||
wincmd w
|
||||
set tagfunc=
|
||||
:%bw!
|
||||
delfunc g:DictTagFunc
|
||||
delfunc SetTagFunc
|
||||
|
||||
" Vim9 tests
|
||||
let lines =<< trim END
|
||||
@ -282,42 +305,11 @@ func Test_tagfunc_callback()
|
||||
g:Vim9tagFuncArgs = []
|
||||
assert_fails('tag a10', 'E433:')
|
||||
assert_equal([60, 'a10', '', {}], g:Vim9tagFuncArgs)
|
||||
|
||||
# Test for using a lambda
|
||||
&tagfunc = (a, b, c) => MytagFunc1(61, a, b, c)
|
||||
new | only
|
||||
g:MytagFunc1_args = []
|
||||
assert_fails('tag a20', 'E433:')
|
||||
assert_equal([61, 'a20', '', {}], g:MytagFunc1_args)
|
||||
|
||||
# Test for using a string(lambda)
|
||||
&tagfunc = '(a, b, c) => MytagFunc1(62, a, b, c)'
|
||||
new | only
|
||||
g:MytagFunc1_args = []
|
||||
assert_fails('tag a20', 'E433:')
|
||||
assert_equal([62, 'a20', '', {}], g:MytagFunc1_args)
|
||||
|
||||
# Test for using a variable with a lambda expression
|
||||
var Fn: func = (a, b, c) => MytagFunc1(63, a, b, c)
|
||||
&tagfunc = Fn
|
||||
new | only
|
||||
g:MytagFunc1_args = []
|
||||
assert_fails('tag a30', 'E433:')
|
||||
assert_equal([63, 'a30', '', {}], g:MytagFunc1_args)
|
||||
|
||||
# Test for using a variable with a lambda expression
|
||||
Fn = (a, b, c) => MytagFunc1(64, a, b, c)
|
||||
&tagfunc = string(Fn)
|
||||
new | only
|
||||
g:MytagFunc1_args = []
|
||||
assert_fails('tag a30', 'E433:')
|
||||
assert_equal([64, 'a30', '', {}], g:MytagFunc1_args)
|
||||
END
|
||||
" call CheckScriptSuccess(lines)
|
||||
|
||||
" cleanup
|
||||
delfunc MytagFunc1
|
||||
delfunc MytagFunc2
|
||||
set tagfunc&
|
||||
%bw!
|
||||
endfunc
|
||||
|
||||
80
src/nvim/testdir/vim9.vim
Normal file
80
src/nvim/testdir/vim9.vim
Normal file
@ -0,0 +1,80 @@
|
||||
|
||||
" Use a different file name for each run.
|
||||
let s:sequence = 1
|
||||
|
||||
" Check that "lines" inside a legacy function has no error.
|
||||
func CheckLegacySuccess(lines)
|
||||
let cwd = getcwd()
|
||||
let fname = 'XlegacySuccess' .. s:sequence
|
||||
let s:sequence += 1
|
||||
call writefile(['func Func()'] + a:lines + ['endfunc'], fname)
|
||||
try
|
||||
exe 'so ' .. fname
|
||||
call Func()
|
||||
finally
|
||||
delfunc! Func
|
||||
call chdir(cwd)
|
||||
call delete(fname)
|
||||
endtry
|
||||
endfunc
|
||||
|
||||
" Check that "lines" inside a legacy function results in the expected error
|
||||
func CheckLegacyFailure(lines, error)
|
||||
let cwd = getcwd()
|
||||
let fname = 'XlegacyFails' .. s:sequence
|
||||
let s:sequence += 1
|
||||
call writefile(['func Func()'] + a:lines + ['endfunc', 'call Func()'], fname)
|
||||
try
|
||||
call assert_fails('so ' .. fname, a:error)
|
||||
finally
|
||||
delfunc! Func
|
||||
call chdir(cwd)
|
||||
call delete(fname)
|
||||
endtry
|
||||
endfunc
|
||||
|
||||
" Execute "lines" in a legacy function, translated as in
|
||||
" CheckLegacyAndVim9Success()
|
||||
func CheckTransLegacySuccess(lines)
|
||||
let legacylines = a:lines->deepcopy()->map({_, v ->
|
||||
\ v->substitute('\<VAR\>', 'let', 'g')
|
||||
\ ->substitute('\<LET\>', 'let', 'g')
|
||||
\ ->substitute('\<LSTART\>', '{', 'g')
|
||||
\ ->substitute('\<LMIDDLE\>', '->', 'g')
|
||||
\ ->substitute('\<LEND\>', '}', 'g')
|
||||
\ ->substitute('\<TRUE\>', '1', 'g')
|
||||
\ ->substitute('\<FALSE\>', '0', 'g')
|
||||
\ ->substitute('#"', ' "', 'g')
|
||||
\ })
|
||||
call CheckLegacySuccess(legacylines)
|
||||
endfunc
|
||||
|
||||
" Execute "lines" in a legacy function
|
||||
" Use 'VAR' for a declaration.
|
||||
" Use 'LET' for an assignment
|
||||
" Use ' #"' for a comment
|
||||
" Use LSTART arg LMIDDLE expr LEND for lambda
|
||||
" Use 'TRUE' for 1
|
||||
" Use 'FALSE' for 0
|
||||
func CheckLegacyAndVim9Success(lines)
|
||||
call CheckTransLegacySuccess(a:lines)
|
||||
endfunc
|
||||
|
||||
" Execute "lines" in a legacy function
|
||||
" Use 'VAR' for a declaration.
|
||||
" Use 'LET' for an assignment
|
||||
" Use ' #"' for a comment
|
||||
func CheckLegacyAndVim9Failure(lines, error)
|
||||
if type(a:error) == type('string')
|
||||
let legacyError = error
|
||||
else
|
||||
let legacyError = error[0]
|
||||
endif
|
||||
|
||||
let legacylines = a:lines->deepcopy()->map({_, v ->
|
||||
\ v->substitute('\<VAR\>', 'let', 'g')
|
||||
\ ->substitute('\<LET\>', 'let', 'g')
|
||||
\ ->substitute('#"', ' "', 'g')
|
||||
\ })
|
||||
call CheckLegacyFailure(legacylines, legacyError)
|
||||
endfunc
|
||||
Loading…
Reference in New Issue
Block a user