vim-patch:9.1.0831: 'findexpr' can't be used as lambad or Funcref (#31058)

Problem:  'findexpr' can't be used for lambads
          (Justin Keyes)
Solution: Replace the findexpr option with the findfunc option
          (Yegappan Lakshmanan)

related: vim/vim#15905
closes: vim/vim#15976

https://github.com/vim/vim/commit/a13f3a4f5de9c150f70298850e34747838904995

Co-authored-by: Yegappan Lakshmanan <yegappan@yahoo.com>

6 files changed, 395 insertions, 126 deletions

diff --git a/test/old/testdir/test_findfile.vim b/test/old/testdir/test_findfile.vim
index d3fdcad045..2c049537f0 100644
--- a/test/old/testdir/test_findfile.vim
+++ b/test/old/testdir/test_findfile.vim
@@ -1,6 +1,7 @@
 " Test findfile() and finddir()
 
 source check.vim
+source vim9.vim
 
 let s:files = [ 'Xfinddir1/foo',
       \         'Xfinddir1/bar',
@@ -288,223 +289,491 @@ func Test_find_non_existing_path()
   let &path = save_path
 endfunc
 
-" Test for 'findexpr'
-func Test_findexpr()
+" Test for 'findfunc'
+func Test_findfunc()
   CheckUnix
-  call assert_equal('', &findexpr)
-  call writefile(['aFile'], 'Xfindexpr1.c', 'D')
-  call writefile(['bFile'], 'Xfindexpr2.c', 'D')
-  call writefile(['cFile'], 'Xfindexpr3.c', 'D')
+  call assert_equal('', &findfunc)
+  call writefile(['aFile'], 'Xfindfunc1.c', 'D')
+  call writefile(['bFile'], 'Xfindfunc2.c', 'D')
+  call writefile(['cFile'], 'Xfindfunc3.c', 'D')
 
   " basic tests
-  func FindExpr1()
-    let fnames = ['Xfindexpr1.c', 'Xfindexpr2.c', 'Xfindexpr3.c']
-    return fnames->copy()->filter('v:val =~? v:fname')
+  func FindFuncBasic(pat, cmdcomplete)
+    let fnames = ['Xfindfunc1.c', 'Xfindfunc2.c', 'Xfindfunc3.c']
+    return fnames->copy()->filter('v:val =~? a:pat')
   endfunc
 
-  set findexpr=FindExpr1()
-  find Xfindexpr3
-  call assert_match('Xfindexpr3.c', @%)
+  set findfunc=FindFuncBasic
+  find Xfindfunc3
+  call assert_match('Xfindfunc3.c', @%)
   bw!
   2find Xfind
-  call assert_match('Xfindexpr2.c', @%)
+  call assert_match('Xfindfunc2.c', @%)
   bw!
   call assert_fails('4find Xfind', 'E347: No more file "Xfind" found in path')
   call assert_fails('find foobar', 'E345: Can''t find file "foobar" in path')
 
-  sfind Xfindexpr2.c
-  call assert_match('Xfindexpr2.c', @%)
+  sfind Xfindfunc2.c
+  call assert_match('Xfindfunc2.c', @%)
   call assert_equal(2, winnr('$'))
   %bw!
   call assert_fails('sfind foobar', 'E345: Can''t find file "foobar" in path')
 
-  tabfind Xfindexpr3.c
-  call assert_match('Xfindexpr3.c', @%)
+  tabfind Xfindfunc3.c
+  call assert_match('Xfindfunc3.c', @%)
   call assert_equal(2, tabpagenr())
   %bw!
   call assert_fails('tabfind foobar', 'E345: Can''t find file "foobar" in path')
 
+  " Test garbage collection
+  call test_garbagecollect_now()
+  find Xfindfunc2
+  call assert_match('Xfindfunc2.c', @%)
+  bw!
+  delfunc FindFuncBasic
+  call test_garbagecollect_now()
+  call assert_fails('find Xfindfunc2', 'E117: Unknown function: FindFuncBasic')
+
   " Buffer-local option
-  set findexpr=['abc']
+  func GlobalFindFunc(pat, cmdcomplete)
+    return ['global']
+  endfunc
+  func LocalFindFunc(pat, cmdcomplete)
+    return ['local']
+  endfunc
+  set findfunc=GlobalFindFunc
   new
-  setlocal findexpr=['def']
+  setlocal findfunc=LocalFindFunc
   find xxxx
-  call assert_equal('def', @%)
+  call assert_equal('local', @%)
   wincmd w
   find xxxx
-  call assert_equal('abc', @%)
+  call assert_equal('global', @%)
   aboveleft new
-  call assert_equal("['abc']", &findexpr)
+  call assert_equal("GlobalFindFunc", &findfunc)
   wincmd k
   aboveleft new
-  call assert_equal("['abc']", &findexpr)
+  call assert_equal("GlobalFindFunc", &findfunc)
   %bw!
+  delfunc GlobalFindFunc
+  delfunc LocalFindFunc
 
-  " Empty list
-  set findexpr=[]
-  call assert_fails('find xxxx', 'E345: Can''t find file "xxxx" in path')
+  " Assign an expression
+  set findfunc=[]
+  call assert_fails('find xxxx', 'E117: Unknown function: []')
 
   " Error cases
 
-  " Syntax error in the expression
-  set findexpr=FindExpr1{}
-  call assert_fails('find Xfindexpr1.c', 'E15: Invalid expression')
+  " Function that doesn't any argument
+  func FindFuncNoArg()
+  endfunc
+  set findfunc=FindFuncNoArg
+  call assert_fails('find Xfindfunc1.c', 'E118: Too many arguments for function: FindFuncNoArg')
+  delfunc FindFuncNoArg
 
-  " Find expression throws an error
-  func FindExpr2()
+  " Syntax error in the function
+  func FindFuncSyntaxError(pat, cmdcomplete)
+    return l
+  endfunc
+  set findfunc=FindFuncSyntaxError
+  call assert_fails('find Xfindfunc1.c', 'E121: Undefined variable: l')
+  delfunc FindFuncSyntaxError
+
+  " Find function throws an error
+  func FindFuncWithThrow(pat, cmdcomplete)
     throw 'find error'
   endfunc
-  set findexpr=FindExpr2()
-  call assert_fails('find Xfindexpr1.c', 'find error')
+  set findfunc=FindFuncWithThrow
+  call assert_fails('find Xfindfunc1.c', 'find error')
+  delfunc FindFuncWithThrow
 
-  " Try using a null List as the expression
-  set findexpr=v:_null_list
-  call assert_fails('find Xfindexpr1.c', 'E345: Can''t find file "Xfindexpr1.c" in path')
+  " Try using a null function
+  "call assert_fails('let &findfunc = test_null_function()', 'E129: Function name required')
 
-  " Try to create a new window from the find expression
-  func FindExpr3()
+  " Try to create a new window from the find function
+  func FindFuncNewWindow(pat, cmdexpand)
     new
     return ["foo"]
   endfunc
-  set findexpr=FindExpr3()
-  call assert_fails('find Xfindexpr1.c', 'E565: Not allowed to change text or change window')
+  set findfunc=FindFuncNewWindow
+  call assert_fails('find Xfindfunc1.c', 'E565: Not allowed to change text or change window')
+  delfunc FindFuncNewWindow
 
-  " Try to modify the current buffer from the find expression
-  func FindExpr4()
+  " Try to modify the current buffer from the find function
+  func FindFuncModifyBuf(pat, cmdexpand)
     call setline(1, ['abc'])
     return ["foo"]
   endfunc
-  set findexpr=FindExpr4()
-  call assert_fails('find Xfindexpr1.c', 'E565: Not allowed to change text or change window')
-
-  " Expression returning a string
-  set findexpr='abc'
-  call assert_fails('find Xfindexpr1.c', "E1514: 'findexpr' did not return a List type")
-
-  set findexpr&
-  delfunc! FindExpr1
-  delfunc! FindExpr2
-  delfunc! FindExpr3
-  delfunc! FindExpr4
+  set findfunc=FindFuncModifyBuf
+  call assert_fails('find Xfindfunc1.c', 'E565: Not allowed to change text or change window')
+  delfunc FindFuncModifyBuf
+
+  " Return the wrong type from the function
+  func FindFuncWrongRet(pat, cmdexpand)
+    return 'foo'
+  endfunc
+  set findfunc=FindFuncWrongRet
+  call assert_fails('find Xfindfunc1.c', "E1514: 'findfunc' did not return a List type")
+  delfunc FindFuncWrongRet
+
+  set findfunc&
 endfunc
 
-" Test for using a script-local function for 'findexpr'
-func Test_findexpr_scriptlocal_func()
-  func! s:FindExprScript()
-    let g:FindExprArg = v:fname
+" Test for using a script-local function for 'findfunc'
+func Test_findfunc_scriptlocal_func()
+  func! s:FindFuncScript(pat, cmdexpand)
+    let g:FindFuncArg = a:pat
     return ['xxx']
   endfunc
 
-  set findexpr=s:FindExprScript()
-  call assert_equal(expand('<SID>') .. 'FindExprScript()', &findexpr)
-  call assert_equal(expand('<SID>') .. 'FindExprScript()', &g:findexpr)
+  set findfunc=s:FindFuncScript
+  call assert_equal(expand('<SID>') .. 'FindFuncScript', &findfunc)
+  call assert_equal(expand('<SID>') .. 'FindFuncScript', &g:findfunc)
   new | only
-  let g:FindExprArg = ''
+  let g:FindFuncArg = ''
   find abc
-  call assert_equal('abc', g:FindExprArg)
+  call assert_equal('abc', g:FindFuncArg)
   bw!
 
-  set findexpr=<SID>FindExprScript()
-  call assert_equal(expand('<SID>') .. 'FindExprScript()', &findexpr)
-  call assert_equal(expand('<SID>') .. 'FindExprScript()', &g:findexpr)
+  set findfunc=<SID>FindFuncScript
+  call assert_equal(expand('<SID>') .. 'FindFuncScript', &findfunc)
+  call assert_equal(expand('<SID>') .. 'FindFuncScript', &g:findfunc)
   new | only
-  let g:FindExprArg = ''
+  let g:FindFuncArg = ''
   find abc
-  call assert_equal('abc', g:FindExprArg)
+  call assert_equal('abc', g:FindFuncArg)
   bw!
 
-  let &findexpr = 's:FindExprScript()'
-  call assert_equal(expand('<SID>') .. 'FindExprScript()', &g:findexpr)
+  let &findfunc = 's:FindFuncScript'
+  call assert_equal(expand('<SID>') .. 'FindFuncScript', &g:findfunc)
   new | only
-  let g:FindExprArg = ''
+  let g:FindFuncArg = ''
   find abc
-  call assert_equal('abc', g:FindExprArg)
+  call assert_equal('abc', g:FindFuncArg)
   bw!
 
-  let &findexpr = '<SID>FindExprScript()'
-  call assert_equal(expand('<SID>') .. 'FindExprScript()', &g:findexpr)
+  let &findfunc = '<SID>FindFuncScript'
+  call assert_equal(expand('<SID>') .. 'FindFuncScript', &g:findfunc)
   new | only
-  let g:FindExprArg = ''
+  let g:FindFuncArg = ''
   find abc
-  call assert_equal('abc', g:FindExprArg)
+  call assert_equal('abc', g:FindFuncArg)
   bw!
 
-  set findexpr=
-  setglobal findexpr=s:FindExprScript()
-  setlocal findexpr=
-  call assert_equal(expand('<SID>') .. 'FindExprScript()', &findexpr)
-  call assert_equal(expand('<SID>') .. 'FindExprScript()', &g:findexpr)
-  call assert_equal('', &l:findexpr)
+  set findfunc=
+  setglobal findfunc=s:FindFuncScript
+  setlocal findfunc=
+  call assert_equal(expand('<SID>') .. 'FindFuncScript', &findfunc)
+  call assert_equal(expand('<SID>') .. 'FindFuncScript', &g:findfunc)
+  call assert_equal('', &l:findfunc)
   new | only
-  let g:FindExprArg = ''
+  let g:FindFuncArg = ''
   find abc
-  call assert_equal('abc', g:FindExprArg)
+  call assert_equal('abc', g:FindFuncArg)
   bw!
 
   new | only
-  set findexpr=
-  setglobal findexpr=
-  setlocal findexpr=s:FindExprScript()
-  call assert_equal(expand('<SID>') .. 'FindExprScript()', &findexpr)
-  call assert_equal(expand('<SID>') .. 'FindExprScript()', &l:findexpr)
-  call assert_equal('', &g:findexpr)
-  let g:FindExprArg = ''
+  set findfunc=
+  setglobal findfunc=
+  setlocal findfunc=s:FindFuncScript
+  call assert_equal(expand('<SID>') .. 'FindFuncScript', &findfunc)
+  call assert_equal(expand('<SID>') .. 'FindFuncScript', &l:findfunc)
+  call assert_equal('', &g:findfunc)
+  let g:FindFuncArg = ''
   find abc
-  call assert_equal('abc', g:FindExprArg)
+  call assert_equal('abc', g:FindFuncArg)
   bw!
 
-  set findexpr=
-  delfunc s:FindExprScript
+  set findfunc=
+  delfunc s:FindFuncScript
 endfunc
 
-" Test for expanding the argument to the :find command using 'findexpr'
-func Test_findexpr_expand_arg()
-  let s:fnames = ['Xfindexpr1.c', 'Xfindexpr2.c', 'Xfindexpr3.c']
+" Test for expanding the argument to the :find command using 'findfunc'
+func Test_findfunc_expand_arg()
+  let s:fnames = ['Xfindfunc1.c', 'Xfindfunc2.c', 'Xfindfunc3.c']
 
-  " 'findexpr' that accepts a regular expression
-  func FindExprRegexp()
-    return s:fnames->copy()->filter('v:val =~? v:fname')
+  " 'findfunc' that accepts a regular expression
+  func FindFuncRegexp(pat, cmdcomplete)
+    return s:fnames->copy()->filter('v:val =~? a:pat')
   endfunc
 
-  " 'findexpr' that accepts a glob
-  func FindExprGlob()
-    let pat = glob2regpat(v:cmdcomplete ? $'*{v:fname}*' : v:fname)
+  " 'findfunc' that accepts a glob
+  func FindFuncGlob(pat_arg, cmdcomplete)
+    let pat = glob2regpat(a:cmdcomplete ? $'*{a:pat_arg}*' : a:pat_arg)
     return s:fnames->copy()->filter('v:val =~? pat')
   endfunc
 
   for regexp in [v:true, v:false]
-    let &findexpr = regexp ? 'FindExprRegexp()' : 'FindExprGlob()'
+    let &findfunc = regexp ? 'FindFuncRegexp' : 'FindFuncGlob'
 
     call feedkeys(":find \<Tab>\<C-B>\"\<CR>", "xt")
-    call assert_equal('"find Xfindexpr1.c', @:)
+    call assert_equal('"find Xfindfunc1.c', @:)
 
     call feedkeys(":find Xfind\<Tab>\<Tab>\<C-B>\"\<CR>", "xt")
-    call assert_equal('"find Xfindexpr2.c', @:)
+    call assert_equal('"find Xfindfunc2.c', @:)
 
     call assert_equal(s:fnames, getcompletion('find ', 'cmdline'))
     call assert_equal(s:fnames, getcompletion('find Xfind', 'cmdline'))
 
     let pat = regexp ? 'X.*1\.c' : 'X*1.c'
     call feedkeys($":find {pat}\<Tab>\<C-B>\"\<CR>", "xt")
-    call assert_equal('"find Xfindexpr1.c', @:)
-    call assert_equal(['Xfindexpr1.c'], getcompletion($'find {pat}', 'cmdline'))
+    call assert_equal('"find Xfindfunc1.c', @:)
+    call assert_equal(['Xfindfunc1.c'], getcompletion($'find {pat}', 'cmdline'))
 
     call feedkeys(":find 3\<Tab>\<C-B>\"\<CR>", "xt")
-    call assert_equal('"find Xfindexpr3.c', @:)
-    call assert_equal(['Xfindexpr3.c'], getcompletion($'find 3', 'cmdline'))
+    call assert_equal('"find Xfindfunc3.c', @:)
+    call assert_equal(['Xfindfunc3.c'], getcompletion($'find 3', 'cmdline'))
 
     call feedkeys(":find Xfind\<C-A>\<C-B>\"\<CR>", "xt")
-    call assert_equal('"find Xfindexpr1.c Xfindexpr2.c Xfindexpr3.c', @:)
+    call assert_equal('"find Xfindfunc1.c Xfindfunc2.c Xfindfunc3.c', @:)
 
     call feedkeys(":find abc\<Tab>\<C-B>\"\<CR>", "xt")
     call assert_equal('"find abc', @:)
     call assert_equal([], getcompletion('find abc', 'cmdline'))
   endfor
 
-  set findexpr&
-  delfunc! FindExprRegexp
-  delfunc! FindExprGlob
+  set findfunc&
+  delfunc! FindFuncRegexp
+  delfunc! FindFuncGlob
   unlet s:fnames
 endfunc
 
+" Test for different ways of setting the 'findfunc' option
+func Test_findfunc_callback()
+  new
+  func FindFunc1(pat, cmdexpand)
+    let g:FindFunc1Args = [a:pat, a:cmdexpand]
+    return ['findfunc1']
+  endfunc
+
+  let lines =<< trim END
+    #" Test for using a function name
+    LET &findfunc = 'g:FindFunc1'
+    LET g:FindFunc1Args = []
+    find abc1
+    call assert_equal(['abc1', v:false], g:FindFunc1Args)
+
+    #" Test for using a function()
+    set findfunc=function('g:FindFunc1')
+    LET g:FindFunc1Args = []
+    find abc2
+    call assert_equal(['abc2', v:false], g:FindFunc1Args)
+
+    #" Using a funcref variable to set 'findfunc'
+    VAR Fn = function('g:FindFunc1')
+    LET &findfunc = Fn
+    LET g:FindFunc1Args = []
+    find abc3
+    call assert_equal(['abc3', v:false], g:FindFunc1Args)
+
+    #" Using a string(funcref_variable) to set 'findfunc'
+    LET Fn = function('g:FindFunc1')
+    LET &findfunc = string(Fn)
+    LET g:FindFunc1Args = []
+    find abc4
+    call assert_equal(['abc4', v:false], g:FindFunc1Args)
+
+    #" Test for using a funcref()
+    set findfunc=funcref('g:FindFunc1')
+    LET g:FindFunc1Args = []
+    find abc5
+    call assert_equal(['abc5', v:false], g:FindFunc1Args)
+
+    #" Using a funcref variable to set 'findfunc'
+    LET Fn = funcref('g:FindFunc1')
+    LET &findfunc = Fn
+    LET g:FindFunc1Args = []
+    find abc6
+    call assert_equal(['abc6', v:false], g:FindFunc1Args)
+
+    #" Using a string(funcref_variable) to set 'findfunc'
+    LET Fn = funcref('g:FindFunc1')
+    LET &findfunc = string(Fn)
+    LET g:FindFunc1Args = []
+    find abc7
+    call assert_equal(['abc7', v:false], g:FindFunc1Args)
+
+    #" Test for using a lambda function using set
+    VAR optval = "LSTART pat, cmdexpand LMIDDLE FindFunc1(pat, cmdexpand) LEND"
+    LET optval = substitute(optval, ' ', '\\ ', 'g')
+    exe "set findfunc=" .. optval
+    LET g:FindFunc1Args = []
+    find abc8
+    call assert_equal(['abc8', v:false], g:FindFunc1Args)
+
+    #" Test for using a lambda function using LET
+    LET &findfunc = LSTART pat, _ LMIDDLE FindFunc1(pat, v:false) LEND
+    LET g:FindFunc1Args = []
+    find abc9
+    call assert_equal(['abc9', v:false], g:FindFunc1Args)
+
+    #" Set 'findfunc' to a string(lambda expression)
+    LET &findfunc = 'LSTART pat, _ LMIDDLE FindFunc1(pat, v:false) LEND'
+    LET g:FindFunc1Args = []
+    find abc10
+    call assert_equal(['abc10', v:false], g:FindFunc1Args)
+
+    #" Set 'findfunc' to a variable with a lambda expression
+    VAR Lambda = LSTART pat, _ LMIDDLE FindFunc1(pat, v:false) LEND
+    LET &findfunc = Lambda
+    LET g:FindFunc1Args = []
+    find abc11
+    call assert_equal(['abc11', v:false], g:FindFunc1Args)
+
+    #" Set 'findfunc' to a string(variable with a lambda expression)
+    LET Lambda = LSTART pat, _ LMIDDLE FindFunc1(pat, v:false) LEND
+    LET &findfunc = string(Lambda)
+    LET g:FindFunc1Args = []
+    find abc12
+    call assert_equal(['abc12', v:false], g:FindFunc1Args)
+
+    #" Try to use 'findfunc' after the function is deleted
+    func g:TmpFindFunc(pat, cmdexpand)
+      let g:TmpFindFunc1Args = [a:pat, a:cmdexpand]
+    endfunc
+    LET &findfunc = function('g:TmpFindFunc')
+    delfunc g:TmpFindFunc
+    call test_garbagecollect_now()
+    LET g:TmpFindFunc1Args = []
+    call assert_fails('find abc13', 'E117:')
+    call assert_equal([], g:TmpFindFunc1Args)
+
+    #" Try to use a function with three arguments for 'findfunc'
+    func g:TmpFindFunc2(x, y, z)
+      let g:TmpFindFunc2Args = [a:x, a:y, a:z]
+    endfunc
+    set findfunc=TmpFindFunc2
+    LET g:TmpFindFunc2Args = []
+    call assert_fails('find abc14', 'E119:')
+    call assert_equal([], g:TmpFindFunc2Args)
+    delfunc TmpFindFunc2
+
+    #" Try to use a function with zero arguments for 'findfunc'
+    func g:TmpFindFunc3()
+      let g:TmpFindFunc3Called = v:true
+    endfunc
+    set findfunc=TmpFindFunc3
+    LET g:TmpFindFunc3Called = v:false
+    call assert_fails('find abc15', 'E118:')
+    call assert_equal(v:false, g:TmpFindFunc3Called)
+    delfunc TmpFindFunc3
+
+    #" Try to use a lambda function with three arguments for 'findfunc'
+    LET &findfunc = LSTART a, b, c LMIDDLE FindFunc1(a, v:false) LEND
+    LET g:FindFunc1Args = []
+    call assert_fails('find abc16', 'E119:')
+    call assert_equal([], g:FindFunc1Args)
+
+    #" Test for clearing the 'findfunc' option
+    set findfunc=''
+    set findfunc&
+    call assert_fails("set findfunc=function('abc')", "E700:")
+    call assert_fails("set findfunc=funcref('abc')", "E700:")
+
+    #" set 'findfunc' to a non-existing function
+    LET &findfunc = function('g:FindFunc1')
+    call assert_fails("set findfunc=function('NonExistingFunc')", 'E700:')
+    call assert_fails("LET &findfunc = function('NonExistingFunc')", 'E700:')
+    LET g:FindFunc1Args = []
+    find abc17
+    call assert_equal(['abc17', v:false], g:FindFunc1Args)
+  END
+  call CheckTransLegacySuccess(lines)
+
+  " Test for using a script-local function name
+  func s:FindFunc2(pat, cmdexpand)
+    let g:FindFunc2Args = [a:pat, a:cmdexpand]
+    return ['findfunc2']
+  endfunc
+  set findfunc=s:FindFunc2
+  let g:FindFunc2Args = []
+  find abc18
+  call assert_equal(['abc18', v:false], g:FindFunc2Args)
+
+  let &findfunc = 's:FindFunc2'
+  let g:FindFunc2Args = []
+  find abc19
+  call assert_equal(['abc19', v:false], g:FindFunc2Args)
+  delfunc s:FindFunc2
+
+  " Using Vim9 lambda expression in legacy context should fail
+  set findfunc=(pat,\ cmdexpand)\ =>\ FindFunc1(pat,\ v:false)
+  let g:FindFunc1Args = []
+  call assert_fails('find abc20', 'E117:')
+  call assert_equal([], g:FindFunc1Args)
+
+  " set 'findfunc' to a partial with dict.
+  func SetFindFunc()
+    let operator = {'execute': function('FindFuncExecute')}
+    let &findfunc = operator.execute
+  endfunc
+  func FindFuncExecute(pat, cmdexpand) dict
+    return ['findfuncexecute']
+  endfunc
+  call SetFindFunc()
+  call test_garbagecollect_now()
+  set findfunc=
+  delfunc SetFindFunc
+  delfunc FindFuncExecute
+
+  func FindFunc2(pat, cmdexpand)
+    let g:FindFunc2Args = [a:pat, a:cmdexpand]
+    return ['findfunc2']
+  endfunc
+
+  " Vim9 tests
+  let lines =<< trim END
+    vim9script
+
+    def g:Vim9findFunc(pat: string, cmdexpand: bool): list<string>
+      g:FindFunc1Args = [pat, cmdexpand]
+      return ['vim9findfunc']
+    enddef
+
+    # Test for using a def function with findfunc
+    set findfunc=function('g:Vim9findFunc')
+    g:FindFunc1Args = []
+    find abc21
+    assert_equal(['abc21', false], g:FindFunc1Args)
+
+    # Test for using a global function name
+    &findfunc = g:FindFunc2
+    g:FindFunc2Args = []
+    find abc22
+    assert_equal(['abc22', false], g:FindFunc2Args)
+    bw!
+
+    # Test for using a script-local function name
+    def LocalFindFunc(pat: string, cmdexpand: bool): list<string>
+      g:LocalFindFuncArgs = [pat, cmdexpand]
+      return ['localfindfunc']
+    enddef
+    &findfunc = LocalFindFunc
+    g:LocalFindFuncArgs = []
+    find abc23
+    assert_equal(['abc23', false], g:LocalFindFuncArgs)
+    bw!
+  END
+  call CheckScriptSuccess(lines)
+
+  " setting 'findfunc' to a script local function outside of a script context
+  " should fail
+  let cleanup =<< trim END
+    call writefile([execute('messages')], 'Xtest.out')
+    qall
+  END
+  call writefile(cleanup, 'Xverify.vim', 'D')
+  call RunVim([], [], "-c \"set findfunc=s:abc\" -S Xverify.vim")
+  call assert_match('E81: Using <SID> not in a', readfile('Xtest.out')[0])
+  call delete('Xtest.out')
+
+  " cleanup
+  set findfunc&
+  delfunc FindFunc1
+  delfunc FindFunc2
+  unlet g:FindFunc1Args g:FindFunc2Args
+  %bw!
+endfunc
+
+
 " vim: shiftwidth=2 sts=2 expandtab
diff --git a/test/old/testdir/test_ins_complete.vim b/test/old/testdir/test_ins_complete.vim
index 48319f5017..8e2a7c4631 100644
--- a/test/old/testdir/test_ins_complete.vim
+++ b/test/old/testdir/test_ins_complete.vim
@@ -1713,10 +1713,10 @@ func Test_completefunc_callback()
   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)
