diff options
Diffstat (limited to 'src/testdir/test_vim9_func.vim')
| -rw-r--r-- | src/testdir/test_vim9_func.vim | 4576 |
1 files changed, 4576 insertions, 0 deletions
diff --git a/src/testdir/test_vim9_func.vim b/src/testdir/test_vim9_func.vim new file mode 100644 index 0000000..0f28ba0 --- /dev/null +++ b/src/testdir/test_vim9_func.vim @@ -0,0 +1,4576 @@ +" Test various aspects of the Vim9 script language. + +source check.vim +source term_util.vim +source view_util.vim +import './vim9.vim' as v9 +source screendump.vim + +func Test_def_basic() + def SomeFunc(): string + return 'yes' + enddef + call SomeFunc()->assert_equal('yes') +endfunc + +func Test_compiling_error() + " use a terminal to see the whole error message + CheckRunVimInTerminal + + call TestCompilingError() + call TestCompilingErrorInTry() +endfunc + +def TestCompilingError() + var lines =<< trim END + vim9script + def Fails() + echo nothing + enddef + defcompile + END + writefile(lines, 'XTest_compile_error', 'D') + var buf = g:RunVimInTerminal('-S XTest_compile_error', + {rows: 10, wait_for_ruler: 0}) + g:WaitForAssert(() => assert_match('Error detected while compiling command line.*Fails.*Variable not found: nothing', + g:Term_getlines(buf, range(1, 9)))) + + # clean up + g:StopVimInTerminal(buf) +enddef + +def TestCompilingErrorInTry() + var dir = 'Xcompdir/autoload' + mkdir(dir, 'pR') + + var lines =<< trim END + vim9script + export def OnlyCompiled() + g:runtime = 'yes' + invalid + enddef + END + writefile(lines, dir .. '/script.vim') + + lines =<< trim END + vim9script + todo + try + script#OnlyCompiled() + catch /nothing/ + endtry + END + lines[1] = 'set rtp=' .. getcwd() .. '/Xcompdir' + writefile(lines, 'XTest_compile_error', 'D') + + var buf = g:RunVimInTerminal('-S XTest_compile_error', {rows: 10, wait_for_ruler: 0}) + g:WaitForAssert(() => assert_match('Error detected while compiling command line.*function script#OnlyCompiled.*Invalid command: invalid', + g:Term_getlines(buf, range(1, 9)))) + + # clean up + g:StopVimInTerminal(buf) +enddef + +def Test_comment_error() + v9.CheckDefFailure(['#{ comment'], 'E1170:') +enddef + +def Test_compile_error_in_called_function() + var lines =<< trim END + vim9script + var n: number + def Foo() + &hls = n + enddef + def Bar() + Foo() + enddef + silent! Foo() + Bar() + END + v9.CheckScriptFailureList(lines, ['E1012:', 'E1191:']) +enddef + +def Test_wrong_function_name() + var lines =<< trim END + vim9script + func _Foo() + echo 'foo' + endfunc + END + v9.CheckScriptFailure(lines, 'E1267:') + + lines =<< trim END + vim9script + def _Foo() + echo 'foo' + enddef + END + v9.CheckScriptFailure(lines, 'E1267:') + + lines =<< trim END + vim9script + var Object = {} + function Object.Method() + endfunction + END + v9.CheckScriptFailure(lines, 'E1182:') + + lines =<< trim END + vim9script + var Object = {} + def Object.Method() + enddef + END + v9.CheckScriptFailure(lines, 'E1182:') + + lines =<< trim END + vim9script + g:Object = {} + function g:Object.Method() + endfunction + END + v9.CheckScriptFailure(lines, 'E1182:') + + lines =<< trim END + let s:Object = {} + def Define() + function s:Object.Method() + endfunction + enddef + defcompile + END + v9.CheckScriptFailure(lines, 'E1182:') + delfunc g:Define + + lines =<< trim END + let s:Object = {} + def Define() + def Object.Method() + enddef + enddef + defcompile + END + v9.CheckScriptFailure(lines, 'E1182:') + delfunc g:Define + + lines =<< trim END + let g:Object = {} + def Define() + function g:Object.Method() + endfunction + enddef + defcompile + END + v9.CheckScriptFailure(lines, 'E1182:') + delfunc g:Define +enddef + +def Test_break_in_skipped_block() + var lines =<< trim END + vim9script + + def FixStackFrame(): string + for _ in [2] + var path = 'xxx' + if !!path + if false + break + else + return 'foo' + endif + endif + endfor + return 'xxx' + enddef + + disas FixStackFrame + + FixStackFrame() + END + v9.CheckScriptSuccess(lines) +enddef + +def Test_autoload_name_mismatch() + var dir = 'Xnamedir/autoload' + mkdir(dir, 'pR') + + var lines =<< trim END + vim9script + export def NoFunction() + # comment + g:runtime = 'yes' + enddef + END + writefile(lines, dir .. '/script.vim') + + var save_rtp = &rtp + exe 'set rtp=' .. getcwd() .. '/Xnamedir' + lines =<< trim END + call script#Function() + END + v9.CheckScriptFailure(lines, 'E117:', 1) + + &rtp = save_rtp +enddef + +def Test_autoload_names() + var dir = 'Xandir/autoload' + mkdir(dir, 'pR') + + var lines =<< trim END + func foobar#function() + return 'yes' + endfunc + let foobar#var = 'no' + END + writefile(lines, dir .. '/foobar.vim') + + var save_rtp = &rtp + exe 'set rtp=' .. getcwd() .. '/Xandir' + + lines =<< trim END + assert_equal('yes', foobar#function()) + var Function = foobar#function + assert_equal('yes', Function()) + + assert_equal('no', foobar#var) + END + v9.CheckDefAndScriptSuccess(lines) + + &rtp = save_rtp +enddef + +def Test_autoload_error_in_script() + var dir = 'Xaedir/autoload' + mkdir(dir, 'pR') + + var lines =<< trim END + func scripterror#function() + let g:called_function = 'yes' + endfunc + let 0 = 1 + END + writefile(lines, dir .. '/scripterror.vim') + + var save_rtp = &rtp + exe 'set rtp=' .. getcwd() .. '/Xaedir' + + g:called_function = 'no' + # The error in the autoload script cannot be checked with assert_fails(), use + # CheckDefSuccess() instead of CheckDefFailure() + try + v9.CheckDefSuccess(['scripterror#function()']) + catch + assert_match('E121: Undefined variable: 0', v:exception) + endtry + assert_equal('no', g:called_function) + + lines =<< trim END + func scriptcaught#function() + let g:called_function = 'yes' + endfunc + try + let 0 = 1 + catch + let g:caught = v:exception + endtry + END + writefile(lines, dir .. '/scriptcaught.vim') + + g:called_function = 'no' + v9.CheckDefSuccess(['scriptcaught#function()']) + assert_match('E121: Undefined variable: 0', g:caught) + assert_equal('yes', g:called_function) + + &rtp = save_rtp +enddef + +def s:CallRecursive(n: number): number + return CallRecursive(n + 1) +enddef + +def s:CallMapRecursive(l: list<number>): number + return map(l, (_, v) => CallMapRecursive([v]))[0] +enddef + +def Test_funcdepth_error() + set maxfuncdepth=10 + + var caught = false + try + CallRecursive(1) + catch /E132:/ + caught = true + endtry + assert_true(caught) + + caught = false + try + CallMapRecursive([1]) + catch /E132:/ + caught = true + endtry + assert_true(caught) + + set maxfuncdepth& +enddef + +def Test_endfunc_enddef() + var lines =<< trim END + def Test() + echo 'test' + endfunc + enddef + END + v9.CheckScriptFailure(lines, 'E1151:', 3) + + lines =<< trim END + def Test() + func Nested() + echo 'test' + enddef + enddef + END + v9.CheckScriptFailure(lines, 'E1152:', 4) + + lines =<< trim END + def Ok() + echo 'hello' + enddef | echo 'there' + def Bad() + echo 'hello' + enddef there + END + v9.CheckScriptFailure(lines, 'E1173: Text found after enddef: there', 6) +enddef + +def Test_missing_endfunc_enddef() + var lines =<< trim END + vim9script + def Test() + echo 'test' + endef + END + v9.CheckScriptFailure(lines, 'E1057:', 2) + + lines =<< trim END + vim9script + func Some() + echo 'test' + enfffunc + END + v9.CheckScriptFailure(lines, 'E126:', 2) +enddef + +def Test_white_space_before_paren() + var lines =<< trim END + vim9script + def Test () + echo 'test' + enddef + END + v9.CheckScriptFailure(lines, 'E1068:', 2) + + lines =<< trim END + vim9script + func Test () + echo 'test' + endfunc + END + v9.CheckScriptFailure(lines, 'E1068:', 2) + + lines =<< trim END + def Test () + echo 'test' + enddef + END + v9.CheckScriptFailure(lines, 'E1068:', 1) + + lines =<< trim END + func Test () + echo 'test' + endfunc + END + v9.CheckScriptSuccess(lines) +enddef + +def Test_enddef_dict_key() + var d = { + enddef: 'x', + endfunc: 'y', + } + assert_equal({enddef: 'x', endfunc: 'y'}, d) +enddef + +def ReturnString(): string + return 'string' +enddef + +def ReturnNumber(): number + return 123 +enddef + +let g:notNumber = 'string' + +def ReturnGlobal(): number + return g:notNumber +enddef + +def Test_return_something() + g:ReturnString()->assert_equal('string') + g:ReturnNumber()->assert_equal(123) + assert_fails('g:ReturnGlobal()', 'E1012: Type mismatch; expected number but got string', '', 1, 'ReturnGlobal') + + var lines =<< trim END + vim9script + + def Msg() + echomsg 'in Msg()...' + enddef + + def Func() + return Msg() + enddef + defcompile + END + v9.CheckScriptFailure(lines, 'E1096:') +enddef + +def Test_check_argument_type() + var lines =<< trim END + vim9script + def Val(a: number, b: number): number + return 0 + enddef + def Func() + var x: any = true + Val(0, x) + enddef + disass Func + Func() + END + v9.CheckScriptFailure(lines, 'E1013: Argument 2: type mismatch, expected number but got bool', 2) + + lines =<< trim END + vim9script + + def Foobar(Fn: func(any, ?string): any) + enddef + + Foobar((t) => 0) + END + v9.CheckScriptSuccess(lines) +enddef + +def Test_missing_return() + v9.CheckDefFailure(['def Missing(): number', + ' if g:cond', + ' echo "no return"', + ' else', + ' return 0', + ' endif', + 'enddef'], 'E1027:') + v9.CheckDefFailure(['def Missing(): number', + ' if g:cond', + ' return 1', + ' else', + ' echo "no return"', + ' endif', + 'enddef'], 'E1027:') + v9.CheckDefFailure(['def Missing(): number', + ' if g:cond', + ' return 1', + ' else', + ' return 2', + ' endif', + ' return 3', + 'enddef'], 'E1095:') +enddef + +def Test_return_bool() + var lines =<< trim END + vim9script + def MenuFilter(id: number, key: string): bool + return popup_filter_menu(id, key) + enddef + def YesnoFilter(id: number, key: string): bool + return popup_filter_yesno(id, key) + enddef + defcompile + END + v9.CheckScriptSuccess(lines) +enddef + +def Test_return_void_comment_follows() + var lines =<< trim END + vim9script + def ReturnCommentFollows(): void + return # Some comment + enddef + defcompile + END + v9.CheckScriptSuccess(lines) +enddef + +let s:nothing = 0 +def ReturnNothing() + s:nothing = 1 + if true + return + endif + s:nothing = 2 +enddef + +def Test_return_nothing() + g:ReturnNothing() + s:nothing->assert_equal(1) +enddef + +def Test_return_invalid() + var lines =<< trim END + vim9script + def Func(): invalid + return xxx + enddef + defcompile + END + v9.CheckScriptFailure(lines, 'E1010:', 2) + + lines =<< trim END + vim9script + def Test(Fun: func(number): number): list<number> + return map([1, 2, 3], (_, i) => Fun(i)) + enddef + defcompile + def Inc(nr: number): nr + return nr + 2 + enddef + echo Test(Inc) + END + # doing this twice was leaking memory + v9.CheckScriptFailure(lines, 'E1010:') + v9.CheckScriptFailure(lines, 'E1010:') +enddef + +def Test_return_list_any() + # This used to fail but now the actual list type is checked, and since it has + # an item of type string it can be used as list<string>. + var lines =<< trim END + vim9script + def Func(): list<string> + var l: list<any> + l->add('string') + return l + enddef + echo Func() + END + v9.CheckScriptSuccess(lines) + + lines =<< trim END + vim9script + def Func(): list<string> + var l: list<any> + l += ['string'] + return l + enddef + echo Func() + END + v9.CheckScriptSuccess(lines) +enddef + +def Test_return_any_two_types() + var lines =<< trim END + vim9script + + def G(Fn: func(string): any) + g:result = Fn("hello") + enddef + + def F(a: number, b: string): any + echo b + if a > 0 + return 1 + else + return [] + endif + enddef + + G(function(F, [1])) + END + v9.CheckScriptSuccess(lines) + assert_equal(1, g:result) + unlet g:result +enddef + +func s:Increment() + let g:counter += 1 +endfunc + +def Test_call_ufunc_count() + g:counter = 1 + Increment() + Increment() + Increment() + # works with and without :call + g:counter->assert_equal(4) + eval g:counter->assert_equal(4) + unlet g:counter +enddef + +def Test_call_ufunc_failure() + var lines =<< trim END + vim9script + def Tryit() + g:Global(1, 2, 3) + enddef + + func g:Global(a, b, c) + echo a:a a:b a:c + endfunc + + defcompile + + func! g:Global(a, b) + echo a:a a:b + endfunc + Tryit() + END + v9.CheckScriptFailure(lines, 'E118: Too many arguments for function: Global') + delfunc g:Global + + lines =<< trim END + vim9script + + g:Ref = function('len') + def Tryit() + g:Ref('x') + enddef + + defcompile + + g:Ref = function('add') + Tryit() + END + v9.CheckScriptFailure(lines, 'E119: Not enough arguments for function: add') + unlet g:Ref +enddef + +def s:MyVarargs(arg: string, ...rest: list<string>): string + var res = arg + for s in rest + res ..= ',' .. s + endfor + return res +enddef + +def Test_call_varargs() + MyVarargs('one')->assert_equal('one') + MyVarargs('one', 'two')->assert_equal('one,two') + MyVarargs('one', 'two', 'three')->assert_equal('one,two,three') +enddef + +def Test_call_white_space() + v9.CheckDefAndScriptFailure(["call Test ('text')"], ['E476:', 'E1068:']) +enddef + +def MyDefaultArgs(name = 'string'): string + return name +enddef + +def s:MyDefaultSecond(name: string, second: bool = true): string + return second ? name : 'none' +enddef + + +def Test_call_default_args() + g:MyDefaultArgs()->assert_equal('string') + g:MyDefaultArgs(v:none)->assert_equal('string') + g:MyDefaultArgs('one')->assert_equal('one') + assert_fails('g:MyDefaultArgs("one", "two")', 'E118:', '', 4, 'Test_call_default_args') + + MyDefaultSecond('test')->assert_equal('test') + MyDefaultSecond('test', true)->assert_equal('test') + MyDefaultSecond('test', false)->assert_equal('none') + + var lines =<< trim END + def MyDefaultThird(name: string, aa = 'aa', bb = 'bb'): string + return name .. aa .. bb + enddef + + MyDefaultThird('->')->assert_equal('->aabb') + MyDefaultThird('->', v:none)->assert_equal('->aabb') + MyDefaultThird('->', 'xx')->assert_equal('->xxbb') + MyDefaultThird('->', v:none, v:none)->assert_equal('->aabb') + MyDefaultThird('->', 'xx', v:none)->assert_equal('->xxbb') + MyDefaultThird('->', v:none, 'yy')->assert_equal('->aayy') + MyDefaultThird('->', 'xx', 'yy')->assert_equal('->xxyy') + + def DefArg(mandatory: any, optional = mandatory): string + return mandatory .. optional + enddef + DefArg(1234)->assert_equal('12341234') + DefArg("ok")->assert_equal('okok') + END + v9.CheckDefAndScriptSuccess(lines) + + v9.CheckScriptFailure(['def Func(arg: number = asdf)', 'enddef', 'defcompile'], 'E1001:') + delfunc g:Func + v9.CheckScriptFailure(['def Func(arg: number = "text")', 'enddef', 'defcompile'], 'E1013: Argument 1: type mismatch, expected number but got string') + delfunc g:Func + v9.CheckDefFailure(['def Func(x: number = )', 'enddef'], 'E15:') + + lines =<< trim END + vim9script + def Func(a = b == 0 ? 1 : 2, b = 0) + enddef + defcompile + END + v9.CheckScriptFailure(lines, 'E1001: Variable not found: b') + + # using script variable requires matching type or type cast when executed + lines =<< trim END + vim9script + var a: any + def Func(arg: string = a) + echo arg + enddef + defcompile + END + v9.CheckScriptSuccess(lines + ['a = "text"', 'Func()']) + v9.CheckScriptFailure(lines + ['a = 123', 'Func()'], 'E1013: Argument 1: type mismatch, expected string but got number') + + # using global variable does not require type cast + lines =<< trim END + vim9script + def Func(arg: string = g:str) + echo arg + enddef + g:str = 'works' + Func() + END + v9.CheckScriptSuccess(lines) +enddef + +def Test_convert_number_to_float() + var lines =<< trim END + vim9script + def Foo(a: float, b: float): float + return a + b + enddef + + assert_equal(5.3, Foo(3.3, 2)) + END + v9.CheckScriptSuccess(lines) +enddef + +def s:FuncWithComment( # comment + a: number, #comment + b: bool, # comment + c: string) #comment + assert_equal(4, a) + assert_equal(true, b) + assert_equal('yes', c) +enddef + +def Test_func_with_comments() + FuncWithComment(4, true, 'yes') + + var lines =<< trim END + def Func(# comment + arg: string) + enddef + END + v9.CheckScriptFailure(lines, 'E125:', 1) + + lines =<< trim END + def Func( + arg: string# comment + ) + enddef + END + v9.CheckScriptFailure(lines, 'E475:', 2) + + lines =<< trim END + def Func( + arg: string + )# comment + enddef + END + v9.CheckScriptFailure(lines, 'E488:', 3) +enddef + +def Test_nested_function() + def NestedDef(arg: string): string + return 'nested ' .. arg + enddef + NestedDef(':def')->assert_equal('nested :def') + + func NestedFunc(arg) + return 'nested ' .. a:arg + endfunc + NestedFunc(':func')->assert_equal('nested :func') + + v9.CheckDefFailure(['def Nested()', 'enddef', 'Nested(66)'], 'E118:') + v9.CheckDefFailure(['def Nested(arg: string)', 'enddef', 'Nested()'], 'E119:') + + v9.CheckDefFailure(['def s:Nested()', 'enddef'], 'E1075:') + v9.CheckDefFailure(['def b:Nested()', 'enddef'], 'E1075:') + + var lines =<< trim END + def Outer() + def Inner() + # comment + enddef + def Inner() + enddef + enddef + END + v9.CheckDefFailure(lines, 'E1073:') + + lines =<< trim END + def Outer() + def Inner() + # comment + enddef + def! Inner() + enddef + enddef + END + v9.CheckDefFailure(lines, 'E1117:') + + lines =<< trim END + vim9script + def Outer() + def Inner() + g:result = 'ok' + enddef + Inner() + enddef + Outer() + Inner() + END + v9.CheckScriptFailure(lines, 'E117: Unknown function: Inner') + assert_equal('ok', g:result) + unlet g:result + + lines =<< trim END + vim9script + def Outer() + def _Inner() + echo 'bad' + enddef + _Inner() + enddef + defcompile + END + v9.CheckScriptFailure(lines, 'E1267:') + + lines =<< trim END + vim9script + def Outer() + def g:inner() + echo 'bad' + enddef + g:inner() + enddef + defcompile + END + v9.CheckScriptFailure(lines, 'E1267:') + + lines =<< trim END + vim9script + def g:_Func() + echo 'bad' + enddef + END + v9.CheckScriptFailure(lines, 'E1267:') + + lines =<< trim END + vim9script + def _Func() + echo 'bad' + enddef + END + v9.CheckScriptFailure(lines, 'E1267:') + + # nested function inside conditional + lines =<< trim END + vim9script + var thecount = 0 + if true + def Test(): number + def TheFunc(): number + thecount += 1 + return thecount + enddef + return TheFunc() + enddef + endif + defcompile + assert_equal(1, Test()) + assert_equal(2, Test()) + END + v9.CheckScriptSuccess(lines) + + # also works when "thecount" is inside the "if" block + lines =<< trim END + vim9script + if true + var thecount = 0 + def Test(): number + def TheFunc(): number + thecount += 1 + return thecount + enddef + return TheFunc() + enddef + endif + defcompile + assert_equal(1, Test()) + assert_equal(2, Test()) + END + v9.CheckScriptSuccess(lines) + + # nested function with recursive call + lines =<< trim END + vim9script + + def MyFunc(): number + def Fib(n: number): number + if n < 2 + return 1 + endif + return Fib(n - 2) + Fib(n - 1) + enddef + + return Fib(5) + enddef + + assert_equal(8, MyFunc()) + END + v9.CheckScriptSuccess(lines) + + lines =<< trim END + vim9script + def Outer() + def Inner() + echo 'hello' + enddef burp + enddef + defcompile + END + v9.CheckScriptFailure(lines, 'E1173: Text found after enddef: burp', 3) +enddef + +def Test_nested_function_fails() + var lines =<< trim END + def T() + def Func(g: string):string + enddef + Func() + enddef + silent! defcompile + END + v9.CheckScriptFailure(lines, 'E1069:') +enddef + +def Test_not_nested_function() + echo printf('%d', + function('len')('xxx')) +enddef + +func Test_call_default_args_from_func() + call MyDefaultArgs()->assert_equal('string') + call MyDefaultArgs('one')->assert_equal('one') + call assert_fails('call MyDefaultArgs("one", "two")', 'E118:', '', 3, 'Test_call_default_args_from_func') +endfunc + +def Test_nested_global_function() + var lines =<< trim END + vim9script + def Outer() + def g:Inner(): string + return 'inner' + enddef + enddef + defcompile + Outer() + g:Inner()->assert_equal('inner') + delfunc g:Inner + Outer() + g:Inner()->assert_equal('inner') + delfunc g:Inner + Outer() + g:Inner()->assert_equal('inner') + delfunc g:Inner + END + v9.CheckScriptSuccess(lines) + + lines =<< trim END + vim9script + def Outer() + func g:Inner() + return 'inner' + endfunc + enddef + defcompile + Outer() + g:Inner()->assert_equal('inner') + delfunc g:Inner + Outer() + g:Inner()->assert_equal('inner') + delfunc g:Inner + Outer() + g:Inner()->assert_equal('inner') + delfunc g:Inner + END + v9.CheckScriptSuccess(lines) + + lines =<< trim END + vim9script + def Outer() + def g:Inner(): string + return 'inner' + enddef + enddef + defcompile + Outer() + Outer() + END + v9.CheckScriptFailure(lines, "E122:") + delfunc g:Inner + + lines =<< trim END + vim9script + def Outer() + def g:Inner() + echo map([1, 2, 3], (_, v) => v + 1) + enddef + g:Inner() + enddef + Outer() + END + v9.CheckScriptSuccess(lines) + delfunc g:Inner + + lines =<< trim END + vim9script + def Func() + echo 'script' + enddef + def Outer() + def Func() + echo 'inner' + enddef + enddef + defcompile + END + v9.CheckScriptFailure(lines, "E1073:", 1) + + lines =<< trim END + vim9script + def Func() + echo 'script' + enddef + def Func() + echo 'script' + enddef + END + v9.CheckScriptFailure(lines, "E1073:", 5) +enddef + +def DefListAll() + def +enddef + +def DefListOne() + def DefListOne +enddef + +def DefListMatches() + def /DefList +enddef + +def Test_nested_def_list() + var funcs = split(execute('call DefListAll()'), "\n") + assert_true(len(funcs) > 10) + assert_true(funcs->index('def DefListAll()') >= 0) + + funcs = split(execute('call DefListOne()'), "\n") + assert_equal([' def DefListOne()', '1 def DefListOne', ' enddef'], funcs) + + funcs = split(execute('call DefListMatches()'), "\n") + assert_true(len(funcs) >= 3) + assert_true(funcs->index('def DefListAll()') >= 0) + assert_true(funcs->index('def DefListOne()') >= 0) + assert_true(funcs->index('def DefListMatches()') >= 0) + + var lines =<< trim END + vim9script + def Func() + def +Func+ + enddef + defcompile + END + v9.CheckScriptFailure(lines, 'E476:', 1) +enddef + +def Test_global_function_not_found() + var lines =<< trim END + g:Ref = 123 + call g:Ref() + END + v9.CheckDefExecAndScriptFailure(lines, ['E117:', 'E1085:'], 2) +enddef + +def Test_global_local_function() + var lines =<< trim END + vim9script + def g:Func(): string + return 'global' + enddef + def Func(): string + return 'local' + enddef + g:Func()->assert_equal('global') + Func()->assert_equal('local') + delfunc g:Func + END + v9.CheckScriptSuccess(lines) + + lines =<< trim END + vim9script + def g:Funcy() + echo 'funcy' + enddef + Funcy() + END + v9.CheckScriptFailure(lines, 'E117:') +enddef + +def Test_local_function_shadows_global() + var lines =<< trim END + vim9script + def g:Gfunc(): string + return 'global' + enddef + def AnotherFunc(): number + var Gfunc = function('len') + return Gfunc('testing') + enddef + g:Gfunc()->assert_equal('global') + AnotherFunc()->assert_equal(7) + delfunc g:Gfunc + END + v9.CheckScriptSuccess(lines) + + lines =<< trim END + vim9script + def g:Func(): string + return 'global' + enddef + def AnotherFunc() + g:Func = function('len') + enddef + AnotherFunc() + END + v9.CheckScriptFailure(lines, 'E705:') + delfunc g:Func + + # global function is not found with g: prefix + lines =<< trim END + vim9script + def g:Func(): string + return 'global' + enddef + def AnotherFunc(): string + return Func() + enddef + assert_equal('global', AnotherFunc()) + END + v9.CheckScriptFailure(lines, 'E117:') + delfunc g:Func + + lines =<< trim END + vim9script + def g:Func(): string + return 'global' + enddef + assert_equal('global', g:Func()) + delfunc g:Func + END + v9.CheckScriptSuccess(lines) + + # This does not shadow "i" which is visible only inside the for loop + lines =<< trim END + vim9script + + def Foo(i: number) + echo i + enddef + + for i in range(3) + # Foo() is compiled here + Foo(i) + endfor + END + v9.CheckScriptSuccess(lines) +enddef + +func TakesOneArg(arg) + echo a:arg +endfunc + +def Test_call_wrong_args() + v9.CheckDefFailure(['g:TakesOneArg()'], 'E119:') + v9.CheckDefFailure(['g:TakesOneArg(11, 22)'], 'E118:') + v9.CheckDefFailure(['bufnr(xxx)'], 'E1001:') + v9.CheckScriptFailure(['def Func(Ref: func(s: string))'], 'E475:') + + var lines =<< trim END + vim9script + def Func(s: string) + echo s + enddef + Func([]) + END + v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected string but got list<unknown>', 5) + + # argument name declared earlier is found when declaring a function + lines =<< trim END + vim9script + var name = 'piet' + def FuncOne(name: string) + echo name + enddef + END + v9.CheckScriptFailure(lines, 'E1168:') + + # same, inside the same block + lines =<< trim END + vim9script + if true + var name = 'piet' + def FuncOne(name: string) + echo name + enddef + endif + END + v9.CheckScriptFailure(lines, 'E1168:') + + # variable in other block is OK + lines =<< trim END + vim9script + if true + var name = 'piet' + endif + def FuncOne(name: string) + echo name + enddef + END + v9.CheckScriptSuccess(lines) + + # with another variable in another block + lines =<< trim END + vim9script + if true + var name = 'piet' + # define a function so that the variable isn't cleared + def GetItem(): string + return item + enddef + endif + if true + var name = 'peter' + def FuncOne(name: string) + echo name + enddef + endif + END + v9.CheckScriptFailure(lines, 'E1168:') + + # only variable in another block is OK + lines =<< trim END + vim9script + if true + var name = 'piet' + # define a function so that the variable isn't cleared + def GetItem(): string + return item + enddef + endif + if true + def FuncOne(name: string) + echo name + enddef + endif + END + v9.CheckScriptSuccess(lines) + + # argument name declared later is only found when compiling + lines =<< trim END + vim9script + def FuncOne(name: string) + echo nr + enddef + var name = 'piet' + END + v9.CheckScriptSuccess(lines) + v9.CheckScriptFailure(lines + ['defcompile'], 'E1168:') + + lines =<< trim END + vim9script + def FuncOne(nr: number) + echo nr + enddef + def FuncTwo() + FuncOne() + enddef + defcompile + END + writefile(lines, 'Xscript') + var didCatch = false + try + source Xscript + catch + assert_match('E119: Not enough arguments for function: <SNR>\d\+_FuncOne', v:exception) + assert_match('Xscript\[8\]..function <SNR>\d\+_FuncTwo, line 1', v:throwpoint) + didCatch = true + endtry + assert_true(didCatch) + + lines =<< trim END + vim9script + def FuncOne(nr: number) + echo nr + enddef + def FuncTwo() + FuncOne(1, 2) + enddef + defcompile + END + writefile(lines, 'Xscript', 'D') + didCatch = false + try + source Xscript + catch + assert_match('E118: Too many arguments for function: <SNR>\d\+_FuncOne', v:exception) + assert_match('Xscript\[8\]..function <SNR>\d\+_FuncTwo, line 1', v:throwpoint) + didCatch = true + endtry + assert_true(didCatch) +enddef + +def Test_call_funcref_wrong_args() + var head =<< trim END + vim9script + def Func3(a1: string, a2: number, a3: list<number>) + echo a1 .. a2 .. a3[0] + enddef + def Testme() + var funcMap: dict<func> = {func: Func3} + END + var tail =<< trim END + enddef + Testme() + END + v9.CheckScriptSuccess(head + ["funcMap['func']('str', 123, [1, 2, 3])"] + tail) + + v9.CheckScriptFailure(head + ["funcMap['func']('str', 123)"] + tail, 'E119:') + v9.CheckScriptFailure(head + ["funcMap['func']('str', 123, [1], 4)"] + tail, 'E118:') + + var lines =<< trim END + vim9script + var Ref: func(number): any + Ref = (j) => !j + echo Ref(false) + END + v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected number but got bool', 4) + + lines =<< trim END + vim9script + var Ref: func(number): any + Ref = (j) => !j + call Ref(false) + END + v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected number but got bool', 4) +enddef + +def Test_call_lambda_args() + var lines =<< trim END + var Callback = (..._) => 'anything' + assert_equal('anything', Callback()) + assert_equal('anything', Callback(1)) + assert_equal('anything', Callback('a', 2)) + + assert_equal('xyz', ((a: string): string => a)('xyz')) + END + v9.CheckDefAndScriptSuccess(lines) + + v9.CheckDefFailure(['echo ((i) => 0)()'], + 'E119: Not enough arguments for function: ((i) => 0)()') + + lines =<< trim END + var Ref = (x: number, y: number) => x + y + echo Ref(1, 'x') + END + v9.CheckDefFailure(lines, 'E1013: Argument 2: type mismatch, expected number but got string') + + lines =<< trim END + var Ref: func(job, string, number) + Ref = (x, y) => 0 + END + v9.CheckDefAndScriptFailure(lines, 'E1012:') + + lines =<< trim END + var Ref: func(job, string) + Ref = (x, y, z) => 0 + END + v9.CheckDefAndScriptFailure(lines, 'E1012:') + + lines =<< trim END + var one = 1 + var l = [1, 2, 3] + echo map(l, (one) => one) + END + v9.CheckDefFailure(lines, 'E1167:') + v9.CheckScriptFailure(['vim9script'] + lines, 'E1168:') + + lines =<< trim END + var Ref: func(any, ?any): bool + Ref = (_, y = 1) => false + END + v9.CheckDefAndScriptFailure(lines, 'E1172:') + + lines =<< trim END + var a = 0 + var b = (a == 0 ? 1 : 2) + assert_equal(1, b) + var txt = 'a' + b = (txt =~ 'x' ? 1 : 2) + assert_equal(2, b) + END + v9.CheckDefAndScriptSuccess(lines) + + lines =<< trim END + def ShadowLocal() + var one = 1 + var l = [1, 2, 3] + echo map(l, (one) => one) + enddef + END + v9.CheckDefFailure(lines, 'E1167:') + + lines =<< trim END + def Shadowarg(one: number) + var l = [1, 2, 3] + echo map(l, (one) => one) + enddef + END + v9.CheckDefFailure(lines, 'E1167:') + + lines =<< trim END + echo ((a) => a)('aa', 'bb') + END + v9.CheckDefAndScriptFailure(lines, 'E118:', 1) + + lines =<< trim END + echo 'aa'->((a) => a)('bb') + END + v9.CheckDefFailure(lines, 'E118: Too many arguments for function: ->((a) => a)(''bb'')', 1) + v9.CheckScriptFailure(['vim9script'] + lines, 'E118: Too many arguments for function: <lambda>', 2) +enddef + +def Test_lambda_line_nr() + var lines =<< trim END + vim9script + # comment + # comment + var id = timer_start(1'000, (_) => 0) + var out = execute('verbose ' .. timer_info(id)[0].callback + ->string() + ->substitute("('\\|')", ' ', 'g')) + assert_match('Last set from .* line 4', out) + END + v9.CheckScriptSuccess(lines) +enddef + +def FilterWithCond(x: string, Cond: func(string): bool): bool + return Cond(x) +enddef + +def Test_lambda_return_type() + var lines =<< trim END + var Ref = (): => 123 + END + v9.CheckDefAndScriptFailure(lines, 'E1157:', 1) + + # no space before the return type + lines =<< trim END + var Ref = (x):number => x + 1 + END + v9.CheckDefAndScriptFailure(lines, 'E1069:', 1) + + # this works + for x in ['foo', 'boo'] + echo g:FilterWithCond(x, (v) => v =~ '^b') + endfor + + # this fails + lines =<< trim END + echo g:FilterWithCond('foo', (v) => v .. '^b') + END + v9.CheckDefAndScriptFailure(lines, 'E1013: Argument 2: type mismatch, expected func(string): bool but got func(any): string', 1) + + lines =<< trim END + var Lambda1 = (x) => { + return x + } + assert_equal('asdf', Lambda1('asdf')) + var Lambda2 = (x): string => { + return x + } + assert_equal('foo', Lambda2('foo')) + END + v9.CheckDefAndScriptSuccess(lines) + + lines =<< trim END + var Lambda = (x): string => { + return x + } + echo Lambda(['foo']) + END + v9.CheckDefExecAndScriptFailure(lines, 'E1012:') +enddef + +def Test_lambda_uses_assigned_var() + v9.CheckDefSuccess([ + 'var x: any = "aaa"', + 'x = filter(["bbb"], (_, v) => v =~ x)']) +enddef + +def Test_lambda_invalid_block() + var lines =<< trim END + timer_start(0, (_) => { # echo + echo 'yes' + }) + END + v9.CheckDefAndScriptSuccess(lines) + + lines =<< trim END + timer_start(0, (_) => { " echo + echo 'yes' + }) + END + v9.CheckDefAndScriptFailure(lines, 'E488: Trailing characters: " echo') + + lines =<< trim END + timer_start(0, (_) => { | echo + echo 'yes' + }) + END + v9.CheckDefAndScriptFailure(lines, 'E488: Trailing characters: | echo') +enddef + +def Test_lambda_with_following_cmd() + var lines =<< trim END + set ts=2 + var Lambda = () => { + set ts=4 + } | set ts=3 + assert_equal(3, &ts) + Lambda() + assert_equal(4, &ts) + END + v9.CheckDefAndScriptSuccess(lines) + set ts=8 +enddef + +def Test_pass_legacy_lambda_to_def_func() + var lines =<< trim END + vim9script + func Foo() + eval s:Bar({x -> 0}) + endfunc + def Bar(y: any) + enddef + Foo() + END + v9.CheckScriptSuccess(lines) + + lines =<< trim END + vim9script + def g:TestFunc(F: func) + enddef + legacy call g:TestFunc({-> 0}) + delfunc g:TestFunc + + def g:TestFunc(F: func(number)) + enddef + legacy call g:TestFunc({nr -> 0}) + delfunc g:TestFunc + END + v9.CheckScriptSuccess(lines) +enddef + +def Test_lambda_in_reduce_line_break() + # this was using freed memory + var lines =<< trim END + vim9script + const result: dict<number> = + ['Bob', 'Sam', 'Cat', 'Bob', 'Cat', 'Cat'] + ->reduce((acc, val) => { + if has_key(acc, val) + acc[val] += 1 + return acc + else + acc[val] = 1 + return acc + endif + }, {}) + assert_equal({Bob: 2, Sam: 1, Cat: 3}, result) + END + v9.CheckScriptSuccess(lines) +enddef + +def Test_set_opfunc_to_lambda() + var lines =<< trim END + vim9script + nnoremap <expr> <F4> <SID>CountSpaces() .. '_' + def CountSpaces(type = ''): string + if type == '' + &operatorfunc = (t) => CountSpaces(t) + return 'g@' + endif + normal! '[V']y + g:result = getreg('"')->count(' ') + return '' + enddef + new + 'a b c d e'->setline(1) + feedkeys("\<F4>", 'x') + assert_equal(4, g:result) + bwipe! + END + v9.CheckScriptSuccess(lines) +enddef + +def Test_set_opfunc_to_global_function() + var lines =<< trim END + vim9script + def g:CountSpaces(type = ''): string + normal! '[V']y + g:result = getreg('"')->count(' ') + return '' + enddef + # global function works at script level + &operatorfunc = g:CountSpaces + new + 'a b c d e'->setline(1) + feedkeys("g@_", 'x') + assert_equal(4, g:result) + + &operatorfunc = '' + g:result = 0 + # global function works in :def function + def Func() + &operatorfunc = g:CountSpaces + enddef + Func() + feedkeys("g@_", 'x') + assert_equal(4, g:result) + + bwipe! + END + v9.CheckScriptSuccess(lines) + &operatorfunc = '' +enddef + +def Test_use_script_func_name_with_prefix() + var lines =<< trim END + vim9script + func g:Getit() + return 'it' + endfunc + var Fn = g:Getit + assert_equal('it', Fn()) + END + v9.CheckScriptSuccess(lines) +enddef + +def Test_lambda_type_allocated() + # Check that unreferencing a partial using a lambda can use the variable type + # after the lambda has been freed and does not leak memory. + var lines =<< trim END + vim9script + + func MyomniFunc1(val, findstart, base) + return a:findstart ? 0 : [] + endfunc + + var Lambda = (a, b) => MyomniFunc1(19, a, b) + &omnifunc = Lambda + Lambda = (a, b) => MyomniFunc1(20, a, b) + &omnifunc = string(Lambda) + Lambda = (a, b) => strlen(a) + END + v9.CheckScriptSuccess(lines) +enddef + +def Test_define_lambda_in_execute() + var lines =<< trim [CODE] + vim9script + + def BuildFuncMultiLine(): func + var x =<< trim END + g:SomeRandomFunc = (d: dict<any>) => { + return d.k1 + d.k2 + } + END + execute(x) + return g:SomeRandomFunc + enddef + var ResultPlus = BuildFuncMultiLine() + assert_equal(7, ResultPlus({k1: 3, k2: 4})) + [CODE] + v9.CheckScriptSuccess(lines) + unlet g:SomeRandomFunc +enddef + +" Default arg and varargs +def MyDefVarargs(one: string, two = 'foo', ...rest: list<string>): string + var res = one .. ',' .. two + for s in rest + res ..= ',' .. s + endfor + return res +enddef + +def Test_call_def_varargs() + assert_fails('g:MyDefVarargs()', 'E119:', '', 1, 'Test_call_def_varargs') + g:MyDefVarargs('one')->assert_equal('one,foo') + g:MyDefVarargs('one', 'two')->assert_equal('one,two') + g:MyDefVarargs('one', 'two', 'three')->assert_equal('one,two,three') + v9.CheckDefFailure(['g:MyDefVarargs("one", 22)'], + 'E1013: Argument 2: type mismatch, expected string but got number') + v9.CheckDefFailure(['g:MyDefVarargs("one", "two", 123)'], + 'E1013: Argument 3: type mismatch, expected string but got number') + + var lines =<< trim END + vim9script + def Func(...l: list<string>) + echo l + enddef + Func('a', 'b', 'c') + END + v9.CheckScriptSuccess(lines) + + lines =<< trim END + vim9script + def Func(...l: list<string>) + echo l + enddef + Func() + END + v9.CheckScriptSuccess(lines) + + lines =<< trim END + vim9script + def Func(...l: list<any>) + echo l + enddef + Func(0) + END + v9.CheckScriptSuccess(lines) + + lines =<< trim END + vim9script + def Func(...l: any) + echo l + enddef + Func(0) + END + v9.CheckScriptFailure(lines, 'E1180:', 2) + + lines =<< trim END + vim9script + def Func(..._l: list<string>) + echo _l + enddef + Func('a', 'b', 'c') + END + v9.CheckScriptSuccess(lines) + + lines =<< trim END + vim9script + def Func(...l: list<string>) + echo l + enddef + Func(1, 2, 3) + END + v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch') + + lines =<< trim END + vim9script + def Func(...l: list<string>) + echo l + enddef + Func('a', 9) + END + v9.CheckScriptFailure(lines, 'E1013: Argument 2: type mismatch') + + lines =<< trim END + vim9script + def Func(...l: list<string>) + echo l + enddef + Func(1, 'a') + END + v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch') + + lines =<< trim END + vim9script + def Func( # some comment + ...l = [] + ) + echo l + enddef + END + v9.CheckScriptFailure(lines, 'E1160:') + + lines =<< trim END + vim9script + def DoIt() + g:Later('') + enddef + defcompile + def g:Later(...l: list<number>) + enddef + DoIt() + END + v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected number but got string') +enddef + +let s:value = '' + +def FuncOneDefArg(opt = 'text') + s:value = opt +enddef + +def FuncTwoDefArg(nr = 123, opt = 'text'): string + return nr .. opt +enddef + +def FuncVarargs(...arg: list<string>): string + return join(arg, ',') +enddef + +def Test_func_type_varargs() + var RefDefArg: func(?string) + RefDefArg = g:FuncOneDefArg + RefDefArg() + s:value->assert_equal('text') + RefDefArg('some') + s:value->assert_equal('some') + + var RefDef2Arg: func(?number, ?string): string + RefDef2Arg = g:FuncTwoDefArg + RefDef2Arg()->assert_equal('123text') + RefDef2Arg(99)->assert_equal('99text') + RefDef2Arg(77, 'some')->assert_equal('77some') + + v9.CheckDefFailure(['var RefWrong: func(string?)'], 'E1010:') + v9.CheckDefFailure(['var RefWrong: func(?string, string)'], 'E1007:') + + var RefVarargs: func(...list<string>): string + RefVarargs = g:FuncVarargs + RefVarargs()->assert_equal('') + RefVarargs('one')->assert_equal('one') + RefVarargs('one', 'two')->assert_equal('one,two') + + v9.CheckDefFailure(['var RefWrong: func(...list<string>, string)'], 'E110:') + v9.CheckDefFailure(['var RefWrong: func(...list<string>, ?string)'], 'E110:') +enddef + +" Only varargs +def MyVarargsOnly(...args: list<string>): string + return join(args, ',') +enddef + +def Test_call_varargs_only() + g:MyVarargsOnly()->assert_equal('') + g:MyVarargsOnly('one')->assert_equal('one') + g:MyVarargsOnly('one', 'two')->assert_equal('one,two') + v9.CheckDefFailure(['g:MyVarargsOnly(1)'], 'E1013: Argument 1: type mismatch, expected string but got number') + v9.CheckDefFailure(['g:MyVarargsOnly("one", 2)'], 'E1013: Argument 2: type mismatch, expected string but got number') +enddef + +def Test_varargs_mismatch() + var lines =<< trim END + vim9script + + def Map(Fn: func(...any): number): number + return Fn('12') + enddef + + var res = Map((v) => str2nr(v)) + assert_equal(12, res) + END + v9.CheckScriptSuccess(lines) +enddef + +def Test_using_var_as_arg() + var lines =<< trim END + def Func(x: number) + var x = 234 + enddef + END + v9.CheckDefFailure(lines, 'E1006:') + + lines =<< trim END + def Func(Ref: number) + def Ref() + enddef + enddef + END + v9.CheckDefFailure(lines, 'E1073:') +enddef + +def s:DictArg(arg: dict<string>) + arg['key'] = 'value' +enddef + +def s:ListArg(arg: list<string>) + arg[0] = 'value' +enddef + +def Test_assign_to_argument() + # works for dict and list + var d: dict<string> = {} + DictArg(d) + d['key']->assert_equal('value') + var l: list<string> = [] + ListArg(l) + l[0]->assert_equal('value') + + v9.CheckScriptFailure(['def Func(arg: number)', 'arg = 3', 'enddef', 'defcompile'], 'E1090:') + delfunc! g:Func +enddef + +" These argument names are reserved in legacy functions. +def s:WithReservedNames(firstline: string, lastline: string): string + return firstline .. lastline +enddef + +def Test_argument_names() + assert_equal('OK', WithReservedNames('O', 'K')) +enddef + +def Test_call_func_defined_later() + g:DefinedLater('one')->assert_equal('one') + assert_fails('NotDefined("one")', 'E117:', '', 2, 'Test_call_func_defined_later') +enddef + +func DefinedLater(arg) + return a:arg +endfunc + +def Test_call_funcref() + g:SomeFunc('abc')->assert_equal(3) + assert_fails('NotAFunc()', 'E117:', '', 2, 'Test_call_funcref') # comment after call + assert_fails('g:NotAFunc()', 'E1085:', '', 3, 'Test_call_funcref') + + var lines =<< trim END + vim9script + def RetNumber(): number + return 123 + enddef + var Funcref: func: number = function('RetNumber') + Funcref()->assert_equal(123) + END + v9.CheckScriptSuccess(lines) + + lines =<< trim END + vim9script + def RetNumber(): number + return 123 + enddef + def Bar(F: func: number): number + return F() + enddef + var Funcref = function('RetNumber') + Bar(Funcref)->assert_equal(123) + END + v9.CheckScriptSuccess(lines) + + lines =<< trim END + vim9script + def UseNumber(nr: number) + echo nr + enddef + var Funcref: func(number) = function('UseNumber') + Funcref(123) + END + v9.CheckScriptSuccess(lines) + + lines =<< trim END + vim9script + def UseNumber(nr: number) + echo nr + enddef + var Funcref: func(string) = function('UseNumber') + END + v9.CheckScriptFailure(lines, 'E1012: Type mismatch; expected func(string) but got func(number)') + + lines =<< trim END + vim9script + def EchoNr(nr = 34) + g:echo = nr + enddef + var Funcref: func(?number) = function('EchoNr') + Funcref() + g:echo->assert_equal(34) + Funcref(123) + g:echo->assert_equal(123) + END + v9.CheckScriptSuccess(lines) + + lines =<< trim END + vim9script + def EchoList(...l: list<number>) + g:echo = l + enddef + var Funcref: func(...list<number>) = function('EchoList') + Funcref() + g:echo->assert_equal([]) + Funcref(1, 2, 3) + g:echo->assert_equal([1, 2, 3]) + END + v9.CheckScriptSuccess(lines) + + lines =<< trim END + vim9script + def OptAndVar(nr: number, opt = 12, ...l: list<number>): number + g:optarg = opt + g:listarg = l + return nr + enddef + var Funcref: func(number, ?number, ...list<number>): number = function('OptAndVar') + Funcref(10)->assert_equal(10) + g:optarg->assert_equal(12) + g:listarg->assert_equal([]) + + Funcref(11, 22)->assert_equal(11) + g:optarg->assert_equal(22) + g:listarg->assert_equal([]) + + Funcref(17, 18, 1, 2, 3)->assert_equal(17) + g:optarg->assert_equal(18) + g:listarg->assert_equal([1, 2, 3]) + END + v9.CheckScriptSuccess(lines) + + lines =<< trim END + function s:func(num) + return a:num * 2 + endfunction + + def s:CallFuncref() + var Funcref = function('s:func') + Funcref(3)->assert_equal(6) + enddef + call s:CallFuncref() + END + v9.CheckScriptSuccess(lines) + + lines =<< trim END + function s:func(num) + return a:num * 2 + endfunction + + def s:CallFuncref() + var Funcref = function(s:func) + Funcref(3)->assert_equal(6) + enddef + call s:CallFuncref() + END + v9.CheckScriptSuccess(lines) + + lines =<< trim END + function s:func(num) + return a:num * 2 + endfunction + + def s:CallFuncref() + var Funcref = s:func + Funcref(3)->assert_equal(6) + enddef + call s:CallFuncref() + END + v9.CheckScriptSuccess(lines) +enddef + +let SomeFunc = function('len') +let NotAFunc = 'text' + +def CombineFuncrefTypes() + # same arguments, different return type + var Ref1: func(bool): string + var Ref2: func(bool): number + var Ref3: func(bool): any + Ref3 = g:cond ? Ref1 : Ref2 + + # different number of arguments + var Refa1: func(bool): number + var Refa2: func(bool, number): number + var Refa3: func: number + Refa3 = g:cond ? Refa1 : Refa2 + + # different argument types + var Refb1: func(bool, string): number + var Refb2: func(string, number): number + var Refb3: func(any, any): number + Refb3 = g:cond ? Refb1 : Refb2 +enddef + +def FuncWithForwardCall() + return g:DefinedEvenLater("yes") +enddef + +def DefinedEvenLater(arg: string): string + return arg +enddef + +def Test_error_in_nested_function() + # Error in called function requires unwinding the call stack. + assert_fails('g:FuncWithForwardCall()', 'E1096:', '', 1, 'FuncWithForwardCall') +enddef + +def Test_nested_function_with_nextcmd() + var lines =<< trim END + vim9script + # Define an outer function + def FirstFunction() + # Define an inner function + def SecondFunction() + # the function has a body, a double free is detected. + AAAAA + + # enddef followed by | or } followed by # one or more characters + enddef|BBBB + enddef + + # Compile all functions + defcompile + END + v9.CheckScriptFailure(lines, 'E1173: Text found after enddef: BBBB') +enddef + +def Test_nested_function_with_args_split() + var lines =<< trim END + vim9script + def FirstFunction() + def SecondFunction( + ) + # had a double free if the right parenthesis of the nested function is + # on the next line + + enddef|BBBB + enddef + # Compile all functions + defcompile + END + v9.CheckScriptFailure(lines, 'E1173: Text found after enddef: BBBB') + + lines =<< trim END + vim9script + def FirstFunction() + func SecondFunction() + endfunc|BBBB + enddef + defcompile + END + v9.CheckScriptFailure(lines, 'E1173: Text found after endfunction: BBBB') +enddef + +def Test_error_in_function_args() + var lines =<< trim END + def FirstFunction() + def SecondFunction(J = + # Nois + # one + + enddef|BBBB + enddef + # Compile all functions + defcompile + END + v9.CheckScriptFailure(lines, 'E488:') +enddef + +def Test_return_type_wrong() + v9.CheckScriptFailure([ + 'def Func(): number', + 'return "a"', + 'enddef', + 'defcompile'], 'expected number but got string') + delfunc! g:Func + v9.CheckScriptFailure([ + 'def Func(): string', + 'return 1', + 'enddef', + 'defcompile'], 'expected string but got number') + delfunc! g:Func + v9.CheckScriptFailure([ + 'def Func(): void', + 'return "a"', + 'enddef', + 'defcompile'], + 'E1096: Returning a value in a function without a return type') + delfunc! g:Func + v9.CheckScriptFailure([ + 'def Func()', + 'return "a"', + 'enddef', + 'defcompile'], + 'E1096: Returning a value in a function without a return type') + delfunc! g:Func + + v9.CheckScriptFailure([ + 'def Func(): number', + 'return', + 'enddef', + 'defcompile'], 'E1003:') + delfunc! g:Func + + v9.CheckScriptFailure([ + 'def Func():number', + 'return 123', + 'enddef', + 'defcompile'], 'E1069:') + delfunc! g:Func + + v9.CheckScriptFailure([ + 'def Func() :number', + 'return 123', + 'enddef', + 'defcompile'], 'E1059:') + delfunc! g:Func + + v9.CheckScriptFailure([ + 'def Func() : number', + 'return 123', + 'enddef', + 'defcompile'], 'E1059:') + delfunc! g:Func + + v9.CheckScriptFailure(['def Func(): list', 'return []', 'enddef'], 'E1008: Missing <type> after list') + delfunc! g:Func + v9.CheckScriptFailure(['def Func(): dict', 'return {}', 'enddef'], 'E1008: Missing <type> after dict') + delfunc! g:Func + v9.CheckScriptFailure(['def Func()', 'return 1'], 'E1057:') + delfunc! g:Func + + v9.CheckScriptFailure([ + 'vim9script', + 'def FuncB()', + ' return 123', + 'enddef', + 'def FuncA()', + ' FuncB()', + 'enddef', + 'defcompile'], 'E1096:') +enddef + +def Test_arg_type_wrong() + v9.CheckScriptFailure(['def Func3(items: list)', 'echo "a"', 'enddef'], 'E1008: Missing <type> after list') + v9.CheckScriptFailure(['def Func4(...)', 'echo "a"', 'enddef'], 'E1055: Missing name after ...') + v9.CheckScriptFailure(['def Func5(items:string)', 'echo "a"'], 'E1069:') + v9.CheckScriptFailure(['def Func5(items)', 'echo "a"'], 'E1077:') + v9.CheckScriptFailure(['def Func6(...x:list<number>)', 'echo "a"', 'enddef'], 'E1069:') + v9.CheckScriptFailure(['def Func7(...x: int)', 'echo "a"', 'enddef'], 'E1010:') +enddef + +def Test_white_space_before_comma() + var lines =<< trim END + vim9script + def Func(a: number , b: number) + enddef + END + v9.CheckScriptFailure(lines, 'E1068:') + call assert_fails('vim9cmd echo stridx("a" .. "b" , "a")', 'E1068:') +enddef + +def Test_white_space_after_comma() + var lines =<< trim END + vim9script + def Func(a: number,b: number) + enddef + END + v9.CheckScriptFailure(lines, 'E1069:') + + # OK in legacy function + lines =<< trim END + vim9script + func Func(a,b) + endfunc + END + v9.CheckScriptSuccess(lines) +enddef + +def Test_vim9script_call() + var lines =<< trim END + vim9script + var name = '' + def MyFunc(arg: string) + name = arg + enddef + MyFunc('foobar') + name->assert_equal('foobar') + + var str = 'barfoo' + str->MyFunc() + name->assert_equal('barfoo') + + g:value = 'value' + g:value->MyFunc() + name->assert_equal('value') + + var listvar = [] + def ListFunc(arg: list<number>) + listvar = arg + enddef + [1, 2, 3]->ListFunc() + listvar->assert_equal([1, 2, 3]) + + var dictvar = {} + def DictFunc(arg: dict<number>) + dictvar = arg + enddef + {a: 1, b: 2}->DictFunc() + dictvar->assert_equal({a: 1, b: 2}) + def CompiledDict() + {a: 3, b: 4}->DictFunc() + enddef + CompiledDict() + dictvar->assert_equal({a: 3, b: 4}) + + {a: 3, b: 4}->DictFunc() + dictvar->assert_equal({a: 3, b: 4}) + + ('text')->MyFunc() + name->assert_equal('text') + ("some")->MyFunc() + name->assert_equal('some') + + # line starting with single quote is not a mark + # line starting with double quote can be a method call + 'asdfasdf'->MyFunc() + name->assert_equal('asdfasdf') + "xyz"->MyFunc() + name->assert_equal('xyz') + + def UseString() + 'xyork'->MyFunc() + enddef + UseString() + name->assert_equal('xyork') + + def UseString2() + "knife"->MyFunc() + enddef + UseString2() + name->assert_equal('knife') + + # prepending a colon makes it a mark + new + setline(1, ['aaa', 'bbb', 'ccc']) + normal! 3Gmt1G + :'t + getcurpos()[1]->assert_equal(3) + bwipe! + + MyFunc( + 'continued' + ) + assert_equal('continued', + name + ) + + call MyFunc( + 'more' + .. + 'lines' + ) + assert_equal( + 'morelines', + name) + END + writefile(lines, 'Xcall.vim', 'D') + source Xcall.vim +enddef + +def Test_vim9script_call_fail_decl() + var lines =<< trim END + vim9script + var name = '' + def MyFunc(arg: string) + var name = 123 + enddef + defcompile + END + v9.CheckScriptFailure(lines, 'E1054:') +enddef + +def Test_vim9script_call_fail_type() + var lines =<< trim END + vim9script + def MyFunc(arg: string) + echo arg + enddef + MyFunc(1234) + END + v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected string but got number') +enddef + +def Test_vim9script_call_fail_const() + var lines =<< trim END + vim9script + const var = '' + def MyFunc(arg: string) + var = 'asdf' + enddef + defcompile + END + writefile(lines, 'Xcall_const.vim', 'D') + assert_fails('source Xcall_const.vim', 'E46:', '', 1, 'MyFunc') + + lines =<< trim END + const g:Aconst = 77 + def Change() + # comment + g:Aconst = 99 + enddef + call Change() + unlet g:Aconst + END + v9.CheckScriptFailure(lines, 'E741: Value is locked: Aconst', 2) +enddef + +" Test that inside :function a Python function can be defined, :def is not +" recognized. +func Test_function_python() + CheckFeature python3 + let py = 'python3' + execute py "<< EOF" +def do_something(): + return 1 +EOF +endfunc + +def Test_delfunc() + var lines =<< trim END + vim9script + def g:GoneSoon() + echo 'hello' + enddef + + def CallGoneSoon() + g:GoneSoon() + enddef + defcompile + + delfunc g:GoneSoon + CallGoneSoon() + END + writefile(lines, 'XToDelFunc', 'D') + assert_fails('so XToDelFunc', 'E933:', '', 1, 'CallGoneSoon') + assert_fails('so XToDelFunc', 'E933:', '', 1, 'CallGoneSoon') +enddef + +func Test_free_dict_while_in_funcstack() + " relies on the sleep command + CheckUnix + call Run_Test_free_dict_while_in_funcstack() +endfunc + +def Run_Test_free_dict_while_in_funcstack() + # this was freeing the TermRun() default argument dictionary while it was + # still referenced in a funcstack_T + var lines =<< trim END + vim9script + + &updatetime = 400 + def TermRun(_ = {}) + def Post() + enddef + def Exec() + term_start('sleep 1', { + term_finish: 'close', + exit_cb: (_, _) => Post(), + }) + enddef + Exec() + enddef + nnoremap <F4> <Cmd>call <SID>TermRun()<CR> + timer_start(100, (_) => feedkeys("\<F4>")) + timer_start(1000, (_) => feedkeys("\<F4>")) + sleep 1500m + END + v9.CheckScriptSuccess(lines) + nunmap <F4> + set updatetime& +enddef + +def Test_redef_failure() + writefile(['def Func0(): string', 'return "Func0"', 'enddef'], 'Xdef') + so Xdef + writefile(['def Func1(): string', 'return "Func1"', 'enddef'], 'Xdef') + so Xdef + writefile(['def! Func0(): string', 'enddef', 'defcompile'], 'Xdef') + assert_fails('so Xdef', 'E1027:', '', 1, 'Func0') + writefile(['def Func2(): string', 'return "Func2"', 'enddef'], 'Xdef') + so Xdef + delete('Xdef') + + assert_fails('g:Func0()', 'E1091:') + g:Func1()->assert_equal('Func1') + g:Func2()->assert_equal('Func2') + + delfunc! Func0 + delfunc! Func1 + delfunc! Func2 +enddef + +def Test_vim9script_func() + var lines =<< trim END + vim9script + func Func(arg) + echo a:arg + endfunc + Func('text') + END + writefile(lines, 'XVim9Func', 'D') + so XVim9Func +enddef + +let s:funcResult = 0 + +def FuncNoArgNoRet() + s:funcResult = 11 +enddef + +def FuncNoArgRetNumber(): number + s:funcResult = 22 + return 1234 +enddef + +def FuncNoArgRetString(): string + s:funcResult = 45 + return 'text' +enddef + +def FuncOneArgNoRet(arg: number) + s:funcResult = arg +enddef + +def FuncOneArgRetNumber(arg: number): number + s:funcResult = arg + return arg +enddef + +def FuncTwoArgNoRet(one: bool, two: number) + s:funcResult = two +enddef + +def s:FuncOneArgRetString(arg: string): string + return arg +enddef + +def s:FuncOneArgRetAny(arg: any): any + return arg +enddef + +def Test_func_type() + var Ref1: func() + s:funcResult = 0 + Ref1 = g:FuncNoArgNoRet + Ref1() + s:funcResult->assert_equal(11) + + var Ref2: func + s:funcResult = 0 + Ref2 = g:FuncNoArgNoRet + Ref2() + s:funcResult->assert_equal(11) + + s:funcResult = 0 + Ref2 = g:FuncOneArgNoRet + Ref2(12) + s:funcResult->assert_equal(12) + + s:funcResult = 0 + Ref2 = g:FuncNoArgRetNumber + Ref2()->assert_equal(1234) + s:funcResult->assert_equal(22) + + s:funcResult = 0 + Ref2 = g:FuncOneArgRetNumber + Ref2(13)->assert_equal(13) + s:funcResult->assert_equal(13) +enddef + +def Test_repeat_return_type() + var res = 0 + for n in repeat([1], 3) + res += n + endfor + res->assert_equal(3) + + res = 0 + for n in repeat(0z01, 3)->blob2list() + res += n + endfor + res->assert_equal(3) + + res = 0 + for n in add([1, 2], 3) + res += n + endfor + res->assert_equal(6) +enddef + +def Test_argv_return_type() + next fileone filetwo + var res = '' + for name in argv() + res ..= name + endfor + res->assert_equal('fileonefiletwo') +enddef + +def Test_func_type_part() + var RefVoid: func: void + RefVoid = g:FuncNoArgNoRet + RefVoid = g:FuncOneArgNoRet + v9.CheckDefFailure(['var RefVoid: func: void', 'RefVoid = g:FuncNoArgRetNumber'], 'E1012: Type mismatch; expected func(...) but got func(): number') + v9.CheckDefFailure(['var RefVoid: func: void', 'RefVoid = g:FuncNoArgRetString'], 'E1012: Type mismatch; expected func(...) but got func(): string') + + var RefAny: func(): any + RefAny = g:FuncNoArgRetNumber + RefAny = g:FuncNoArgRetString + v9.CheckDefFailure(['var RefAny: func(): any', 'RefAny = g:FuncNoArgNoRet'], 'E1012: Type mismatch; expected func(): any but got func()') + v9.CheckDefFailure(['var RefAny: func(): any', 'RefAny = g:FuncOneArgNoRet'], 'E1012: Type mismatch; expected func(): any but got func(number)') + + var RefAnyNoArgs: func: any = RefAny + + var RefNr: func: number + RefNr = g:FuncNoArgRetNumber + RefNr = g:FuncOneArgRetNumber + v9.CheckDefFailure(['var RefNr: func: number', 'RefNr = g:FuncNoArgNoRet'], 'E1012: Type mismatch; expected func(...): number but got func()') + v9.CheckDefFailure(['var RefNr: func: number', 'RefNr = g:FuncNoArgRetString'], 'E1012: Type mismatch; expected func(...): number but got func(): string') + + var RefStr: func: string + RefStr = g:FuncNoArgRetString + RefStr = FuncOneArgRetString + v9.CheckDefFailure(['var RefStr: func: string', 'RefStr = g:FuncNoArgNoRet'], 'E1012: Type mismatch; expected func(...): string but got func()') + v9.CheckDefFailure(['var RefStr: func: string', 'RefStr = g:FuncNoArgRetNumber'], 'E1012: Type mismatch; expected func(...): string but got func(): number') +enddef + +def Test_func_type_fails() + v9.CheckDefFailure(['var ref1: func()'], 'E704:') + + v9.CheckDefFailure(['var Ref1: func()', 'Ref1 = g:FuncNoArgRetNumber'], 'E1012: Type mismatch; expected func() but got func(): number') + v9.CheckDefFailure(['var Ref1: func()', 'Ref1 = g:FuncOneArgNoRet'], 'E1012: Type mismatch; expected func() but got func(number)') + v9.CheckDefFailure(['var Ref1: func()', 'Ref1 = g:FuncOneArgRetNumber'], 'E1012: Type mismatch; expected func() but got func(number): number') + v9.CheckDefFailure(['var Ref1: func(bool)', 'Ref1 = g:FuncTwoArgNoRet'], 'E1012: Type mismatch; expected func(bool) but got func(bool, number)') + v9.CheckDefFailure(['var Ref1: func(?bool)', 'Ref1 = g:FuncTwoArgNoRet'], 'E1012: Type mismatch; expected func(?bool) but got func(bool, number)') + v9.CheckDefFailure(['var Ref1: func(...bool)', 'Ref1 = g:FuncTwoArgNoRet'], 'E1012: Type mismatch; expected func(...bool) but got func(bool, number)') + + v9.CheckDefFailure(['var RefWrong: func(string ,number)'], 'E1068:') + v9.CheckDefFailure(['var RefWrong: func(string,number)'], 'E1069:') + v9.CheckDefFailure(['var RefWrong: func(bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool)'], 'E1005:') + v9.CheckDefFailure(['var RefWrong: func(bool):string'], 'E1069:') +enddef + +def Test_func_return_type() + var nr: number + nr = g:FuncNoArgRetNumber() + nr->assert_equal(1234) + + nr = FuncOneArgRetAny(122) + nr->assert_equal(122) + + var str: string + str = FuncOneArgRetAny('yes') + str->assert_equal('yes') + + v9.CheckDefFailure(['var str: string', 'str = g:FuncNoArgRetNumber()'], 'E1012: Type mismatch; expected string but got number') +enddef + +def Test_func_common_type() + def FuncOne(n: number): number + return n + enddef + def FuncTwo(s: string): number + return len(s) + enddef + def FuncThree(n: number, s: string): number + return n + len(s) + enddef + var list = [FuncOne, FuncTwo, FuncThree] + assert_equal(8, list[0](8)) + assert_equal(4, list[1]('word')) + assert_equal(7, list[2](3, 'word')) +enddef + +def s:MultiLine( + arg1: string, + arg2 = 1234, + ...rest: list<string> + ): string + return arg1 .. arg2 .. join(rest, '-') +enddef + +def MultiLineComment( + arg1: string, # comment + arg2 = 1234, # comment + ...rest: list<string> # comment + ): string # comment + return arg1 .. arg2 .. join(rest, '-') +enddef + +def Test_multiline() + MultiLine('text')->assert_equal('text1234') + MultiLine('text', 777)->assert_equal('text777') + MultiLine('text', 777, 'one')->assert_equal('text777one') + MultiLine('text', 777, 'one', 'two')->assert_equal('text777one-two') +enddef + +func Test_multiline_not_vim9() + call s:MultiLine('text')->assert_equal('text1234') + call s:MultiLine('text', 777)->assert_equal('text777') + call s:MultiLine('text', 777, 'one')->assert_equal('text777one') + call s:MultiLine('text', 777, 'one', 'two')->assert_equal('text777one-two') +endfunc + + +" When using CheckScriptFailure() for the below test, E1010 is generated instead +" of E1056. +func Test_E1056_1059() + let caught_1056 = 0 + try + def F(): + return 1 + enddef + catch /E1056:/ + let caught_1056 = 1 + endtry + eval caught_1056->assert_equal(1) + + let caught_1059 = 0 + try + def F5(items : list) + echo 'a' + enddef + catch /E1059:/ + let caught_1059 = 1 + endtry + eval caught_1059->assert_equal(1) +endfunc + +func DelMe() + echo 'DelMe' +endfunc + +def Test_error_reporting() + # comment lines at the start of the function + var lines =<< trim END + " comment + def Func() + # comment + # comment + invalid + enddef + defcompile + END + writefile(lines, 'Xdef', 'D') + try + source Xdef + assert_report('should have failed') + catch /E476:/ + v:exception->assert_match('Invalid command: invalid') + v:throwpoint->assert_match(', line 3$') + endtry + delfunc! g:Func + + # comment lines after the start of the function + lines =<< trim END + " comment + def Func() + var x = 1234 + # comment + # comment + invalid + enddef + defcompile + END + writefile(lines, 'Xdef') + try + source Xdef + assert_report('should have failed') + catch /E476:/ + v:exception->assert_match('Invalid command: invalid') + v:throwpoint->assert_match(', line 4$') + endtry + delfunc! g:Func + + lines =<< trim END + vim9script + def Func() + var db = {foo: 1, bar: 2} + # comment + var x = db.asdf + enddef + defcompile + Func() + END + writefile(lines, 'Xdef') + try + source Xdef + assert_report('should have failed') + catch /E716:/ + v:throwpoint->assert_match('_Func, line 3$') + endtry + delfunc! g:Func +enddef + +def Test_deleted_function() + v9.CheckDefExecFailure([ + 'var RefMe: func = function("g:DelMe")', + 'delfunc g:DelMe', + 'echo RefMe()'], 'E117:') +enddef + +def Test_unknown_function() + v9.CheckDefExecFailure([ + 'var Ref: func = function("NotExist")', + 'delfunc g:NotExist'], 'E700:') +enddef + +def s:RefFunc(Ref: func(any): any): string + return Ref('more') +enddef + +def Test_closure_simple() + var local = 'some ' + RefFunc((s) => local .. s)->assert_equal('some more') +enddef + +def s:MakeRef() + var local = 'some ' + g:Ref = (s) => local .. s +enddef + +def Test_closure_ref_after_return() + MakeRef() + g:Ref('thing')->assert_equal('some thing') + unlet g:Ref +enddef + +def s:MakeTwoRefs() + var local = ['some'] + g:Extend = (s) => local->add(s) + g:Read = () => local +enddef + +def Test_closure_two_refs() + MakeTwoRefs() + join(g:Read(), ' ')->assert_equal('some') + g:Extend('more') + join(g:Read(), ' ')->assert_equal('some more') + g:Extend('even') + join(g:Read(), ' ')->assert_equal('some more even') + + unlet g:Extend + unlet g:Read +enddef + +def s:ReadRef(Ref: func(): list<string>): string + return join(Ref(), ' ') +enddef + +def s:ExtendRef(Ref: func(string): list<string>, add: string) + Ref(add) +enddef + +def Test_closure_two_indirect_refs() + MakeTwoRefs() + ReadRef(g:Read)->assert_equal('some') + ExtendRef(g:Extend, 'more') + ReadRef(g:Read)->assert_equal('some more') + ExtendRef(g:Extend, 'even') + ReadRef(g:Read)->assert_equal('some more even') + + unlet g:Extend + unlet g:Read +enddef + +def s:MakeArgRefs(theArg: string) + var local = 'loc_val' + g:UseArg = (s) => theArg .. '/' .. local .. '/' .. s +enddef + +def s:MakeArgRefsVarargs(theArg: string, ...rest: list<string>) + var local = 'the_loc' + g:UseVararg = (s) => theArg .. '/' .. local .. '/' .. s .. '/' .. join(rest) +enddef + +def Test_closure_using_argument() + MakeArgRefs('arg_val') + g:UseArg('call_val')->assert_equal('arg_val/loc_val/call_val') + + MakeArgRefsVarargs('arg_val', 'one', 'two') + g:UseVararg('call_val')->assert_equal('arg_val/the_loc/call_val/one two') + + unlet g:UseArg + unlet g:UseVararg + + var lines =<< trim END + vim9script + def Test(Fun: func(number): number): list<number> + return map([1, 2, 3], (_, i) => Fun(i)) + enddef + def Inc(nr: number): number + return nr + 2 + enddef + assert_equal([3, 4, 5], Test(Inc)) + END + v9.CheckScriptSuccess(lines) +enddef + +def s:MakeGetAndAppendRefs() + var local = 'a' + + def Append(arg: string) + local ..= arg + enddef + g:Append = Append + + def Get(): string + return local + enddef + g:Get = Get +enddef + +def Test_closure_append_get() + MakeGetAndAppendRefs() + g:Get()->assert_equal('a') + g:Append('-b') + g:Get()->assert_equal('a-b') + g:Append('-c') + g:Get()->assert_equal('a-b-c') + + unlet g:Append + unlet g:Get +enddef + +def Test_nested_closure() + var local = 'text' + def Closure(arg: string): string + return local .. arg + enddef + Closure('!!!')->assert_equal('text!!!') +enddef + +func s:GetResult(Ref) + return a:Ref('some') +endfunc + +def Test_call_closure_not_compiled() + var text = 'text' + g:Ref = (s) => s .. text + GetResult(g:Ref)->assert_equal('sometext') +enddef + +def Test_double_closure_fails() + var lines =<< trim END + vim9script + def Func() + var name = 0 + for i in range(2) + timer_start(0, () => name) + endfor + enddef + Func() + END + v9.CheckScriptSuccess(lines) +enddef + +def Test_nested_closure_used() + var lines =<< trim END + vim9script + def Func() + var x = 'hello' + var Closure = () => x + g:Myclosure = () => Closure() + enddef + Func() + assert_equal('hello', g:Myclosure()) + END + v9.CheckScriptSuccess(lines) +enddef + +def Test_nested_closure_fails() + var lines =<< trim END + vim9script + def FuncA() + FuncB(0) + enddef + def FuncB(n: number): list<string> + return map([0], (_, v) => n) + enddef + FuncA() + END + v9.CheckScriptFailure(lines, 'E1012:') +enddef + +def Run_Test_closure_in_for_loop_fails() + var lines =<< trim END + vim9script + redraw + for n in [0] + # time should be enough for startup to finish + timer_start(200, (_) => { + echo n + }) + endfor + END + writefile(lines, 'XTest_closure_fails', 'D') + + # Check that an error shows + var buf = g:RunVimInTerminal('-S XTest_closure_fails', {rows: 6, wait_for_ruler: 0}) + g:VerifyScreenDump(buf, 'Test_vim9_closure_fails', {wait: 3000}) + + # clean up + g:StopVimInTerminal(buf) +enddef + +func Test_closure_in_for_loop_fails() + CheckScreendump + call Run_Test_closure_in_for_loop_fails() +endfunc + +def Test_global_closure() + var lines =<< trim END + vim9script + def ReverseEveryNLines(n: number, line1: number, line2: number) + var mods = 'sil keepj keepp lockm ' + var range = ':' .. line1 .. ',' .. line2 + def g:Offset(): number + var offset = (line('.') - line1 + 1) % n + return offset != 0 ? offset : n + enddef + exe mods .. range .. 'g/^/exe "m .-" .. g:Offset()' + enddef + + new + repeat(['aaa', 'bbb', 'ccc'], 3)->setline(1) + ReverseEveryNLines(3, 1, 9) + END + v9.CheckScriptSuccess(lines) + var expected = repeat(['ccc', 'bbb', 'aaa'], 3) + assert_equal(expected, getline(1, 9)) + bwipe! +enddef + +def Test_global_closure_called_directly() + var lines =<< trim END + vim9script + def Outer() + var x = 1 + def g:Inner() + var y = x + x += 1 + assert_equal(1, y) + enddef + g:Inner() + assert_equal(2, x) + enddef + Outer() + END + v9.CheckScriptSuccess(lines) + delfunc g:Inner +enddef + +def Test_closure_called_from_legacy() + var lines =<< trim END + vim9script + def Func() + var outer = 'foo' + var F = () => { + outer = 'bar' + } + execute printf('call %s()', string(F)) + enddef + Func() + END + v9.CheckScriptFailure(lines, 'E1248') +enddef + +def Test_failure_in_called_function() + # this was using the frame index as the return value + var lines =<< trim END + vim9script + au TerminalWinOpen * eval [][0] + def PopupTerm(a: any) + # make sure typvals on stack are string + ['a', 'b', 'c', 'd', 'e', 'f', 'g']->join() + FireEvent() + enddef + def FireEvent() + do TerminalWinOpen + enddef + # use try/catch to make eval fail + try + call PopupTerm(0) + catch + endtry + au! TerminalWinOpen + END + v9.CheckScriptSuccess(lines) +enddef + +def Test_nested_lambda() + var lines =<< trim END + vim9script + def Func() + var x = 4 + var Lambda1 = () => 7 + var Lambda2 = () => [Lambda1(), x] + var res = Lambda2() + assert_equal([7, 4], res) + enddef + Func() + END + v9.CheckScriptSuccess(lines) +enddef + +def Test_double_nested_lambda() + var lines =<< trim END + vim9script + def F(head: string): func(string): func(string): string + return (sep: string): func(string): string => ((tail: string): string => { + return head .. sep .. tail + }) + enddef + assert_equal('hello-there', F('hello')('-')('there')) + END + v9.CheckScriptSuccess(lines) +enddef + +def Test_nested_inline_lambda() + var lines =<< trim END + vim9script + def F(text: string): func(string): func(string): string + return (arg: string): func(string): string => ((sep: string): string => { + return sep .. arg .. text + }) + enddef + assert_equal('--there++', F('++')('there')('--')) + END + v9.CheckScriptSuccess(lines) + + lines =<< trim END + vim9script + echo range(4)->mapnew((_, v) => { + return range(v) ->mapnew((_, s) => { + return string(s) + }) + }) + END + v9.CheckScriptSuccess(lines) + + lines =<< trim END + vim9script + + def Func() + range(10) + ->mapnew((_, _) => ({ + key: range(10)->mapnew((_, _) => { + return ' ' + }), + })) + enddef + + defcomp + END + v9.CheckScriptSuccess(lines) +enddef + +def Shadowed(): list<number> + var FuncList: list<func: number> = [() => 42] + return FuncList->mapnew((_, Shadowed) => Shadowed()) +enddef + +def Test_lambda_arg_shadows_func() + assert_equal([42], g:Shadowed()) +enddef + +def Test_compiling_referenced_func_no_shadow() + var lines =<< trim END + vim9script + + def InitializeReply(lspserver: dict<any>) + enddef + + def ProcessReply(lspserver: dict<any>) + var lsp_reply_handlers: dict<func> = + { 'initialize': InitializeReply } + lsp_reply_handlers['initialize'](lspserver) + enddef + + call ProcessReply({}) + END + v9.CheckScriptSuccess(lines) +enddef + +def s:Line_continuation_in_def(dir: string = ''): string + var path: string = empty(dir) + \ ? 'empty' + \ : 'full' + return path +enddef + +def Test_line_continuation_in_def() + Line_continuation_in_def('.')->assert_equal('full') +enddef + +def Test_script_var_in_lambda() + var lines =<< trim END + vim9script + var script = 'test' + assert_equal(['test'], map(['one'], (_, _) => script)) + END + v9.CheckScriptSuccess(lines) +enddef + +def s:Line_continuation_in_lambda(): list<string> + var x = range(97, 100) + ->mapnew((_, v) => nr2char(v) + ->toupper()) + ->reverse() + return x +enddef + +def Test_line_continuation_in_lambda() + Line_continuation_in_lambda()->assert_equal(['D', 'C', 'B', 'A']) + + var lines =<< trim END + vim9script + var res = [{n: 1, m: 2, s: 'xxx'}] + ->mapnew((_, v: dict<any>): string => printf('%d:%d:%s', + v.n, + v.m, + substitute(v.s, '.*', 'yyy', '') + )) + assert_equal(['1:2:yyy'], res) + END + v9.CheckScriptSuccess(lines) +enddef + +def Test_list_lambda() + timer_start(1000, (_) => 0) + var body = execute(timer_info()[0].callback + ->string() + ->substitute("('", ' ', '') + ->substitute("')", '', '') + ->substitute('function\zs', ' ', '')) + assert_match('def <lambda>\d\+(_: any): number\n1 return 0\n enddef', body) +enddef + +def Test_lambda_block_variable() + var lines =<< trim END + vim9script + var flist: list<func> + for i in range(10) + var inloop = i + flist[i] = () => inloop + endfor + END + v9.CheckScriptSuccess(lines) + + lines =<< trim END + vim9script + if true + var outloop = 5 + var flist: list<func> + for i in range(10) + flist[i] = () => outloop + endfor + endif + END + v9.CheckScriptSuccess(lines) + + lines =<< trim END + vim9script + if true + var outloop = 5 + endif + var flist: list<func> + for i in range(10) + flist[i] = () => outloop + endfor + END + v9.CheckScriptFailure(lines, 'E1001: Variable not found: outloop', 1) + + lines =<< trim END + vim9script + for i in range(10) + var Ref = () => 0 + endfor + assert_equal(0, ((i) => 0)(0)) + END + v9.CheckScriptSuccess(lines) +enddef + +def Test_legacy_lambda() + legacy echo {x -> 'hello ' .. x}('foo') + + var lines =<< trim END + echo {x -> 'hello ' .. x}('foo') + END + v9.CheckDefAndScriptFailure(lines, 'E720:') + + lines =<< trim END + vim9script + def Func() + echo (() => 'no error')() + enddef + legacy call s:Func() + END + v9.CheckScriptSuccess(lines) +enddef + +def Test_legacy() + var lines =<< trim END + vim9script + func g:LegacyFunction() + let g:legacyvar = 1 + endfunc + def Testit() + legacy call g:LegacyFunction() + enddef + Testit() + assert_equal(1, g:legacyvar) + unlet g:legacyvar + delfunc g:LegacyFunction + END + v9.CheckScriptSuccess(lines) +enddef + +def Test_legacy_errors() + for cmd in ['if', 'elseif', 'else', 'endif', + 'for', 'endfor', 'continue', 'break', + 'while', 'endwhile', + 'try', 'catch', 'finally', 'endtry'] + v9.CheckDefFailure(['legacy ' .. cmd .. ' expr'], 'E1189:') + endfor +enddef + +def Test_call_legacy_with_dict() + var lines =<< trim END + vim9script + func Legacy() dict + let g:result = self.value + endfunc + def TestDirect() + var d = {value: 'yes', func: Legacy} + d.func() + enddef + TestDirect() + assert_equal('yes', g:result) + unlet g:result + + def TestIndirect() + var d = {value: 'foo', func: Legacy} + var Fi = d.func + Fi() + enddef + TestIndirect() + assert_equal('foo', g:result) + unlet g:result + + var d = {value: 'bar', func: Legacy} + d.func() + assert_equal('bar', g:result) + unlet g:result + END + v9.CheckScriptSuccess(lines) +enddef + +def s:DoFilterThis(a: string): list<string> + # closure nested inside another closure using argument + var Filter = (l) => filter(l, (_, v) => stridx(v, a) == 0) + return ['x', 'y', 'a', 'x2', 'c']->Filter() +enddef + +def Test_nested_closure_using_argument() + assert_equal(['x', 'x2'], DoFilterThis('x')) +enddef + +def Test_triple_nested_closure() + var what = 'x' + var Match = (val: string, cmp: string): bool => stridx(val, cmp) == 0 + var Filter = (l) => filter(l, (_, v) => Match(v, what)) + assert_equal(['x', 'x2'], ['x', 'y', 'a', 'x2', 'c']->Filter()) +enddef + +func Test_silent_echo() + CheckScreendump + call Run_Test_silent_echo() +endfunc + +def Run_Test_silent_echo() + var lines =<< trim END + vim9script + def EchoNothing() + silent echo '' + enddef + defcompile + END + writefile(lines, 'XTest_silent_echo', 'D') + + # Check that the balloon shows up after a mouse move + var buf = g:RunVimInTerminal('-S XTest_silent_echo', {'rows': 6}) + term_sendkeys(buf, ":abc") + g:VerifyScreenDump(buf, 'Test_vim9_silent_echo', {}) + + # clean up + g:StopVimInTerminal(buf) +enddef + +def SilentlyError() + execute('silent! invalid') + g:did_it = 'yes' +enddef + +func s:UserError() + silent! invalid +endfunc + +def SilentlyUserError() + UserError() + g:did_it = 'yes' +enddef + +" This can't be a :def function, because the assert would not be reached. +func Test_ignore_silent_error() + let g:did_it = 'no' + call SilentlyError() + call assert_equal('yes', g:did_it) + + let g:did_it = 'no' + call SilentlyUserError() + call assert_equal('yes', g:did_it) + + unlet g:did_it +endfunc + +def Test_ignore_silent_error_in_filter() + var lines =<< trim END + vim9script + def Filter(winid: number, key: string): bool + if key == 'o' + silent! eval [][0] + return true + endif + return popup_filter_menu(winid, key) + enddef + + popup_create('popup', {filter: Filter}) + feedkeys("o\r", 'xnt') + END + v9.CheckScriptSuccess(lines) +enddef + +def s:Fibonacci(n: number): number + if n < 2 + return n + else + return Fibonacci(n - 1) + Fibonacci(n - 2) + endif +enddef + +def Test_recursive_call() + Fibonacci(20)->assert_equal(6765) +enddef + +def s:TreeWalk(dir: string): list<any> + return readdir(dir)->mapnew((_, val) => + fnamemodify(dir .. '/' .. val, ':p')->isdirectory() + ? {[val]: TreeWalk(dir .. '/' .. val)} + : val + ) +enddef + +def Test_closure_in_map() + mkdir('XclosureDir/tdir', 'pR') + writefile(['111'], 'XclosureDir/file1') + writefile(['222'], 'XclosureDir/file2') + writefile(['333'], 'XclosureDir/tdir/file3') + + TreeWalk('XclosureDir')->assert_equal(['file1', 'file2', {tdir: ['file3']}]) +enddef + +def Test_invalid_function_name() + var lines =<< trim END + vim9script + def s: list<string> + END + v9.CheckScriptFailure(lines, 'E1268:') + + lines =<< trim END + vim9script + def g: list<string> + END + v9.CheckScriptFailure(lines, 'E129:') + + lines =<< trim END + vim9script + def <SID>: list<string> + END + v9.CheckScriptFailure(lines, 'E884:') + + lines =<< trim END + vim9script + def F list<string> + END + v9.CheckScriptFailure(lines, 'E488:') +enddef + +def Test_partial_call() + var lines =<< trim END + var Xsetlist: func + Xsetlist = function('setloclist', [0]) + Xsetlist([], ' ', {title: 'test'}) + getloclist(0, {title: 1})->assert_equal({title: 'test'}) + + Xsetlist = function('setloclist', [0, [], ' ']) + Xsetlist({title: 'test'}) + getloclist(0, {title: 1})->assert_equal({title: 'test'}) + + Xsetlist = function('setqflist') + Xsetlist([], ' ', {title: 'test'}) + getqflist({title: 1})->assert_equal({title: 'test'}) + + Xsetlist = function('setqflist', [[], ' ']) + Xsetlist({title: 'test'}) + getqflist({title: 1})->assert_equal({title: 'test'}) + + var Len: func: number = function('len', ['word']) + assert_equal(4, Len()) + + var RepeatFunc = function('repeat', ['o']) + assert_equal('ooooo', RepeatFunc(5)) + END + v9.CheckDefAndScriptSuccess(lines) + + lines =<< trim END + vim9script + def Foo(Parser: any) + enddef + var Expr: func(dict<any>): dict<any> + const Call = Foo(Expr) + END + v9.CheckScriptFailure(lines, 'E1031:') +enddef + +def Test_partial_double_nested() + var idx = 123 + var Get = () => idx + var Ref = function(Get, []) + var RefRef = function(Ref, []) + assert_equal(123, RefRef()) +enddef + +def Test_partial_null_function() + var lines =<< trim END + var d: dict<func> = {f: null_function} + var Ref = d.f + assert_equal('func(...): unknown', typename(Ref)) + END + v9.CheckDefAndScriptSuccess(lines) +enddef + +def Test_cmd_modifier() + tab echo '0' + v9.CheckDefFailure(['5tab echo 3'], 'E16:') +enddef + +def Test_restore_modifiers() + # check that when compiling a :def function command modifiers are not messed + # up. + var lines =<< trim END + vim9script + set eventignore= + autocmd QuickFixCmdPost * copen + def AutocmdsDisabled() + eval 1 + 2 + enddef + func Func() + noautocmd call s:AutocmdsDisabled() + let g:ei_after = &eventignore + endfunc + Func() + END + v9.CheckScriptSuccess(lines) + g:ei_after->assert_equal('') +enddef + +def StackTop() + eval 1 + 2 + eval 2 + 3 + # call not on fourth line + g:StackBot() +enddef + +def StackBot() + # throw an error + eval [][0] +enddef + +def Test_callstack_def() + try + g:StackTop() + catch + v:throwpoint->assert_match('Test_callstack_def\[2\]..StackTop\[4\]..StackBot, line 2') + endtry +enddef + +" Re-using spot for variable used in block +def Test_block_scoped_var() + var lines =<< trim END + vim9script + def Func() + var x = ['a', 'b', 'c'] + if 1 + var y = 'x' + map(x, (_, _) => y) + endif + var z = x + assert_equal(['x', 'x', 'x'], z) + enddef + Func() + END + v9.CheckScriptSuccess(lines) +enddef + +def Test_reset_did_emsg() + var lines =<< trim END + @s = 'blah' + au BufWinLeave * # + def Func() + var winid = popup_create('popup', {}) + exe '*s' + popup_close(winid) + enddef + Func() + END + v9.CheckScriptFailure(lines, 'E492:', 8) + delfunc! g:Func +enddef + +def Test_did_emsg_reset() + # executing an autocommand resets did_emsg, this should not result in a + # builtin function considered failing + var lines =<< trim END + vim9script + au BufWinLeave * # + def Func() + popup_menu('', {callback: (a, b) => popup_create('', {})->popup_close()}) + eval [][0] + enddef + nno <F3> <cmd>call <sid>Func()<cr> + feedkeys("\<F3>\e", 'xt') + END + writefile(lines, 'XemsgReset', 'D') + assert_fails('so XemsgReset', ['E684:', 'E684:'], lines, 2) + + nunmap <F3> + au! BufWinLeave +enddef + +def Test_abort_with_silent_call() + var lines =<< trim END + vim9script + g:result = 'none' + def Func() + g:result += 3 + g:result = 'yes' + enddef + # error is silenced, but function aborts on error + silent! Func() + assert_equal('none', g:result) + unlet g:result + END + v9.CheckScriptSuccess(lines) +enddef + +def Test_continues_with_silent_error() + var lines =<< trim END + vim9script + g:result = 'none' + def Func() + silent! g:result += 3 + g:result = 'yes' + enddef + # error is silenced, function does not abort + Func() + assert_equal('yes', g:result) + unlet g:result + END + v9.CheckScriptSuccess(lines) +enddef + +def Test_abort_even_with_silent() + var lines =<< trim END + vim9script + g:result = 'none' + def Func() + eval {-> ''}() .. '' .. {}['X'] + g:result = 'yes' + enddef + silent! Func() + assert_equal('none', g:result) + unlet g:result + END + v9.CheckScriptSuccess(lines) +enddef + +def Test_cmdmod_silent_restored() + var lines =<< trim END + vim9script + def Func() + g:result = 'none' + silent! g:result += 3 + g:result = 'none' + g:result += 3 + enddef + Func() + END + # can't use CheckScriptFailure, it ignores the :silent! + var fname = 'Xdefsilent' + writefile(lines, fname, 'D') + var caught = 'no' + try + exe 'source ' .. fname + catch /E1030:/ + caught = 'yes' + assert_match('Func, line 4', v:throwpoint) + endtry + assert_equal('yes', caught) +enddef + +def Test_cmdmod_silent_nested() + var lines =<< trim END + vim9script + var result = '' + + def Error() + result ..= 'Eb' + eval [][0] + result ..= 'Ea' + enddef + + def Crash() + result ..= 'Cb' + sil! Error() + result ..= 'Ca' + enddef + + Crash() + assert_equal('CbEbEaCa', result) + END + v9.CheckScriptSuccess(lines) +enddef + +def Test_dict_member_with_silent() + var lines =<< trim END + vim9script + g:result = 'none' + var d: dict<any> + def Func() + try + g:result = map([], (_, v) => ({}[v]))->join() .. d[''] + catch + endtry + enddef + silent! Func() + assert_equal('0', g:result) + unlet g:result + END + v9.CheckScriptSuccess(lines) +enddef + +def Test_skip_cmds_with_silent() + var lines =<< trim END + vim9script + + def Func(b: bool) + Crash() + enddef + + def Crash() + sil! :/not found/d _ + sil! :/not found/put _ + enddef + + Func(true) + END + v9.CheckScriptSuccess(lines) +enddef + +def Test_opfunc() + nnoremap <F3> <cmd>set opfunc=g:Opfunc<cr>g@ + def g:Opfunc(_: any): string + setline(1, 'ASDF') + return '' + enddef + new + setline(1, 'asdf') + feedkeys("\<F3>$", 'x') + assert_equal('ASDF', getline(1)) + + bwipe! + nunmap <F3> +enddef + +func Test_opfunc_error() + CheckScreendump + call Run_Test_opfunc_error() +endfunc + +def Run_Test_opfunc_error() + # test that the error from Opfunc() is displayed right away + var lines =<< trim END + vim9script + + def Opfunc(type: string) + try + eval [][0] + catch /nothing/ # error not caught + endtry + enddef + &operatorfunc = Opfunc + nnoremap <expr> l <SID>L() + def L(): string + return 'l' + enddef + 'x'->repeat(10)->setline(1) + feedkeys('g@l', 'n') + feedkeys('llll') + END + call writefile(lines, 'XTest_opfunc_error', 'D') + + var buf = g:RunVimInTerminal('-S XTest_opfunc_error', {rows: 6, wait_for_ruler: 0}) + g:WaitForAssert(() => assert_match('Press ENTER', term_getline(buf, 6))) + g:WaitForAssert(() => assert_match('E684: List index out of range: 0', term_getline(buf, 5))) + + # clean up + g:StopVimInTerminal(buf) +enddef + +" this was crashing on exit +def Test_nested_lambda_in_closure() + var lines =<< trim END + vim9script + command WriteDone writefile(['Done'], 'XnestedDone') + def Outer() + def g:Inner() + echo map([1, 2, 3], {_, v -> v + 1}) + enddef + g:Inner() + enddef + defcompile + # not reached + END + if !g:RunVim([], lines, '--clean -c WriteDone -c quit') + return + endif + assert_equal(['Done'], readfile('XnestedDone')) + delete('XnestedDone') +enddef + +def Test_nested_closure_funcref() + var lines =<< trim END + vim9script + def Func() + var n: number + def Nested() + ++n + enddef + Nested() + g:result_one = n + var Ref = function(Nested) + Ref() + g:result_two = n + enddef + Func() + END + v9.CheckScriptSuccess(lines) + assert_equal(1, g:result_one) + assert_equal(2, g:result_two) + unlet g:result_one g:result_two +enddef + +def Test_nested_closure_in_dict() + var lines =<< trim END + vim9script + def Func(): dict<any> + var n: number + def Inc(): number + ++n + return n + enddef + return {inc: function(Inc)} + enddef + disas Func + var d = Func() + assert_equal(1, d.inc()) + assert_equal(2, d.inc()) + END + v9.CheckScriptSuccess(lines) +enddef + +def Test_script_local_other_script() + var lines =<< trim END + function LegacyJob() + let FuncRef = function('s:close_cb') + endfunction + function s:close_cb(...) + endfunction + END + lines->writefile('Xlegacy.vim', 'D') + source Xlegacy.vim + g:LegacyJob() + g:LegacyJob() + g:LegacyJob() + + delfunc g:LegacyJob +enddef + +def Test_check_func_arg_types() + var lines =<< trim END + vim9script + def F1(x: string): string + return x + enddef + + def F2(x: number): number + return x + 1 + enddef + + def G(Fg: func): dict<func> + return {f: Fg} + enddef + + def H(d: dict<func>): string + return d.f('a') + enddef + END + + v9.CheckScriptSuccess(lines + ['echo H(G(F1))']) + v9.CheckScriptFailure(lines + ['echo H(G(F2))'], 'E1013:') + + v9.CheckScriptFailure(lines + ['def SomeFunc(ff: func)', 'enddef'], 'E704:') +enddef + +def Test_call_func_with_null() + var lines =<< trim END + def Fstring(v: string) + assert_equal(null_string, v) + enddef + Fstring(null_string) + def Fblob(v: blob) + assert_equal(null_blob, v) + enddef + Fblob(null_blob) + def Flist(v: list<number>) + assert_equal(null_list, v) + enddef + Flist(null_list) + def Fdict(v: dict<number>) + assert_equal(null_dict, v) + enddef + Fdict(null_dict) + def Ffunc(Fv: func(number): number) + assert_equal(null_function, Fv) + enddef + Ffunc(null_function) + if has('channel') + def Fchannel(v: channel) + assert_equal(null_channel, v) + enddef + Fchannel(null_channel) + def Fjob(v: job) + assert_equal(null_job, v) + enddef + Fjob(null_job) + endif + END + v9.CheckDefAndScriptSuccess(lines) +enddef + +def Test_null_default_argument() + var lines =<< trim END + def Fstring(v: string = null_string) + assert_equal(null_string, v) + enddef + Fstring() + def Fblob(v: blob = null_blob) + assert_equal(null_blob, v) + enddef + Fblob() + def Flist(v: list<number> = null_list) + assert_equal(null_list, v) + enddef + Flist() + def Fdict(v: dict<number> = null_dict) + assert_equal(null_dict, v) + enddef + Fdict() + def Ffunc(Fv: func(number): number = null_function) + assert_equal(null_function, Fv) + enddef + Ffunc() + if has('channel') + def Fchannel(v: channel = null_channel) + assert_equal(null_channel, v) + enddef + Fchannel() + def Fjob(v: job = null_job) + assert_equal(null_job, v) + enddef + Fjob() + endif + END + v9.CheckDefAndScriptSuccess(lines) +enddef + +def Test_null_return() + var lines =<< trim END + def Fstring(): string + return null_string + enddef + assert_equal(null_string, Fstring()) + def Fblob(): blob + return null_blob + enddef + assert_equal(null_blob, Fblob()) + def Flist(): list<number> + return null_list + enddef + assert_equal(null_list, Flist()) + def Fdict(): dict<number> + return null_dict + enddef + assert_equal(null_dict, Fdict()) + def Ffunc(): func(number): number + return null_function + enddef + assert_equal(null_function, Ffunc()) + if has('channel') + def Fchannel(): channel + return null_channel + enddef + assert_equal(null_channel, Fchannel()) + def Fjob(): job + return null_job + enddef + assert_equal(null_job, Fjob()) + endif + END + v9.CheckDefAndScriptSuccess(lines) +enddef + +def Test_list_any_type_checked() + var lines =<< trim END + vim9script + def Foo() + --decl-- + Bar(l) + enddef + def Bar(ll: list<dict<any>>) + enddef + Foo() + END + # "any" could be "dict<any>", thus OK + lines[2] = 'var l: list<any>' + v9.CheckScriptSuccess(lines) + lines[2] = 'var l: list<any> = []' + v9.CheckScriptSuccess(lines) + + lines[2] = 'var l: list<any> = [11]' + v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected list<dict<any>> but got list<number>', 2) +enddef + +def Test_compile_error() + var lines =<< trim END + def g:Broken() + echo 'a' + {} + enddef + call g:Broken() + END + # First call: compilation error + v9.CheckScriptFailure(lines, 'E1051: Wrong argument type for +') + + # Second call won't try compiling again + assert_fails('call g:Broken()', 'E1091: Function is not compiled: Broken') + delfunc g:Broken + + # No error when compiling with :silent! + lines =<< trim END + def g:Broken() + echo 'a' + [] + enddef + silent! defcompile + END + v9.CheckScriptSuccess(lines) + + # Calling the function won't try compiling again + assert_fails('call g:Broken()', 'E1091: Function is not compiled: Broken') + delfunc g:Broken +enddef + +def Test_ignored_argument() + var lines =<< trim END + vim9script + def Ignore(_, _): string + return 'yes' + enddef + assert_equal('yes', Ignore(1, 2)) + + func Ok(_) + return a:_ + endfunc + assert_equal('ok', Ok('ok')) + + func Oktoo() + let _ = 'too' + return _ + endfunc + assert_equal('too', Oktoo()) + + assert_equal([[1], [2], [3]], range(3)->mapnew((_, v) => [v]->map((_, w) => w + 1))) + END + v9.CheckScriptSuccess(lines) + + lines =<< trim END + def Ignore(_: string): string + return _ + enddef + defcompile + END + v9.CheckScriptFailure(lines, 'E1181:', 1) + + lines =<< trim END + var _ = 1 + END + v9.CheckDefAndScriptFailure(lines, 'E1181:', 1) + + lines =<< trim END + var x = _ + END + v9.CheckDefAndScriptFailure(lines, 'E1181:', 1) +enddef + +def Test_too_many_arguments() + var lines =<< trim END + echo [0, 1, 2]->map(() => 123) + END + v9.CheckDefAndScriptFailure(lines, ['E176:', 'E1106: 2 arguments too many'], 1) + + lines =<< trim END + echo [0, 1, 2]->map((_) => 123) + END + v9.CheckDefAndScriptFailure(lines, ['E176', 'E1106: One argument too many'], 1) + + lines =<< trim END + vim9script + def OneArgument(arg: string) + echo arg + enddef + var Ref = OneArgument + Ref('a', 'b') + END + v9.CheckScriptFailure(lines, 'E118:') +enddef + +def Test_funcref_with_base() + var lines =<< trim END + vim9script + def TwoArguments(str: string, nr: number) + echo str nr + enddef + var Ref = TwoArguments + Ref('a', 12) + 'b'->Ref(34) + END + v9.CheckScriptSuccess(lines) + + lines =<< trim END + vim9script + def TwoArguments(str: string, nr: number) + echo str nr + enddef + var Ref = TwoArguments + 'a'->Ref('b') + END + v9.CheckScriptFailure(lines, 'E1013: Argument 2: type mismatch, expected number but got string', 6) + + lines =<< trim END + vim9script + def TwoArguments(str: string, nr: number) + echo str nr + enddef + var Ref = TwoArguments + 123->Ref(456) + END + v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected string but got number') + + lines =<< trim END + vim9script + def TwoArguments(nr: number, str: string) + echo str nr + enddef + var Ref = TwoArguments + 123->Ref('b') + def AndNowCompiled() + 456->Ref('x') + enddef + AndNowCompiled() + END + v9.CheckScriptSuccess(lines) +enddef + +def Test_closing_brace_at_start_of_line() + var lines =<< trim END + def Func() + enddef + Func( + ) + END + v9.CheckDefAndScriptSuccess(lines) +enddef + +func s:CreateMydict() + let g:mydict = {} + func g:mydict.afunc() + let g:result = self.key + endfunc +endfunc + +def Test_numbered_function_reference() + CreateMydict() + var output = execute('legacy func g:mydict.afunc') + var funcName = 'g:' .. substitute(output, '.*function \(\d\+\).*', '\1', '') + execute 'function(' .. funcName .. ', [], {key: 42})()' + # check that the function still exists + assert_equal(output, execute('legacy func g:mydict.afunc')) + unlet g:mydict +enddef + +def Test_numbered_function_call() + var lines =<< trim END + let s:legacyscript = {} + func s:legacyscript.Helper() abort + return "Success" + endfunc + let g:legacyscript = deepcopy(s:legacyscript) + + let g:legacy_result = eval("g:legacyscript.Helper()") + vim9cmd g:vim9_result = eval("g:legacyscript.Helper()") + END + v9.CheckScriptSuccess(lines) + assert_equal('Success', g:legacy_result) + assert_equal('Success', g:vim9_result) + + unlet g:legacy_result + unlet g:vim9_result +enddef + +def Test_go_beyond_end_of_cmd() + # this was reading the byte after the end of the line + var lines =<< trim END + def F() + cal + enddef + defcompile + END + v9.CheckScriptFailure(lines, 'E476:') +enddef + +" Test for memory allocation failure when defining a new lambda +func Test_lambda_allocation_failure() + new + let lines =<< trim END + vim9script + g:Xlambda = (x): number => { + return x + 1 + } + END + call setline(1, lines) + call test_alloc_fail(GetAllocId('get_func'), 0, 0) + call assert_fails('source', 'E342:') + call assert_false(exists('g:Xlambda')) + bw! +endfunc + +def Test_lambda_argument_type_check() + var lines =<< trim END + vim9script + + def Scan(ll: list<any>): func(func(any)) + return (Emit: func(any)) => { + for e in ll + Emit(e) + endfor + } + enddef + + def Sum(Cont: func(func(any))): any + var sum = 0.0 + Cont((v: float) => { # <== NOTE: the lambda expects a float + sum += v + }) + return sum + enddef + + const ml = [3.0, 2, '7'] + echo Scan(ml)->Sum() + END + v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected float but got string') +enddef + +def Test_multiple_funcref() + # This was using a NULL pointer + var lines =<< trim END + vim9script + def A(F: func, ...args: list<any>): func + return funcref(F, args) + enddef + + def B(F: func): func + return funcref(A, [F]) + enddef + + def Test(n: number) + enddef + + const X = B(Test) + X(1) + END + v9.CheckScriptSuccess(lines) + + # slightly different case + lines =<< trim END + vim9script + + def A(F: func, ...args: list<any>): any + return call(F, args) + enddef + + def B(F: func): func + return funcref(A, [F]) + enddef + + def Test(n: number) + enddef + + const X = B(Test) + X(1) + END + v9.CheckScriptSuccess(lines) +enddef + +def Test_cexpr_errmsg_line_number() + var lines =<< trim END + vim9script + def Func() + var qfl = {} + cexpr qfl + enddef + Func() + END + v9.CheckScriptFailure(lines, 'E777', 2) +enddef + +def AddDefer(s: string) + g:deferred->extend([s]) +enddef + +def DeferTwo() + g:deferred->extend(['in Two']) + for n in range(3) + defer g:AddDefer('two' .. n) + endfor + g:deferred->extend(['end Two']) +enddef + +def DeferOne() + g:deferred->extend(['in One']) + defer g:AddDefer('one') + g:DeferTwo() + g:deferred->extend(['end One']) + + writefile(['text'], 'XdeferFile') + defer delete('XdeferFile') +enddef + +def Test_defer() + g:deferred = [] + g:DeferOne() + assert_equal(['in One', 'in Two', 'end Two', 'two2', 'two1', 'two0', 'end One', 'one'], g:deferred) + unlet g:deferred + assert_equal('', glob('XdeferFile')) +enddef + +def Test_invalid_redir() + var lines =<< trim END + def Tone() + if 1 + redi =>@ + redi END + endif + enddef + defcompile + END + v9.CheckScriptFailure(lines, 'E354:') + delfunc g:Tone + + # this was reading past the end of the line + lines =<< trim END + def Ttwo() + if 0 + redi =>@ + redi END + endif + enddef + defcompile + END + v9.CheckScriptFailure(lines, 'E354:') + delfunc g:Ttwo +enddef + +func Test_keytyped_in_nested_function() + CheckRunVimInTerminal + + call Run_Test_keytyped_in_nested_function() +endfunc + +def Run_Test_keytyped_in_nested_function() + var lines =<< trim END + vim9script + autocmd CmdlineEnter * sample#Init() + + exe 'set rtp=' .. getcwd() .. '/Xrtpdir' + END + writefile(lines, 'Xkeytyped', 'D') + + var dir = 'Xrtpdir/autoload' + mkdir(dir, 'pR') + + lines =<< trim END + vim9script + export def Init(): void + cnoremap <expr>" <SID>Quote('"') + enddef + def Quote(str: string): string + def InPair(): number + return 0 + enddef + return str + enddef + END + writefile(lines, dir .. '/sample.vim') + + var buf = g:RunVimInTerminal('-S Xkeytyped', {rows: 6}) + + term_sendkeys(buf, ':"') + g:VerifyScreenDump(buf, 'Test_keytyped_in_nested_func', {}) + + # clean up + term_sendkeys(buf, "\<Esc>") + g:StopVimInTerminal(buf) +enddef + +" The following messes up syntax highlight, keep near the end. +if has('python3') + def Test_python3_command() + py3 import vim + py3 vim.command("g:done = 'yes'") + assert_equal('yes', g:done) + unlet g:done + enddef + + def Test_python3_heredoc() + py3 << trim EOF + import vim + vim.vars['didit'] = 'yes' + EOF + assert_equal('yes', g:didit) + + python3 << trim EOF + import vim + vim.vars['didit'] = 'again' + EOF + assert_equal('again', g:didit) + enddef +endif + +if has('lua') + def Test_lua_heredoc() + g:d = {} + lua << trim EOF + x = vim.eval('g:d') + x['key'] = 'val' + EOF + assert_equal('val', g:d.key) + enddef + + def Test_lua_heredoc_fails() + var lines = [ + 'vim9script', + 'def ExeLua()', + 'lua << trim EOLUA', + "x = vim.eval('g:nodict')", + 'EOLUA', + 'enddef', + 'ExeLua()', + ] + v9.CheckScriptFailure(lines, 'E121: Undefined variable: g:nodict') + enddef +endif + +if has('perl') + def Test_perl_heredoc_nested() + var lines =<< trim END + vim9script + def F(): string + def G(): string + perl << EOF + EOF + return 'done' + enddef + return G() + enddef + assert_equal('done', F()) + END + v9.CheckScriptSuccess(lines) + enddef +endif + + +" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker |