Patch 8.2.3751

[Bram Moolenaar]

Patch 8.2.3751
Problem: Cannot assign a lambda to an option that takes a function.
Solution: Automatically convert the lambda to a string. (Yegappan
Lakshmanan, closes #9286)
Files: runtime/doc/options.txt, src/eval.c, src/proto/eval.pro,
src/evalvars.c, src/if_mzsch.c, src/if_ruby.c, src/if_tcl.c,
src/option.c, src/option.h, src/optiondefs.h,
src/proto/option.pro, src/spell.c, src/typval.c,
src/vim9compile.c, src/testdir/test_iminsert.vim,
src/testdir/test_ins_complete.vim, src/testdir/test_tagfunc.vim


*** ../vim-8.2.3750/runtime/doc/options.txt 2021-12-04 14:02:25.457024636 +0000
--- runtime/doc/options.txt 2021-12-06 10:47:35.320266764 +0000
***************
*** 367,373 ****
*option-value-function*
Some options ('completefunc', 'imactivatefunc', 'imstatusfunc', 'omnifunc',
'operatorfunc', 'quickfixtextfunc', 'tagfunc' and 'thesaurusfunc') are set to
! a function name or a function reference or a lambda function. Examples:
>
set opfunc=MyOpFunc
set opfunc=function('MyOpFunc')
--- 376,383 ----
*option-value-function*
Some options ('completefunc', 'imactivatefunc', 'imstatusfunc', 'omnifunc',
'operatorfunc', 'quickfixtextfunc', 'tagfunc' and 'thesaurusfunc') are set to
! a function name or a function reference or a lambda function. When using a
! lambda it will be converted to the name, e.g. "<lambda>123". Examples:
>
set opfunc=MyOpFunc
set opfunc=function('MyOpFunc')
***************
*** 377,386 ****
let Fn = function('MyTagFunc')
let &tagfunc = string(Fn)
" set using a lambda expression
! let &tagfunc = "{t -> MyTagFunc(t)}"
" set using a variable with lambda expression
let L = {a, b, c -> MyTagFunc(a, b , c)}
! let &tagfunc = string(L)
<

Setting the filetype
--- 387,396 ----
let Fn = function('MyTagFunc')
let &tagfunc = string(Fn)
" set using a lambda expression
! let &tagfunc = {t -> MyTagFunc(t)}
" set using a variable with lambda expression
let L = {a, b, c -> MyTagFunc(a, b , c)}
! let &tagfunc = L
<

Setting the filetype
*** ../vim-8.2.3750/src/eval.c 2021-11-29 13:44:52.452955930 +0000
--- src/eval.c 2021-12-06 10:53:22.995957744 +0000
***************
*** 6281,6303 ****
* after the option name.
*/
char_u *
! find_option_end(char_u **arg, int *opt_flags)
{
char_u *p = *arg;

++p;
if (*p == 'g' && p[1] == ':')
{
! *opt_flags = OPT_GLOBAL;
p += 2;
}
else if (*p == 'l' && p[1] == ':')
{
! *opt_flags = OPT_LOCAL;
p += 2;
}
else
! *opt_flags = 0;

if (!ASCII_ISALPHA(*p))
return NULL;
--- 6281,6303 ----
* after the option name.
*/
char_u *
! find_option_end(char_u **arg, int *scope)
{
char_u *p = *arg;

++p;
if (*p == 'g' && p[1] == ':')
{
! *scope = OPT_GLOBAL;
p += 2;
}
else if (*p == 'l' && p[1] == ':')
{
! *scope = OPT_LOCAL;
p += 2;
}
else
! *scope = 0;

if (!ASCII_ISALPHA(*p))
return NULL;
*** ../vim-8.2.3750/src/proto/eval.pro 2021-10-23 13:32:27.223954845 +0100
--- src/proto/eval.pro 2021-12-06 11:01:27.731173044 +0000
***************
*** 73,79 ****
void ex_echohl(exarg_T *eap);
int get_echo_attr(void);
void ex_execute(exarg_T *eap);
! char_u *find_option_end(char_u **arg, int *opt_flags);
void last_set_msg(sctx_T script_ctx);
char_u *do_string_sub(char_u *str, char_u *pat, char_u *sub, typval_T *expr, char_u *flags);
/* vim: set ft=c : */
--- 73,79 ----
void ex_echohl(exarg_T *eap);
int get_echo_attr(void);
void ex_execute(exarg_T *eap);
! char_u *find_option_end(char_u **arg, int *scope);
void last_set_msg(sctx_T script_ctx);
char_u *do_string_sub(char_u *str, char_u *pat, char_u *sub, typval_T *expr, char_u *flags);
/* vim: set ft=c : */
*** ../vim-8.2.3750/src/evalvars.c 2021-11-29 16:01:45.384711994 +0000
--- src/evalvars.c 2021-12-06 10:57:31.063589884 +0000
***************
*** 1367,1373 ****
char_u *op)
{
char_u *p;
! int opt_flags;
char_u *arg_end = NULL;

if ((flags & (ASSIGN_CONST | ASSIGN_FINAL))
--- 1367,1373 ----
char_u *op)
{
char_u *p;
! int scope;
char_u *arg_end = NULL;

if ((flags & (ASSIGN_CONST | ASSIGN_FINAL))
***************
*** 1378,1384 ****
}

// Find the end of the name.
! p = find_option_end(&arg, &opt_flags);
if (p == NULL || (endchars != NULL
&& vim_strchr(endchars, *skipwhite(p)) == NULL))
emsg(_(e_unexpected_characters_in_let));
--- 1378,1384 ----
}

// Find the end of the name.
! p = find_option_end(&arg, &scope);
if (p == NULL || (endchars != NULL
&& vim_strchr(endchars, *skipwhite(p)) == NULL))
emsg(_(e_unexpected_characters_in_let));
***************
*** 1391,1401 ****
char_u *stringval = NULL;
char_u *s = NULL;
int failed = FALSE;

c1 = *p;
*p = NUL;

! opt_type = get_option_value(arg, &numval, &stringval, opt_flags);
if ((opt_type == gov_bool
|| opt_type == gov_number
|| opt_type == gov_hidden_bool
--- 1391,1404 ----
char_u *stringval = NULL;
char_u *s = NULL;
int failed = FALSE;
+ int opt_p_flags;
+ char_u *tofree = NULL;

c1 = *p;
*p = NUL;

! opt_type = get_option_value(arg, &numval, &stringval, &opt_p_flags,
! scope);
if ((opt_type == gov_bool
|| opt_type == gov_number
|| opt_type == gov_hidden_bool
***************
*** 1410,1418 ****
n = (long)tv_get_number(tv);
}

// Avoid setting a string option to the text "v:false" or similar.
// In Vim9 script also don't convert a number to string.
! if (tv->v_type != VAR_BOOL && tv->v_type != VAR_SPECIAL
&& (!in_vim9script() || tv->v_type != VAR_NUMBER))
s = tv_get_string_chk(tv);

--- 1413,1432 ----
n = (long)tv_get_number(tv);
}

+ if (opt_p_flags & P_FUNC && (tv->v_type == VAR_PARTIAL
+ || tv->v_type == VAR_FUNC))
+ {
+ char_u numbuf[NUMBUFLEN];
+
+ // If the option can be set to a function reference or a lambda
+ // and the passed value is a function reference, then convert it to
+ // the name (string) of the function reference.
+
+ s = tv2string(tv, &tofree, numbuf, 0);
+ }
// Avoid setting a string option to the text "v:false" or similar.
// In Vim9 script also don't convert a number to string.
! else if (tv->v_type != VAR_BOOL && tv->v_type != VAR_SPECIAL
&& (!in_vim9script() || tv->v_type != VAR_NUMBER))
s = tv_get_string_chk(tv);

***************
*** 1458,1464 ****
{
if (opt_type != gov_string || s != NULL)
{
! set_option_value(arg, n, s, opt_flags);
arg_end = p;
}
else
--- 1472,1478 ----
{
if (opt_type != gov_string || s != NULL)
{
! set_option_value(arg, n, s, scope);
arg_end = p;
}
else
***************
*** 1466,1471 ****
--- 1480,1486 ----
}
*p = c1;
vim_free(stringval);
+ vim_free(tofree);
}
return arg_end;
}
*** ../vim-8.2.3750/src/if_mzsch.c 2021-08-02 17:07:15.186473836 +0100
--- src/if_mzsch.c 2021-12-06 10:56:44.687665026 +0000
***************
*** 1715,1721 ****
getoption_T rc;
Scheme_Object *rval = NULL;
Scheme_Object *name = NULL;
! int opt_flags = 0;
buf_T *save_curb = curbuf;
win_T *save_curw = curwin;

--- 1715,1721 ----
getoption_T rc;
Scheme_Object *rval = NULL;
Scheme_Object *name = NULL;
! int scope = 0;
buf_T *save_curb = curbuf;
win_T *save_curw = curwin;

***************
*** 1736,1746 ****
}

if (argv[1] == M_global)
! opt_flags = OPT_GLOBAL;
else if (SCHEME_VIMBUFFERP(argv[1]))
{
curbuf = get_valid_buffer(argv[1]);
! opt_flags = OPT_LOCAL;
}
else if (SCHEME_VIMWINDOWP(argv[1]))
{
--- 1736,1746 ----
}

if (argv[1] == M_global)
! scope = OPT_GLOBAL;
else if (SCHEME_VIMBUFFERP(argv[1]))
{
curbuf = get_valid_buffer(argv[1]);
! scope = OPT_LOCAL;
}
else if (SCHEME_VIMWINDOWP(argv[1]))
{
***************
*** 1748,1761 ****

curwin = win;
curbuf = win->w_buffer;
! opt_flags = OPT_LOCAL;
}
else
scheme_wrong_type(prim->name, "vim-buffer/window", 1, argc, argv);
}

rc = get_option_value(BYTE_STRING_VALUE(name), &value, (char_u **)&strval,
! opt_flags);
curbuf = save_curb;
curwin = save_curw;

--- 1748,1761 ----

curwin = win;
curbuf = win->w_buffer;
! scope = OPT_LOCAL;
}
else
scheme_wrong_type(prim->name, "vim-buffer/window", 1, argc, argv);
}

