Archive/vim
1
0
Fork 0
mirror of https://github.com/vim/vim.git synced 2025-12-10 18:46:57 -05:00
Code Issues Packages Projects Releases Wiki Activity

patch 8.2.3788: lambda for option that is a function may be freed

Browse Source 
Problem:    Lambda for option that is a function may be garbage collected.
Solution:   Set a reference in the funcref. (Yegappan Lakshmanan,
            closes #9330)
This commit is contained in:
Yegappan Lakshmanan
2021-12-12 16:26:44 +00:00
committed by Bram Moolenaar
parent 6e371ecb27
commit 6ae8fae869
19 changed files with 1090 additions and 897 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
src/eval.c
View File

@ -4516,6 +4516,18 @@ garbage_collect(int testing)
// callbacks in buffers
abort = abort || set_ref_in_buffers(copyID);
// 'completefunc', 'omnifunc' and 'thesaurusfunc' callbacks
abort = abort || set_ref_in_insexpand_funcs(copyID);
// 'operatorfunc' callback
abort = abort || set_ref_in_opfunc(copyID);
// 'tagfunc' callback
abort = abort || set_ref_in_tagfunc(copyID);
// 'imactivatefunc' and 'imstatusfunc' callbacks
abort = abort || set_ref_in_im_funcs(copyID);
#ifdef FEAT_LUA
abort = abort || set_ref_in_lua(copyID);
#endif
@ -4743,6 +4755,22 @@ set_ref_in_list_items(list_T *l, int copyID, ht_stack_T **ht_stack)
return abort;
}
/*
* Mark the partial in callback 'cb' with "copyID".
*/
int
set_ref_in_callback(callback_T *cb, int copyID)
{
typval_T tv;
if (cb->cb_name == NULL || *cb->cb_name == NUL || cb->cb_partial == NULL)
return FALSE;
tv.v_type = VAR_PARTIAL;
tv.vval.v_partial = cb->cb_partial;
return set_ref_in_item(&tv, copyID, NULL, NULL);
}
/*
* Mark all lists and dicts referenced through typval "tv" with "copyID".
* "list_stack" is used to add lists to be marked. Can be NULL.

36
src/evalbuffer.c
View File

@ -26,31 +26,25 @@ set_ref_in_buffers(int copyID)
FOR_ALL_BUFFERS(bp)
{
listener_T *lnr;
typval_T tv;
for (lnr = bp->b_listener; !abort && lnr != NULL; lnr = lnr->lr_next)
{
if (lnr->lr_callback.cb_partial != NULL)
{
tv.v_type = VAR_PARTIAL;
tv.vval.v_partial = lnr->lr_callback.cb_partial;
abort = abort || set_ref_in_item(&tv, copyID, NULL, NULL);
}
}
abort = abort || set_ref_in_callback(&lnr->lr_callback, copyID);
# ifdef FEAT_JOB_CHANNEL
if (!abort && bp->b_prompt_callback.cb_partial != NULL)
{
tv.v_type = VAR_PARTIAL;
tv.vval.v_partial = bp->b_prompt_callback.cb_partial;
abort = abort || set_ref_in_item(&tv, copyID, NULL, NULL);
}
if (!abort && bp->b_prompt_interrupt.cb_partial != NULL)
{
tv.v_type = VAR_PARTIAL;
tv.vval.v_partial = bp->b_prompt_interrupt.cb_partial;
abort = abort || set_ref_in_item(&tv, copyID, NULL, NULL);
}
if (!abort)
abort = abort || set_ref_in_callback(&bp->b_prompt_callback, copyID);
if (!abort)
abort = abort || set_ref_in_callback(&bp->b_prompt_interrupt, copyID);
# endif
#ifdef FEAT_COMPL_FUNC
if (!abort)
abort = abort || set_ref_in_callback(&bp->b_cfu_cb, copyID);
if (!abort)
abort = abort || set_ref_in_callback(&bp->b_ofu_cb, copyID);
if (!abort)
abort = abort || set_ref_in_callback(&bp->b_tsrfu_cb, copyID);
#endif
if (!abort)
abort = abort || set_ref_in_callback(&bp->b_tfu_cb, copyID);
if (abort)
break;
}

1
src/evalvars.c
View File

@ -1395,7 +1395,6 @@ ex_let_option(
char_u *tofree = NULL;
char_u numbuf[NUMBUFLEN];
c1 = *p;
*p = NUL;

20
src/gui_xim.c
View File

@ -117,7 +117,7 @@ call_imstatusfunc(void)
void
free_xim_stuff(void)
{
#if defined(FEAT_EVAL) && \
# if defined(FEAT_EVAL) && \
(defined(FEAT_XIM) || defined(IME_WITHOUT_XIM) || defined(VIMDLL))
free_callback(&imaf_cb);
free_callback(&imsf_cb);
@ -125,6 +125,24 @@ free_xim_stuff(void)
}
#endif
/*
* Mark the global 'imactivatefunc' and 'imstatusfunc' callbacks with 'copyID'
* so that they are not garbage collected.
*/
int
set_ref_in_im_funcs(int copyID UNUSED)
{
int abort = FALSE;
#if defined(FEAT_EVAL) && \
(defined(FEAT_XIM) || defined(IME_WITHOUT_XIM) || defined(VIMDLL))
abort = set_ref_in_callback(&imaf_cb, copyID);
abort = abort || set_ref_in_callback(&imsf_cb, copyID);
#endif
return abort;
}
#if defined(FEAT_XIM) || defined(PROTO)