+  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_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.
@@ -1970,10 +1970,10 @@ func Test_omnifunc_callback()
   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)
+  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_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.
@@ -2250,10 +2250,10 @@ func Test_thesaurusfunc_callback()
   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)
+  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_fails('call feedkeys("A\<C-X>\<C-T>\<Esc>", "x")', 'E117:')
   call assert_equal([], g:TsrFunc1Args)
   bw!
 
diff --git a/test/old/testdir/test_modeline.vim b/test/old/testdir/test_modeline.vim
index 7b7163d372..2cd9e49a12 100644
--- a/test/old/testdir/test_modeline.vim
+++ b/test/old/testdir/test_modeline.vim
@@ -217,7 +217,7 @@ func Test_modeline_fails_always()
   call s:modeline_fails('equalprg', 'equalprg=Something()', 'E520:')
   call s:modeline_fails('errorfile', 'errorfile=Something()', 'E520:')
   call s:modeline_fails('exrc', 'exrc=Something()', 'E520:')
-  call s:modeline_fails('findexpr', 'findexpr=Something()', 'E520:')
+  call s:modeline_fails('findfunc', 'findfunc=Something', 'E520:')
   call s:modeline_fails('formatprg', 'formatprg=Something()', 'E520:')
   call s:modeline_fails('fsync', 'fsync=Something()', 'E520:')
   call s:modeline_fails('grepprg', 'grepprg=Something()', 'E520:')
diff --git a/test/old/testdir/test_normal.vim b/test/old/testdir/test_normal.vim
index 46fddd6c1a..faa93c4b61 100644
--- a/test/old/testdir/test_normal.vim
+++ b/test/old/testdir/test_normal.vim
@@ -692,9 +692,9 @@ func Test_opfunc_callback()
   delfunc s:OpFunc3
 
   " Using Vim9 lambda expression in legacy context should fail
-  " set opfunc=(a)\ =>\ OpFunc1(24,\ a)
+  set opfunc=(a)\ =>\ OpFunc1(24,\ a)
   let g:OpFunc1Args = []
-  " call assert_fails('normal! g@l', 'E117:')
+  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.
diff --git a/test/old/testdir/test_options.vim b/test/old/testdir/test_options.vim
index 6902560518..540936e7ec 100644
--- a/test/old/testdir/test_options.vim
+++ b/test/old/testdir/test_options.vim
@@ -1559,7 +1559,7 @@ endfunc
 
 " Test for changing options in a sandbox
 func Test_opt_sandbox()
-  for opt in ['backupdir', 'cdpath', 'exrc', 'findexpr']
+  for opt in ['backupdir', 'cdpath', 'exrc', 'findfunc']
     call assert_fails('sandbox set ' .. opt .. '?', 'E48:')
     call assert_fails('sandbox let &' .. opt .. ' = 1', 'E48:')
   endfor
diff --git a/test/old/testdir/test_tagfunc.vim b/test/old/testdir/test_tagfunc.vim
index 812603a430..ec1f93e9be 100644
--- a/test/old/testdir/test_tagfunc.vim
+++ b/test/old/testdir/test_tagfunc.vim
@@ -291,10 +291,10 @@ func Test_tagfunc_callback()
   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)
+  set tagfunc=(a,\ b,\ c)\ =>\ g:TagFunc1(21,\ a,\ b,\ c)
   new
   let g:TagFunc1Args = []
-  " call assert_fails("tag a17", "E117:")
+  call assert_fails("tag a17", "E117:")
   call assert_equal([], g:TagFunc1Args)
   bw!