rc = get_option_value(BYTE_STRING_VALUE(name), &value, (char_u **)&strval,
! NULL, scope);
curbuf = save_curb;
curwin = save_curw;

***************
*** 1793,1799 ****
set_option(void *data, int argc, Scheme_Object **argv)
{
char_u *command = NULL;
! int opt_flags = 0;
buf_T *save_curb = curbuf;
win_T *save_curw = curwin;
Vim_Prim *prim = (Vim_Prim *)data;
--- 1793,1799 ----
set_option(void *data, int argc, Scheme_Object **argv)
{
char_u *command = NULL;
! int scope = 0;
buf_T *save_curb = curbuf;
win_T *save_curw = curwin;
Vim_Prim *prim = (Vim_Prim *)data;
***************
*** 1814,1831 ****
}

if (argv[1] == M_global)
! opt_flags = OPT_GLOBAL;
else if (SCHEME_VIMBUFFERP(argv[1]))
{
curbuf = get_valid_buffer(argv[1]);
! opt_flags = OPT_LOCAL;
}
else if (SCHEME_VIMWINDOWP(argv[1]))
{
win_T *win = get_valid_window(argv[1]);
curwin = win;
curbuf = win->w_buffer;
! opt_flags = OPT_LOCAL;
}
else
scheme_wrong_type(prim->name, "vim-buffer/window", 1, argc, argv);
--- 1814,1831 ----
}

if (argv[1] == M_global)
! scope = OPT_GLOBAL;
else if (SCHEME_VIMBUFFERP(argv[1]))
{
curbuf = get_valid_buffer(argv[1]);
! scope = OPT_LOCAL;
}
else if (SCHEME_VIMWINDOWP(argv[1]))
{
win_T *win = get_valid_window(argv[1]);
curwin = win;
curbuf = win->w_buffer;
! scope = OPT_LOCAL;
}
else
scheme_wrong_type(prim->name, "vim-buffer/window", 1, argc, argv);
***************
*** 1834,1840 ****
// do_set can modify cmd, make copy
command = vim_strsave(BYTE_STRING_VALUE(cmd));
MZ_GC_UNREG();
! do_set(command, opt_flags);
vim_free(command);
update_screen(NOT_VALID);
curbuf = save_curb;
--- 1834,1840 ----
// do_set can modify cmd, make copy
command = vim_strsave(BYTE_STRING_VALUE(cmd));
MZ_GC_UNREG();
! do_set(command, scope);
vim_free(command);
update_screen(NOT_VALID);
curbuf = save_curb;
*** ../vim-8.2.3750/src/if_ruby.c 2021-07-24 12:57:25.481296527 +0100
--- src/if_ruby.c 2021-12-06 10:41:05.780060960 +0000
***************
*** 875,881 ****
char_u *sval;
rb_encoding *enc;

