Patch 8.2.3792

[Bram Moolenaar]

Patch 8.2.3792
Problem: Setting *func options insufficiently tested.
Solution: Impove tests. (Yegappan Lakshmanan, closes #9337)
Files: src/testdir/test_iminsert.vim, src/testdir/test_ins_complete.vim,
src/testdir/test_normal.vim, src/testdir/test_quickfix.vim,
src/testdir/test_tagfunc.vim


*** ../vim-8.2.3791/src/testdir/test_iminsert.vim 2021-12-12 16:26:35.868627601 +0000
--- src/testdir/test_iminsert.vim 2021-12-12 20:06:43.188489742 +0000
***************
*** 125,130 ****
--- 125,135 ----
LET g:IMactivatefunc_called = 0
LET g:IMstatusfunc_called = 0

+ #" Test for using a function name
+ LET &imactivatefunc = 'g:IMactivatefunc1'
+ LET &imstatusfunc = 'g:IMstatusfunc1'
+ normal! i
+
#" Test for using a function()
set imactivatefunc=function('g:IMactivatefunc1')
set imstatusfunc=function('g:IMstatusfunc1')
***************
*** 215,222 ****
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)

--- 220,227 ----
call assert_fails("LET &imstatusfunc = function('NonExistingFunc')", 'E700:')
normal! i

! call assert_equal(14, g:IMactivatefunc_called)
! call assert_equal(28, g:IMstatusfunc_called)
END
call CheckLegacyAndVim9Success(lines)

***************
*** 283,294 ****
call CheckScriptSuccess(lines)

" cleanup
delfunc IMactivatefunc1
delfunc IMstatusfunc1
! set iminsert=0
! set imactivatefunc=
! set imstatusfunc=
!
%bw!
endfunc

--- 288,299 ----
call CheckScriptSuccess(lines)

" cleanup
+ set iminsert=0
+ set imactivatefunc&
+ set imstatusfunc&
delfunc IMactivatefunc1
delfunc IMstatusfunc1
! unlet g:IMactivatefunc_called g:IMstatusfunc_called
%bw!
endfunc

*** ../vim-8.2.3791/src/testdir/test_ins_complete.vim 2021-12-12 16:26:35.872627594 +0000
--- src/testdir/test_ins_complete.vim 2021-12-12 20:06:43.192489733 +0000
***************
*** 870,992 ****

" Test for different ways of setting the 'completefunc' option
func Test_completefunc_callback()
! func MycompleteFunc1(val, findstart, base)
! call add(g:MycompleteFunc1_args, [a:val, a:findstart, a:base])
return a:findstart ? 0 : []
endfunc

let lines =<< trim END
#" Test for using a function()
! set completefunc=function('g:MycompleteFunc1',\ [10])
! new | only
call setline(1, 'one')
! LET g:MycompleteFunc1_args = []
call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
! call assert_equal([[10, 1, ''], [10, 0, 'one']], g:MycompleteFunc1_args)
bw!

#" Using a funcref variable to set 'completefunc'
! VAR Fn = function('g:MycompleteFunc1', [11])
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([[11, 1, ''], [11, 0, 'two']], g:MycompleteFunc1_args)
bw!

#" Using string(funcref_variable) to set 'completefunc'
! LET Fn = function('g:MycompleteFunc1', [12])
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([[12, 1, ''], [12, 0, 'two']], g:MycompleteFunc1_args)
bw!

#" Test for using a funcref()
! set completefunc=funcref('g:MycompleteFunc1',\ [13])
! new | only
call setline(1, 'three')
! LET g:MycompleteFunc1_args = []
call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
! call assert_equal([[13, 1, ''], [13, 0, 'three']], g:MycompleteFunc1_args)
bw!

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

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

#" Test for using a lambda function with set
! VAR optval = "LSTART a, b LMIDDLE MycompleteFunc1(16, a, b) LEND"
LET optval = substitute(optval, ' ', '\\ ', 'g')
exe "set completefunc=" .. optval
! new | only
call setline(1, 'five')
! LET g:MycompleteFunc1_args = []
call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
! call assert_equal([[16, 1, ''], [16, 0, 'five']], g:MycompleteFunc1_args)
bw!

#" Set 'completefunc' to a lambda expression
! LET &completefunc = LSTART a, b LMIDDLE MycompleteFunc1(17, a, b) LEND
! new | only
call setline(1, 'six')
! LET g:MycompleteFunc1_args = []
call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
! call assert_equal([[17, 1, ''], [17, 0, 'six']], g:MycompleteFunc1_args)
bw!

#" Set 'completefunc' to string(lambda_expression)
! LET &completefunc = 'LSTART a, b LMIDDLE MycompleteFunc1(18, a, b) LEND'
! new | only
call setline(1, 'six')
! LET g:MycompleteFunc1_args = []
call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
! call assert_equal([[18, 1, ''], [18, 0, 'six']], g:MycompleteFunc1_args)
bw!

#" Set 'completefunc' to a variable with a lambda expression
! VAR Lambda = LSTART a, b LMIDDLE MycompleteFunc1(19, a, b) LEND
LET &completefunc = Lambda
! new | only
call setline(1, 'seven')
! LET g:MycompleteFunc1_args = []
call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
! call assert_equal([[19, 1, ''], [19, 0, 'seven']], g:MycompleteFunc1_args)
bw!

#" Set 'completefunc' to a string(variable with a lambda expression)
! LET Lambda = LSTART a, b LMIDDLE MycompleteFunc1(20, a, b) LEND
LET &completefunc = string(Lambda)
! new | only
call setline(1, 'seven')
! LET g:MycompleteFunc1_args = []
call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
! call assert_equal([[20, 1, ''], [20, 0, 'seven']], g:MycompleteFunc1_args)
bw!

#" Test for using a lambda function with incorrect return value
LET Lambda = LSTART a, b LMIDDLE strlen(a) LEND
LET &completefunc = Lambda
! new | only
call setline(1, 'eight')
call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
bw!
--- 870,1005 ----

" Test for different ways of setting the 'completefunc' option
func Test_completefunc_callback()
! func CompleteFunc1(callnr, findstart, base)
! call add(g:CompleteFunc1Args, [a:callnr, a:findstart, a:base])
! return a:findstart ? 0 : []
! endfunc
! func CompleteFunc2(findstart, base)
! call add(g:CompleteFunc2Args, [a:findstart, a:base])
return a:findstart ? 0 : []
endfunc

let lines =<< trim END
+ #" Test for using a function name
+ LET &completefunc = 'g:CompleteFunc2'
+ new
+ call setline(1, 'zero')
+ LET g:CompleteFunc2Args = []
+ call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
+ call assert_equal([[1, ''], [0, 'zero']], g:CompleteFunc2Args)
+ bw!
+
#" Test for using a function()
! set completefunc=function('g:CompleteFunc1',\ [10])
! new
call setline(1, 'one')
! LET g:CompleteFunc1Args = []
call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
! call assert_equal([[10, 1, ''], [10, 0, 'one']], g:CompleteFunc1Args)
bw!

#" Using a funcref variable to set 'completefunc'
! VAR Fn = function('g:CompleteFunc1', [11])
LET &completefunc = Fn
! new
call setline(1, 'two')
! LET g:CompleteFunc1Args = []
call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
! call assert_equal([[11, 1, ''], [11, 0, 'two']], g:CompleteFunc1Args)
bw!

#" Using string(funcref_variable) to set 'completefunc'
! LET Fn = function('g:CompleteFunc1', [12])
LET &completefunc = string(Fn)
! new
call setline(1, 'two')
! LET g:CompleteFunc1Args = []
call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
! call assert_equal([[12, 1, ''], [12, 0, 'two']], g:CompleteFunc1Args)
bw!

#" Test for using a funcref()
! set completefunc=funcref('g:CompleteFunc1',\ [13])
! new
call setline(1, 'three')
! LET g:CompleteFunc1Args = []
call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
! call assert_equal([[13, 1, ''], [13, 0, 'three']], g:CompleteFunc1Args)
bw!

#" Using a funcref variable to set 'completefunc'
! LET Fn = funcref('g:CompleteFunc1', [14])
LET &completefunc = Fn
! new
call setline(1, 'four')
! LET g:CompleteFunc1Args = []
call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
! call assert_equal([[14, 1, ''], [14, 0, 'four']], g:CompleteFunc1Args)
bw!

#" Using a string(funcref_variable) to set 'completefunc'
! LET Fn = funcref('g:CompleteFunc1', [15])
LET &completefunc = string(Fn)
! new
call setline(1, 'four')
! LET g:CompleteFunc1Args = []
call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
! call assert_equal([[15, 1, ''], [15, 0, 'four']], g:CompleteFunc1Args)
bw!

#" Test for using a lambda function with set
! VAR optval = "LSTART a, b LMIDDLE CompleteFunc1(16, a, b) LEND"
LET optval = substitute(optval, ' ', '\\ ', 'g')
exe "set completefunc=" .. optval
! new
call setline(1, 'five')
! LET g:CompleteFunc1Args = []
call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
! call assert_equal([[16, 1, ''], [16, 0, 'five']], g:CompleteFunc1Args)
bw!

#" Set 'completefunc' to a lambda expression
! LET &completefunc = LSTART a, b LMIDDLE CompleteFunc1(17, a, b) LEND
! new
call setline(1, 'six')
! LET g:CompleteFunc1Args = []
call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
! call assert_equal([[17, 1, ''], [17, 0, 'six']], g:CompleteFunc1Args)
bw!

#" Set 'completefunc' to string(lambda_expression)
! LET &completefunc = 'LSTART a, b LMIDDLE CompleteFunc1(18, a, b) LEND'
! new
call setline(1, 'six')
! LET g:CompleteFunc1Args = []
call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
! call assert_equal([[18, 1, ''], [18, 0, 'six']], g:CompleteFunc1Args)
bw!

#" Set 'completefunc' to a variable with a lambda expression
! VAR Lambda = LSTART a, b LMIDDLE CompleteFunc1(19, a, b) LEND
LET &completefunc = Lambda
! new
call setline(1, 'seven')
! LET g:CompleteFunc1Args = []
call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
! call assert_equal([[19, 1, ''], [19, 0, 'seven']], g:CompleteFunc1Args)
bw!

#" Set 'completefunc' to a string(variable with a lambda expression)
! LET Lambda = LSTART a, b LMIDDLE CompleteFunc1(20, a, b) LEND
LET &completefunc = string(Lambda)
! new
call setline(1, 'seven')
! LET g:CompleteFunc1Args = []
call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
! call assert_equal([[20, 1, ''], [20, 0, 'seven']], g:CompleteFunc1Args)
bw!

#" Test for using a lambda function with incorrect return value
LET Lambda = LSTART a, b LMIDDLE strlen(a) LEND
LET &completefunc = Lambda
! new
call setline(1, 'eight')
call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
bw!
***************
*** 998,1014 ****
call assert_fails("set completefunc=funcref('abc')", "E700:")

#" set 'completefunc' to a non-existing function
! func MycompleteFunc2(findstart, base)
! call add(g:MycompleteFunc2_args, [a:findstart, a:base])
! return a:findstart ? 0 : []
! endfunc
! set completefunc=MycompleteFunc2
call setline(1, 'five')
call assert_fails("set completefunc=function('NonExistingFunc')", 'E700:')
call assert_fails("LET &completefunc = function('NonExistingFunc')", 'E700:')
! LET g:MycompleteFunc2_args = []
call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
! call assert_equal([[1, ''], [0, 'five']], g:MycompleteFunc2_args)
bw!
END
call CheckLegacyAndVim9Success(lines)
--- 1011,1023 ----
call assert_fails("set completefunc=funcref('abc')", "E700:")

#" set 'completefunc' to a non-existing function
! set completefunc=CompleteFunc2
call setline(1, 'five')
call assert_fails("set completefunc=function('NonExistingFunc')", 'E700:')
call assert_fails("LET &completefunc = function('NonExistingFunc')", 'E700:')
! LET g:CompleteFunc2Args = []
call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
! call assert_equal([[1, ''], [0, 'five']], g:CompleteFunc2Args)
bw!
END
call CheckLegacyAndVim9Success(lines)
***************
*** 1017,1027 ****
call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')

" Using Vim9 lambda expression in legacy context should fail
! set completefunc=(a,\ b)\ =>\ MycompleteFunc1(21,\ a,\ b)
new | only
! let g:MycompleteFunc1_args = []
call assert_fails('call feedkeys("A\<C-X>\<C-U>\<Esc>", "x")', 'E117:')
! call assert_equal([], g:MycompleteFunc1_args)

" set 'completefunc' to a partial with dict. This used to cause a crash.
func SetCompleteFunc()
--- 1026,1036 ----
call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')

" Using Vim9 lambda expression in legacy context should fail
! set completefunc=(a,\ b)\ =>\ CompleteFunc1(21,\ a,\ b)
new | only
! let g:CompleteFunc1Args = []
call assert_fails('call feedkeys("A\<C-X>\<C-U>\<Esc>", "x")', 'E117:')
! call assert_equal([], g:CompleteFunc1Args)

" set 'completefunc' to a partial with dict. This used to cause a crash.
func SetCompleteFunc()
***************
*** 1063,1193 ****
call CheckScriptSuccess(lines)

" cleanup
- delfunc MycompleteFunc1
- delfunc MycompleteFunc2
set completefunc&
%bw!
endfunc

" Test for different ways of setting the 'omnifunc' option
func Test_omnifunc_callback()
! func MyomniFunc1(val, findstart, base)
! call add(g:MyomniFunc1_args, [a:val, a:findstart, a:base])
return a:findstart ? 0 : []
endfunc

let lines =<< trim END
#" Test for using a function()
! set omnifunc=function('g:MyomniFunc1',\ [10])
! new | only
call setline(1, 'one')
! LET g:MyomniFunc1_args = []
call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
! call assert_equal([[10, 1, ''], [10, 0, 'one']], g:MyomniFunc1_args)
bw!

#" Using a funcref variable to set 'omnifunc'
! VAR Fn = function('g:MyomniFunc1', [11])
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([[11, 1, ''], [11, 0, 'two']], g:MyomniFunc1_args)
bw!

#" Using a string(funcref_variable) to set 'omnifunc'
! LET Fn = function('g:MyomniFunc1', [12])
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([[12, 1, ''], [12, 0, 'two']], g:MyomniFunc1_args)
bw!

#" Test for using a funcref()
! set omnifunc=funcref('g:MyomniFunc1',\ [13])
! new | only
call setline(1, 'three')
! LET g:MyomniFunc1_args = []
call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
! call assert_equal([[13, 1, ''], [13, 0, 'three']], g:MyomniFunc1_args)
bw!

#" Use let to set 'omnifunc' to a funcref
! LET Fn = funcref('g:MyomniFunc1', [14])
LET &omnifunc = Fn
! new | only
call setline(1, 'four')
! LET g:MyomniFunc1_args = []
call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
! call assert_equal([[14, 1, ''], [14, 0, 'four']], g:MyomniFunc1_args)
bw!

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

#" Test for using a lambda function with set
! VAR optval = "LSTART a, b LMIDDLE MyomniFunc1(16, a, b) LEND"
LET optval = substitute(optval, ' ', '\\ ', 'g')
exe "set omnifunc=" .. optval
! new | only
call setline(1, 'five')
! LET g:MyomniFunc1_args = []
call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
! call assert_equal([[16, 1, ''], [16, 0, 'five']], g:MyomniFunc1_args)
bw!

#" Set 'omnifunc' to a lambda expression
! LET &omnifunc = LSTART a, b LMIDDLE MyomniFunc1(17, a, b) LEND
! new | only
call setline(1, 'six')
! LET g:MyomniFunc1_args = []
call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
! call assert_equal([[17, 1, ''], [17, 0, 'six']], g:MyomniFunc1_args)
bw!

#" Set 'omnifunc' to a string(lambda_expression)
! LET &omnifunc = 'LSTART a, b LMIDDLE MyomniFunc1(18, a, b) LEND'
! new | only
call setline(1, 'six')
! LET g:MyomniFunc1_args = []
call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
! call assert_equal([[18, 1, ''], [18, 0, 'six']], g:MyomniFunc1_args)
bw!

#" Set 'omnifunc' to a variable with a lambda expression
! VAR Lambda = LSTART a, b LMIDDLE MyomniFunc1(19, a, b) LEND
LET &omnifunc = Lambda
! new | only
call setline(1, 'seven')
! LET g:MyomniFunc1_args = []
call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
! call assert_equal([[19, 1, ''], [19, 0, 'seven']], g:MyomniFunc1_args)
bw!

#" Set 'omnifunc' to a string(variable with a lambda expression)
! LET Lambda = LSTART a, b LMIDDLE MyomniFunc1(20, a, b) LEND
LET &omnifunc = string(Lambda)
! new | only
call setline(1, 'seven')
! LET g:MyomniFunc1_args = []
call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
! call assert_equal([[20, 1, ''], [20, 0, 'seven']], g:MyomniFunc1_args)
bw!

#" Test for using a lambda function with incorrect return value
LET Lambda = LSTART a, b LMIDDLE strlen(a) LEND
LET &omnifunc = Lambda
! new | only
call setline(1, 'eight')
call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
bw!
--- 1072,1216 ----
call CheckScriptSuccess(lines)

" cleanup
set completefunc&
+ delfunc CompleteFunc1
+ delfunc CompleteFunc2
+ unlet g:CompleteFunc1Args g:CompleteFunc2Args
%bw!
endfunc

" Test for different ways of setting the 'omnifunc' option
func Test_omnifunc_callback()
! func OmniFunc1(callnr, findstart, base)
! call add(g:OmniFunc1Args, [a:callnr, a:findstart, a:base])
! return a:findstart ? 0 : []
! endfunc
! func OmniFunc2(findstart, base)
! call add(g:OmniFunc2Args, [a:findstart, a:base])
return a:findstart ? 0 : []
endfunc

let lines =<< trim END
+ #" Test for using a function name
+ LET &omnifunc = 'g:OmniFunc2'
+ new
+ call setline(1, 'zero')
+ LET g:OmniFunc2Args = []
+ call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
+ call assert_equal([[1, ''], [0, 'zero']], g:OmniFunc2Args)
+ bw!
+
#" Test for using a function()
! set omnifunc=function('g:OmniFunc1',\ [10])
! new
call setline(1, 'one')
! LET g:OmniFunc1Args = []
call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
! call assert_equal([[10, 1, ''], [10, 0, 'one']], g:OmniFunc1Args)
bw!

#" Using a funcref variable to set 'omnifunc'
! VAR Fn = function('g:OmniFunc1', [11])
LET &omnifunc = Fn
! new
call setline(1, 'two')
! LET g:OmniFunc1Args = []
call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
! call assert_equal([[11, 1, ''], [11, 0, 'two']], g:OmniFunc1Args)
bw!

#" Using a string(funcref_variable) to set 'omnifunc'
! LET Fn = function('g:OmniFunc1', [12])
LET &omnifunc = string(Fn)
! new
call setline(1, 'two')
! LET g:OmniFunc1Args = []
call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
! call assert_equal([[12, 1, ''], [12, 0, 'two']], g:OmniFunc1Args)
bw!

#" Test for using a funcref()
! set omnifunc=funcref('g:OmniFunc1',\ [13])
! new
call setline(1, 'three')
! LET g:OmniFunc1Args = []
call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
! call assert_equal([[13, 1, ''], [13, 0, 'three']], g:OmniFunc1Args)
bw!

#" Use let to set 'omnifunc' to a funcref
! LET Fn = funcref('g:OmniFunc1', [14])
LET &omnifunc = Fn
! new
call setline(1, 'four')
! LET g:OmniFunc1Args = []
call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
! call assert_equal([[14, 1, ''], [14, 0, 'four']], g:OmniFunc1Args)
bw!

#" Using a string(funcref) to set 'omnifunc'
! LET Fn = funcref("g:OmniFunc1", [15])
LET &omnifunc = string(Fn)
! new
call setline(1, 'four')
! LET g:OmniFunc1Args = []
call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
! call assert_equal([[15, 1, ''], [15, 0, 'four']], g:OmniFunc1Args)
bw!

#" Test for using a lambda function with set
! VAR optval = "LSTART a, b LMIDDLE OmniFunc1(16, a, b) LEND"
LET optval = substitute(optval, ' ', '\\ ', 'g')
exe "set omnifunc=" .. optval
! new
call setline(1, 'five')
! LET g:OmniFunc1Args = []
call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
! call assert_equal([[16, 1, ''], [16, 0, 'five']], g:OmniFunc1Args)
bw!

