Merge pull request #20987 from zeertzjq/vim-8.2.3751

vim-patch:8.2.{3735,3751,3756,3758,3788,3792}

5 files changed, 1137 insertions, 569 deletions

diff --git a/src/nvim/testdir/test_ins_complete.vim b/src/nvim/testdir/test_ins_complete.vim
index fc612dcbe2..d788841833 100644
--- a/src/nvim/testdir/test_ins_complete.vim
+++ b/src/nvim/testdir/test_ins_complete.vim
@@ -1,5 +1,8 @@
+" Test for insert completion
+
 source screendump.vim
 source check.vim
+source vim9.vim
 
 " Test for insert expansion
 func Test_ins_complete()
@@ -1287,500 +1290,670 @@ endfunc
 
 " Test for different ways of setting the 'completefunc' option
 func Test_completefunc_callback()
-  " Test for using a function()
-  func MycompleteFunc1(findstart, base)
-    call add(g:MycompleteFunc1_args, [a:findstart, a:base])
+  func CompleteFunc1(callnr, findstart, base)
+    call add(g:CompleteFunc1Args, [a:callnr, a:findstart, a:base])
     return a:findstart ? 0 : []
   endfunc
-  set completefunc=function('MycompleteFunc1')
-  new | only
-  call setline(1, 'one')
-  let g:MycompleteFunc1_args = []
-  call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
-  call assert_equal([[1, ''], [0, 'one']], g:MycompleteFunc1_args)
-  bw!
-
-  " 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()
-  func MycompleteFunc2(findstart, base)
-    call add(g:MycompleteFunc2_args, [a:findstart, a:base])
+  func CompleteFunc2(findstart, base)
+    call add(g:CompleteFunc2Args, [a:findstart, a:base])
     return a:findstart ? 0 : []
   endfunc
-  set completefunc=funcref('MycompleteFunc2')
-  new | only
-  call setline(1, 'three')
-  let g:MycompleteFunc2_args = []
-  call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
-  call assert_equal([[1, ''], [0, 'three']], g:MycompleteFunc2_args)
-  bw!
 
-  " 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!
+  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 lambda function
-  func MycompleteFunc3(findstart, base)
-    call add(g:MycompleteFunc3_args, [a:findstart, a:base])
-    return a:findstart ? 0 : []
-  endfunc
-  set completefunc={a,\ b,\ ->\ MycompleteFunc3(a,\ b,)}
-  new | only
-  call setline(1, 'five')
-  let g:MycompleteFunc3_args = []
-  call feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
-  call assert_equal([[1, ''], [0, 'five']], g:MycompleteFunc3_args)
-  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!
 
-  " 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!
+    #" 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!
 
-  " 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!
+    #" 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 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')
-  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!
 
-  " Test for clearing the 'completefunc' option
-  set completefunc=''
-  set completefunc&
+    #" 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!
+
+    #" Test for clearing the 'completefunc' option
+    set completefunc=''
+    set completefunc&
+    call assert_fails("set completefunc=function('abc')", "E700:")
+    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)
 
-  call assert_fails("set completefunc=function('abc')", "E700:")
-  call assert_fails("set completefunc=funcref('abc')", "E700:")
-  let &completefunc = "{a -> 'abc'}"
+  let &completefunc = {a -> 'abc'}
   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()
+    let params = {'complete': function('g:DictCompleteFunc')}
+    let &completefunc = params.complete
+  endfunc
+  func g:DictCompleteFunc(_) dict
+  endfunc
+  call SetCompleteFunc()
+  new
+  call SetCompleteFunc()
+  bw
+  call test_garbagecollect_now()
+  new
+  set completefunc=
+  wincmd w
+  set completefunc=
+  %bw!
+  delfunc g:DictCompleteFunc
+  delfunc SetCompleteFunc
+
   " Vim9 tests
   let lines =<< trim END
     vim9script
 
-    # Test for using function()
-    def MycompleteFunc1(findstart: number, base: string): any
-      add(g:MycompleteFunc1_args, [findstart, base])
+    # Test for using a def function with completefunc
+    def Vim9CompleteFunc(val: number, findstart: number, base: string): any
+      add(g:Vim9completeFuncArgs, [val, findstart, base])
       return findstart ? 0 : []
     enddef
-    set completefunc=function('MycompleteFunc1')
+    set completefunc=function('Vim9CompleteFunc',\ [60])
     new | only
     setline(1, 'one')
-    g:MycompleteFunc1_args = []
-    feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
-    assert_equal([[1, ''], [0, 'one']], g:MycompleteFunc1_args)
-    bw!
-
-    # Test for using a lambda
-    def MycompleteFunc2(findstart: number, base: string): any
-      add(g:MycompleteFunc2_args, [findstart, base])
-      return findstart ? 0 : []
-    enddef
-    &completefunc = '(a, b) => MycompleteFunc2(a, b)'
-    new | only
-    setline(1, 'two')
-    g:MycompleteFunc2_args = []
-    feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
-    assert_equal([[1, ''], [0, 'two']], g:MycompleteFunc2_args)
-    bw!
-
-    # Test for using a variable with a lambda expression
-    var Fn: func = (a, b) => MycompleteFunc2(a, b)
-    &completefunc = string(Fn)
-    new | only
-    setline(1, 'three')
-    g:MycompleteFunc2_args = []
+    g:Vim9completeFuncArgs = []
     feedkeys("A\<C-X>\<C-U>\<Esc>", 'x')
-    assert_equal([[1, ''], [0, 'three']], g:MycompleteFunc2_args)
+    assert_equal([[60, 1, ''], [60, 0, 'one']], g:Vim9completeFuncArgs)
     bw!
   END
   " call CheckScriptSuccess(lines)
 
-  " Using Vim9 lambda expression in legacy context should fail
-  " set completefunc=(a,\ b)\ =>\ g:MycompleteFunc2(a,\ b)
-  " new | only
-  " let g:MycompleteFunc2_args = []
-  " call assert_fails('call feedkeys("A\<C-X>\<C-U>\<Esc>", "x")', 'E117:')
-  " call assert_equal([], g:MycompleteFunc2_args)
-
   " cleanup
-  delfunc MycompleteFunc1
-  delfunc MycompleteFunc2
-  delfunc MycompleteFunc3
   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()
-  " Test for using a function()
-  func MyomniFunc1(findstart, base)
-    call add(g:MyomniFunc1_args, [a:findstart, a:base])
+  func OmniFunc1(callnr, findstart, base)
+    call add(g:OmniFunc1Args, [a:callnr, a:findstart, a:base])
     return a:findstart ? 0 : []
   endfunc
-  set omnifunc=function('MyomniFunc1')
-  new | only
-  call setline(1, 'one')
-  let g:MyomniFunc1_args = []
-  call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
-  call assert_equal([[1, ''], [0, 'one']], g:MyomniFunc1_args)
-  bw!
-
-  " 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()
-  func MyomniFunc2(findstart, base)
-    call add(g:MyomniFunc2_args, [a:findstart, a:base])
+  func OmniFunc2(findstart, base)
+    call add(g:OmniFunc2Args, [a:findstart, a:base])
     return a:findstart ? 0 : []
   endfunc
-  set omnifunc=funcref('MyomniFunc2')
-  new | only
-  call setline(1, 'three')
-  let g:MyomniFunc2_args = []
-  call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
-  call assert_equal([[1, ''], [0, 'three']], g:MyomniFunc2_args)
-  bw!
 
-  " 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!
+  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 lambda function
-  func MyomniFunc3(findstart, base)
-    call add(g:MyomniFunc3_args, [a:findstart, a:base])
-    return a:findstart ? 0 : []
-  endfunc
-  set omnifunc={a,\ b,\ ->\ MyomniFunc3(a,\ b,)}
-  new | only
-  call setline(1, 'five')
-  let g:MyomniFunc3_args = []
-  call feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
-  call assert_equal([[1, ''], [0, 'five']], g:MyomniFunc3_args)
-  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!
 
-  " 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!
+    #" 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!
 
-  " 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!
+    #" 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 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')
-  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!
 
-  " Test for clearing the 'omnifunc' option
-  set omnifunc=''
-  set omnifunc&
+    #" 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!
 
-  call assert_fails("set omnifunc=function('abc')", "E700:")
-  call assert_fails("set omnifunc=funcref('abc')", "E700:")
-  let &omnifunc = "{a -> 'abc'}"
+    #" 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!
+
+    #" Test for clearing the 'omnifunc' option
+    set omnifunc=''
+    set omnifunc&
+    call assert_fails("set omnifunc=function('abc')", "E700:")
+    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)
+
+  let &omnifunc = {a -> 'abc'}
   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()
+    let params = {'omni': function('g:DictOmniFunc')}
+    let &omnifunc = params.omni
+  endfunc
+  func g:DictOmniFunc(_) dict
+  endfunc
+  call SetOmniFunc()
+  new
+  call SetOmniFunc()
+  bw
+  call test_garbagecollect_now()
+  new
+  set omnifunc=
+  wincmd w
+  set omnifunc=
+  %bw!
+  delfunc g:DictOmniFunc
+  delfunc SetOmniFunc
+
   " Vim9 tests
   let lines =<< trim END
     vim9script
 
-    # Test for using function()
-    def MyomniFunc1(findstart: number, base: string): any
-      add(g:MyomniFunc1_args, [findstart, base])
+    # Test for using a def function with omnifunc
+    def Vim9omniFunc(val: number, findstart: number, base: string): any
+      add(g:Vim9omniFunc_Args, [val, findstart, base])
       return findstart ? 0 : []
     enddef
-    set omnifunc=function('MyomniFunc1')
+    set omnifunc=function('Vim9omniFunc',\ [60])
     new | only
     setline(1, 'one')
-    g:MyomniFunc1_args = []
+    g:Vim9omniFunc_Args = []
     feedkeys("A\<C-X>\<C-O>\<Esc>", 'x')
-    assert_equal([[1, ''], [0, 'one']], g:MyomniFunc1_args)
-    bw!
-
-    # Test for using a lambda
-    def MyomniFunc2(findstart: number, base: string): any
-      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 variable with a lambda expression
-    var Fn: func = (a, b) => MyomniFunc2(a, b)
-    &omnifunc = string(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)
+    assert_equal([[60, 1, ''], [60, 0, 'one']], g:Vim9omniFunc_Args)
     bw!
   END
   " call CheckScriptSuccess(lines)
 
-  " Using Vim9 lambda expression in legacy context should fail
-  " set omnifunc=(a,\ b)\ =>\ g:MyomniFunc2(a,\ b)
-  " new | only
-  " let g:MyomniFunc2_args = []
-  " call assert_fails('call feedkeys("A\<C-X>\<C-O>\<Esc>", "x")', 'E117:')
-  " call assert_equal([], g:MyomniFunc2_args)
-
   " cleanup
-  delfunc MyomniFunc1
-  delfunc MyomniFunc2
-  delfunc MyomniFunc3
   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()
-  " Test for using a function()
-  func MytsrFunc1(findstart, base)
-    call add(g:MytsrFunc1_args, [a:findstart, a:base])
+  func TsrFunc1(callnr, findstart, base)
+    call add(g:TsrFunc1Args, [a:callnr, a:findstart, a:base])
     return a:findstart ? 0 : []
   endfunc
-  set thesaurusfunc=function('MytsrFunc1')
-  new | only
-  call setline(1, 'one')
-  let g:MytsrFunc1_args = []
-  call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
-  call assert_equal([[1, ''], [0, 'one']], g:MytsrFunc1_args)
-  bw!
+  func TsrFunc2(findstart, base)
+    call add(g:TsrFunc2Args, [a:findstart, a:base])
+    return a:findstart ? 0 : ['sunday']
+  endfunc
 
-  " 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!
+  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 funcref()
-  func MytsrFunc2(findstart, base)
-    call add(g:MytsrFunc2_args, [a:findstart, a:base])
-    return a:findstart ? 0 : []
-  endfunc
-  set thesaurusfunc=funcref('MytsrFunc2')
-  new | only
-  call setline(1, 'three')
-  let g:MytsrFunc2_args = []
-  call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
-  call assert_equal([[1, ''], [0, 'three']], g:MytsrFunc2_args)
-  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'
-  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!
+    #" 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!
 
-  " Test for using a lambda function
-  func MytsrFunc3(findstart, base)
-    call add(g:MytsrFunc3_args, [a:findstart, a:base])
-    return a:findstart ? 0 : []
-  endfunc
-  set thesaurusfunc={a,\ b,\ ->\ MytsrFunc3(a,\ b,)}
-  new | only
-  call setline(1, 'five')
-  let g:MytsrFunc3_args = []
-  call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
-  call assert_equal([[1, ''], [0, 'five']], g:MytsrFunc3_args)
-  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!
 
-  " 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!
+    #" 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!
 
-  " 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 = []
+    #" 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!
+
+    #" Test for clearing the 'thesaurusfunc' option
+    set thesaurusfunc=''
+    set thesaurusfunc&
+    call assert_fails("set thesaurusfunc=function('abc')", "E700:")
+    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)
+
+  let &thesaurusfunc = {a -> 'abc'}
   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)
+  " Using Vim9 lambda expression in legacy context should fail
+  " set thesaurusfunc=(a,\ b)\ =>\ TsrFunc1(21,\ a,\ b)
   new | only
-  call setline(1, 'eight')
-  call feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
+  let g:TsrFunc1Args = []
+  " call assert_fails('call feedkeys("A\<C-X>\<C-T>\<Esc>", "x")', 'E117:')
+  call assert_equal([], g:TsrFunc1Args)
   bw!
 
-  " Test for clearing the 'thesaurusfunc' option
-  set thesaurusfunc=''
-  set thesaurusfunc&
+  " set 'thesaurusfunc' to a partial with dict. This used to cause a crash.
+  func SetTsrFunc()
+    let params = {'thesaurus': function('g:DictTsrFunc')}
+    let &thesaurusfunc = params.thesaurus
+  endfunc
+  func g:DictTsrFunc(_) dict
+  endfunc
+  call SetTsrFunc()
+  new
+  call SetTsrFunc()
+  bw
+  call test_garbagecollect_now()
+  new
+  set thesaurusfunc=
+  wincmd w
+  %bw!
+  delfunc SetTsrFunc
 