15
src/insexpand.c
View File

@ -2341,6 +2341,21 @@ set_thesaurusfunc_option(void)
return retval;
}
/*
* Mark the global 'completefunc' 'omnifunc' and 'thesaurusfunc' callbacks with
* 'copyID' so that they are not garbage collected.
*/
int
set_ref_in_insexpand_funcs(int copyID)
{
int abort = FALSE;
abort = set_ref_in_callback(&cfu_cb, copyID);
abort = abort || set_ref_in_callback(&ofu_cb, copyID);
abort = abort || set_ref_in_callback(&tsrfu_cb, copyID);
return abort;
}
/*
* Get the user-defined completion function name for completion 'type'

20
src/ops.c
View File

@ -3341,12 +3341,28 @@ set_operatorfunc_option(void)
void
free_operatorfunc_option(void)
{
# ifdef FEAT_EVAL
# ifdef FEAT_EVAL
free_callback(&opfunc_cb);
# endif
# endif
}
#endif
/*
* Mark the global 'operatorfunc' callback with 'copyID' so that it is not
* garbage collected.
*/
int
set_ref_in_opfunc(int copyID UNUSED)
{
int abort = FALSE;
#ifdef FEAT_EVAL
abort = set_ref_in_callback(&opfunc_cb, copyID);
#endif
return abort;
}
/*
* Handle the "g@" operator: call 'operatorfunc'.
*/

1
src/proto/eval.pro
View File

@ -52,6 +52,7 @@ int set_ref_in_ht(hashtab_T *ht, int copyID, list_stack_T **list_stack);
int set_ref_in_dict(dict_T *d, int copyID);
int set_ref_in_list(list_T *ll, int copyID);
int set_ref_in_list_items(list_T *l, int copyID, ht_stack_T **ht_stack);
int set_ref_in_callback(callback_T *cb, int copyID);
int set_ref_in_item(typval_T *tv, int copyID, ht_stack_T **ht_stack, list_stack_T **list_stack);
char_u *echo_string_core(typval_T *tv, char_u **tofree, char_u *numbuf, int copyID, int echo_style, int restore_copyID, int composite_val);
char_u *echo_string(typval_T *tv, char_u **tofree, char_u *numbuf, int copyID);

1
src/proto/gui_xim.pro
View File

@ -2,6 +2,7 @@
int set_imactivatefunc_option(void);
int set_imstatusfunc_option(void);
void free_xim_stuff(void);
int set_ref_in_im_funcs(int copyID);
void im_set_active(int active);
void xim_set_focus(int focus);
void im_set_position(int row, int col);

1
src/proto/insexpand.pro
View File

@ -44,6 +44,7 @@ void set_buflocal_cfu_callback(buf_T *buf);
int set_omnifunc_option(void);
void set_buflocal_ofu_callback(buf_T *buf);
int set_thesaurusfunc_option(void);
int set_ref_in_insexpand_funcs(int copyID);
callback_T *get_insert_callback(int type);
void f_complete(typval_T *argvars, typval_T *rettv);
void f_complete_add(typval_T *argvars, typval_T *rettv);

1
src/proto/ops.pro
View File

@ -19,5 +19,6 @@ void clear_oparg(oparg_T *oap);
void cursor_pos_info(dict_T *dict);
int set_operatorfunc_option(void);
void free_operatorfunc_option(void);
int set_ref_in_opfunc(int copyID);
void do_pending_operator(cmdarg_T *cap, int old_col, int gui_yank);
/* vim: set ft=c : */

1
src/proto/tag.pro
View File