#" Set 'omnifunc' to a lambda expression
! LET &omnifunc = LSTART a, b LMIDDLE OmniFunc1(17, a, b) LEND
! new
call setline(1, 'six')
! LET g:OmniFunc1Args = []
call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
! call assert_equal([[17, 1, ''], [17, 0, 'six']], g:OmniFunc1Args)
bw!

#" Set 'omnifunc' to a string(lambda_expression)
! LET &omnifunc = 'LSTART a, b LMIDDLE OmniFunc1(18, a, b) LEND'
! new
call setline(1, 'six')
! LET g:OmniFunc1Args = []
call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
! call assert_equal([[18, 1, ''], [18, 0, 'six']], g:OmniFunc1Args)
bw!

#" Set 'omnifunc' to a variable with a lambda expression
! VAR Lambda = LSTART a, b LMIDDLE OmniFunc1(19, a, b) LEND
LET &omnifunc = Lambda
! new
call setline(1, 'seven')
! LET g:OmniFunc1Args = []
call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
! call assert_equal([[19, 1, ''], [19, 0, 'seven']], g:OmniFunc1Args)
bw!

#" Set 'omnifunc' to a string(variable with a lambda expression)
! LET Lambda = LSTART a, b LMIDDLE OmniFunc1(20, a, b) LEND
LET &omnifunc = string(Lambda)
! new
call setline(1, 'seven')
! LET g:OmniFunc1Args = []
call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
! call assert_equal([[20, 1, ''], [20, 0, 'seven']], g:OmniFunc1Args)
bw!

#" Test for using a lambda function with incorrect return value
LET Lambda = LSTART a, b LMIDDLE strlen(a) LEND
LET &omnifunc = Lambda
! new
call setline(1, 'eight')
call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
bw!
***************
*** 1199,1215 ****
call assert_fails("set omnifunc=funcref('abc')", "E700:")

#" set 'omnifunc' to a non-existing function
! func MyomniFunc2(findstart, base)
! call add(g:MyomniFunc2_args, [a:findstart, a:base])
! return a:findstart ? 0 : []
! endfunc
! set omnifunc=MyomniFunc2
call setline(1, 'nine')
call assert_fails("set omnifunc=function('NonExistingFunc')", 'E700:')
call assert_fails("LET &omnifunc = function('NonExistingFunc')", 'E700:')
! LET g:MyomniFunc2_args = []
call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
! call assert_equal([[1, ''], [0, 'nine']], g:MyomniFunc2_args)
bw!
END
call CheckLegacyAndVim9Success(lines)
--- 1222,1234 ----
call assert_fails("set omnifunc=funcref('abc')", "E700:")

#" set 'omnifunc' to a non-existing function
! set omnifunc=OmniFunc2
call setline(1, 'nine')
call assert_fails("set omnifunc=function('NonExistingFunc')", 'E700:')
call assert_fails("LET &omnifunc = function('NonExistingFunc')", 'E700:')
! LET g:OmniFunc2Args = []
call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
! call assert_equal([[1, ''], [0, 'nine']], g:OmniFunc2Args)
bw!
END
call CheckLegacyAndVim9Success(lines)
***************
*** 1218,1228 ****
call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')

" Using Vim9 lambda expression in legacy context should fail
! set omnifunc=(a,\ b)\ =>\ MyomniFunc1(21,\ a,\ b)
new | only
! let g:MyomniFunc1_args = []
call assert_fails('call feedkeys("A\<C-X>\<C-O>\<Esc>", "x")', 'E117:')
! call assert_equal([], g:MyomniFunc1_args)

" set 'omnifunc' to a partial with dict. This used to cause a crash.
func SetOmniFunc()
--- 1237,1247 ----
call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')

" Using Vim9 lambda expression in legacy context should fail
! set omnifunc=(a,\ b)\ =>\ OmniFunc1(21,\ a,\ b)
new | only
! let g:OmniFunc1Args = []
call assert_fails('call feedkeys("A\<C-X>\<C-O>\<Esc>", "x")', 'E117:')
! call assert_equal([], g:OmniFunc1Args)

" set 'omnifunc' to a partial with dict. This used to cause a crash.
func SetOmniFunc()
***************
*** 1264,1394 ****
call CheckScriptSuccess(lines)

" cleanup
- delfunc MyomniFunc1
- delfunc MyomniFunc2
set omnifunc&
%bw!
endfunc

" Test for different ways of setting the 'thesaurusfunc' option
func Test_thesaurusfunc_callback()
! func MytsrFunc1(val, findstart, base)
! call add(g:MytsrFunc1_args, [a:val, a:findstart, a:base])
return a:findstart ? 0 : []
endfunc

let lines =<< trim END
#" Test for using a function()
! set thesaurusfunc=function('g:MytsrFunc1',\ [10])
! new | only
call setline(1, 'one')
! LET g:MytsrFunc1_args = []
call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
! call assert_equal([[10, 1, ''], [10, 0, 'one']], g:MytsrFunc1_args)
bw!

#" Using a funcref variable to set 'thesaurusfunc'
! VAR Fn = function('g:MytsrFunc1', [11])
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([[11, 1, ''], [11, 0, 'two']], g:MytsrFunc1_args)
bw!

#" Using a string(funcref_variable) to set 'thesaurusfunc'
! LET Fn = function('g:MytsrFunc1', [12])
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([[12, 1, ''], [12, 0, 'two']], g:MytsrFunc1_args)
bw!

#" Test for using a funcref()
! set thesaurusfunc=funcref('g:MytsrFunc1',\ [13])
! new | only
call setline(1, 'three')
! LET g:MytsrFunc1_args = []
call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
! call assert_equal([[13, 1, ''], [13, 0, 'three']], g:MytsrFunc1_args)
bw!

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

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

#" Test for using a lambda function
! VAR optval = "LSTART a, b LMIDDLE MytsrFunc1(16, a, b) LEND"
LET optval = substitute(optval, ' ', '\\ ', 'g')
exe "set thesaurusfunc=" .. optval
! new | only
call setline(1, 'five')
! LET g:MytsrFunc1_args = []
call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
! call assert_equal([[16, 1, ''], [16, 0, 'five']], g:MytsrFunc1_args)
bw!

#" Test for using a lambda function with set
! LET &thesaurusfunc = LSTART a, b LMIDDLE MytsrFunc1(17, a, b) LEND
! new | only
call setline(1, 'six')
! LET g:MytsrFunc1_args = []
call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
! call assert_equal([[17, 1, ''], [17, 0, 'six']], g:MytsrFunc1_args)
bw!

#" Set 'thesaurusfunc' to a string(lambda expression)
! LET &thesaurusfunc = 'LSTART a, b LMIDDLE MytsrFunc1(18, a, b) LEND'
! new | only
call setline(1, 'six')
! LET g:MytsrFunc1_args = []
call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
! call assert_equal([[18, 1, ''], [18, 0, 'six']], g:MytsrFunc1_args)
bw!