-  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')
+  " set buffer-local 'thesaurusfunc' to a partial with dict. This used to
+  " cause a crash.
+  func SetLocalTsrFunc()
+    let params = {'thesaurus': function('g:DictTsrFunc')}
+    let &l:thesaurusfunc = params.thesaurus
+  endfunc
+  call SetLocalTsrFunc()
+  call test_garbagecollect_now()
+  call SetLocalTsrFunc()
+  set thesaurusfunc=
+  bw!
+  delfunc g:DictTsrFunc
+  delfunc SetLocalTsrFunc
 
   " Vim9 tests
   let lines =<< trim END
     vim9script
 
-    # Test for using function()
-    def MytsrFunc1(findstart: number, base: string): any
-      add(g:MytsrFunc1_args, [findstart, base])
+    # Test for using a def function with thesaurusfunc
+    def Vim9tsrFunc(val: number, findstart: number, base: string): any
+      add(g:Vim9tsrFunc_Args, [val, findstart, base])
       return findstart ? 0 : []
     enddef
-    set thesaurusfunc=function('MytsrFunc1')
+    set thesaurusfunc=function('Vim9tsrFunc',\ [60])
     new | only
     setline(1, 'one')
-    g:MytsrFunc1_args = []
+    g:Vim9tsrFunc_Args = []
     feedkeys("A\<C-X>\<C-T>\<Esc>", 'x')
-    assert_equal([[1, ''], [0, 'one']], g:MytsrFunc1_args)
-    bw!
-
-    # Test for using a lambda
-    def MytsrFunc2(findstart: number, base: string): any
-      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 variable with a lambda expression
-    var Fn: func = (a, b) => MytsrFunc2(a, b)
-    &thesaurusfunc = string(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)
+    assert_equal([[60, 1, ''], [60, 0, 'one']], g:Vim9tsrFunc_Args)
     bw!
   END
   " call CheckScriptSuccess(lines)
 
-  " Using Vim9 lambda expression in legacy context should fail
-  " set thesaurusfunc=(a,\ b)\ =>\ g:MytsrFunc2(a,\ b)
-  " new | only
-  " let g:MytsrFunc2_args = []
-  " call assert_fails('call feedkeys("A\<C-X>\<C-T>\<Esc>", "x")', 'E117:')
-  " call assert_equal([], g:MytsrFunc2_args)
-  " bw!
-
-  " Use a buffer-local value and a global value
-  func MytsrFunc4(findstart, base)
-    call add(g:MytsrFunc4_args, [a:findstart, a:base])
-    return a:findstart ? 0 : ['sunday']
-  endfunc
-  set thesaurusfunc&
-  setlocal thesaurusfunc=function('MytsrFunc4')
-  call setline(1, 'sun')
-  let g:MytsrFunc4_args = []
-  call feedkeys("A\<C-X>\<C-T>\<Esc>", "x")
-  call assert_equal('sunday', getline(1))
-  call assert_equal([[1, ''], [0, 'sun']], g:MytsrFunc4_args)
-  new
-  call setline(1, 'sun')
-  let g:MytsrFunc4_args = []
-  call feedkeys("A\<C-X>\<C-T>\<Esc>", "x")
-  call assert_equal('sun', getline(1))
-  call assert_equal([], g:MytsrFunc4_args)
-  set thesaurusfunc=function('MytsrFunc1')
-  wincmd w
-  call setline(1, 'sun')
-  let g:MytsrFunc4_args = []
-  call feedkeys("A\<C-X>\<C-T>\<Esc>", "x")
-  call assert_equal('sunday', getline(1))
-  call assert_equal([[1, ''], [0, 'sun']], g:MytsrFunc4_args)
-
   " cleanup
   set thesaurusfunc&
-  delfunc MytsrFunc1
-  delfunc MytsrFunc2
-  delfunc MytsrFunc3
-  delfunc MytsrFunc4
+  delfunc TsrFunc1
+  delfunc TsrFunc2
+  unlet g:TsrFunc1Args g:TsrFunc2Args
   %bw!
 endfunc
 
diff --git a/src/nvim/testdir/test_normal.vim b/src/nvim/testdir/test_normal.vim
index 6160352052..0d75644920 100644
--- a/src/nvim/testdir/test_normal.vim
+++ b/src/nvim/testdir/test_normal.vim
@@ -3,6 +3,7 @@
 source shared.vim
 source check.vim
 source view_util.vim
+source vim9.vim
 source screendump.vim
 
 func Setup_NewWindow()