@ -1,6 +1,7 @@
/* tag.c */
int set_tagfunc_option(void);
void free_tagfunc_option(void);
int set_ref_in_tagfunc(int copyID);
void set_buflocal_tfu_callback(buf_T *buf);
int do_tag(char_u *tag, int type, int count, int forceit, int verbose);
void tag_freematch(void);

13
src/quickfix.c
View File

@ -7675,7 +7675,8 @@ set_errorlist(
}
/*
* 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 int
mark_quickfix_ctx(qf_info_T *qi, int copyID)
@ -7683,13 +7684,17 @@ mark_quickfix_ctx(qf_info_T *qi, int copyID)
int i;
int abort = FALSE;
typval_T *ctx;
callback_T *cb;
for (i = 0; i < LISTCOUNT && !abort; ++i)
{
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);
cb = &qi->qf_lists[i].qftf_cb;
abort = abort || set_ref_in_callback(cb, copyID);
}
return abort;
@ -7710,6 +7715,10 @@ set_ref_in_quickfix(int copyID)
if (abort)
return abort;
abort = set_ref_in_callback(&qftf_cb, copyID);
if (abort)
return abort;
FOR_ALL_TAB_WINDOWS(tp, win)
{
if (win->w_llist != NULL)

24
src/tag.c
View File

@ -133,15 +133,31 @@ set_tagfunc_option(void)
return OK;
}
# if defined(EXITFREE) || defined(PROTO)
#if defined(EXITFREE) || defined(PROTO)
void
free_tagfunc_option(void)
{
# ifdef FEAT_EVAL
# ifdef FEAT_EVAL
free_callback(&tfu_cb);
# endif
}
# endif
}
#endif
/*
* Mark the global 'tagfunc' callback with 'copyID' so that it is not garbage
* collected.
*/
int
set_ref_in_tagfunc(int copyID UNUSED)
{
int abort = FALSE;
#ifdef FEAT_EVAL
abort = set_ref_in_callback(&tfu_cb, copyID);
#endif
return abort;
}
/*
* Copy the global 'tagfunc' callback function to the buffer-local 'tagfunc'

230
src/testdir/test_iminsert.vim
View File

@ -119,83 +119,142 @@ func Test_imactivatefunc_imstatusfunc_callback()
let g:IMstatusfunc_called += 1
return 1
endfunc
let g:IMactivatefunc_called = 0
let g:IMstatusfunc_called = 0
set iminsert=2
" Test for using a function()
set imactivatefunc=function('IMactivatefunc1')
set imstatusfunc=function('IMstatusfunc1')
normal! i
let lines =<< trim END
LET g:IMactivatefunc_called = 0
LET g:IMstatusfunc_called = 0
" Using a funcref variable to set 'completefunc'
let Fn1 = function('IMactivatefunc1')
let &imactivatefunc = Fn1
let Fn2 = function('IMstatusfunc1')
let &imstatusfunc = Fn2
normal! i
#" Test for using a function()
set imactivatefunc=function('g:IMactivatefunc1')
set imstatusfunc=function('g:IMstatusfunc1')
normal! i
" Using a string(funcref variable) to set 'completefunc'
let &imactivatefunc = string(Fn1)
let &imstatusfunc = string(Fn2)
normal! i
#" Using a funcref variable to set 'completefunc'
VAR Fn1 = function('g:IMactivatefunc1')
LET &imactivatefunc = Fn1
VAR Fn2 = function('g:IMstatusfunc1')
LET &imstatusfunc = Fn2
normal! i
" Test for using a funcref()
set imactivatefunc=funcref('IMactivatefunc1')
set imstatusfunc=funcref('IMstatusfunc1')
normal! i
#" Using a string(funcref variable) to set 'completefunc'
LET &imactivatefunc = string(Fn1)
LET &imstatusfunc = string(Fn2)
normal! i
" Using a funcref variable to set 'imactivatefunc'
let Fn1 = funcref('IMactivatefunc1')
let &imactivatefunc = Fn1
let Fn2 = funcref('IMstatusfunc1')
let &imstatusfunc = Fn2
normal! i
#" Test for using a funcref()
set imactivatefunc=funcref('g:IMactivatefunc1')
set imstatusfunc=funcref('g:IMstatusfunc1')
normal! i
" Using a string(funcref variable) to set 'imactivatefunc'
let &imactivatefunc = string(Fn1)
let &imstatusfunc = string(Fn2)
normal! i
#" Using a funcref variable to set 'imactivatefunc'
LET Fn1 = funcref('g:IMactivatefunc1')
LET &imactivatefunc = Fn1
LET Fn2 = funcref('g:IMstatusfunc1')
LET &imstatusfunc = Fn2
normal! i
" Test for using a lambda function
set imactivatefunc={a\ ->\ IMactivatefunc1(a)}
set imstatusfunc={\ ->\ IMstatusfunc1()}
normal! i
#" Using a string(funcref variable) to set 'imactivatefunc'
LET &imactivatefunc = string(Fn1)
LET &imstatusfunc = string(Fn2)
normal! i
" Set 'imactivatefunc' and 'imstatusfunc' to a lambda expression
let &imactivatefunc = {a -> IMactivatefunc1(a)}
let &imstatusfunc = { -> IMstatusfunc1()}
normal! i
#" Test for using a lambda function
VAR optval = "LSTART a LMIDDLE IMactivatefunc1(a) LEND"
LET optval = substitute(optval, ' ', '\\ ', 'g')
exe "set imactivatefunc=" .. optval
LET optval = "LSTART LMIDDLE IMstatusfunc1() LEND"
LET optval = substitute(optval, ' ', '\\ ', 'g')
exe "set imstatusfunc=" .. optval
normal! i
" Set 'imactivatefunc' and 'imstatusfunc' to a string(lambda expression)
let &imactivatefunc = '{a -> IMactivatefunc1(a)}'
let &imstatusfunc = '{ -> IMstatusfunc1()}'
normal! i
#" Set 'imactivatefunc' and 'imstatusfunc' to a lambda expression
LET &imactivatefunc = LSTART a LMIDDLE IMactivatefunc1(a) LEND
LET &imstatusfunc = LSTART LMIDDLE IMstatusfunc1() LEND
normal! i
" Set 'imactivatefunc' 'imstatusfunc' to a variable with a lambda expression
let Lambda1 = {a -> IMactivatefunc1(a)}
let Lambda2 = { -> IMstatusfunc1()}
let &imactivatefunc = Lambda1
let &imstatusfunc = Lambda2
normal! i
#" Set 'imactivatefunc' and 'imstatusfunc' to a string(lambda expression)
LET &imactivatefunc = 'LSTART a LMIDDLE IMactivatefunc1(a) LEND'
LET &imstatusfunc = 'LSTART LMIDDLE IMstatusfunc1() LEND'
normal! i
" Set 'imactivatefunc' 'imstatusfunc' to a string(variable with a lambda
" expression)
let &imactivatefunc = string(Lambda1)
let &imstatusfunc = string(Lambda2)
normal! i
#" Set 'imactivatefunc' 'imstatusfunc' to a variable with a lambda
#" expression
VAR Lambda1 = LSTART a LMIDDLE IMactivatefunc1(a) LEND
VAR Lambda2 = LSTART LMIDDLE IMstatusfunc1() LEND
LET &imactivatefunc = Lambda1
LET &imstatusfunc = Lambda2
normal! i
" Test for clearing the 'completefunc' option
set imactivatefunc='' imstatusfunc=''
set imactivatefunc& imstatusfunc&
#" Set 'imactivatefunc' 'imstatusfunc' to a string(variable with a lambda
#" expression)
LET &imactivatefunc = string(Lambda1)
LET &imstatusfunc = string(Lambda2)
normal! i
call assert_fails("set imactivatefunc=function('abc')", "E700:")
call assert_fails("set imstatusfunc=function('abc')", "E700:")
call assert_fails("set imactivatefunc=funcref('abc')", "E700:")
call assert_fails("set imstatusfunc=funcref('abc')", "E700:")
#" Test for clearing the 'completefunc' option
set imactivatefunc='' imstatusfunc=''
set imactivatefunc& imstatusfunc&
call assert_equal(11, g:IMactivatefunc_called)
call assert_equal(22, g:IMstatusfunc_called)
set imactivatefunc=g:IMactivatefunc1
set imstatusfunc=g:IMstatusfunc1
call assert_fails("set imactivatefunc=function('abc')", "E700:")
call assert_fails("set imstatusfunc=function('abc')", "E700:")
call assert_fails("set imactivatefunc=funcref('abc')", "E700:")
call assert_fails("set imstatusfunc=funcref('abc')", "E700:")
call assert_fails("LET &imstatusfunc = function('abc')", "E700:")
call assert_fails("LET &imactivatefunc = function('abc')", "E700:")
normal! i
#" set 'imactivatefunc' and 'imstatusfunc' to a non-existing function
set imactivatefunc=IMactivatefunc1
set imstatusfunc=IMstatusfunc1
call assert_fails("set imactivatefunc=function('NonExistingFunc')", 'E700:')
call assert_fails("set imstatusfunc=function('NonExistingFunc')", 'E700:')
call assert_fails("LET &imactivatefunc = function('NonExistingFunc')", 'E700:')
call assert_fails("LET &imstatusfunc = function('NonExistingFunc')", 'E700:')
normal! i
call assert_equal(13, g:IMactivatefunc_called)
call assert_equal(26, g:IMstatusfunc_called)
END
call CheckLegacyAndVim9Success(lines)
" Using Vim9 lambda expression in legacy context should fail
set imactivatefunc=(a)\ =>\ IMactivatefunc1(a)
set imstatusfunc=IMstatusfunc1
call assert_fails('normal! i', 'E117:')
set imactivatefunc=IMactivatefunc1
set imstatusfunc=()\ =>\ IMstatusfunc1(a)
call assert_fails('normal! i', 'E117:')
" set 'imactivatefunc' and 'imstatusfunc' to a partial with dict. This used
" to cause a crash.
func SetIMFunc()
let params1 = {'activate': function('g:DictActivateFunc')}
let params2 = {'status': function('g:DictStatusFunc')}
let &imactivatefunc = params1.activate
let &imstatusfunc = params2.status
endfunc
func g:DictActivateFunc(_) dict
endfunc
func g:DictStatusFunc(_) dict
endfunc
call SetIMFunc()
new
call SetIMFunc()
bw
call test_garbagecollect_now()
new
set imactivatefunc=
set imstatusfunc=
wincmd w
set imactivatefunc=
set imstatusfunc=
:%bw!
delfunc g:DictActivateFunc
delfunc g:DictStatusFunc
delfunc SetIMFunc
" Vim9 tests
let lines =<< trim END
@ -217,59 +276,12 @@ func Test_imactivatefunc_imstatusfunc_callback()
set imstatusfunc=function('IMstatusfunc1')
normal! i
# Test for using a lambda
&imactivatefunc = '(a) => IMactivatefunc1(a)'
&imstatusfunc = '() => IMstatusfunc1()'
normal! i
# Test for using a variable with a lambda expression
var Fn1: func = (active) => {
g:IMactivatefunc_called += 1
return 1
}
var Fn2: func = () => {
g:IMstatusfunc_called += 1
return 1
}
&imactivatefunc = Fn1
&imstatusfunc = Fn2
normal! i
# Test for using a string(variable with a lambda expression)
&imactivatefunc = string(Fn1)
&imstatusfunc = string(Fn2)
normal! i
assert_equal(4, g:IMactivatefunc_called)
assert_equal(8, g:IMstatusfunc_called)
set iminsert=0
set imactivatefunc=
set imstatusfunc=
END
call CheckScriptSuccess(lines)
" Using Vim9 lambda expression in legacy context should fail
set imactivatefunc=(a)\ =>\ IMactivatefunc1(a)
set imstatusfunc=IMstatusfunc1
call assert_fails('normal! i', 'E117:')
set imactivatefunc=IMactivatefunc1
set imstatusfunc=()\ =>\ IMstatusfunc1(a)
call assert_fails('normal! i', 'E117:')
" set 'imactivatefunc' and 'imstatusfunc' to a non-existing function
set imactivatefunc=IMactivatefunc1
set imstatusfunc=IMstatusfunc1
call assert_fails("set imactivatefunc=function('NonExistingFunc')", 'E700:')
call assert_fails("set imstatusfunc=function('NonExistingFunc')", 'E700:')
call assert_fails("let &imactivatefunc = function('NonExistingFunc')", 'E700:')
call assert_fails("let &imstatusfunc = function('NonExistingFunc')", 'E700:')
let g:IMactivatefunc_called = 0
let g:IMstatusfunc_called = 0
normal! i
call assert_equal(2, g:IMactivatefunc_called)
call assert_equal(2, g:IMstatusfunc_called)
" cleanup
delfunc IMactivatefunc1
delfunc IMstatusfunc1

965
src/testdir/test_ins_complete.vim
View File

File diff suppressed because it is too large Load Diff

238
src/testdir/test_normal.vim
View File

@ -448,110 +448,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)
@ -559,19 +571,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
@ -579,33 +596,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)

126
src/testdir/test_quickfix.vim
View File

@ -1,6 +1,7 @@
" Test for the quickfix feature.
source check.vim
source vim9.vim
CheckFeature quickfix
source screendump.vim
@ -5282,6 +5283,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()

264
src/testdir/test_tagfunc.vim
View File

@ -132,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
@ -205,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
@ -284,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

2
src/version.c
View File

@ -753,6 +753,8 @@ static char *(features[]) =
static int included_patches[] =
{ /* Add new patch number below this line */
/**/
3788,
/**/
3787,
/**/