#" Set 'thesaurusfunc' to a variable with a lambda expression
! VAR Lambda = LSTART a, b LMIDDLE MytsrFunc1(19, a, b) LEND
LET &thesaurusfunc = Lambda
! new | only
call setline(1, 'seven')
! LET g:MytsrFunc1_args = []
call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
! call assert_equal([[19, 1, ''], [19, 0, 'seven']], g:MytsrFunc1_args)
bw!

#" Set 'thesaurusfunc' to a string(variable with a lambda expression)
! LET Lambda = LSTART a, b LMIDDLE MytsrFunc1(20, a, b) LEND
LET &thesaurusfunc = string(Lambda)
! new | only
call setline(1, 'seven')
! LET g:MytsrFunc1_args = []
call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
! call assert_equal([[20, 1, ''], [20, 0, 'seven']], g:MytsrFunc1_args)
bw!

#" Test for using a lambda function with incorrect return value
LET Lambda = LSTART a, b LMIDDLE strlen(a) LEND
LET &thesaurusfunc = Lambda
! new | only
call setline(1, 'eight')
call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
bw!
--- 1283,1427 ----
call CheckScriptSuccess(lines)

" cleanup
set omnifunc&
+ delfunc OmniFunc1
+ delfunc OmniFunc2
+ unlet g:OmniFunc1Args g:OmniFunc2Args
%bw!
endfunc

" Test for different ways of setting the 'thesaurusfunc' option
func Test_thesaurusfunc_callback()
! func TsrFunc1(callnr, findstart, base)
! call add(g:TsrFunc1Args, [a:callnr, a:findstart, a:base])
return a:findstart ? 0 : []
endfunc
+ func TsrFunc2(findstart, base)
+ call add(g:TsrFunc2Args, [a:findstart, a:base])
+ return a:findstart ? 0 : ['sunday']
+ endfunc

let lines =<< trim END
+ #" Test for using a function name
+ LET &thesaurusfunc = 'g:TsrFunc2'
+ new
+ call setline(1, 'zero')
+ LET g:TsrFunc2Args = []
+ call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
+ call assert_equal([[1, ''], [0, 'zero']], g:TsrFunc2Args)
+ bw!
+
#" Test for using a function()
! set thesaurusfunc=function('g:TsrFunc1',\ [10])
! new
call setline(1, 'one')
! LET g:TsrFunc1Args = []
call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
! call assert_equal([[10, 1, ''], [10, 0, 'one']], g:TsrFunc1Args)
bw!

#" Using a funcref variable to set 'thesaurusfunc'
! VAR Fn = function('g:TsrFunc1', [11])
LET &thesaurusfunc = Fn
! new
call setline(1, 'two')
! LET g:TsrFunc1Args = []
call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
! call assert_equal([[11, 1, ''], [11, 0, 'two']], g:TsrFunc1Args)
bw!

#" Using a string(funcref_variable) to set 'thesaurusfunc'
! LET Fn = function('g:TsrFunc1', [12])
LET &thesaurusfunc = string(Fn)
! new
call setline(1, 'two')
! LET g:TsrFunc1Args = []
call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
! call assert_equal([[12, 1, ''], [12, 0, 'two']], g:TsrFunc1Args)
bw!

#" Test for using a funcref()
! set thesaurusfunc=funcref('g:TsrFunc1',\ [13])
! new
call setline(1, 'three')
! LET g:TsrFunc1Args = []
call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
! call assert_equal([[13, 1, ''], [13, 0, 'three']], g:TsrFunc1Args)
bw!

#" Using a funcref variable to set 'thesaurusfunc'
! LET Fn = funcref('g:TsrFunc1', [14])
LET &thesaurusfunc = Fn
! new
call setline(1, 'four')
! LET g:TsrFunc1Args = []
call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
! call assert_equal([[14, 1, ''], [14, 0, 'four']], g:TsrFunc1Args)
bw!

#" Using a string(funcref_variable) to set 'thesaurusfunc'
! LET Fn = funcref('g:TsrFunc1', [15])
LET &thesaurusfunc = string(Fn)
! new
call setline(1, 'four')
! LET g:TsrFunc1Args = []
call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
! call assert_equal([[15, 1, ''], [15, 0, 'four']], g:TsrFunc1Args)
bw!

#" Test for using a lambda function
! VAR optval = "LSTART a, b LMIDDLE TsrFunc1(16, a, b) LEND"
LET optval = substitute(optval, ' ', '\\ ', 'g')
exe "set thesaurusfunc=" .. optval
! new
call setline(1, 'five')
! LET g:TsrFunc1Args = []
call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
! call assert_equal([[16, 1, ''], [16, 0, 'five']], g:TsrFunc1Args)
bw!

#" Test for using a lambda function with set
! LET &thesaurusfunc = LSTART a, b LMIDDLE TsrFunc1(17, a, b) LEND
! new
call setline(1, 'six')
! LET g:TsrFunc1Args = []
call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
! call assert_equal([[17, 1, ''], [17, 0, 'six']], g:TsrFunc1Args)
bw!

#" Set 'thesaurusfunc' to a string(lambda expression)
! LET &thesaurusfunc = 'LSTART a, b LMIDDLE TsrFunc1(18, a, b) LEND'
! new
call setline(1, 'six')
! LET g:TsrFunc1Args = []
call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
! call assert_equal([[18, 1, ''], [18, 0, 'six']], g:TsrFunc1Args)
bw!

#" Set 'thesaurusfunc' to a variable with a lambda expression
! VAR Lambda = LSTART a, b LMIDDLE TsrFunc1(19, a, b) LEND
LET &thesaurusfunc = Lambda
! new
call setline(1, 'seven')
! LET g:TsrFunc1Args = []
call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
! call assert_equal([[19, 1, ''], [19, 0, 'seven']], g:TsrFunc1Args)
bw!

#" Set 'thesaurusfunc' to a string(variable with a lambda expression)
! LET Lambda = LSTART a, b LMIDDLE TsrFunc1(20, a, b) LEND
LET &thesaurusfunc = string(Lambda)
! new
call setline(1, 'seven')
! LET g:TsrFunc1Args = []
call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
! call assert_equal([[20, 1, ''], [20, 0, 'seven']], g:TsrFunc1Args)
bw!

#" Test for using a lambda function with incorrect return value
LET Lambda = LSTART a, b LMIDDLE strlen(a) LEND
LET &thesaurusfunc = Lambda
! new
call setline(1, 'eight')
call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
bw!
***************
*** 1400,1439 ****
call assert_fails("set thesaurusfunc=funcref('abc')", "E700:")