@@ -388,70 +389,6 @@ func Test_normal09a_operatorfunc()
   norm V10j,,
   call assert_equal(22, g:a)
 
-  " Use a lambda function for 'opfunc'
-  unmap <buffer> ,,
-  call cursor(1, 1)
-  let g:a=0
-  nmap <buffer><silent> ,, :set opfunc={type\ ->\ CountSpaces(type)}<CR>g@
-  vmap <buffer><silent> ,, :<C-U>call CountSpaces(visualmode(), 1)<CR>
-  50
-  norm V2j,,
-  call assert_equal(6, g:a)
-  norm V,,
-  call assert_equal(2, g:a)
-  norm ,,l
-  call assert_equal(0, g:a)
-  50
-  exe "norm 0\<c-v>10j2l,,"
-  call assert_equal(11, g:a)
-  50
-  norm V10j,,
-  call assert_equal(22, g:a)
-
-  " use a partial function for 'opfunc'
-  let g:OpVal = 0
-  func! Test_opfunc1(x, y, type)
-    let g:OpVal =  a:x + a:y
-  endfunc
-  set opfunc=function('Test_opfunc1',\ [5,\ 7])
-  normal! g@l
-  call assert_equal(12, g:OpVal)
-  " delete the function and try to use g@
-  delfunc Test_opfunc1
-  call test_garbagecollect_now()
-  call assert_fails('normal! g@l', 'E117:')
-  set opfunc=
-
-  " use a funcref for 'opfunc'
-  let g:OpVal = 0
-  func! Test_opfunc2(x, y, type)
-    let g:OpVal =  a:x + a:y
-  endfunc
-  set opfunc=funcref('Test_opfunc2',\ [4,\ 3])
-  normal! g@l
-  call assert_equal(7, g:OpVal)
-  " delete the function and try to use g@
-  delfunc Test_opfunc2
-  call test_garbagecollect_now()
-  call assert_fails('normal! g@l', 'E933:')
-  set opfunc=
-
-  " Try to use a function with two arguments for 'operatorfunc'
-  let g:OpVal = 0
-  func! Test_opfunc3(x, y)
-    let g:OpVal = 4
-  endfunc
-  set opfunc=Test_opfunc3
-  call assert_fails('normal! g@l', 'E119:')
-  call assert_equal(0, g:OpVal)
-  set opfunc=
-  delfunc Test_opfunc3
-  unlet g:OpVal
-
-  " Try to use a lambda function with two arguments for 'operatorfunc'
-  set opfunc={x,\ y\ ->\ 'done'}
-  call assert_fails('normal! g@l', 'E119:')
-
   " clean up
   unmap <buffer> ,,
   set opfunc=
@@ -520,6 +457,182 @@ func Test_normal09c_operatorfunc()
   set operatorfunc=
 endfunc
 