! if (get_option_value((char_u *)"enc", &lval, &sval, 0) == gov_string)
{
enc = rb_enc_find((char *)sval);
vim_free(sval);
--- 875,881 ----
char_u *sval;
rb_encoding *enc;

! if (get_option_value((char_u *)"enc", &lval, &sval, NULL, 0) == gov_string)
{
enc = rb_enc_find((char *)sval);
vim_free(sval);
***************
*** 895,901 ****
rb_encoding *enc;
VALUE v;

! if (get_option_value((char_u *)"enc", &lval, &sval, 0) == gov_string)
{
enc = rb_enc_find((char *)sval);
vim_free(sval);
--- 895,901 ----
rb_encoding *enc;
VALUE v;

! if (get_option_value((char_u *)"enc", &lval, &sval, NULL, 0) == gov_string)
{
enc = rb_enc_find((char *)sval);
vim_free(sval);
*** ../vim-8.2.3750/src/if_tcl.c 2021-12-05 11:36:20.187448497 +0000
--- src/if_tcl.c 2021-12-06 10:41:05.780060960 +0000
***************
*** 1308,1314 ****

option = (char_u *)Tcl_GetStringFromObj(objv[objn], NULL);
++objn;
! gov = get_option_value(option, &lval, &sval, 0);
err = TCL_OK;
switch (gov)
{
--- 1308,1314 ----

option = (char_u *)Tcl_GetStringFromObj(objv[objn], NULL);
++objn;
! gov = get_option_value(option, &lval, &sval, NULL, 0);
err = TCL_OK;
switch (gov)
{
*** ../vim-8.2.3750/src/option.c 2021-12-03 20:43:20.088234242 +0000
--- src/option.c 2021-12-06 10:58:40.807472391 +0000
***************
*** 56,65 ****
static int put_setnum(FILE *fd, char *cmd, char *name, long *valuep);
static int put_setbool(FILE *fd, char *cmd, char *name, int value);
static int istermoption(struct vimoption *p);
! static char_u *get_varp_scope(struct vimoption *p, int opt_flags);
static char_u *get_varp(struct vimoption *);
static void check_win_options(win_T *win);
! static void option_value2string(struct vimoption *, int opt_flags);
static void check_winopt(winopt_T *wop);
static int wc_use_keyname(char_u *varp, long *wcp);
static void paste_option_changed(void);
--- 56,65 ----
static int put_setnum(FILE *fd, char *cmd, char *name, long *valuep);
static int put_setbool(FILE *fd, char *cmd, char *name, int value);
static int istermoption(struct vimoption *p);
! static char_u *get_varp_scope(struct vimoption *p, int scope);
static char_u *get_varp(struct vimoption *);
static void check_win_options(win_T *win);
! static void option_value2string(struct vimoption *, int scope);
static void check_winopt(winopt_T *wop);
static int wc_use_keyname(char_u *varp, long *wcp);
static void paste_option_changed(void);
***************
*** 3937,3949 ****
* Hidden Toggle option: gov_hidden_bool.
* Hidden String option: gov_hidden_string.
* Unknown option: gov_unknown.
*/
getoption_T
get_option_value(
char_u *name,
long *numval,
char_u **stringval, // NULL when only checking existence
! int opt_flags)
{
int opt_idx;
char_u *varp;
--- 3937,3952 ----
* Hidden Toggle option: gov_hidden_bool.
* Hidden String option: gov_hidden_string.
* Unknown option: gov_unknown.
+ *
+ * "flagsp" (if not NULL) is set to the option flags (P_xxxx).
*/
getoption_T
get_option_value(
char_u *name,
long *numval,
char_u **stringval, // NULL when only checking existence
! int *flagsp,
! int scope)
{
int opt_idx;
char_u *varp;
***************
*** 3981,3987 ****
return gov_unknown;
}

! varp = get_varp_scope(&(options[opt_idx]), opt_flags);

if (options[opt_idx].flags & P_STRING)
{
--- 3984,3994 ----
return gov_unknown;
}

! varp = get_varp_scope(&(options[opt_idx]), scope);
!
! if (flagsp != NULL)
! // Return the P_xxxx option flags.
! *flagsp = options[opt_idx].flags;

if (options[opt_idx].flags & P_STRING)
{
***************
*** 5179,5195 ****

/*
* Get pointer to option variable, depending on local or global scope.
*/
static char_u *
! get_varp_scope(struct vimoption *p, int opt_flags)
{
! if ((opt_flags & OPT_GLOBAL) && p->indir != PV_NONE)
{
if (p->var == VAR_WIN)
return (char_u *)GLOBAL_WO(get_varp(p));
return p->var;
}
! if ((opt_flags & OPT_LOCAL) && ((int)p->indir & PV_BOTH))
{
switch ((int)p->indir)
{
--- 5186,5203 ----

/*
* Get pointer to option variable, depending on local or global scope.
+ * "scope" can be OPT_LOCAL, OPT_GLOBAL or a combination.
*/
static char_u *
! get_varp_scope(struct vimoption *p, int scope)
{
! if ((scope & OPT_GLOBAL) && p->indir != PV_NONE)
{
if (p->var == VAR_WIN)
return (char_u *)GLOBAL_WO(get_varp(p));
return p->var;
}
! if ((scope & OPT_LOCAL) && ((int)p->indir & PV_BOTH))
{
switch ((int)p->indir)
{
***************
*** 5248,5256 ****
* scope.
*/
char_u *
! get_option_varp_scope(int opt_idx, int opt_flags)
{
! return get_varp_scope(&(options[opt_idx]), opt_flags);
}

/*
--- 5256,5264 ----
* scope.
*/
char_u *
! get_option_varp_scope(int opt_idx, int scope)
{
! return get_varp_scope(&(options[opt_idx]), scope);
}

/*
***************
*** 6618,6628 ****
static void
option_value2string(
struct vimoption *opp,
! int opt_flags) // OPT_GLOBAL and/or OPT_LOCAL
{
char_u *varp;

! varp = get_varp_scope(opp, opt_flags);

if (opp->flags & P_NUM)
{
--- 6626,6636 ----
static void
option_value2string(
struct vimoption *opp,
! int scope) // OPT_GLOBAL and/or OPT_LOCAL
{
char_u *varp;

! varp = get_varp_scope(opp, scope);

if (opp->flags & P_NUM)
{
*** ../vim-8.2.3750/src/option.h 2021-11-29 20:39:06.682101619 +0000
--- src/option.h 2021-12-06 10:41:05.784060967 +0000
***************
*** 59,64 ****
--- 59,65 ----
#define P_NDNAME 0x8000000L // only normal dir name chars allowed
#define P_RWINONLY 0x10000000L // only redraw current window
#define P_MLE 0x20000000L // under control of 'modelineexpr'
+ #define P_FUNC 0x40000000L // accept a function reference or a lambda

// Returned by get_option_value().
typedef enum {
*** ../vim-8.2.3750/src/optiondefs.h 2021-11-29 20:39:06.682101619 +0000
--- src/optiondefs.h 2021-12-06 10:41:05.784060967 +0000
***************
*** 684,690 ****
#endif
{(char_u *)0L, (char_u *)0L}
SCTX_INIT},
! {"completefunc", "cfu", P_STRING|P_ALLOCED|P_VI_DEF|P_SECURE,
#ifdef FEAT_COMPL_FUNC
(char_u *)&p_cfu, PV_CFU,
{(char_u *)"", (char_u *)0L}
--- 684,690 ----
#endif
{(char_u *)0L, (char_u *)0L}
SCTX_INIT},
! {"completefunc", "cfu", P_STRING|P_ALLOCED|P_VI_DEF|P_SECURE|P_FUNC,
#ifdef FEAT_COMPL_FUNC
(char_u *)&p_cfu, PV_CFU,
{(char_u *)"", (char_u *)0L}
***************
*** 1321,1327 ****
{"ignorecase", "ic", P_BOOL|P_VI_DEF,
(char_u *)&p_ic, PV_NONE,
{(char_u *)FALSE, (char_u *)0L} SCTX_INIT},
! {"imactivatefunc","imaf",P_STRING|P_VI_DEF|P_SECURE,
#if defined(FEAT_EVAL)
(char_u *)&p_imaf, PV_NONE,
{(char_u *)"", (char_u *)NULL}
--- 1321,1327 ----
{"ignorecase", "ic", P_BOOL|P_VI_DEF,
(char_u *)&p_ic, PV_NONE,
{(char_u *)FALSE, (char_u *)0L} SCTX_INIT},
! {"imactivatefunc","imaf",P_STRING|P_VI_DEF|P_SECURE|P_FUNC,
#if defined(FEAT_EVAL)
(char_u *)&p_imaf, PV_NONE,
{(char_u *)"", (char_u *)NULL}
***************
*** 1356,1362 ****
(char_u *)&p_imsearch, PV_IMS,
{(char_u *)B_IMODE_USE_INSERT, (char_u *)0L}
SCTX_INIT},
! {"imstatusfunc","imsf",P_STRING|P_VI_DEF|P_SECURE,
#if defined(FEAT_EVAL)
(char_u *)&p_imsf, PV_NONE,
{(char_u *)"", (char_u *)NULL}
--- 1356,1362 ----
(char_u *)&p_imsearch, PV_IMS,
{(char_u *)B_IMODE_USE_INSERT, (char_u *)0L}
SCTX_INIT},
! {"imstatusfunc","imsf",P_STRING|P_VI_DEF|P_SECURE|P_FUNC,
#if defined(FEAT_EVAL)
(char_u *)&p_imsf, PV_NONE,
{(char_u *)"", (char_u *)NULL}
***************
*** 1822,1828 ****
(char_u *)NULL, PV_NONE,
#endif
{(char_u *)8L, (char_u *)4L} SCTX_INIT},
! {"omnifunc", "ofu", P_STRING|P_ALLOCED|P_VI_DEF|P_SECURE,
#ifdef FEAT_COMPL_FUNC
(char_u *)&p_ofu, PV_OFU,
{(char_u *)"", (char_u *)0L}
--- 1822,1828 ----
(char_u *)NULL, PV_NONE,
#endif
{(char_u *)8L, (char_u *)4L} SCTX_INIT},
! {"omnifunc", "ofu", P_STRING|P_ALLOCED|P_VI_DEF|P_SECURE|P_FUNC,
#ifdef FEAT_COMPL_FUNC
(char_u *)&p_ofu, PV_OFU,
{(char_u *)"", (char_u *)0L}
***************
*** 1842,1848 ****
#endif
{(char_u *)FALSE, (char_u *)FALSE}
SCTX_INIT},
! {"operatorfunc", "opfunc", P_STRING|P_VI_DEF|P_SECURE,
(char_u *)&p_opfunc, PV_NONE,
{(char_u *)"", (char_u *)0L} SCTX_INIT},
{"optimize", "opt", P_BOOL|P_VI_DEF,
--- 1842,1848 ----
#endif
{(char_u *)FALSE, (char_u *)FALSE}
SCTX_INIT},
! {"operatorfunc", "opfunc", P_STRING|P_VI_DEF|P_SECURE|P_FUNC,
(char_u *)&p_opfunc, PV_NONE,
{(char_u *)"", (char_u *)0L} SCTX_INIT},
{"optimize", "opt", P_BOOL|P_VI_DEF,
***************
*** 2055,2061 ****
#endif
{(char_u *)DEFAULT_PYTHON_VER, (char_u *)0L}
SCTX_INIT},
! {"quickfixtextfunc", "qftf", P_STRING|P_ALLOCED|P_VI_DEF|P_VIM|P_SECURE,
#if defined(FEAT_QUICKFIX) && defined(FEAT_EVAL)
(char_u *)&p_qftf, PV_NONE,
{(char_u *)"", (char_u *)0L}
--- 2055,2061 ----
#endif
{(char_u *)DEFAULT_PYTHON_VER, (char_u *)0L}
SCTX_INIT},
! {"quickfixtextfunc", "qftf", P_STRING|P_ALLOCED|P_VI_DEF|P_VIM|P_SECURE|P_FUNC,
#if defined(FEAT_QUICKFIX) && defined(FEAT_EVAL)
(char_u *)&p_qftf, PV_NONE,
{(char_u *)"", (char_u *)0L}
***************
*** 2507,2513 ****
{"tagcase", "tc", P_STRING|P_VIM,
(char_u *)&p_tc, PV_TC,
{(char_u *)"followic", (char_u *)"followic"} SCTX_INIT},
! {"tagfunc", "tfu", P_STRING|P_ALLOCED|P_VI_DEF|P_SECURE,
#ifdef FEAT_EVAL
(char_u *)&p_tfu, PV_TFU,
{(char_u *)"", (char_u *)0L}
--- 2507,2513 ----
{"tagcase", "tc", P_STRING|P_VIM,
(char_u *)&p_tc, PV_TC,
{(char_u *)"followic", (char_u *)"followic"} SCTX_INIT},
! {"tagfunc", "tfu", P_STRING|P_ALLOCED|P_VI_DEF|P_SECURE|P_FUNC,
#ifdef FEAT_EVAL
(char_u *)&p_tfu, PV_TFU,
{(char_u *)"", (char_u *)0L}
***************
*** 2624,2630 ****
{"thesaurus", "tsr", P_STRING|P_EXPAND|P_VI_DEF|P_ONECOMMA|P_NODUP|P_NDNAME,
(char_u *)&p_tsr, PV_TSR,
{(char_u *)"", (char_u *)0L} SCTX_INIT},
! {"thesaurusfunc", "tsrfu", P_STRING|P_ALLOCED|P_VI_DEF|P_SECURE,
#ifdef FEAT_COMPL_FUNC
(char_u *)&p_tsrfu, PV_TSRFU,
{(char_u *)"", (char_u *)0L}
--- 2624,2630 ----
{"thesaurus", "tsr", P_STRING|P_EXPAND|P_VI_DEF|P_ONECOMMA|P_NODUP|P_NDNAME,
(char_u *)&p_tsr, PV_TSR,
{(char_u *)"", (char_u *)0L} SCTX_INIT},
! {"thesaurusfunc", "tsrfu", P_STRING|P_ALLOCED|P_VI_DEF|P_SECURE|P_FUNC,
#ifdef FEAT_COMPL_FUNC
(char_u *)&p_tsrfu, PV_TSRFU,
{(char_u *)"", (char_u *)0L}
*** ../vim-8.2.3750/src/proto/option.pro 2021-11-18 22:08:52.007682711 +0000
--- src/proto/option.pro 2021-12-06 11:01:31.739165582 +0000
***************
*** 25,31 ****
void set_term_option_sctx_idx(char *name, int opt_idx);
void check_redraw(long_u flags);
int findoption(char_u *arg);
! getoption_T get_option_value(char_u *name, long *numval, char_u **stringval, int opt_flags);
int get_option_value_strict(char_u *name, long *numval, char_u **stringval, int opt_type, void *from);
char_u *option_iter_next(void **option, int opt_type);
long_u get_option_flags(int opt_idx);
--- 25,31 ----
void set_term_option_sctx_idx(char *name, int opt_idx);
void check_redraw(long_u flags);
int findoption(char_u *arg);
! getoption_T get_option_value(char_u *name, long *numval, char_u **stringval, int *flagsp, int scope);
int get_option_value_strict(char_u *name, long *numval, char_u **stringval, int opt_type, void *from);
char_u *option_iter_next(void **option, int opt_type);
long_u get_option_flags(int opt_idx);
***************
*** 48,54 ****
void set_term_defaults(void);
int istermoption_idx(int opt_idx);
void unset_global_local_option(char_u *name, void *from);
! char_u *get_option_varp_scope(int opt_idx, int opt_flags);
char_u *get_option_var(int opt_idx);
char_u *get_option_fullname(int opt_idx);
char_u *get_equalprg(void);
--- 48,54 ----
void set_term_defaults(void);
int istermoption_idx(int opt_idx);
void unset_global_local_option(char_u *name, void *from);
! char_u *get_option_varp_scope(int opt_idx, int scope);
char_u *get_option_var(int opt_idx);
char_u *get_option_fullname(int opt_idx);
char_u *get_equalprg(void);
*** ../vim-8.2.3750/src/spell.c 2021-08-09 18:59:01.442811242 +0100
--- src/spell.c 2021-12-06 10:41:05.784060967 +0000
***************
*** 3830,3836 ****

if (no_spell_checking(curwin))
return;
! (void)get_option_value((char_u*)"spl", &dummy, &spl, OPT_LOCAL);

// Create a new empty buffer in a new window.
do_cmdline_cmd((char_u *)"new");
--- 3830,3836 ----

if (no_spell_checking(curwin))
return;
! (void)get_option_value((char_u*)"spl", &dummy, &spl, NULL, OPT_LOCAL);

// Create a new empty buffer in a new window.
do_cmdline_cmd((char_u *)"new");
*** ../vim-8.2.3750/src/typval.c 2021-11-30 11:56:19.030972202 +0000
--- src/typval.c 2021-12-06 10:54:14.087889527 +0000
***************
*** 1639,1648 ****
int c;
int working = (**arg == '+'); // has("+option")
int ret = OK;
! int opt_flags;

// Isolate the option name and find its value.
! option_end = find_option_end(arg, &opt_flags);
if (option_end == NULL)
{
if (rettv != NULL)
--- 1639,1648 ----
int c;
int working = (**arg == '+'); // has("+option")
int ret = OK;
! int scope;

// Isolate the option name and find its value.
! option_end = find_option_end(arg, &scope);
if (option_end == NULL)
{
if (rettv != NULL)
***************
*** 1659,1665 ****
c = *option_end;
*option_end = NUL;
opt_type = get_option_value(*arg, &numval,
! rettv == NULL ? NULL : &stringval, opt_flags);

if (opt_type == gov_unknown)
{
--- 1659,1665 ----
c = *option_end;
*option_end = NUL;
opt_type = get_option_value(*arg, &numval,
! rettv == NULL ? NULL : &stringval, NULL, scope);

if (opt_type == gov_unknown)
{
*** ../vim-8.2.3750/src/vim9compile.c 2021-12-04 11:56:30.352101259 +0000
--- src/vim9compile.c 2021-12-06 10:55:29.979780418 +0000
***************
*** 6072,6078 ****
/*
* For one assignment figure out the type of destination. Return it in "dest".
* When not recognized "dest" is not set.
! * For an option "opt_flags" is set.
* For a v:var "vimvaridx" is set.
* "type" is set to the destination type if known, unchanted otherwise.
* Return FAIL if an error message was given.
--- 6072,6078 ----
/*
* For one assignment figure out the type of destination. Return it in "dest".
* When not recognized "dest" is not set.
! * For an option "option_scope" is set.
* For a v:var "vimvaridx" is set.
* "type" is set to the destination type if known, unchanted otherwise.
* Return FAIL if an error message was given.
***************
*** 6082,6088 ****
char_u *name,
assign_dest_T *dest,
int cmdidx,
! int *opt_flags,
int *vimvaridx,
type_T **type,
cctx_T *cctx)
--- 6082,6088 ----
char_u *name,
assign_dest_T *dest,
int cmdidx,
! int *option_scope,
int *vimvaridx,
type_T **type,
cctx_T *cctx)
***************
*** 6102,6108 ****
return FAIL;
}
p = name;
! p = find_option_end(&p, opt_flags);
if (p == NULL)
{
// cannot happen?
--- 6102,6108 ----
return FAIL;
}
p = name;
! p = find_option_end(&p, option_scope);
if (p == NULL)
{
// cannot happen?
***************
*** 6112,6118 ****
cc = *p;
*p = NUL;
opt_type = get_option_value(skip_option_env_lead(name),
! &numval, NULL, *opt_flags);
*p = cc;
switch (opt_type)
{
--- 6112,6118 ----
cc = *p;
*p = NUL;
opt_type = get_option_value(skip_option_env_lead(name),
! &numval, NULL, NULL, *option_scope);
*p = cc;
switch (opt_type)
{
*** ../vim-8.2.3750/src/testdir/test_iminsert.vim 2021-12-04 14:02:25.457024636 +0000
--- src/testdir/test_iminsert.vim 2021-12-06 10:41:05.784060967 +0000
***************
*** 130,141 ****

" Using a funcref variable to set 'completefunc'
let Fn1 = function('IMactivatefunc1')
! let &imactivatefunc = string(Fn1)
let Fn2 = function('IMstatusfunc1')
let &imstatusfunc = string(Fn2)
normal! i
- call assert_fails('let &imactivatefunc = Fn1', 'E729:')
- call assert_fails('let &imstatusfunc = Fn2', 'E729:')

" Test for using a funcref()
set imactivatefunc=funcref('IMactivatefunc1')
--- 130,144 ----

" Using a funcref variable to set 'completefunc'
let Fn1 = function('IMactivatefunc1')
! let &imactivatefunc = Fn1
let Fn2 = function('IMstatusfunc1')
+ let &imstatusfunc = Fn2
+ normal! i
+
+ " Using a string(funcref variable) to set 'completefunc'
+ let &imactivatefunc = string(Fn1)
let &imstatusfunc = string(Fn2)
normal! i

" Test for using a funcref()
set imactivatefunc=funcref('IMactivatefunc1')
***************
*** 144,155 ****

" Using a funcref variable to set 'imactivatefunc'
let Fn1 = funcref('IMactivatefunc1')
! let &imactivatefunc = string(Fn1)
let Fn2 = funcref('IMstatusfunc1')
let &imstatusfunc = string(Fn2)
normal! i
- call assert_fails('let &imactivatefunc = Fn1', 'E729:')
- call assert_fails('let &imstatusfunc = Fn2', 'E729:')

" Test for using a lambda function
set imactivatefunc={a\ ->\ IMactivatefunc1(a)}
--- 147,161 ----

" Using a funcref variable to set 'imactivatefunc'
let Fn1 = funcref('IMactivatefunc1')
! let &imactivatefunc = Fn1
let Fn2 = funcref('IMstatusfunc1')
+ let &imstatusfunc = Fn2
+ normal! i
+
+ " Using a string(funcref variable) to set 'imactivatefunc'
+ let &imactivatefunc = string(Fn1)
let &imstatusfunc = string(Fn2)
normal! i

" Test for using a lambda function
set imactivatefunc={a\ ->\ IMactivatefunc1(a)}
***************
*** 157,162 ****
--- 163,173 ----
normal! i

" Set 'imactivatefunc' and 'imstatusfunc' to a lambda expression
+ let &imactivatefunc = {a -> IMactivatefunc1(a)}
+ let &imstatusfunc = { -> IMstatusfunc1()}
+ normal! i
+
+ " Set 'imactivatefunc' and 'imstatusfunc' to a string(lambda expression)
let &imactivatefunc = '{a -> IMactivatefunc1(a)}'
let &imstatusfunc = '{ -> IMstatusfunc1()}'
normal! i
***************
*** 164,174 ****
" Set 'imactivatefunc' 'imstatusfunc' to a variable with a lambda expression
let Lambda1 = {a -> IMactivatefunc1(a)}
let Lambda2 = { -> IMstatusfunc1()}
let &imactivatefunc = string(Lambda1)
let &imstatusfunc = string(Lambda2)
normal! i
- call assert_fails('let &imactivatefunc = Lambda1', 'E729:')
- call assert_fails('let &imstatusfunc = Lambda2', 'E729:')

" Test for clearing the 'completefunc' option
set imactivatefunc='' imstatusfunc=''
--- 175,189 ----
" 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' 'imstatusfunc' to a string(variable with a lambda
+ " expression)
let &imactivatefunc = string(Lambda1)
let &imstatusfunc = string(Lambda2)
normal! i

" Test for clearing the 'completefunc' option
set imactivatefunc='' imstatusfunc=''
***************
*** 179,186 ****
call assert_fails("set imactivatefunc=funcref('abc')", "E700:")
call assert_fails("set imstatusfunc=funcref('abc')", "E700:")

! call assert_equal(7, g:IMactivatefunc_called)
! call assert_equal(14, g:IMstatusfunc_called)

" Vim9 tests
let lines =<< trim END
--- 194,201 ----
call assert_fails("set imactivatefunc=funcref('abc')", "E700:")
call assert_fails("set imstatusfunc=funcref('abc')", "E700:")

! call assert_equal(11, g:IMactivatefunc_called)
! call assert_equal(22, g:IMstatusfunc_called)

" Vim9 tests
let lines =<< trim END
***************
*** 216,227 ****
g:IMstatusfunc_called += 1
return 1
}
&imactivatefunc = string(Fn1)
&imstatusfunc = string(Fn2)
normal! i

! assert_equal(3, g:IMactivatefunc_called)
! assert_equal(6, g:IMstatusfunc_called)

set iminsert=0
set imactivatefunc=
--- 231,247 ----
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=
*** ../vim-8.2.3750/src/testdir/test_ins_complete.vim 2021-12-04 14:02:25.457024636 +0000
--- src/testdir/test_ins_complete.vim 2021-12-06 10:41:05.784060967 +0000
***************
*** 885,897 ****

" Using a funcref variable to set 'completefunc'
let Fn = function('MycompleteFunc1')
let &completefunc = string(Fn)
new | only
call setline(1, 'two')
let g:MycompleteFunc1_args = []
call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
call assert_equal([[1, ''], [0, 'two']], g:MycompleteFunc1_args)
- call assert_fails('let &completefunc = Fn', 'E729:')
bw!

" Test for using a funcref()
--- 885,906 ----

" Using a funcref variable to set 'completefunc'
let Fn = function('MycompleteFunc1')
+ let &completefunc = Fn
+ new | only
+ call setline(1, 'two')
+ let g:MycompleteFunc1_args = []
+ call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
+ call assert_equal([[1, ''], [0, 'two']], g:MycompleteFunc1_args)
+ bw!
+
+ " Using string(funcref_variable) to set 'completefunc'
+ let Fn = function('MycompleteFunc1')
let &completefunc = string(Fn)
new | only
call setline(1, 'two')
let g:MycompleteFunc1_args = []
call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
call assert_equal([[1, ''], [0, 'two']], g:MycompleteFunc1_args)
bw!

" Test for using a funcref()
***************
*** 909,921 ****

" Using a funcref variable to set 'completefunc'
let Fn = funcref('MycompleteFunc2')
let &completefunc = string(Fn)
new | only
call setline(1, 'four')
let g:MycompleteFunc2_args = []
call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
call assert_equal([[1, ''], [0, 'four']], g:MycompleteFunc2_args)
- call assert_fails('let &completefunc = Fn', 'E729:')
bw!

" Test for using a lambda function
--- 918,939 ----

" Using a funcref variable to set 'completefunc'
let Fn = funcref('MycompleteFunc2')
+ let &completefunc = Fn
+ new | only
+ call setline(1, 'four')
+ let g:MycompleteFunc2_args = []
+ call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
+ call assert_equal([[1, ''], [0, 'four']], g:MycompleteFunc2_args)
+ bw!
+
+ " Using a string(funcref_variable) to set 'completefunc'
+ let Fn = funcref('MycompleteFunc2')
let &completefunc = string(Fn)
new | only
call setline(1, 'four')
let g:MycompleteFunc2_args = []
call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
call assert_equal([[1, ''], [0, 'four']], g:MycompleteFunc2_args)
bw!

" Test for using a lambda function
***************
*** 932,937 ****
--- 950,964 ----
bw!

" Set 'completefunc' to a lambda expression
+ let &completefunc = {a, b -> MycompleteFunc3(a, b)}
+ new | only
+ call setline(1, 'six')
+ let g:MycompleteFunc3_args = []
+ call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
+ call assert_equal([[1, ''], [0, 'six']], g:MycompleteFunc3_args)
+ bw!
+
+ " Set 'completefunc' to string(lambda_expression)
let &completefunc = '{a, b -> MycompleteFunc3(a, b)}'
new | only
call setline(1, 'six')
***************
*** 942,959 ****

" Set 'completefunc' to a variable with a lambda expression
let Lambda = {a, b -> MycompleteFunc3(a, b)}
let &completefunc = string(Lambda)
new | only
call setline(1, 'seven')
let g:MycompleteFunc3_args = []
call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
call assert_equal([[1, ''], [0, 'seven']], g:MycompleteFunc3_args)
- call assert_fails('let &completefunc = Lambda', 'E729:')
bw!

" Test for using a lambda function with incorrect return value
let Lambda = {s -> strlen(s)}
! let &completefunc = string(Lambda)
new | only
call setline(1, 'eight')
call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
--- 969,995 ----

" Set 'completefunc' to a variable with a lambda expression
let Lambda = {a, b -> MycompleteFunc3(a, b)}
+ let &completefunc = Lambda
+ new | only
+ call setline(1, 'seven')
+ let g:MycompleteFunc3_args = []
+ call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
+ call assert_equal([[1, ''], [0, 'seven']], g:MycompleteFunc3_args)
+ bw!
+
+ " Set 'completefunc' to a string(variable with a lambda expression)
+ let Lambda = {a, b -> MycompleteFunc3(a, b)}
let &completefunc = string(Lambda)
new | only
call setline(1, 'seven')
let g:MycompleteFunc3_args = []
call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
call assert_equal([[1, ''], [0, 'seven']], g:MycompleteFunc3_args)
bw!

" Test for using a lambda function with incorrect return value
let Lambda = {s -> strlen(s)}
! let &completefunc = Lambda
new | only
call setline(1, 'eight')
call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
***************
*** 965,971 ****

call assert_fails("set completefunc=function('abc')", "E700:")
call assert_fails("set completefunc=funcref('abc')", "E700:")
! let &completefunc = "{a -> 'abc'}"
call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')

" Vim9 tests
--- 1001,1007 ----

call assert_fails("set completefunc=function('abc')", "E700:")
call assert_fails("set completefunc=funcref('abc')", "E700:")
! let &completefunc = {a -> 'abc'}
call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')

" Vim9 tests
***************
*** 990,995 ****
--- 1026,1040 ----
add(g:LambdaComplete1_args, [findstart, base])
return findstart ? 0 : []
enddef
+ &completefunc = (a, b) => LambdaComplete1(a, b)
+ new | only
+ setline(1, 'two')
+ g:LambdaComplete1_args = []
+ feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
+ assert_equal([[1, ''], [0, 'two']], g:LambdaComplete1_args)
+ bw!
+
+ # Test for using a string(lambda)
&completefunc = '(a, b) => LambdaComplete1(a, b)'
new | only
setline(1, 'two')
***************
*** 1003,1008 ****
--- 1048,1062 ----
add(g:LambdaComplete2_args, [findstart, base])
return findstart ? 0 : []
}
+ &completefunc = Fn
+ new | only
+ setline(1, 'three')
+ g:LambdaComplete2_args = []
+ feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
+ assert_equal([[1, ''], [0, 'three']], g:LambdaComplete2_args)
+ bw!
+
+ # Test for using a string(variable with a lambda expression)
&completefunc = string(Fn)
new | only
setline(1, 'three')
***************
*** 1045,1057 ****

" Using a funcref variable to set 'omnifunc'
let Fn = function('MyomniFunc1')
let &omnifunc = string(Fn)
new | only
call setline(1, 'two')
let g:MyomniFunc1_args = []
call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
call assert_equal([[1, ''], [0, 'two']], g:MyomniFunc1_args)
- call assert_fails('let &omnifunc = Fn', 'E729:')
bw!

" Test for using a funcref()
--- 1099,1120 ----

" Using a funcref variable to set 'omnifunc'
let Fn = function('MyomniFunc1')
+ let &omnifunc = Fn
+ new | only
+ call setline(1, 'two')
+ let g:MyomniFunc1_args = []
+ call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
+ call assert_equal([[1, ''], [0, 'two']], g:MyomniFunc1_args)
+ bw!
+
+ " Using a string(funcref_variable) to set 'omnifunc'
+ let Fn = function('MyomniFunc1')
let &omnifunc = string(Fn)
new | only
call setline(1, 'two')
let g:MyomniFunc1_args = []
call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
call assert_equal([[1, ''], [0, 'two']], g:MyomniFunc1_args)
bw!

" Test for using a funcref()
***************
*** 1069,1081 ****

" Using a funcref variable to set 'omnifunc'
let Fn = funcref('MyomniFunc2')
let &omnifunc = string(Fn)
new | only
call setline(1, 'four')
let g:MyomniFunc2_args = []
call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
call assert_equal([[1, ''], [0, 'four']], g:MyomniFunc2_args)
- call assert_fails('let &omnifunc = Fn', 'E729:')
bw!

" Test for using a lambda function
--- 1132,1153 ----

" Using a funcref variable to set 'omnifunc'
let Fn = funcref('MyomniFunc2')
+ let &omnifunc = Fn
+ new | only
+ call setline(1, 'four')
+ let g:MyomniFunc2_args = []
+ call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
+ call assert_equal([[1, ''], [0, 'four']], g:MyomniFunc2_args)
+ bw!
+
+ " Using a string(funcref_variable) to set 'omnifunc'
+ let Fn = funcref('MyomniFunc2')
let &omnifunc = string(Fn)
new | only
call setline(1, 'four')
let g:MyomniFunc2_args = []
call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
call assert_equal([[1, ''], [0, 'four']], g:MyomniFunc2_args)
bw!

" Test for using a lambda function
***************
*** 1092,1097 ****
--- 1164,1178 ----
bw!

" Set 'omnifunc' to a lambda expression
+ let &omnifunc = {a, b -> MyomniFunc3(a, b)}
+ new | only
+ call setline(1, 'six')
+ let g:MyomniFunc3_args = []
+ call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
+ call assert_equal([[1, ''], [0, 'six']], g:MyomniFunc3_args)
+ bw!
+
+ " Set 'omnifunc' to a string(lambda_expression)
let &omnifunc = '{a, b -> MyomniFunc3(a, b)}'
new | only
call setline(1, 'six')
***************
*** 1102,1119 ****

" Set 'omnifunc' to a variable with a lambda expression
let Lambda = {a, b -> MyomniFunc3(a, b)}
let &omnifunc = string(Lambda)
new | only
call setline(1, 'seven')
let g:MyomniFunc3_args = []
call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
call assert_equal([[1, ''], [0, 'seven']], g:MyomniFunc3_args)
- call assert_fails('let &omnifunc = Lambda', 'E729:')
bw!

" Test for using a lambda function with incorrect return value
let Lambda = {s -> strlen(s)}
! let &omnifunc = string(Lambda)
new | only
call setline(1, 'eight')
call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
--- 1183,1209 ----

" Set 'omnifunc' to a variable with a lambda expression
let Lambda = {a, b -> MyomniFunc3(a, b)}
+ let &omnifunc = Lambda
+ new | only
+ call setline(1, 'seven')
+ let g:MyomniFunc3_args = []
+ call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
+ call assert_equal([[1, ''], [0, 'seven']], g:MyomniFunc3_args)
+ bw!
+
+ " Set 'omnifunc' to a string(variable with a lambda expression)
+ let Lambda = {a, b -> MyomniFunc3(a, b)}
let &omnifunc = string(Lambda)
new | only
call setline(1, 'seven')
let g:MyomniFunc3_args = []
call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
call assert_equal([[1, ''], [0, 'seven']], g:MyomniFunc3_args)
bw!

" Test for using a lambda function with incorrect return value
let Lambda = {s -> strlen(s)}
! let &omnifunc = Lambda
new | only
call setline(1, 'eight')
call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
***************
*** 1125,1131 ****

call assert_fails("set omnifunc=function('abc')", "E700:")
call assert_fails("set omnifunc=funcref('abc')", "E700:")
! let &omnifunc = "{a -> 'abc'}"
call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')

" Vim9 tests
--- 1215,1221 ----

call assert_fails("set omnifunc=function('abc')", "E700:")
call assert_fails("set omnifunc=funcref('abc')", "E700:")
! let &omnifunc = {a -> 'abc'}
call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')

" Vim9 tests
***************
*** 1150,1155 ****
--- 1240,1254 ----
add(g:MyomniFunc2_args, [findstart, base])
return findstart ? 0 : []
enddef
+ &omnifunc = (a, b) => MyomniFunc2(a, b)
+ new | only
+ setline(1, 'two')
+ g:MyomniFunc2_args = []
+ feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
+ assert_equal([[1, ''], [0, 'two']], g:MyomniFunc2_args)
+ bw!
+
+ # Test for using a string(lambda)
&omnifunc = '(a, b) => MyomniFunc2(a, b)'
new | only
setline(1, 'two')
***************
*** 1160,1165 ****
--- 1259,1273 ----

# Test for using a variable with a lambda expression
var Fn: func = (a, b) => MyomniFunc2(a, b)
+ &omnifunc = Fn
+ new | only
+ setline(1, 'three')
+ g:MyomniFunc2_args = []
+ feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
+ assert_equal([[1, ''], [0, 'three']], g:MyomniFunc2_args)
+ bw!
+
+ # Test for using a string(variable with a lambda expression)
&omnifunc = string(Fn)
new | only
setline(1, 'three')
***************
*** 1202,1214 ****

" Using a funcref variable to set 'thesaurusfunc'
let Fn = function('MytsrFunc1')
let &thesaurusfunc = string(Fn)
new | only
call setline(1, 'two')
let g:MytsrFunc1_args = []
call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
call assert_equal([[1, ''], [0, 'two']], g:MytsrFunc1_args)
- call assert_fails('let &thesaurusfunc = Fn', 'E729:')
bw!

" Test for using a funcref()
--- 1310,1331 ----

" Using a funcref variable to set 'thesaurusfunc'
let Fn = function('MytsrFunc1')
+ let &thesaurusfunc = Fn
+ new | only
+ call setline(1, 'two')
+ let g:MytsrFunc1_args = []
+ call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
+ call assert_equal([[1, ''], [0, 'two']], g:MytsrFunc1_args)
+ bw!
+
+ " Using a string(funcref_variable) to set 'thesaurusfunc'
+ let Fn = function('MytsrFunc1')
let &thesaurusfunc = string(Fn)
new | only
call setline(1, 'two')
let g:MytsrFunc1_args = []
call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
call assert_equal([[1, ''], [0, 'two']], g:MytsrFunc1_args)
bw!

" Test for using a funcref()
***************
*** 1226,1238 ****

" Using a funcref variable to set 'thesaurusfunc'
let Fn = funcref('MytsrFunc2')
let &thesaurusfunc = string(Fn)
new | only
call setline(1, 'four')
let g:MytsrFunc2_args = []
call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
call assert_equal([[1, ''], [0, 'four']], g:MytsrFunc2_args)
- call assert_fails('let &thesaurusfunc = Fn', 'E729:')
bw!

" Test for using a lambda function
--- 1343,1364 ----

" Using a funcref variable to set 'thesaurusfunc'
let Fn = funcref('MytsrFunc2')
+ let &thesaurusfunc = Fn
+ new | only
+ call setline(1, 'four')
+ let g:MytsrFunc2_args = []
+ call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
+ call assert_equal([[1, ''], [0, 'four']], g:MytsrFunc2_args)
+ bw!
+
+ " Using a string(funcref_variable) to set 'thesaurusfunc'
+ let Fn = funcref('MytsrFunc2')
let &thesaurusfunc = string(Fn)
new | only
call setline(1, 'four')
let g:MytsrFunc2_args = []
call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
call assert_equal([[1, ''], [0, 'four']], g:MytsrFunc2_args)
bw!

" Test for using a lambda function
***************
*** 1249,1254 ****
--- 1375,1389 ----
bw!

" Set 'thesaurusfunc' to a lambda expression
+ let &thesaurusfunc = {a, b -> MytsrFunc3(a, b)}
+ new | only
+ call setline(1, 'six')
+ let g:MytsrFunc3_args = []
+ call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
+ call assert_equal([[1, ''], [0, 'six']], g:MytsrFunc3_args)
+ bw!
+
+ " Set 'thesaurusfunc' to a string(lambda expression)
let &thesaurusfunc = '{a, b -> MytsrFunc3(a, b)}'
new | only
call setline(1, 'six')
***************
*** 1259,1276 ****

" Set 'thesaurusfunc' to a variable with a lambda expression
let Lambda = {a, b -> MytsrFunc3(a, b)}
let &thesaurusfunc = string(Lambda)
new | only
call setline(1, 'seven')
let g:MytsrFunc3_args = []
call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
call assert_equal([[1, ''], [0, 'seven']], g:MytsrFunc3_args)
- call assert_fails('let &thesaurusfunc = Lambda', 'E729:')
bw!

" Test for using a lambda function with incorrect return value
let Lambda = {s -> strlen(s)}
! let &thesaurusfunc = string(Lambda)
new | only
call setline(1, 'eight')
call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
--- 1394,1420 ----

" Set 'thesaurusfunc' to a variable with a lambda expression
let Lambda = {a, b -> MytsrFunc3(a, b)}
+ let &thesaurusfunc = Lambda
+ new | only
+ call setline(1, 'seven')
+ let g:MytsrFunc3_args = []
+ call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
+ call assert_equal([[1, ''], [0, 'seven']], g:MytsrFunc3_args)
+ bw!
+
+ " Set 'thesaurusfunc' to a string(variable with a lambda expression)
+ let Lambda = {a, b -> MytsrFunc3(a, b)}
let &thesaurusfunc = string(Lambda)
new | only
call setline(1, 'seven')
let g:MytsrFunc3_args = []
call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
call assert_equal([[1, ''], [0, 'seven']], g:MytsrFunc3_args)
bw!

" Test for using a lambda function with incorrect return value
let Lambda = {s -> strlen(s)}
! let &thesaurusfunc = Lambda
new | only
call setline(1, 'eight')
call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
***************
*** 1282,1288 ****

call assert_fails("set thesaurusfunc=function('abc')", "E700:")
call assert_fails("set thesaurusfunc=funcref('abc')", "E700:")
! let &thesaurusfunc = "{a -> 'abc'}"
call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')

" Vim9 tests
--- 1426,1432 ----

call assert_fails("set thesaurusfunc=function('abc')", "E700:")
call assert_fails("set thesaurusfunc=funcref('abc')", "E700:")
! let &thesaurusfunc = {a -> 'abc'}
call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')

" Vim9 tests
***************
*** 1307,1312 ****
--- 1451,1465 ----
add(g:MytsrFunc2_args, [findstart, base])
return findstart ? 0 : []
enddef
+ &thesaurusfunc = (a, b) => MytsrFunc2(a, b)
+ new | only
+ setline(1, 'two')
+ g:MytsrFunc2_args = []
+ feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
+ assert_equal([[1, ''], [0, 'two']], g:MytsrFunc2_args)
+ bw!
+
+ # Test for using a string(lambda)
&thesaurusfunc = '(a, b) => MytsrFunc2(a, b)'
new | only
setline(1, 'two')
***************
*** 1317,1322 ****
--- 1470,1484 ----

# Test for using a variable with a lambda expression
var Fn: func = (a, b) => MytsrFunc2(a, b)
+ &thesaurusfunc = Fn
+ new | only
+ setline(1, 'three')
+ g:MytsrFunc2_args = []
+ feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
+ assert_equal([[1, ''], [0, 'three']], g:MytsrFunc2_args)
+ bw!
+
+ # Test for using a string(variable with a lambda expression)
&thesaurusfunc = string(Fn)
new | only
setline(1, 'three')
*** ../vim-8.2.3750/src/testdir/test_tagfunc.vim 2021-12-03 11:08:34.260842706 +0000
--- src/testdir/test_tagfunc.vim 2021-12-06 10:41:05.784060967 +0000
***************
*** 140,151 ****

" Using a funcref variable to set 'tagfunc'
let Fn = function('MytagFunc1')
let &tagfunc = string(Fn)
new | only
let g:MytagFunc1_args = []
call assert_fails('tag a12', 'E433:')
call assert_equal(['a12', '', {}], g:MytagFunc1_args)
- call assert_fails('let &tagfunc = Fn', 'E729:')

" Test for using a funcref()
func MytagFunc2(pat, flags, info)
--- 140,158 ----

" Using a funcref variable to set 'tagfunc'
let Fn = function('MytagFunc1')
+ let &tagfunc = Fn
+ new | only
+ let g:MytagFunc1_args = []
+ call assert_fails('tag a12', 'E433:')
+ call assert_equal(['a12', '', {}], g:MytagFunc1_args)
+
+ " Using a string(funcref_variable) to set 'tagfunc'
+ let Fn = function('MytagFunc1')
let &tagfunc = string(Fn)
new | only
let g:MytagFunc1_args = []
call assert_fails('tag a12', 'E433:')
call assert_equal(['a12', '', {}], g:MytagFunc1_args)

" Test for using a funcref()
func MytagFunc2(pat, flags, info)
***************
*** 160,171 ****

" Using a funcref variable to set 'tagfunc'
let Fn = funcref('MytagFunc2')
let &tagfunc = string(Fn)
new | only
let g:MytagFunc2_args = []
call assert_fails('tag a14', 'E433:')
call assert_equal(['a14', '', {}], g:MytagFunc2_args)
- call assert_fails('let &tagfunc = Fn', 'E729:')

" Test for using a script local function
set tagfunc=<SID>ScriptLocalTagFunc
--- 167,185 ----

" Using a funcref variable to set 'tagfunc'
let Fn = funcref('MytagFunc2')
+ let &tagfunc = Fn
+ new | only
+ let g:MytagFunc2_args = []
+ call assert_fails('tag a14', 'E433:')
+ call assert_equal(['a14', '', {}], g:MytagFunc2_args)
+
+ " Using a string(funcref_variable) to set 'tagfunc'
+ let Fn = funcref('MytagFunc2')
let &tagfunc = string(Fn)
new | only
let g:MytagFunc2_args = []
call assert_fails('tag a14', 'E433:')
call assert_equal(['a14', '', {}], g:MytagFunc2_args)

" Test for using a script local function
set tagfunc=<SID>ScriptLocalTagFunc
***************
*** 176,181 ****
--- 190,203 ----

" Test for using a script local funcref variable
let Fn = function("s:ScriptLocalTagFunc")
+ let &tagfunc= Fn
+ new | only
+ let g:ScriptLocalFuncArgs = []
+ call assert_fails('tag a16', 'E433:')
+ call assert_equal(['a16', '', {}], g:ScriptLocalFuncArgs)
+
+ " Test for using a string(script local funcref variable)
+ let Fn = function("s:ScriptLocalTagFunc")
let &tagfunc= string(Fn)
new | only
let g:ScriptLocalFuncArgs = []
***************
*** 194,199 ****
--- 216,228 ----
call assert_equal(['a17', '', {}], g:MytagFunc3_args)

" Set 'tagfunc' to a lambda expression
+ let &tagfunc = {a, b, c -> MytagFunc3(a, b, c)}
+ new | only
+ let g:MytagFunc3_args = []
+ call assert_fails('tag a18', 'E433:')
+ call assert_equal(['a18', '', {}], g:MytagFunc3_args)
+
+ " Set 'tagfunc' to a string(lambda expression)
let &tagfunc = '{a, b, c -> MytagFunc3(a, b, c)}'
new | only
let g:MytagFunc3_args = []
***************
*** 202,213 ****

" Set 'tagfunc' to a variable with a lambda expression
let Lambda = {a, b, c -> MytagFunc3(a, b, c)}
let &tagfunc = string(Lambda)
new | only
let g:MytagFunc3_args = []
call assert_fails("tag a19", "E433:")
call assert_equal(['a19', '', {}], g:MytagFunc3_args)
- call assert_fails('let &tagfunc = Lambda', 'E729:')

" Test for using a lambda function with incorrect return value
let Lambda = {s -> strlen(s)}
--- 231,249 ----

" Set 'tagfunc' to a variable with a lambda expression
let Lambda = {a, b, c -> MytagFunc3(a, b, c)}
+ let &tagfunc = Lambda
+ new | only
+ let g:MytagFunc3_args = []
+ call assert_fails("tag a19", "E433:")
+ call assert_equal(['a19', '', {}], g:MytagFunc3_args)
+
+ " Set 'tagfunc' to a string(variable with a lambda expression)
+ let Lambda = {a, b, c -> MytagFunc3(a, b, c)}
let &tagfunc = string(Lambda)
new | only
let g:MytagFunc3_args = []
call assert_fails("tag a19", "E433:")
call assert_equal(['a19', '', {}], g:MytagFunc3_args)

" Test for using a lambda function with incorrect return value
let Lambda = {s -> strlen(s)}
***************
*** 244,249 ****
--- 280,292 ----
g:MytagFunc2_args = [pat, flags, info]
return null
enddef
+ &tagfunc = (a, b, c) => MytagFunc2(a, b, c)
+ new | only
+ g:MytagFunc2_args = []
+ assert_fails('tag a20', 'E433:')
+ assert_equal(['a20', '', {}], g:MytagFunc2_args)
+
+ # Test for using a string(lambda)
&tagfunc = '(a, b, c) => MytagFunc2(a, b, c)'
new | only
g:MytagFunc2_args = []
***************
*** 252,257 ****
--- 295,307 ----

# Test for using a variable with a lambda expression
var Fn: func = (a, b, c) => MytagFunc2(a, b, c)
+ &tagfunc = Fn
+ new | only
+ g:MytagFunc2_args = []
+ assert_fails('tag a30', 'E433:')
+ assert_equal(['a30', '', {}], g:MytagFunc2_args)
+
+ # Test for using a variable with a lambda expression
&tagfunc = string(Fn)
new | only
g:MytagFunc2_args = []
*** ../vim-8.2.3750/src/version.c 2021-12-05 22:19:22.840153470 +0000
--- src/version.c 2021-12-06 10:45:32.884284965 +0000
***************
*** 755,756 ****
--- 755,758 ----
{ /* Add new patch number below this line */
+ /**/
+ 3751,
/**/

--
I used to be indecisive, now I'm not sure.

/// Bram Moolenaar -- Br...@Moolenaar.net -- http://www.Moolenaar.net \\\
/// \\\
\\\ sponsor Vim, vote for features -- http://www.Vim.org/sponsor/ ///
\\\ help me help AIDS victims -- http://ICCF-Holland.org ///