#" set 'thesaurusfunc' to a non-existing function
! func MytsrFunc2(findstart, base)
! call add(g:MytsrFunc2_args, [a:findstart, a:base])
! return a:findstart ? 0 : ['sunday']
! endfunc
! set thesaurusfunc=MytsrFunc2
call setline(1, 'ten')
call assert_fails("set thesaurusfunc=function('NonExistingFunc')", 'E700:')
call assert_fails("LET &thesaurusfunc = function('NonExistingFunc')", 'E700:')
! LET g:MytsrFunc2_args = []
call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
! call assert_equal([[1, ''], [0, 'ten']], g:MytsrFunc2_args)
bw!

#" Use a buffer-local value and a global value
set thesaurusfunc&
! setlocal thesaurusfunc=function('g:MytsrFunc1',\ [22])
call setline(1, 'sun')
! LET g:MytsrFunc1_args = []
call feedkeys("A\<C-X>\<C-T>\<Esc>", "x")
call assert_equal('sun', getline(1))
! call assert_equal([[22, 1, ''], [22, 0, 'sun']], g:MytsrFunc1_args)
new
call setline(1, 'sun')
! LET g:MytsrFunc1_args = []
call feedkeys("A\<C-X>\<C-T>\<Esc>", "x")
call assert_equal('sun', getline(1))
! call assert_equal([], g:MytsrFunc1_args)
! set thesaurusfunc=function('g:MytsrFunc1',\ [23])
wincmd w
call setline(1, 'sun')
! LET g:MytsrFunc1_args = []
call feedkeys("A\<C-X>\<C-T>\<Esc>", "x")
call assert_equal('sun', getline(1))
! call assert_equal([[22, 1, ''], [22, 0, 'sun']], g:MytsrFunc1_args)
:%bw!
END
call CheckLegacyAndVim9Success(lines)
--- 1433,1468 ----
call assert_fails("set thesaurusfunc=funcref('abc')", "E700:")

#" set 'thesaurusfunc' to a non-existing function
! set thesaurusfunc=TsrFunc2
call setline(1, 'ten')
call assert_fails("set thesaurusfunc=function('NonExistingFunc')", 'E700:')
call assert_fails("LET &thesaurusfunc = function('NonExistingFunc')", 'E700:')
! LET g:TsrFunc2Args = []
call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
! call assert_equal([[1, ''], [0, 'ten']], g:TsrFunc2Args)
bw!

#" Use a buffer-local value and a global value
set thesaurusfunc&
! setlocal thesaurusfunc=function('g:TsrFunc1',\ [22])
call setline(1, 'sun')
! LET g:TsrFunc1Args = []
call feedkeys("A\<C-X>\<C-T>\<Esc>", "x")
call assert_equal('sun', getline(1))
! call assert_equal([[22, 1, ''], [22, 0, 'sun']], g:TsrFunc1Args)
new
call setline(1, 'sun')
! LET g:TsrFunc1Args = []
call feedkeys("A\<C-X>\<C-T>\<Esc>", "x")
call assert_equal('sun', getline(1))
! call assert_equal([], g:TsrFunc1Args)
! set thesaurusfunc=function('g:TsrFunc1',\ [23])
wincmd w
call setline(1, 'sun')
! LET g:TsrFunc1Args = []
call feedkeys("A\<C-X>\<C-T>\<Esc>", "x")
call assert_equal('sun', getline(1))
! call assert_equal([[22, 1, ''], [22, 0, 'sun']], g:TsrFunc1Args)
:%bw!
END
call CheckLegacyAndVim9Success(lines)
***************
*** 1442,1452 ****
call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')

" Using Vim9 lambda expression in legacy context should fail
! set thesaurusfunc=(a,\ b)\ =>\ MytsrFunc1(21,\ a,\ b)
new | only
! let g:MytsrFunc1_args = []
call assert_fails('call feedkeys("A\<C-X>\<C-T>\<Esc>", "x")', 'E117:')
! call assert_equal([], g:MytsrFunc1_args)
bw!

" set 'thesaurusfunc' to a partial with dict. This used to cause a crash.
--- 1471,1481 ----
call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')

" Using Vim9 lambda expression in legacy context should fail
! set thesaurusfunc=(a,\ b)\ =>\ TsrFunc1(21,\ a,\ b)
new | only
! let g:TsrFunc1Args = []
call assert_fails('call feedkeys("A\<C-X>\<C-T>\<Esc>", "x")', 'E117:')
! call assert_equal([], g:TsrFunc1Args)
bw!

" set 'thesaurusfunc' to a partial with dict. This used to cause a crash.
***************
*** 1502,1509 ****

" cleanup
set thesaurusfunc&
! delfunc MytsrFunc1
! delfunc MytsrFunc2
%bw!
endfunc

--- 1531,1539 ----

" cleanup
set thesaurusfunc&
! delfunc TsrFunc1
! delfunc TsrFunc2
! unlet g:TsrFunc1Args g:TsrFunc2Args
%bw!
endfunc