+" 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=''
+    set opfunc&
+    call assert_fails("set opfunc=function('abc')", "E700:")
+    call assert_fails("set opfunc=funcref('abc')", "E700:")
+
+    #" set 'operatorfunc' to a non-existing function
+    LET &opfunc = function('g: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()
+    let operator = {'execute': function('OperatorExecute')}
+    let &opfunc = operator.execute
+  endfunc
+  func OperatorExecute(_) dict
+  endfunc
+  call SetOpFunc()
+  call test_garbagecollect_now()
+  set operatorfunc=
+  delfunc SetOpFunc
+  delfunc OperatorExecute
+
+  " Vim9 tests
+  let lines =<< trim END
+    vim9script
+
+    # Test for using 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
+
 func Test_normal10_expand()
   " Test for expand()
   10new
diff --git a/src/nvim/testdir/test_quickfix.vim b/src/nvim/testdir/test_quickfix.vim
index 9d9fc5e77b..42bdb7bad1 100644
--- a/src/nvim/testdir/test_quickfix.vim
+++ b/src/nvim/testdir/test_quickfix.vim
@@ -1,6 +1,7 @@
 " Test for the quickfix feature.
 
 source check.vim
+source vim9.vim
 CheckFeature quickfix
 
 source screendump.vim
@@ -5690,6 +5691,138 @@ func Test_qftextfunc()
   call Xtest_qftextfunc('l')
 endfunc
 
+func Test_qftextfunc_callback()
+  let lines =<< trim END
+    set efm=%f:%l:%c:%m
+
+    #" Test for using a function 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"
+    copen
+    call assert_equal('F1-L1C1-L1', getline(1))
+    cclose
+
+    #" Using a funcref variable to set 'quickfixtextfunc'
+    VAR Fn = function('g:Tqfexpr')
+    LET &qftf = Fn
+    cexpr "F2:2:2:L2"
+    copen
+    call assert_equal('F2-L2C2-L2', getline(1))
+    cclose
+
+    #" Using string(funcref_variable) to set 'quickfixtextfunc'
+    LET Fn = function('g:Tqfexpr')
+    LET &qftf = string(Fn)
+    cexpr "F3:3:3:L3"
+    copen
+    call assert_equal('F3-L3C3-L3', getline(1))
+    cclose
+
+    #" Test for using a funcref()
+    set qftf=funcref('g:Tqfexpr')
+    cexpr "F4:4:4:L4"
+    copen
+    call assert_equal('F4-L4C4-L4', getline(1))
+    cclose
+
+    #" Using a funcref variable to set 'quickfixtextfunc'
+    LET Fn = funcref('g:Tqfexpr')
+    LET &qftf = Fn
+    cexpr "F5:5:5:L5"
+    copen
+    call assert_equal('F5-L5C5-L5', getline(1))
+    cclose
+
+    #" Using a string(funcref_variable) to set 'quickfixtextfunc'
+    LET Fn = funcref('g:Tqfexpr')
+    LET &qftf = string(Fn)
+    cexpr "F5:5:5:L5"
+    copen
+    call assert_equal('F5-L5C5-L5', getline(1))
+    cclose
+
+    #" Test for using a lambda function with set
+    VAR optval = "LSTART a LMIDDLE Tqfexpr(a) LEND"
+    LET optval = substitute(optval, ' ', '\\ ', 'g')
+    exe "set qftf=" .. optval
+    cexpr "F6:6:6:L6"
+    copen
+    call assert_equal('F6-L6C6-L6', getline(1))
+    cclose
+
+    #" Set 'quickfixtextfunc' to a lambda expression
+    LET &qftf = LSTART a LMIDDLE Tqfexpr(a) LEND
+    cexpr "F7:7:7:L7"
+    copen
+    call assert_equal('F7-L7C7-L7', getline(1))
+    cclose
+
+    #" Set 'quickfixtextfunc' to string(lambda_expression)
+    LET &qftf = "LSTART a LMIDDLE Tqfexpr(a) LEND"
+    cexpr "F8:8:8:L8"
+    copen
+    call assert_equal('F8-L8C8-L8', getline(1))
+    cclose
+
+    #" Set 'quickfixtextfunc' to a variable with a lambda expression
+    VAR Lambda = LSTART a LMIDDLE Tqfexpr(a) LEND
+    LET &qftf = Lambda
+    cexpr "F9:9:9:L9"
+    copen
+    call assert_equal('F9-L9C9-L9', getline(1))
+    cclose
+
+    #" Set 'quickfixtextfunc' to a string(variable with a lambda expression)
+    LET Lambda = LSTART a LMIDDLE Tqfexpr(a) LEND
+    LET &qftf = string(Lambda)
+    cexpr "F9:9:9:L9"
+    copen
+    call assert_equal('F9-L9C9-L9', getline(1))
+    cclose
+  END
+  call CheckLegacyAndVim9Success(lines)
+
+  " set 'quickfixtextfunc' to a partial with dict. This used to cause a crash.
+  func SetQftfFunc()
+    let params = {'qftf': function('g:DictQftfFunc')}
+    let &quickfixtextfunc = params.qftf
+  endfunc
+  func g:DictQftfFunc(_) dict
+  endfunc
+  call SetQftfFunc()
+  new
+  call SetQftfFunc()
+  bw
+  call test_garbagecollect_now()
+  new
+  set qftf=
+  wincmd w
+  set qftf=
+  :%bw!
+
+  " set per-quickfix list 'quickfixtextfunc' to a partial with dict. This used
+  " to cause a crash.
+  let &qftf = ''
+  func SetLocalQftfFunc()
+    let params = {'qftf': function('g:DictQftfFunc')}
+    call setqflist([], 'a', {'quickfixtextfunc' : params.qftf})
+  endfunc
+  call SetLocalQftfFunc()
+  call test_garbagecollect_now()
+  call setqflist([], 'a', {'quickfixtextfunc' : ''})
+  delfunc g:DictQftfFunc
+  delfunc SetQftfFunc
+  delfunc SetLocalQftfFunc
+  set efm&
+endfunc
+
 " Test for updating a location list for some other window and check that
 " 'qftextfunc' uses the correct location list.
 func Test_qftextfunc_other_loclist()
diff --git a/src/nvim/testdir/test_tagfunc.vim b/src/nvim/testdir/test_tagfunc.vim
index 8690e30e77..7a88723bc0 100644
--- a/src/nvim/testdir/test_tagfunc.vim
+++ b/src/nvim/testdir/test_tagfunc.vim
@@ -1,5 +1,7 @@
 " Test 'tagfunc'
 
+source vim9.vim
+
 func TagFunc(pat, flag, info)
   let g:tagfunc_args = [a:pat, a:flag, a:info]
   let tags = []
@@ -125,45 +127,153 @@ endfunc
 
 " Test for different ways of setting the 'tagfunc' option
 func Test_tagfunc_callback()
-  " Test for using a function()
-  func MytagFunc1(pat, flags, info)
-    let g:MytagFunc1_args = [a:pat, a:flags, a:info]
+  func TagFunc1(callnr, pat, flags, info)
+    let g:TagFunc1Args = [a:callnr, a:pat, a:flags, a:info]
     return v:null
   endfunc
-  set tagfunc=function('MytagFunc1')
-  new | only
-  let g:MytagFunc1_args = []
-  call assert_fails('tag a11', 'E433:')
-  call assert_equal(['a11', '', {}], g:MytagFunc1_args)
-
-  " 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)
-    let g:MytagFunc2_args = [a:pat, a:flags, a:info]
+  func TagFunc2(pat, flags, info)
+    let g:TagFunc2Args = [a:pat, a:flags, a:info]
     return v:null
   endfunc
-  set tagfunc=funcref('MytagFunc2')
-  new | only
-  let g:MytagFunc2_args = []
-  call assert_fails('tag a13', 'E433:')
-  call assert_equal(['a13', '', {}], g:MytagFunc2_args)
 
-  " Using a funcref variable to set 'tagfunc'
-  let Fn = funcref('MytagFunc2')
-  let &tagfunc = string(Fn)
+  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=''
+    set tagfunc&
+    call assert_fails("set tagfunc=function('abc')", "E700:")
+    call assert_fails("set tagfunc=funcref('abc')", "E700:")
+
+    #" set 'tagfunc' to a non-existing function
+    LET &tagfunc = function('g: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)
+
+  let &tagfunc = "{a -> 'abc'}"
+  call assert_fails("echo taglist('a')", "E987:")
+
+  " Using Vim9 lambda expression in legacy context should fail
+  " set tagfunc=(a,\ b,\ c)\ =>\ g:TagFunc1(21,\ a,\ b,\ c)
   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:')
+  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
@@ -174,101 +284,60 @@ func Test_tagfunc_callback()
 
   " Test for using a script local funcref variable
   let Fn = function("s:ScriptLocalTagFunc")
-  let &tagfunc= string(Fn)
+  let &tagfunc= Fn
   new | only
   let g:ScriptLocalFuncArgs = []
   call assert_fails('tag a16', 'E433:')
   call assert_equal(['a16', '', {}], g:ScriptLocalFuncArgs)
 
-  " Test for using a lambda function
-  func MytagFunc3(pat, flags, info)
-    let g:MytagFunc3_args = [a:pat, a:flags, a:info]
-    return v:null
-  endfunc
-  set tagfunc={a,\ b,\ c\ ->\ MytagFunc3(a,\ b,\ c)}
-  new | only
-  let g:MytagFunc3_args = []
-  call assert_fails('tag a17', 'E433:')
-  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 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)}
-  let &tagfunc = string(Lambda)
+  " Test for using a string(script local funcref variable)
+  let Fn = function("s:ScriptLocalTagFunc")
+  let &tagfunc= string(Fn)
   new | only