*** ../vim-8.2.3791/src/testdir/test_normal.vim 2021-12-12 16:26:35.872627594 +0000
--- src/testdir/test_normal.vim 2021-12-12 20:06:43.192489733 +0000
***************
*** 444,553 ****
" Test for different ways of setting the 'operatorfunc' option
func Test_opfunc_callback()
new
! func MyopFunc(val, type)
! let g:OpFuncArgs = [a:val, a:type]
endfunc

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'
! 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('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('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('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('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
! 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 = 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 = '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
! 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 = 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 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 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=''
--- 444,563 ----
" Test for different ways of setting the 'operatorfunc' option
func Test_opfunc_callback()
new
! func OpFunc1(callnr, type)
! let g:OpFunc1Args = [a:callnr, a:type]
! endfunc
! func OpFunc2(type)
! let g:OpFunc2Args = [a:type]
endfunc

let lines =<< trim END
+ #" Test for using a function name
+ LET &opfunc = 'g:OpFunc2'
+ LET g:OpFunc2Args = []
+ normal! g@l
+ call assert_equal(['char'], g:OpFunc2Args)
+
#" Test for using a function()
! set opfunc=function('g:OpFunc1',\ [10])
! LET g:OpFunc1Args = []
normal! g@l
! call assert_equal([10, 'char'], g:OpFunc1Args)

#" Using a funcref variable to set 'operatorfunc'
! VAR Fn = function('g:OpFunc1', [11])
LET &opfunc = Fn
! LET g:OpFunc1Args = []
normal! g@l
! call assert_equal([11, 'char'], g:OpFunc1Args)

#" Using a string(funcref_variable) to set 'operatorfunc'
! LET Fn = function('g:OpFunc1', [12])
LET &operatorfunc = string(Fn)
! LET g:OpFunc1Args = []
normal! g@l
! call assert_equal([12, 'char'], g:OpFunc1Args)

#" Test for using a funcref()
! set operatorfunc=funcref('g:OpFunc1',\ [13])
! LET g:OpFunc1Args = []
normal! g@l
! call assert_equal([13, 'char'], g:OpFunc1Args)

#" Using a funcref variable to set 'operatorfunc'
! LET Fn = funcref('g:OpFunc1', [14])
LET &opfunc = Fn
! LET g:OpFunc1Args = []
normal! g@l
! call assert_equal([14, 'char'], g:OpFunc1Args)

#" Using a string(funcref_variable) to set 'operatorfunc'
! LET Fn = funcref('g:OpFunc1', [15])
LET &opfunc = string(Fn)
! LET g:OpFunc1Args = []
normal! g@l
! call assert_equal([15, 'char'], g:OpFunc1Args)

#" Test for using a lambda function using set
! VAR optval = "LSTART a LMIDDLE OpFunc1(16, a) LEND"
LET optval = substitute(optval, ' ', '\\ ', 'g')
exe "set opfunc=" .. optval
! LET g:OpFunc1Args = []
normal! g@l
! call assert_equal([16, 'char'], g:OpFunc1Args)

#" Test for using a lambda function using LET
! LET &opfunc = LSTART a LMIDDLE OpFunc1(17, a) LEND
! LET g:OpFunc1Args = []
normal! g@l
! call assert_equal([17, 'char'], g:OpFunc1Args)

#" Set 'operatorfunc' to a string(lambda expression)
! LET &opfunc = 'LSTART a LMIDDLE OpFunc1(18, a) LEND'
! LET g:OpFunc1Args = []
normal! g@l
! call assert_equal([18, 'char'], g:OpFunc1Args)

#" Set 'operatorfunc' to a variable with a lambda expression
! VAR Lambda = LSTART a LMIDDLE OpFunc1(19, a) LEND
LET &opfunc = Lambda
! LET g:OpFunc1Args = []
normal! g@l
! call assert_equal([19, 'char'], g:OpFunc1Args)

#" Set 'operatorfunc' to a string(variable with a lambda expression)
! LET Lambda = LSTART a LMIDDLE OpFunc1(20, a) LEND
LET &opfunc = string(Lambda)
! LET g:OpFunc1Args = []
normal! g@l
! call assert_equal([20, 'char'], g:OpFunc1Args)

#" Try to use 'operatorfunc' after the function is deleted
! func g:TmpOpFunc1(type)
! let g:TmpOpFunc1Args = [21, a:type]
endfunc
! LET &opfunc = function('g:TmpOpFunc1')
! delfunc g:TmpOpFunc1
call test_garbagecollect_now()
! LET g:TmpOpFunc1Args = []
call assert_fails('normal! g@l', 'E117:')
! call assert_equal([], g:TmpOpFunc1Args)

#" Try to use a function with two arguments for 'operatorfunc'
! func g:TmpOpFunc2(x, y)
! let g:TmpOpFunc2Args = [a:x, a:y]
endfunc
! set opfunc=TmpOpFunc2
! LET g:TmpOpFunc2Args = []
call assert_fails('normal! g@l', 'E119:')
! call assert_equal([], g:TmpOpFunc2Args)
! delfunc TmpOpFunc2

#" Try to use a lambda function with two arguments for 'operatorfunc'
! LET &opfunc = LSTART a, b LMIDDLE OpFunc1(22, b) LEND
! LET g:OpFunc1Args = []
call assert_fails('normal! g@l', 'E119:')
! call assert_equal([], g:OpFunc1Args)

#" Test for clearing the 'operatorfunc' option
set opfunc=''
***************
*** 556,575 ****
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)
! let g:OpFuncArgs = []
call assert_fails('normal! g@l', 'E117:')
! call assert_equal([], g:OpFuncArgs)

" set 'operatorfunc' to a partial with dict. This used to cause a crash.
func SetOpFunc()
--- 566,585 ----
call assert_fails("set opfunc=funcref('abc')", "E700:")

#" set 'operatorfunc' to a non-existing function
! LET &opfunc = function('g:OpFunc1', [23])
call assert_fails("set opfunc=function('NonExistingFunc')", 'E700:')
call assert_fails("LET &opfunc = function('NonExistingFunc')", 'E700:')
! LET g:OpFunc1Args = []
normal! g@l
! call assert_equal([23, 'char'], g:OpFunc1Args)
END
call CheckTransLegacySuccess(lines)

" Using Vim9 lambda expression in legacy context should fail
! set opfunc=(a)\ =>\ OpFunc1(24,\ a)
! let g:OpFunc1Args = []
call assert_fails('normal! g@l', 'E117:')
! call assert_equal([], g:OpFunc1Args)

" set 'operatorfunc' to a partial with dict. This used to cause a crash.
func SetOpFunc()
***************
*** 590,609 ****

# Test for using a def function with opfunc
def g:Vim9opFunc(val: number, type: string): void
! g:OpFuncArgs = [val, type]
enddef
set opfunc=function('g:Vim9opFunc',\ [60])
! g:OpFuncArgs = []
normal! g@l
! assert_equal([60, 'char'], g:OpFuncArgs)
END
call CheckScriptSuccess(lines)

" cleanup
set opfunc&
! delfunc MyopFunc
! delfunc MyopFunc2
! unlet g:OpFuncArgs
%bw!
endfunc

--- 600,619 ----

# Test for using a def function with opfunc
def g:Vim9opFunc(val: number, type: string): void
! g:OpFunc1Args = [val, type]
enddef
set opfunc=function('g:Vim9opFunc',\ [60])
! g:OpFunc1Args = []
normal! g@l
! assert_equal([60, 'char'], g:OpFunc1Args)
END
call CheckScriptSuccess(lines)

" cleanup
set opfunc&
! delfunc OpFunc1
! delfunc OpFunc2
! unlet g:OpFunc1Args g:OpFunc2Args
%bw!
endfunc

*** ../vim-8.2.3791/src/testdir/test_quickfix.vim 2021-12-12 16:26:35.872627594 +0000
--- src/testdir/test_quickfix.vim 2021-12-12 20:06:43.192489733 +0000
***************
*** 5287,5292 ****
--- 5287,5299 ----
let lines =<< trim END
set efm=%f:%l:%c:%m

+ #" Test for using a function name
+ LET &qftf = 'g:Tqfexpr'
+ cexpr "F0:0:0:L0"
+ copen
+ call assert_equal('F0-L0C0-L0', getline(1))
+ cclose
+
#" Test for using a function()
set qftf=function('g:Tqfexpr')
cexpr "F1:1:1:L1"
*** ../vim-8.2.3791/src/testdir/test_tagfunc.vim 2021-12-12 16:26:35.872627594 +0000
--- src/testdir/test_tagfunc.vim 2021-12-12 20:06:43.192489733 +0000
***************
*** 127,228 ****

" Test for different ways of setting the 'tagfunc' option
func Test_tagfunc_callback()
! func MytagFunc1(val, pat, flags, info)
! let g:MytagFunc1_args = [a:val, a:pat, a:flags, a:info]
return v:null
endfunc

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'
! 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('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()
! 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('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('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=''
--- 127,252 ----

" Test for different ways of setting the 'tagfunc' option
func Test_tagfunc_callback()
! func TagFunc1(callnr, pat, flags, info)
! let g:TagFunc1Args = [a:callnr, a:pat, a:flags, a:info]
! return v:null
! endfunc
! func TagFunc2(pat, flags, info)
! let g:TagFunc2Args = [a:pat, a:flags, a:info]
return v:null
endfunc

let lines =<< trim END
+ #" Test for using a function name
+ LET &tagfunc = 'g:TagFunc2'
+ new
+ LET g:TagFunc2Args = []
+ call assert_fails('tag a10', 'E433:')
+ call assert_equal(['a10', '', {}], g:TagFunc2Args)
+ bw!
+
#" Test for using a function()
! set tagfunc=function('g:TagFunc1',\ [10])
! new
! LET g:TagFunc1Args = []
call assert_fails('tag a11', 'E433:')
! call assert_equal([10, 'a11', '', {}], g:TagFunc1Args)
! bw!

#" Using a funcref variable to set 'tagfunc'
! VAR Fn = function('g:TagFunc1', [11])
LET &tagfunc = Fn
! new
! LET g:TagFunc1Args = []
call assert_fails('tag a12', 'E433:')
! call assert_equal([11, 'a12', '', {}], g:TagFunc1Args)
! bw!

#" Using a string(funcref_variable) to set 'tagfunc'
! LET Fn = function('g:TagFunc1', [12])
LET &tagfunc = string(Fn)
! new
! LET g:TagFunc1Args = []
call assert_fails('tag a12', 'E433:')
! call assert_equal([12, 'a12', '', {}], g:TagFunc1Args)
! bw!

#" Test for using a funcref()
! set tagfunc=funcref('g:TagFunc1',\ [13])
! new
! LET g:TagFunc1Args = []
call assert_fails('tag a13', 'E433:')
! call assert_equal([13, 'a13', '', {}], g:TagFunc1Args)
! bw!

#" Using a funcref variable to set 'tagfunc'
! LET Fn = funcref('g:TagFunc1', [14])
LET &tagfunc = Fn
! new
! LET g:TagFunc1Args = []
call assert_fails('tag a14', 'E433:')
! call assert_equal([14, 'a14', '', {}], g:TagFunc1Args)
! bw!

#" Using a string(funcref_variable) to set 'tagfunc'
! LET Fn = funcref('g:TagFunc1', [15])
LET &tagfunc = string(Fn)
! new
! LET g:TagFunc1Args = []
call assert_fails('tag a14', 'E433:')
! call assert_equal([15, 'a14', '', {}], g:TagFunc1Args)
! bw!

#" Test for using a lambda function
! VAR optval = "LSTART a, b, c LMIDDLE TagFunc1(16, a, b, c) LEND"
LET optval = substitute(optval, ' ', '\\ ', 'g')
exe "set tagfunc=" .. optval
! new
! LET g:TagFunc1Args = []
call assert_fails('tag a17', 'E433:')
! call assert_equal([16, 'a17', '', {}], g:TagFunc1Args)
! bw!

#" Set 'tagfunc' to a lambda expression
! LET &tagfunc = LSTART a, b, c LMIDDLE TagFunc1(17, a, b, c) LEND
! new
! LET g:TagFunc1Args = []
call assert_fails('tag a18', 'E433:')
! call assert_equal([17, 'a18', '', {}], g:TagFunc1Args)
! bw!

#" Set 'tagfunc' to a string(lambda expression)
! LET &tagfunc = 'LSTART a, b, c LMIDDLE TagFunc1(18, a, b, c) LEND'
! new
! LET g:TagFunc1Args = []
call assert_fails('tag a18', 'E433:')
! call assert_equal([18, 'a18', '', {}], g:TagFunc1Args)
! bw!

#" Set 'tagfunc' to a variable with a lambda expression
! VAR Lambda = LSTART a, b, c LMIDDLE TagFunc1(19, a, b, c) LEND
LET &tagfunc = Lambda
! new
! LET g:TagFunc1Args = []
call assert_fails("tag a19", "E433:")
! call assert_equal([19, 'a19', '', {}], g:TagFunc1Args)
! bw!

#" Set 'tagfunc' to a string(variable with a lambda expression)
! LET Lambda = LSTART a, b, c LMIDDLE TagFunc1(20, a, b, c) LEND
LET &tagfunc = string(Lambda)
! new
! LET g:TagFunc1Args = []
call assert_fails("tag a19", "E433:")
! call assert_equal([20, 'a19', '', {}], g:TagFunc1Args)
! bw!

#" 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
call assert_fails("tag a20", "E987:")
+ bw!

#" Test for clearing the 'tagfunc' option
set tagfunc=''
***************
*** 231,240 ****
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)

--- 255,267 ----
call assert_fails("set tagfunc=funcref('abc')", "E700:")

#" set 'tagfunc' to a non-existing function
! LET &tagfunc = function('g:TagFunc2', [21])
! LET g:TagFunc2Args = []
call assert_fails("set tagfunc=function('NonExistingFunc')", 'E700:')
call assert_fails("LET &tagfunc = function('NonExistingFunc')", 'E700:')
call assert_fails("tag axb123", 'E426:')
+ call assert_equal([], g:TagFunc2Args)
+ bw!
END
call CheckLegacyAndVim9Success(lines)

***************
*** 242,252 ****
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)

" Test for using a script local function
set tagfunc=<SID>ScriptLocalTagFunc
--- 269,279 ----
call assert_fails("echo taglist('a')", "E987:")

" Using Vim9 lambda expression in legacy context should fail
! set tagfunc=(a,\ b,\ c)\ =>\ g:TagFunc1(21,\ a,\ b,\ c)
new | only
! let g:TagFunc1Args = []
call assert_fails("tag a17", "E117:")
! call assert_equal([], g:TagFunc1Args)

" Test for using a script local function
set tagfunc=<SID>ScriptLocalTagFunc
***************
*** 309,315 ****
call CheckScriptSuccess(lines)

" cleanup
! delfunc MytagFunc1
set tagfunc&
%bw!
endfunc
--- 336,343 ----
call CheckScriptSuccess(lines)

" cleanup
! delfunc TagFunc1
! delfunc TagFunc2
set tagfunc&
%bw!
endfunc
*** ../vim-8.2.3791/src/version.c 2021-12-12 19:10:39.629912018 +0000
--- src/version.c 2021-12-12 20:07:21.044413342 +0000
***************
*** 755,756 ****
--- 755,758 ----
{ /* Add new patch number below this line */
+ /**/
+ 3792,
/**/

--
"So this is it," said Arthur, "we are going to die."
"Yes," said Ford, "except...no! Wait a minute!" He suddenly lunged across
the chamber at something behind Arthur's line of vision. "What's this
switch?" he cried.
"What? Where?" cried Arthur, twisting around.
"No, I was only fooling," said Ford, "we are going to die after all."
-- Douglas Adams, "The Hitchhiker's Guide to the Galaxy"

/// 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 ///