-  call assert_fails("tag a20", "E987:")
-
-  " Test for clearing the 'tagfunc' option
-  set tagfunc=''
-  set tagfunc&
+  let g:ScriptLocalFuncArgs = []
+  call assert_fails('tag a16', 'E433:')
+  call assert_equal(['a16', '', {}], g:ScriptLocalFuncArgs)
 
-  call assert_fails("set tagfunc=function('abc')", "E700:")
-  call assert_fails("set tagfunc=funcref('abc')", "E700:")
-  let &tagfunc = "{a -> 'abc'}"
-  call assert_fails("echo taglist('a')", "E987:")
+  " set 'tagfunc' to a partial with dict. This used to cause a crash.
+  func SetTagFunc()
+    let params = {'tagfn': function('g:DictTagFunc')}
+    let &tagfunc = params.tagfn
+  endfunc
+  func g:DictTagFunc(_) dict
+  endfunc
+  call SetTagFunc()
+  new
+  call SetTagFunc()
+  bw
+  call test_garbagecollect_now()
+  new
+  set tagfunc=
+  wincmd w
+  set tagfunc=
+  :%bw!
+  delfunc g:DictTagFunc
+  delfunc SetTagFunc
 
   " Vim9 tests
   let lines =<< trim END
     vim9script
 
     # Test for using function()
-    def MytagFunc1(pat: string, flags: string, info: dict<any>): any
-      g:MytagFunc1_args = [pat, flags, info]
+    def Vim9tagFunc(val: number, pat: string, flags: string, info: dict<any>): any
+      g:Vim9tagFuncArgs = [val, pat, flags, info]
       return null
     enddef
-    set tagfunc=function('MytagFunc1')
+    set tagfunc=function('Vim9tagFunc',\ [60])
     new | only
-    g:MytagFunc1_args = []
+    g:Vim9tagFuncArgs = []
     assert_fails('tag a10', 'E433:')
-    assert_equal(['a10', '', {}], g:MytagFunc1_args)
-
-    # Test for using a lambda
-    def MytagFunc2(pat: string, flags: string, info: dict<any>): any
-      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 variable with a lambda expression
-    var Fn: func = (a, b, c) => MytagFunc2(a, b, c)
-    &tagfunc = string(Fn)
-    new | only
-    g:MytagFunc2_args = []
-    assert_fails('tag a30', 'E433:')
-    assert_equal(['a30', '', {}], g:MytagFunc2_args)
+    assert_equal([60, 'a10', '', {}], g:Vim9tagFuncArgs)
   END
   " call CheckScriptSuccess(lines)
 
-  " Using Vim9 lambda expression in legacy context should fail
-  " set tagfunc=(a,\ b,\ c)\ =>\ g:MytagFunc2(a,\ b,\ c)
-  " new | only
-  " let g:MytagFunc3_args = []
-  " call assert_fails("tag a17", "E117:")
-  " call assert_equal([], g:MytagFunc3_args)
-
   " cleanup
-  delfunc MytagFunc1
-  delfunc MytagFunc2
-  delfunc MytagFunc3
+  delfunc TagFunc1
+  delfunc TagFunc2
   set tagfunc&
   %bw!
 endfunc
diff --git a/src/nvim/testdir/vim9.vim b/src/nvim/testdir/vim9.vim
new file mode 100644
index 0000000000..db74ce3b11
--- /dev/null
+++ b/src/nvim/testdir/vim9.vim
@@ -0,0 +1,80 @@
+
+" Use a different file name for each run.
+let s:sequence = 1
+
+" Check that "lines" inside a legacy function has no error.
+func CheckLegacySuccess(lines)
+  let cwd = getcwd()
+  let fname = 'XlegacySuccess' .. s:sequence
+  let s:sequence += 1
+  call writefile(['func Func()'] + a:lines + ['endfunc'], fname)
+  try
+    exe 'so ' .. fname
+    call Func()
+  finally
+    delfunc! Func
+    call chdir(cwd)
+    call delete(fname)
+  endtry
+endfunc
+
+" Check that "lines" inside a legacy function results in the expected error
+func CheckLegacyFailure(lines, error)
+  let cwd = getcwd()
+  let fname = 'XlegacyFails' .. s:sequence
+  let s:sequence += 1
+  call writefile(['func Func()'] + a:lines + ['endfunc', 'call Func()'], fname)
+  try
+    call assert_fails('so ' .. fname, a:error)
+  finally
+    delfunc! Func
+    call chdir(cwd)
+    call delete(fname)
+  endtry
+endfunc
+
+" Execute "lines" in a legacy function, translated as in
+" CheckLegacyAndVim9Success()
+func CheckTransLegacySuccess(lines)
+  let legacylines = a:lines->deepcopy()->map({_, v ->
+                              \ v->substitute('\<VAR\>', 'let', 'g')
+                              \  ->substitute('\<LET\>', 'let', 'g')
+                              \  ->substitute('\<LSTART\>', '{', 'g')
+                              \  ->substitute('\<LMIDDLE\>', '->', 'g')
+                              \  ->substitute('\<LEND\>', '}', 'g')
+                              \  ->substitute('\<TRUE\>', '1', 'g')
+                              \  ->substitute('\<FALSE\>', '0', 'g')
+                              \  ->substitute('#"', ' "', 'g')
+                              \ })
+  call CheckLegacySuccess(legacylines)
+endfunc
+
+" Execute "lines" in a legacy function
+" Use 'VAR' for a declaration.
+" Use 'LET' for an assignment
+" Use ' #"' for a comment
+" Use LSTART arg LMIDDLE expr LEND for lambda
+" Use 'TRUE' for 1
+" Use 'FALSE' for 0
+func CheckLegacyAndVim9Success(lines)
+  call CheckTransLegacySuccess(a:lines)
+endfunc
+
+" Execute "lines" in a legacy function
+" Use 'VAR' for a declaration.
+" Use 'LET' for an assignment
+" Use ' #"' for a comment
+func CheckLegacyAndVim9Failure(lines, error)
+  if type(a:error) == type('string')
+    let legacyError = error
+  else
+    let legacyError = error[0]
+  endif
+
+  let legacylines = a:lines->deepcopy()->map({_, v ->
+                              \ v->substitute('\<VAR\>', 'let', 'g')
+                              \  ->substitute('\<LET\>', 'let', 'g')
+                              \  ->substitute('#"', ' "', 'g')
+                              \ })
+  call CheckLegacyFailure(legacylines, legacyError)
+endfunc