blob: bf8b705ed5c00b91ac53089b0827d2c8323f675d [file] [log] [blame]
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001" Test various aspects of the Vim9 script language.
2
3source check.vim
Bram Moolenaarad304702020-09-06 18:22:53 +02004source term_util.vim
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02005source view_util.vim
Bram Moolenaar62aec932022-01-29 21:45:34 +00006import './vim9.vim' as v9
Bram Moolenaar47e7d702020-07-05 18:18:42 +02007source screendump.vim
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02008
9func Test_def_basic()
10 def SomeFunc(): string
11 return 'yes'
12 enddef
Bram Moolenaarc0c71e92020-09-11 19:09:48 +020013 call SomeFunc()->assert_equal('yes')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +020014endfunc
15
Bram Moolenaar2b9b17e2020-10-13 18:38:11 +020016func Test_compiling_error()
17 " use a terminal to see the whole error message
Bram Moolenaarf4e8cdd2020-10-12 22:07:13 +020018 CheckRunVimInTerminal
19
Bram Moolenaar2b9b17e2020-10-13 18:38:11 +020020 call TestCompilingError()
Bram Moolenaare8c46602021-04-05 22:27:37 +020021 call TestCompilingErrorInTry()
Bram Moolenaar2b9b17e2020-10-13 18:38:11 +020022endfunc
23
24def TestCompilingError()
Bram Moolenaarf4e8cdd2020-10-12 22:07:13 +020025 var lines =<< trim END
26 vim9script
27 def Fails()
28 echo nothing
29 enddef
30 defcompile
31 END
Bram Moolenaarf5fec052022-09-11 11:49:22 +010032 writefile(lines, 'XTest_compile_error', 'D')
Bram Moolenaar62aec932022-01-29 21:45:34 +000033 var buf = g:RunVimInTerminal('-S XTest_compile_error',
Bram Moolenaare0de1712020-12-02 17:36:54 +010034 {rows: 10, wait_for_ruler: 0})
Bram Moolenaar62aec932022-01-29 21:45:34 +000035 g:WaitForAssert(() => assert_match('Error detected while compiling command line.*Fails.*Variable not found: nothing',
36 g:Term_getlines(buf, range(1, 9))))
Bram Moolenaarf4e8cdd2020-10-12 22:07:13 +020037
38 # clean up
Bram Moolenaar62aec932022-01-29 21:45:34 +000039 g:StopVimInTerminal(buf)
Bram Moolenaare8c46602021-04-05 22:27:37 +020040enddef
41
42def TestCompilingErrorInTry()
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +010043 var dir = 'Xcompdir/autoload'
Bram Moolenaarf5fec052022-09-11 11:49:22 +010044 mkdir(dir, 'pR')
Bram Moolenaare8c46602021-04-05 22:27:37 +020045
46 var lines =<< trim END
47 vim9script
Bram Moolenaard8fe6d32022-01-30 18:40:44 +000048 export def OnlyCompiled()
Bram Moolenaare8c46602021-04-05 22:27:37 +020049 g:runtime = 'yes'
50 invalid
51 enddef
52 END
53 writefile(lines, dir .. '/script.vim')
54
55 lines =<< trim END
56 vim9script
57 todo
58 try
59 script#OnlyCompiled()
60 catch /nothing/
61 endtry
62 END
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +010063 lines[1] = 'set rtp=' .. getcwd() .. '/Xcompdir'
Bram Moolenaarf5fec052022-09-11 11:49:22 +010064 writefile(lines, 'XTest_compile_error', 'D')
Bram Moolenaare8c46602021-04-05 22:27:37 +020065
Bram Moolenaar62aec932022-01-29 21:45:34 +000066 var buf = g:RunVimInTerminal('-S XTest_compile_error', {rows: 10, wait_for_ruler: 0})
67 g:WaitForAssert(() => assert_match('Error detected while compiling command line.*function script#OnlyCompiled.*Invalid command: invalid',
68 g:Term_getlines(buf, range(1, 9))))
Bram Moolenaare8c46602021-04-05 22:27:37 +020069
70 # clean up
Bram Moolenaar62aec932022-01-29 21:45:34 +000071 g:StopVimInTerminal(buf)
Bram Moolenaarf4e8cdd2020-10-12 22:07:13 +020072enddef
73
Bram Moolenaarad6d9cc2022-08-08 21:43:11 +010074def Test_comment_error()
75 v9.CheckDefFailure(['#{ comment'], 'E1170:')
76enddef
77
Bram Moolenaarb55d6182021-06-08 22:01:53 +020078def Test_compile_error_in_called_function()
79 var lines =<< trim END
80 vim9script
81 var n: number
82 def Foo()
83 &hls = n
84 enddef
85 def Bar()
86 Foo()
87 enddef
88 silent! Foo()
89 Bar()
90 END
Bram Moolenaar62aec932022-01-29 21:45:34 +000091 v9.CheckScriptFailureList(lines, ['E1012:', 'E1191:'])
Bram Moolenaarb55d6182021-06-08 22:01:53 +020092enddef
93
Bram Moolenaar22f17a22021-06-21 20:48:58 +020094def Test_wrong_function_name()
95 var lines =<< trim END
96 vim9script
97 func _Foo()
98 echo 'foo'
99 endfunc
100 END
Bram Moolenaar3787f262022-02-07 21:54:01 +0000101 v9.CheckScriptFailure(lines, 'E1267:')
Bram Moolenaar22f17a22021-06-21 20:48:58 +0200102
103 lines =<< trim END
104 vim9script
105 def _Foo()
106 echo 'foo'
107 enddef
108 END
Bram Moolenaar3787f262022-02-07 21:54:01 +0000109 v9.CheckScriptFailure(lines, 'E1267:')
Bram Moolenaardea5ab02022-02-23 22:12:02 +0000110
111 lines =<< trim END
112 vim9script
113 var Object = {}
114 function Object.Method()
115 endfunction
116 END
117 v9.CheckScriptFailure(lines, 'E1182:')
118
119 lines =<< trim END
120 vim9script
121 var Object = {}
122 def Object.Method()
123 enddef
124 END
125 v9.CheckScriptFailure(lines, 'E1182:')
126
127 lines =<< trim END
128 vim9script
129 g:Object = {}
130 function g:Object.Method()
131 endfunction
132 END
133 v9.CheckScriptFailure(lines, 'E1182:')
134
135 lines =<< trim END
136 let s:Object = {}
137 def Define()
138 function s:Object.Method()
139 endfunction
140 enddef
141 defcompile
142 END
143 v9.CheckScriptFailure(lines, 'E1182:')
144 delfunc g:Define
145
146 lines =<< trim END
147 let s:Object = {}
148 def Define()
149 def Object.Method()
150 enddef
151 enddef
152 defcompile
153 END
154 v9.CheckScriptFailure(lines, 'E1182:')
155 delfunc g:Define
156
157 lines =<< trim END
158 let g:Object = {}
159 def Define()
160 function g:Object.Method()
161 endfunction
162 enddef
163 defcompile
164 END
165 v9.CheckScriptFailure(lines, 'E1182:')
166 delfunc g:Define
Bram Moolenaar22f17a22021-06-21 20:48:58 +0200167enddef
168
Bram Moolenaarf48b2fa2021-04-12 22:02:36 +0200169def Test_autoload_name_mismatch()
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +0100170 var dir = 'Xnamedir/autoload'
Bram Moolenaarf5fec052022-09-11 11:49:22 +0100171 mkdir(dir, 'pR')
Bram Moolenaarf48b2fa2021-04-12 22:02:36 +0200172
173 var lines =<< trim END
174 vim9script
Bram Moolenaard8fe6d32022-01-30 18:40:44 +0000175 export def NoFunction()
Bram Moolenaarf48b2fa2021-04-12 22:02:36 +0200176 # comment
177 g:runtime = 'yes'
178 enddef
179 END
180 writefile(lines, dir .. '/script.vim')
181
182 var save_rtp = &rtp
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +0100183 exe 'set rtp=' .. getcwd() .. '/Xnamedir'
Bram Moolenaarf48b2fa2021-04-12 22:02:36 +0200184 lines =<< trim END
185 call script#Function()
186 END
Bram Moolenaard8fe6d32022-01-30 18:40:44 +0000187 v9.CheckScriptFailure(lines, 'E117:', 1)
Bram Moolenaarf48b2fa2021-04-12 22:02:36 +0200188
189 &rtp = save_rtp
Bram Moolenaarf48b2fa2021-04-12 22:02:36 +0200190enddef
191
Bram Moolenaarf0a40692021-06-11 22:05:47 +0200192def Test_autoload_names()
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +0100193 var dir = 'Xandir/autoload'
Bram Moolenaarf5fec052022-09-11 11:49:22 +0100194 mkdir(dir, 'pR')
Bram Moolenaarf0a40692021-06-11 22:05:47 +0200195
196 var lines =<< trim END
197 func foobar#function()
198 return 'yes'
199 endfunc
200 let foobar#var = 'no'
201 END
202 writefile(lines, dir .. '/foobar.vim')
203
204 var save_rtp = &rtp
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +0100205 exe 'set rtp=' .. getcwd() .. '/Xandir'
Bram Moolenaarf0a40692021-06-11 22:05:47 +0200206
207 lines =<< trim END
208 assert_equal('yes', foobar#function())
209 var Function = foobar#function
210 assert_equal('yes', Function())
211
212 assert_equal('no', foobar#var)
213 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000214 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarf0a40692021-06-11 22:05:47 +0200215
216 &rtp = save_rtp
Bram Moolenaarf0a40692021-06-11 22:05:47 +0200217enddef
218
Bram Moolenaar88c89c72021-08-14 14:01:05 +0200219def Test_autoload_error_in_script()
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +0100220 var dir = 'Xaedir/autoload'
Bram Moolenaarf5fec052022-09-11 11:49:22 +0100221 mkdir(dir, 'pR')
Bram Moolenaar88c89c72021-08-14 14:01:05 +0200222
223 var lines =<< trim END
224 func scripterror#function()
225 let g:called_function = 'yes'
226 endfunc
227 let 0 = 1
228 END
229 writefile(lines, dir .. '/scripterror.vim')
230
231 var save_rtp = &rtp
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +0100232 exe 'set rtp=' .. getcwd() .. '/Xaedir'
Bram Moolenaar88c89c72021-08-14 14:01:05 +0200233
234 g:called_function = 'no'
235 # The error in the autoload script cannot be checked with assert_fails(), use
236 # CheckDefSuccess() instead of CheckDefFailure()
237 try
Bram Moolenaar62aec932022-01-29 21:45:34 +0000238 v9.CheckDefSuccess(['scripterror#function()'])
Bram Moolenaar88c89c72021-08-14 14:01:05 +0200239 catch
240 assert_match('E121: Undefined variable: 0', v:exception)
241 endtry
242 assert_equal('no', g:called_function)
243
244 lines =<< trim END
245 func scriptcaught#function()
246 let g:called_function = 'yes'
247 endfunc
248 try
249 let 0 = 1
250 catch
251 let g:caught = v:exception
252 endtry
253 END
254 writefile(lines, dir .. '/scriptcaught.vim')
255
256 g:called_function = 'no'
Bram Moolenaar62aec932022-01-29 21:45:34 +0000257 v9.CheckDefSuccess(['scriptcaught#function()'])
Bram Moolenaar88c89c72021-08-14 14:01:05 +0200258 assert_match('E121: Undefined variable: 0', g:caught)
259 assert_equal('yes', g:called_function)
260
261 &rtp = save_rtp
Bram Moolenaar88c89c72021-08-14 14:01:05 +0200262enddef
263
Bram Moolenaar62aec932022-01-29 21:45:34 +0000264def s:CallRecursive(n: number): number
Bram Moolenaar0ba48e82020-11-17 18:23:19 +0100265 return CallRecursive(n + 1)
266enddef
267
Bram Moolenaar62aec932022-01-29 21:45:34 +0000268def s:CallMapRecursive(l: list<number>): number
Bram Moolenaar2949cfd2020-12-31 21:28:47 +0100269 return map(l, (_, v) => CallMapRecursive([v]))[0]
Bram Moolenaar0ba48e82020-11-17 18:23:19 +0100270enddef
271
272def Test_funcdepth_error()
273 set maxfuncdepth=10
274
275 var caught = false
276 try
277 CallRecursive(1)
278 catch /E132:/
279 caught = true
280 endtry
281 assert_true(caught)
282
283 caught = false
284 try
285 CallMapRecursive([1])
286 catch /E132:/
287 caught = true
288 endtry
289 assert_true(caught)
290
291 set maxfuncdepth&
292enddef
293
Bram Moolenaar5178b1b2021-01-01 18:43:51 +0100294def Test_endfunc_enddef()
295 var lines =<< trim END
296 def Test()
297 echo 'test'
298 endfunc
299 enddef
300 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000301 v9.CheckScriptFailure(lines, 'E1151:', 3)
Bram Moolenaar5178b1b2021-01-01 18:43:51 +0100302
303 lines =<< trim END
304 def Test()
305 func Nested()
306 echo 'test'
307 enddef
308 enddef
309 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000310 v9.CheckScriptFailure(lines, 'E1152:', 4)
Bram Moolenaar49f1e9e2021-03-22 20:49:02 +0100311
312 lines =<< trim END
313 def Ok()
314 echo 'hello'
315 enddef | echo 'there'
316 def Bad()
317 echo 'hello'
318 enddef there
319 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000320 v9.CheckScriptFailure(lines, 'E1173: Text found after enddef: there', 6)
Bram Moolenaar5178b1b2021-01-01 18:43:51 +0100321enddef
322
Bram Moolenaarb8ba9b92021-01-01 18:54:34 +0100323def Test_missing_endfunc_enddef()
324 var lines =<< trim END
325 vim9script
326 def Test()
327 echo 'test'
328 endef
329 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000330 v9.CheckScriptFailure(lines, 'E1057:', 2)
Bram Moolenaarb8ba9b92021-01-01 18:54:34 +0100331
332 lines =<< trim END
333 vim9script
334 func Some()
335 echo 'test'
336 enfffunc
337 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000338 v9.CheckScriptFailure(lines, 'E126:', 2)
Bram Moolenaarb8ba9b92021-01-01 18:54:34 +0100339enddef
340
Bram Moolenaar4efd9942021-01-24 21:14:20 +0100341def Test_white_space_before_paren()
342 var lines =<< trim END
343 vim9script
344 def Test ()
345 echo 'test'
346 enddef
347 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000348 v9.CheckScriptFailure(lines, 'E1068:', 2)
Bram Moolenaar4efd9942021-01-24 21:14:20 +0100349
350 lines =<< trim END
351 vim9script
352 func Test ()
353 echo 'test'
354 endfunc
355 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000356 v9.CheckScriptFailure(lines, 'E1068:', 2)
Bram Moolenaar4efd9942021-01-24 21:14:20 +0100357
358 lines =<< trim END
359 def Test ()
360 echo 'test'
361 enddef
362 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000363 v9.CheckScriptFailure(lines, 'E1068:', 1)
Bram Moolenaar4efd9942021-01-24 21:14:20 +0100364
365 lines =<< trim END
366 func Test ()
367 echo 'test'
368 endfunc
369 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000370 v9.CheckScriptSuccess(lines)
Bram Moolenaar4efd9942021-01-24 21:14:20 +0100371enddef
372
Bram Moolenaar832ea892021-01-08 21:55:26 +0100373def Test_enddef_dict_key()
374 var d = {
375 enddef: 'x',
376 endfunc: 'y',
377 }
378 assert_equal({enddef: 'x', endfunc: 'y'}, d)
379enddef
380
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200381def ReturnString(): string
382 return 'string'
383enddef
384
385def ReturnNumber(): number
386 return 123
387enddef
388
389let g:notNumber = 'string'
390
391def ReturnGlobal(): number
392 return g:notNumber
393enddef
394
395def Test_return_something()
Bram Moolenaar62aec932022-01-29 21:45:34 +0000396 g:ReturnString()->assert_equal('string')
397 g:ReturnNumber()->assert_equal(123)
Bram Moolenaar848fadd2022-01-30 15:28:30 +0000398 assert_fails('g:ReturnGlobal()', 'E1012: Type mismatch; expected number but got string', '', 1, 'ReturnGlobal')
Bram Moolenaaref7aadb2022-01-18 18:46:07 +0000399
400 var lines =<< trim END
401 vim9script
402
403 def Msg()
404 echomsg 'in Msg()...'
405 enddef
406
407 def Func()
408 return Msg()
409 enddef
410 defcompile
411 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000412 v9.CheckScriptFailure(lines, 'E1096:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200413enddef
414
Bram Moolenaare32e5162021-01-21 20:21:29 +0100415def Test_check_argument_type()
416 var lines =<< trim END
417 vim9script
418 def Val(a: number, b: number): number
419 return 0
420 enddef
421 def Func()
422 var x: any = true
423 Val(0, x)
424 enddef
425 disass Func
426 Func()
427 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000428 v9.CheckScriptFailure(lines, 'E1013: Argument 2: type mismatch, expected number but got bool', 2)
Bram Moolenaar56310d32022-12-27 17:25:05 +0000429
430 lines =<< trim END
431 vim9script
432
433 def Foobar(Fn: func(any, ?string): any)
434 enddef
435
436 Foobar((t) => 0)
437 END
438 v9.CheckScriptSuccess(lines)
Bram Moolenaare32e5162021-01-21 20:21:29 +0100439enddef
440
Bram Moolenaarefd88552020-06-18 20:50:10 +0200441def Test_missing_return()
Bram Moolenaar62aec932022-01-29 21:45:34 +0000442 v9.CheckDefFailure(['def Missing(): number',
Bram Moolenaarefd88552020-06-18 20:50:10 +0200443 ' if g:cond',
444 ' echo "no return"',
445 ' else',
446 ' return 0',
Bram Moolenaar2984ed32022-08-20 14:51:17 +0100447 ' endif',
Bram Moolenaarefd88552020-06-18 20:50:10 +0200448 'enddef'], 'E1027:')
Bram Moolenaar62aec932022-01-29 21:45:34 +0000449 v9.CheckDefFailure(['def Missing(): number',
Bram Moolenaarefd88552020-06-18 20:50:10 +0200450 ' if g:cond',
451 ' return 1',
452 ' else',
453 ' echo "no return"',
Bram Moolenaar2984ed32022-08-20 14:51:17 +0100454 ' endif',
Bram Moolenaarefd88552020-06-18 20:50:10 +0200455 'enddef'], 'E1027:')
Bram Moolenaar62aec932022-01-29 21:45:34 +0000456 v9.CheckDefFailure(['def Missing(): number',
Bram Moolenaarefd88552020-06-18 20:50:10 +0200457 ' if g:cond',
458 ' return 1',
459 ' else',
460 ' return 2',
Bram Moolenaar2984ed32022-08-20 14:51:17 +0100461 ' endif',
462 ' return 3',
Bram Moolenaarefd88552020-06-18 20:50:10 +0200463 'enddef'], 'E1095:')
464enddef
465
Bram Moolenaar403dc312020-10-17 19:29:51 +0200466def Test_return_bool()
467 var lines =<< trim END
468 vim9script
469 def MenuFilter(id: number, key: string): bool
470 return popup_filter_menu(id, key)
471 enddef
472 def YesnoFilter(id: number, key: string): bool
473 return popup_filter_yesno(id, key)
474 enddef
475 defcompile
476 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000477 v9.CheckScriptSuccess(lines)
Bram Moolenaar403dc312020-10-17 19:29:51 +0200478enddef
479
mityu500c4442022-12-02 18:12:05 +0000480def Test_return_void_comment_follows()
481 var lines =<< trim END
482 vim9script
483 def ReturnCommentFollows(): void
484 return # Some comment
485 enddef
486 defcompile
487 END
488 v9.CheckScriptSuccess(lines)
489enddef
490
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200491let s:nothing = 0
492def ReturnNothing()
493 s:nothing = 1
494 if true
495 return
496 endif
497 s:nothing = 2
498enddef
499
500def Test_return_nothing()
Bram Moolenaar62aec932022-01-29 21:45:34 +0000501 g:ReturnNothing()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200502 s:nothing->assert_equal(1)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200503enddef
504
Bram Moolenaar648ea762021-01-15 19:04:32 +0100505def Test_return_invalid()
506 var lines =<< trim END
507 vim9script
508 def Func(): invalid
509 return xxx
510 enddef
511 defcompile
512 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000513 v9.CheckScriptFailure(lines, 'E1010:', 2)
Bram Moolenaar31842cd2021-02-12 22:10:21 +0100514
515 lines =<< trim END
516 vim9script
517 def Test(Fun: func(number): number): list<number>
518 return map([1, 2, 3], (_, i) => Fun(i))
519 enddef
520 defcompile
521 def Inc(nr: number): nr
522 return nr + 2
523 enddef
524 echo Test(Inc)
525 END
526 # doing this twice was leaking memory
Bram Moolenaar62aec932022-01-29 21:45:34 +0000527 v9.CheckScriptFailure(lines, 'E1010:')
528 v9.CheckScriptFailure(lines, 'E1010:')
Bram Moolenaar648ea762021-01-15 19:04:32 +0100529enddef
530
Bram Moolenaarefc084e2021-09-09 22:30:52 +0200531def Test_return_list_any()
Bram Moolenaar114dbda2022-01-03 12:28:03 +0000532 # This used to fail but now the actual list type is checked, and since it has
533 # an item of type string it can be used as list<string>.
Bram Moolenaarefc084e2021-09-09 22:30:52 +0200534 var lines =<< trim END
535 vim9script
536 def Func(): list<string>
537 var l: list<any>
538 l->add('string')
539 return l
540 enddef
541 echo Func()
542 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000543 v9.CheckScriptSuccess(lines)
Bram Moolenaar114dbda2022-01-03 12:28:03 +0000544
Bram Moolenaarefc084e2021-09-09 22:30:52 +0200545 lines =<< trim END
546 vim9script
547 def Func(): list<string>
548 var l: list<any>
549 l += ['string']
550 return l
551 enddef
552 echo Func()
553 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000554 v9.CheckScriptSuccess(lines)
Bram Moolenaarefc084e2021-09-09 22:30:52 +0200555enddef
556
Bram Moolenaar1a572e92022-03-15 12:28:10 +0000557def Test_return_any_two_types()
558 var lines =<< trim END
559 vim9script
560
561 def G(Fn: func(string): any)
562 g:result = Fn("hello")
563 enddef
564
565 def F(a: number, b: string): any
566 echo b
567 if a > 0
568 return 1
569 else
570 return []
571 endif
572 enddef
573
574 G(function(F, [1]))
575 END
576 v9.CheckScriptSuccess(lines)
577 assert_equal(1, g:result)
578 unlet g:result
579enddef
580
Bram Moolenaar62aec932022-01-29 21:45:34 +0000581func s:Increment()
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200582 let g:counter += 1
583endfunc
584
585def Test_call_ufunc_count()
586 g:counter = 1
587 Increment()
588 Increment()
589 Increment()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200590 # works with and without :call
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200591 g:counter->assert_equal(4)
592 eval g:counter->assert_equal(4)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200593 unlet g:counter
594enddef
595
Bram Moolenaar1983f1a2022-02-28 20:55:02 +0000596def Test_call_ufunc_failure()
597 var lines =<< trim END
598 vim9script
599 def Tryit()
600 g:Global(1, 2, 3)
601 enddef
602
603 func g:Global(a, b, c)
604 echo a:a a:b a:c
605 endfunc
606
607 defcompile
608
609 func! g:Global(a, b)
610 echo a:a a:b
611 endfunc
612 Tryit()
613 END
614 v9.CheckScriptFailure(lines, 'E118: Too many arguments for function: Global')
615 delfunc g:Global
616
617 lines =<< trim END
618 vim9script
619
620 g:Ref = function('len')
621 def Tryit()
622 g:Ref('x')
623 enddef
624
625 defcompile
626
627 g:Ref = function('add')
628 Tryit()
629 END
630 v9.CheckScriptFailure(lines, 'E119: Not enough arguments for function: add')
631 unlet g:Ref
632enddef
633
Bram Moolenaar62aec932022-01-29 21:45:34 +0000634def s:MyVarargs(arg: string, ...rest: list<string>): string
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200635 var res = arg
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200636 for s in rest
637 res ..= ',' .. s
638 endfor
639 return res
640enddef
641
642def Test_call_varargs()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200643 MyVarargs('one')->assert_equal('one')
644 MyVarargs('one', 'two')->assert_equal('one,two')
645 MyVarargs('one', 'two', 'three')->assert_equal('one,two,three')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200646enddef
647
Bram Moolenaar01dd6c32021-09-05 16:36:23 +0200648def Test_call_white_space()
Bram Moolenaar62aec932022-01-29 21:45:34 +0000649 v9.CheckDefAndScriptFailure(["call Test ('text')"], ['E476:', 'E1068:'])
Bram Moolenaar01dd6c32021-09-05 16:36:23 +0200650enddef
651
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200652def MyDefaultArgs(name = 'string'): string
653 return name
654enddef
655
Bram Moolenaar62aec932022-01-29 21:45:34 +0000656def s:MyDefaultSecond(name: string, second: bool = true): string
Bram Moolenaare30f64b2020-07-15 19:48:20 +0200657 return second ? name : 'none'
658enddef
659
Bram Moolenaar38a3bfa2021-03-29 22:14:55 +0200660
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200661def Test_call_default_args()
Bram Moolenaar62aec932022-01-29 21:45:34 +0000662 g:MyDefaultArgs()->assert_equal('string')
663 g:MyDefaultArgs(v:none)->assert_equal('string')
664 g:MyDefaultArgs('one')->assert_equal('one')
665 assert_fails('g:MyDefaultArgs("one", "two")', 'E118:', '', 4, 'Test_call_default_args')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200666
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200667 MyDefaultSecond('test')->assert_equal('test')
668 MyDefaultSecond('test', true)->assert_equal('test')
669 MyDefaultSecond('test', false)->assert_equal('none')
Bram Moolenaare30f64b2020-07-15 19:48:20 +0200670
Bram Moolenaar38a3bfa2021-03-29 22:14:55 +0200671 var lines =<< trim END
672 def MyDefaultThird(name: string, aa = 'aa', bb = 'bb'): string
673 return name .. aa .. bb
674 enddef
675
676 MyDefaultThird('->')->assert_equal('->aabb')
677 MyDefaultThird('->', v:none)->assert_equal('->aabb')
678 MyDefaultThird('->', 'xx')->assert_equal('->xxbb')
679 MyDefaultThird('->', v:none, v:none)->assert_equal('->aabb')
680 MyDefaultThird('->', 'xx', v:none)->assert_equal('->xxbb')
681 MyDefaultThird('->', v:none, 'yy')->assert_equal('->aayy')
682 MyDefaultThird('->', 'xx', 'yy')->assert_equal('->xxyy')
Bram Moolenaare28d9b32021-07-03 18:56:53 +0200683
684 def DefArg(mandatory: any, optional = mandatory): string
685 return mandatory .. optional
686 enddef
687 DefArg(1234)->assert_equal('12341234')
688 DefArg("ok")->assert_equal('okok')
Bram Moolenaar38a3bfa2021-03-29 22:14:55 +0200689 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000690 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar38a3bfa2021-03-29 22:14:55 +0200691
Bram Moolenaar62aec932022-01-29 21:45:34 +0000692 v9.CheckScriptFailure(['def Func(arg: number = asdf)', 'enddef', 'defcompile'], 'E1001:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +0100693 delfunc g:Func
Bram Moolenaar62aec932022-01-29 21:45:34 +0000694 v9.CheckScriptFailure(['def Func(arg: number = "text")', 'enddef', 'defcompile'], 'E1013: Argument 1: type mismatch, expected number but got string')
Bram Moolenaar2d870f82020-12-05 13:41:01 +0100695 delfunc g:Func
Bram Moolenaar62aec932022-01-29 21:45:34 +0000696 v9.CheckDefFailure(['def Func(x: number = )', 'enddef'], 'E15:')
Bram Moolenaar12bce952021-03-11 20:04:04 +0100697
Bram Moolenaar38a3bfa2021-03-29 22:14:55 +0200698 lines =<< trim END
Bram Moolenaar12bce952021-03-11 20:04:04 +0100699 vim9script
700 def Func(a = b == 0 ? 1 : 2, b = 0)
701 enddef
702 defcompile
703 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000704 v9.CheckScriptFailure(lines, 'E1001: Variable not found: b')
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000705
Bram Moolenaarfa46ead2021-12-22 13:18:39 +0000706 # using script variable requires matching type or type cast when executed
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000707 lines =<< trim END
708 vim9script
709 var a: any
710 def Func(arg: string = a)
711 echo arg
712 enddef
713 defcompile
714 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000715 v9.CheckScriptSuccess(lines + ['a = "text"', 'Func()'])
716 v9.CheckScriptFailure(lines + ['a = 123', 'Func()'], 'E1013: Argument 1: type mismatch, expected string but got number')
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000717
718 # using global variable does not require type cast
719 lines =<< trim END
720 vim9script
721 def Func(arg: string = g:str)
722 echo arg
723 enddef
724 g:str = 'works'
725 Func()
726 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000727 v9.CheckScriptSuccess(lines)
Bram Moolenaar04b12692020-05-04 23:24:44 +0200728enddef
729
Bram Moolenaar62aec932022-01-29 21:45:34 +0000730def s:FuncWithComment( # comment
Bram Moolenaarcef12702021-01-04 14:09:43 +0100731 a: number, #comment
732 b: bool, # comment
733 c: string) #comment
734 assert_equal(4, a)
735 assert_equal(true, b)
736 assert_equal('yes', c)
737enddef
738
739def Test_func_with_comments()
740 FuncWithComment(4, true, 'yes')
741
742 var lines =<< trim END
743 def Func(# comment
744 arg: string)
745 enddef
746 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000747 v9.CheckScriptFailure(lines, 'E125:', 1)
Bram Moolenaarcef12702021-01-04 14:09:43 +0100748
749 lines =<< trim END
750 def Func(
751 arg: string# comment
752 )
753 enddef
754 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000755 v9.CheckScriptFailure(lines, 'E475:', 2)
Bram Moolenaarcef12702021-01-04 14:09:43 +0100756
757 lines =<< trim END
758 def Func(
759 arg: string
760 )# comment
761 enddef
762 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000763 v9.CheckScriptFailure(lines, 'E488:', 3)
Bram Moolenaarcef12702021-01-04 14:09:43 +0100764enddef
765
Bram Moolenaar04b12692020-05-04 23:24:44 +0200766def Test_nested_function()
Bram Moolenaar38453522021-11-28 22:00:12 +0000767 def NestedDef(arg: string): string
Bram Moolenaar04b12692020-05-04 23:24:44 +0200768 return 'nested ' .. arg
769 enddef
Bram Moolenaar38453522021-11-28 22:00:12 +0000770 NestedDef(':def')->assert_equal('nested :def')
771
772 func NestedFunc(arg)
773 return 'nested ' .. a:arg
774 endfunc
775 NestedFunc(':func')->assert_equal('nested :func')
Bram Moolenaar04b12692020-05-04 23:24:44 +0200776
Bram Moolenaar62aec932022-01-29 21:45:34 +0000777 v9.CheckDefFailure(['def Nested()', 'enddef', 'Nested(66)'], 'E118:')
778 v9.CheckDefFailure(['def Nested(arg: string)', 'enddef', 'Nested()'], 'E119:')
Bram Moolenaar0e65d3d2020-05-05 17:53:16 +0200779
Bram Moolenaar62aec932022-01-29 21:45:34 +0000780 v9.CheckDefFailure(['def s:Nested()', 'enddef'], 'E1075:')
781 v9.CheckDefFailure(['def b:Nested()', 'enddef'], 'E1075:')
Bram Moolenaar8b848ca2020-09-10 22:28:01 +0200782
Bram Moolenaar54021752020-12-06 18:50:36 +0100783 var lines =<< trim END
784 def Outer()
785 def Inner()
786 # comment
787 enddef
788 def Inner()
789 enddef
790 enddef
791 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000792 v9.CheckDefFailure(lines, 'E1073:')
Bram Moolenaar54021752020-12-06 18:50:36 +0100793
794 lines =<< trim END
795 def Outer()
796 def Inner()
797 # comment
798 enddef
799 def! Inner()
800 enddef
801 enddef
802 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000803 v9.CheckDefFailure(lines, 'E1117:')
Bram Moolenaar54021752020-12-06 18:50:36 +0100804
Bram Moolenaardb8e5c22021-12-25 19:58:22 +0000805 lines =<< trim END
806 vim9script
807 def Outer()
808 def Inner()
809 g:result = 'ok'
810 enddef
811 Inner()
812 enddef
813 Outer()
814 Inner()
815 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000816 v9.CheckScriptFailure(lines, 'E117: Unknown function: Inner')
Bram Moolenaardb8e5c22021-12-25 19:58:22 +0000817 assert_equal('ok', g:result)
818 unlet g:result
819
Bram Moolenaarf681cfb2022-02-07 20:30:57 +0000820 lines =<< trim END
821 vim9script
822 def Outer()
823 def _Inner()
824 echo 'bad'
825 enddef
Bram Moolenaar3787f262022-02-07 21:54:01 +0000826 _Inner()
Bram Moolenaarf681cfb2022-02-07 20:30:57 +0000827 enddef
828 defcompile
829 END
Bram Moolenaar3787f262022-02-07 21:54:01 +0000830 v9.CheckScriptFailure(lines, 'E1267:')
Bram Moolenaarf681cfb2022-02-07 20:30:57 +0000831
832 lines =<< trim END
833 vim9script
834 def Outer()
835 def g:inner()
836 echo 'bad'
837 enddef
Bram Moolenaar3787f262022-02-07 21:54:01 +0000838 g:inner()
Bram Moolenaarf681cfb2022-02-07 20:30:57 +0000839 enddef
840 defcompile
841 END
Bram Moolenaar3787f262022-02-07 21:54:01 +0000842 v9.CheckScriptFailure(lines, 'E1267:')
843
844 lines =<< trim END
845 vim9script
846 def g:_Func()
847 echo 'bad'
848 enddef
849 END
850 v9.CheckScriptFailure(lines, 'E1267:')
851
852 lines =<< trim END
853 vim9script
Bram Moolenaara749a422022-02-12 19:52:25 +0000854 def _Func()
Bram Moolenaar3787f262022-02-07 21:54:01 +0000855 echo 'bad'
856 enddef
857 END
858 v9.CheckScriptFailure(lines, 'E1267:')
Bram Moolenaarf681cfb2022-02-07 20:30:57 +0000859
Bram Moolenaar54021752020-12-06 18:50:36 +0100860 # nested function inside conditional
Bram Moolenaar54021752020-12-06 18:50:36 +0100861 lines =<< trim END
862 vim9script
863 var thecount = 0
864 if true
865 def Test(): number
866 def TheFunc(): number
867 thecount += 1
868 return thecount
869 enddef
870 return TheFunc()
871 enddef
872 endif
873 defcompile
874 assert_equal(1, Test())
875 assert_equal(2, Test())
876 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000877 v9.CheckScriptSuccess(lines)
Bram Moolenaar8863bda2021-03-17 18:42:08 +0100878
879 # also works when "thecount" is inside the "if" block
880 lines =<< trim END
881 vim9script
882 if true
883 var thecount = 0
884 def Test(): number
885 def TheFunc(): number
886 thecount += 1
887 return thecount
888 enddef
889 return TheFunc()
890 enddef
891 endif
892 defcompile
893 assert_equal(1, Test())
894 assert_equal(2, Test())
895 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000896 v9.CheckScriptSuccess(lines)
Bram Moolenaar4bba16d2021-08-15 19:28:05 +0200897
Bram Moolenaara915fa02022-03-23 11:29:15 +0000898 # nested function with recursive call
899 lines =<< trim END
900 vim9script
901
902 def MyFunc(): number
903 def Fib(n: number): number
904 if n < 2
905 return 1
906 endif
907 return Fib(n - 2) + Fib(n - 1)
908 enddef
909
910 return Fib(5)
911 enddef
912
913 assert_equal(8, MyFunc())
914 END
915 v9.CheckScriptSuccess(lines)
916
Bram Moolenaar4bba16d2021-08-15 19:28:05 +0200917 lines =<< trim END
918 vim9script
919 def Outer()
920 def Inner()
921 echo 'hello'
922 enddef burp
923 enddef
924 defcompile
925 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000926 v9.CheckScriptFailure(lines, 'E1173: Text found after enddef: burp', 3)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200927enddef
928
Bram Moolenaar1889f492022-08-16 19:34:44 +0100929def Test_nested_function_fails()
930 var lines =<< trim END
931 def T()
932 def Func(g: string):string
933 enddef
934 Func()
935 enddef
936 silent! defcompile
937 END
938 v9.CheckScriptFailure(lines, 'E1069:')
939enddef
940
Bram Moolenaaradc8e442020-12-31 18:28:18 +0100941def Test_not_nested_function()
942 echo printf('%d',
943 function('len')('xxx'))
944enddef
945
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200946func Test_call_default_args_from_func()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200947 call MyDefaultArgs()->assert_equal('string')
948 call MyDefaultArgs('one')->assert_equal('one')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +0200949 call assert_fails('call MyDefaultArgs("one", "two")', 'E118:', '', 3, 'Test_call_default_args_from_func')
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200950endfunc
951
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200952def Test_nested_global_function()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200953 var lines =<< trim END
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200954 vim9script
955 def Outer()
956 def g:Inner(): string
957 return 'inner'
958 enddef
959 enddef
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200960 defcompile
961 Outer()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200962 g:Inner()->assert_equal('inner')
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200963 delfunc g:Inner
964 Outer()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200965 g:Inner()->assert_equal('inner')
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200966 delfunc g:Inner
967 Outer()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200968 g:Inner()->assert_equal('inner')
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200969 delfunc g:Inner
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200970 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000971 v9.CheckScriptSuccess(lines)
Bram Moolenaar2c79e9d2020-08-01 18:57:52 +0200972
973 lines =<< trim END
974 vim9script
975 def Outer()
Bram Moolenaar38453522021-11-28 22:00:12 +0000976 func g:Inner()
977 return 'inner'
978 endfunc
979 enddef
980 defcompile
981 Outer()
982 g:Inner()->assert_equal('inner')
983 delfunc g:Inner
984 Outer()
985 g:Inner()->assert_equal('inner')
986 delfunc g:Inner
987 Outer()
988 g:Inner()->assert_equal('inner')
989 delfunc g:Inner
990 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000991 v9.CheckScriptSuccess(lines)
Bram Moolenaar38453522021-11-28 22:00:12 +0000992
993 lines =<< trim END
994 vim9script
995 def Outer()
Bram Moolenaar2c79e9d2020-08-01 18:57:52 +0200996 def g:Inner(): string
997 return 'inner'
998 enddef
999 enddef
1000 defcompile
1001 Outer()
1002 Outer()
1003 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001004 v9.CheckScriptFailure(lines, "E122:")
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01001005 delfunc g:Inner
Bram Moolenaarad486a02020-08-01 23:22:18 +02001006
1007 lines =<< trim END
1008 vim9script
Bram Moolenaar58a52f22020-12-22 18:56:55 +01001009 def Outer()
1010 def g:Inner()
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001011 echo map([1, 2, 3], (_, v) => v + 1)
Bram Moolenaar58a52f22020-12-22 18:56:55 +01001012 enddef
1013 g:Inner()
1014 enddef
1015 Outer()
1016 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001017 v9.CheckScriptSuccess(lines)
Bram Moolenaar58a52f22020-12-22 18:56:55 +01001018 delfunc g:Inner
1019
1020 lines =<< trim END
1021 vim9script
Bram Moolenaarad486a02020-08-01 23:22:18 +02001022 def Func()
1023 echo 'script'
1024 enddef
1025 def Outer()
1026 def Func()
1027 echo 'inner'
1028 enddef
1029 enddef
1030 defcompile
1031 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001032 v9.CheckScriptFailure(lines, "E1073:", 1)
Bram Moolenaard604d782021-11-20 21:46:20 +00001033
1034 lines =<< trim END
1035 vim9script
1036 def Func()
1037 echo 'script'
1038 enddef
1039 def Func()
1040 echo 'script'
1041 enddef
1042 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001043 v9.CheckScriptFailure(lines, "E1073:", 5)
Bram Moolenaar38ddf332020-07-31 22:05:04 +02001044enddef
1045
Bram Moolenaar6abdcf82020-11-22 18:15:44 +01001046def DefListAll()
1047 def
1048enddef
1049
1050def DefListOne()
1051 def DefListOne
1052enddef
1053
1054def DefListMatches()
1055 def /DefList
1056enddef
1057
1058def Test_nested_def_list()
1059 var funcs = split(execute('call DefListAll()'), "\n")
1060 assert_true(len(funcs) > 10)
1061 assert_true(funcs->index('def DefListAll()') >= 0)
1062
1063 funcs = split(execute('call DefListOne()'), "\n")
1064 assert_equal([' def DefListOne()', '1 def DefListOne', ' enddef'], funcs)
1065
1066 funcs = split(execute('call DefListMatches()'), "\n")
1067 assert_true(len(funcs) >= 3)
1068 assert_true(funcs->index('def DefListAll()') >= 0)
1069 assert_true(funcs->index('def DefListOne()') >= 0)
1070 assert_true(funcs->index('def DefListMatches()') >= 0)
Bram Moolenaar54021752020-12-06 18:50:36 +01001071
1072 var lines =<< trim END
1073 vim9script
1074 def Func()
1075 def +Func+
1076 enddef
1077 defcompile
1078 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001079 v9.CheckScriptFailure(lines, 'E476:', 1)
Bram Moolenaar6abdcf82020-11-22 18:15:44 +01001080enddef
1081
Bram Moolenaare08be092022-02-17 13:08:26 +00001082def Test_global_function_not_found()
1083 var lines =<< trim END
1084 g:Ref = 123
1085 call g:Ref()
1086 END
1087 v9.CheckDefExecAndScriptFailure(lines, ['E117:', 'E1085:'], 2)
1088enddef
1089
Bram Moolenaar333894b2020-08-01 18:53:07 +02001090def Test_global_local_function()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001091 var lines =<< trim END
Bram Moolenaar333894b2020-08-01 18:53:07 +02001092 vim9script
1093 def g:Func(): string
1094 return 'global'
1095 enddef
1096 def Func(): string
1097 return 'local'
1098 enddef
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001099 g:Func()->assert_equal('global')
1100 Func()->assert_equal('local')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001101 delfunc g:Func
Bram Moolenaar333894b2020-08-01 18:53:07 +02001102 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001103 v9.CheckScriptSuccess(lines)
Bram Moolenaar035d6e92020-08-11 22:30:42 +02001104
1105 lines =<< trim END
1106 vim9script
1107 def g:Funcy()
1108 echo 'funcy'
1109 enddef
Bram Moolenaara749a422022-02-12 19:52:25 +00001110 Funcy()
Bram Moolenaar035d6e92020-08-11 22:30:42 +02001111 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001112 v9.CheckScriptFailure(lines, 'E117:')
Bram Moolenaar333894b2020-08-01 18:53:07 +02001113enddef
1114
Bram Moolenaar0f769812020-09-12 18:32:34 +02001115def Test_local_function_shadows_global()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001116 var lines =<< trim END
Bram Moolenaar0f769812020-09-12 18:32:34 +02001117 vim9script
1118 def g:Gfunc(): string
1119 return 'global'
1120 enddef
1121 def AnotherFunc(): number
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001122 var Gfunc = function('len')
Bram Moolenaar0f769812020-09-12 18:32:34 +02001123 return Gfunc('testing')
1124 enddef
1125 g:Gfunc()->assert_equal('global')
1126 AnotherFunc()->assert_equal(7)
1127 delfunc g:Gfunc
1128 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001129 v9.CheckScriptSuccess(lines)
Bram Moolenaar0f769812020-09-12 18:32:34 +02001130
1131 lines =<< trim END
1132 vim9script
1133 def g:Func(): string
1134 return 'global'
1135 enddef
1136 def AnotherFunc()
1137 g:Func = function('len')
1138 enddef
1139 AnotherFunc()
1140 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001141 v9.CheckScriptFailure(lines, 'E705:')
Bram Moolenaar0f769812020-09-12 18:32:34 +02001142 delfunc g:Func
Bram Moolenaar0865b152021-04-05 15:38:51 +02001143
Bram Moolenaar62aec932022-01-29 21:45:34 +00001144 # global function is not found with g: prefix
Bram Moolenaar0865b152021-04-05 15:38:51 +02001145 lines =<< trim END
1146 vim9script
1147 def g:Func(): string
1148 return 'global'
1149 enddef
1150 def AnotherFunc(): string
1151 return Func()
1152 enddef
1153 assert_equal('global', AnotherFunc())
Bram Moolenaar0865b152021-04-05 15:38:51 +02001154 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001155 v9.CheckScriptFailure(lines, 'E117:')
1156 delfunc g:Func
Bram Moolenaar0865b152021-04-05 15:38:51 +02001157
1158 lines =<< trim END
1159 vim9script
1160 def g:Func(): string
1161 return 'global'
1162 enddef
Bram Moolenaar848fadd2022-01-30 15:28:30 +00001163 assert_equal('global', g:Func())
Bram Moolenaar0865b152021-04-05 15:38:51 +02001164 delfunc g:Func
1165 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001166 v9.CheckScriptSuccess(lines)
Bram Moolenaar58493cf2022-01-06 12:23:30 +00001167
1168 # This does not shadow "i" which is visible only inside the for loop
1169 lines =<< trim END
1170 vim9script
1171
1172 def Foo(i: number)
1173 echo i
1174 enddef
1175
1176 for i in range(3)
1177 # Foo() is compiled here
1178 Foo(i)
1179 endfor
1180 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001181 v9.CheckScriptSuccess(lines)
Bram Moolenaar0f769812020-09-12 18:32:34 +02001182enddef
1183
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001184func TakesOneArg(arg)
1185 echo a:arg
1186endfunc
1187
1188def Test_call_wrong_args()
Bram Moolenaar62aec932022-01-29 21:45:34 +00001189 v9.CheckDefFailure(['g:TakesOneArg()'], 'E119:')
1190 v9.CheckDefFailure(['g:TakesOneArg(11, 22)'], 'E118:')
1191 v9.CheckDefFailure(['bufnr(xxx)'], 'E1001:')
1192 v9.CheckScriptFailure(['def Func(Ref: func(s: string))'], 'E475:')
Bram Moolenaaree8580e2020-08-28 17:19:07 +02001193
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001194 var lines =<< trim END
Bram Moolenaaree8580e2020-08-28 17:19:07 +02001195 vim9script
1196 def Func(s: string)
1197 echo s
1198 enddef
1199 Func([])
1200 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001201 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected string but got list<unknown>', 5)
Bram Moolenaarb185a402020-09-18 22:42:00 +02001202
Bram Moolenaar9a015112021-12-31 14:06:45 +00001203 # argument name declared earlier is found when declaring a function
Bram Moolenaarb185a402020-09-18 22:42:00 +02001204 lines =<< trim END
1205 vim9script
Bram Moolenaarb4893b82021-02-21 22:20:24 +01001206 var name = 'piet'
1207 def FuncOne(name: string)
Bram Moolenaar3a5988c2022-02-08 19:23:35 +00001208 echo name
Bram Moolenaarb4893b82021-02-21 22:20:24 +01001209 enddef
1210 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001211 v9.CheckScriptFailure(lines, 'E1168:')
Bram Moolenaarb4893b82021-02-21 22:20:24 +01001212
Bram Moolenaar3a5988c2022-02-08 19:23:35 +00001213 # same, inside the same block
1214 lines =<< trim END
1215 vim9script
1216 if true
1217 var name = 'piet'
1218 def FuncOne(name: string)
1219 echo name
1220 enddef
1221 endif
1222 END
1223 v9.CheckScriptFailure(lines, 'E1168:')
1224
1225 # variable in other block is OK
1226 lines =<< trim END
1227 vim9script
1228 if true
1229 var name = 'piet'
1230 endif
1231 def FuncOne(name: string)
1232 echo name
1233 enddef
1234 END
1235 v9.CheckScriptSuccess(lines)
1236
Bram Moolenaardce24412022-02-08 20:35:30 +00001237 # with another variable in another block
1238 lines =<< trim END
1239 vim9script
1240 if true
1241 var name = 'piet'
1242 # define a function so that the variable isn't cleared
1243 def GetItem(): string
1244 return item
1245 enddef
1246 endif
1247 if true
1248 var name = 'peter'
1249 def FuncOne(name: string)
1250 echo name
1251 enddef
1252 endif
1253 END
1254 v9.CheckScriptFailure(lines, 'E1168:')
1255
1256 # only variable in another block is OK
1257 lines =<< trim END
1258 vim9script
1259 if true
1260 var name = 'piet'
1261 # define a function so that the variable isn't cleared
1262 def GetItem(): string
1263 return item
1264 enddef
1265 endif
1266 if true
1267 def FuncOne(name: string)
1268 echo name
1269 enddef
1270 endif
1271 END
1272 v9.CheckScriptSuccess(lines)
1273
Bram Moolenaar9a015112021-12-31 14:06:45 +00001274 # argument name declared later is only found when compiling
1275 lines =<< trim END
1276 vim9script
1277 def FuncOne(name: string)
1278 echo nr
1279 enddef
1280 var name = 'piet'
1281 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001282 v9.CheckScriptSuccess(lines)
1283 v9.CheckScriptFailure(lines + ['defcompile'], 'E1168:')
Bram Moolenaar9a015112021-12-31 14:06:45 +00001284
Bram Moolenaarb4893b82021-02-21 22:20:24 +01001285 lines =<< trim END
1286 vim9script
Bram Moolenaarb185a402020-09-18 22:42:00 +02001287 def FuncOne(nr: number)
1288 echo nr
1289 enddef
1290 def FuncTwo()
1291 FuncOne()
1292 enddef
1293 defcompile
1294 END
1295 writefile(lines, 'Xscript')
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001296 var didCatch = false
Bram Moolenaarb185a402020-09-18 22:42:00 +02001297 try
1298 source Xscript
1299 catch
1300 assert_match('E119: Not enough arguments for function: <SNR>\d\+_FuncOne', v:exception)
1301 assert_match('Xscript\[8\]..function <SNR>\d\+_FuncTwo, line 1', v:throwpoint)
1302 didCatch = true
1303 endtry
1304 assert_true(didCatch)
1305
1306 lines =<< trim END
1307 vim9script
1308 def FuncOne(nr: number)
1309 echo nr
1310 enddef
1311 def FuncTwo()
1312 FuncOne(1, 2)
1313 enddef
1314 defcompile
1315 END
Bram Moolenaarf5fec052022-09-11 11:49:22 +01001316 writefile(lines, 'Xscript', 'D')
Bram Moolenaarb185a402020-09-18 22:42:00 +02001317 didCatch = false
1318 try
1319 source Xscript
1320 catch
1321 assert_match('E118: Too many arguments for function: <SNR>\d\+_FuncOne', v:exception)
1322 assert_match('Xscript\[8\]..function <SNR>\d\+_FuncTwo, line 1', v:throwpoint)
1323 didCatch = true
1324 endtry
1325 assert_true(didCatch)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001326enddef
1327
Bram Moolenaar50824712020-12-20 21:10:17 +01001328def Test_call_funcref_wrong_args()
1329 var head =<< trim END
1330 vim9script
1331 def Func3(a1: string, a2: number, a3: list<number>)
1332 echo a1 .. a2 .. a3[0]
1333 enddef
1334 def Testme()
1335 var funcMap: dict<func> = {func: Func3}
1336 END
1337 var tail =<< trim END
1338 enddef
1339 Testme()
1340 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001341 v9.CheckScriptSuccess(head + ["funcMap['func']('str', 123, [1, 2, 3])"] + tail)
Bram Moolenaar50824712020-12-20 21:10:17 +01001342
Bram Moolenaar62aec932022-01-29 21:45:34 +00001343 v9.CheckScriptFailure(head + ["funcMap['func']('str', 123)"] + tail, 'E119:')
1344 v9.CheckScriptFailure(head + ["funcMap['func']('str', 123, [1], 4)"] + tail, 'E118:')
Bram Moolenaar32b3f822021-01-06 21:59:39 +01001345
1346 var lines =<< trim END
1347 vim9script
1348 var Ref: func(number): any
1349 Ref = (j) => !j
1350 echo Ref(false)
1351 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001352 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected number but got bool', 4)
Bram Moolenaar32b3f822021-01-06 21:59:39 +01001353
1354 lines =<< trim END
1355 vim9script
1356 var Ref: func(number): any
1357 Ref = (j) => !j
1358 call Ref(false)
1359 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001360 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected number but got bool', 4)
Bram Moolenaar50824712020-12-20 21:10:17 +01001361enddef
1362
Bram Moolenaarb4d16cb2020-11-05 18:45:46 +01001363def Test_call_lambda_args()
Bram Moolenaar2a389082021-04-09 20:24:31 +02001364 var lines =<< trim END
1365 var Callback = (..._) => 'anything'
1366 assert_equal('anything', Callback())
1367 assert_equal('anything', Callback(1))
1368 assert_equal('anything', Callback('a', 2))
Bram Moolenaar1088b692021-04-09 22:12:44 +02001369
1370 assert_equal('xyz', ((a: string): string => a)('xyz'))
Bram Moolenaar2a389082021-04-09 20:24:31 +02001371 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001372 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar2a389082021-04-09 20:24:31 +02001373
Bram Moolenaar62aec932022-01-29 21:45:34 +00001374 v9.CheckDefFailure(['echo ((i) => 0)()'],
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001375 'E119: Not enough arguments for function: ((i) => 0)()')
Bram Moolenaarb4d16cb2020-11-05 18:45:46 +01001376
Bram Moolenaar2a389082021-04-09 20:24:31 +02001377 lines =<< trim END
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001378 var Ref = (x: number, y: number) => x + y
Bram Moolenaarb4d16cb2020-11-05 18:45:46 +01001379 echo Ref(1, 'x')
1380 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001381 v9.CheckDefFailure(lines, 'E1013: Argument 2: type mismatch, expected number but got string')
Bram Moolenaare68b02a2021-01-03 13:09:51 +01001382
1383 lines =<< trim END
1384 var Ref: func(job, string, number)
1385 Ref = (x, y) => 0
1386 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001387 v9.CheckDefAndScriptFailure(lines, 'E1012:')
Bram Moolenaare68b02a2021-01-03 13:09:51 +01001388
1389 lines =<< trim END
1390 var Ref: func(job, string)
1391 Ref = (x, y, z) => 0
1392 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001393 v9.CheckDefAndScriptFailure(lines, 'E1012:')
Bram Moolenaar057e84a2021-02-28 16:55:11 +01001394
1395 lines =<< trim END
1396 var one = 1
1397 var l = [1, 2, 3]
1398 echo map(l, (one) => one)
1399 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001400 v9.CheckDefFailure(lines, 'E1167:')
1401 v9.CheckScriptFailure(['vim9script'] + lines, 'E1168:')
Bram Moolenaar057e84a2021-02-28 16:55:11 +01001402
1403 lines =<< trim END
Bram Moolenaar14ded112021-06-26 19:25:49 +02001404 var Ref: func(any, ?any): bool
1405 Ref = (_, y = 1) => false
1406 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001407 v9.CheckDefAndScriptFailure(lines, 'E1172:')
Bram Moolenaar14ded112021-06-26 19:25:49 +02001408
1409 lines =<< trim END
Bram Moolenaar015cf102021-06-26 21:52:02 +02001410 var a = 0
1411 var b = (a == 0 ? 1 : 2)
1412 assert_equal(1, b)
Bram Moolenaar98f9a5f2021-06-26 22:22:38 +02001413 var txt = 'a'
1414 b = (txt =~ 'x' ? 1 : 2)
1415 assert_equal(2, b)
Bram Moolenaar015cf102021-06-26 21:52:02 +02001416 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001417 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar015cf102021-06-26 21:52:02 +02001418
1419 lines =<< trim END
Bram Moolenaar057e84a2021-02-28 16:55:11 +01001420 def ShadowLocal()
1421 var one = 1
1422 var l = [1, 2, 3]
1423 echo map(l, (one) => one)
1424 enddef
1425 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001426 v9.CheckDefFailure(lines, 'E1167:')
Bram Moolenaar057e84a2021-02-28 16:55:11 +01001427
1428 lines =<< trim END
1429 def Shadowarg(one: number)
1430 var l = [1, 2, 3]
1431 echo map(l, (one) => one)
1432 enddef
1433 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001434 v9.CheckDefFailure(lines, 'E1167:')
Bram Moolenaar767034c2021-04-09 17:24:52 +02001435
1436 lines =<< trim END
1437 echo ((a) => a)('aa', 'bb')
1438 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001439 v9.CheckDefAndScriptFailure(lines, 'E118:', 1)
Bram Moolenaarc4c56422021-07-21 20:38:46 +02001440
1441 lines =<< trim END
1442 echo 'aa'->((a) => a)('bb')
1443 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001444 v9.CheckDefFailure(lines, 'E118: Too many arguments for function: ->((a) => a)(''bb'')', 1)
1445 v9.CheckScriptFailure(['vim9script'] + lines, 'E118: Too many arguments for function: <lambda>', 2)
Bram Moolenaarb4d16cb2020-11-05 18:45:46 +01001446enddef
1447
Bram Moolenaara755fdb2021-11-20 21:35:41 +00001448def Test_lambda_line_nr()
1449 var lines =<< trim END
1450 vim9script
1451 # comment
1452 # comment
1453 var id = timer_start(1'000, (_) => 0)
1454 var out = execute('verbose ' .. timer_info(id)[0].callback
1455 ->string()
1456 ->substitute("('\\|')", ' ', 'g'))
1457 assert_match('Last set from .* line 4', out)
1458 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001459 v9.CheckScriptSuccess(lines)
Bram Moolenaara755fdb2021-11-20 21:35:41 +00001460enddef
1461
Bram Moolenaar5f91e742021-03-17 21:29:29 +01001462def FilterWithCond(x: string, Cond: func(string): bool): bool
1463 return Cond(x)
1464enddef
1465
Bram Moolenaar0346b792021-01-31 22:18:29 +01001466def Test_lambda_return_type()
1467 var lines =<< trim END
1468 var Ref = (): => 123
1469 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001470 v9.CheckDefAndScriptFailure(lines, 'E1157:', 1)
Bram Moolenaar5f91e742021-03-17 21:29:29 +01001471
Yegappan Lakshmanan611728f2021-05-24 15:15:47 +02001472 # no space before the return type
1473 lines =<< trim END
1474 var Ref = (x):number => x + 1
1475 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001476 v9.CheckDefAndScriptFailure(lines, 'E1069:', 1)
Yegappan Lakshmanan611728f2021-05-24 15:15:47 +02001477
Bram Moolenaar5f91e742021-03-17 21:29:29 +01001478 # this works
1479 for x in ['foo', 'boo']
Bram Moolenaar62aec932022-01-29 21:45:34 +00001480 echo g:FilterWithCond(x, (v) => v =~ '^b')
Bram Moolenaar5f91e742021-03-17 21:29:29 +01001481 endfor
1482
1483 # this fails
1484 lines =<< trim END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001485 echo g:FilterWithCond('foo', (v) => v .. '^b')
Bram Moolenaar5f91e742021-03-17 21:29:29 +01001486 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001487 v9.CheckDefAndScriptFailure(lines, 'E1013: Argument 2: type mismatch, expected func(string): bool but got func(any): string', 1)
Bram Moolenaara9931532021-06-12 15:58:16 +02001488
1489 lines =<< trim END
1490 var Lambda1 = (x) => {
1491 return x
1492 }
1493 assert_equal('asdf', Lambda1('asdf'))
1494 var Lambda2 = (x): string => {
1495 return x
1496 }
1497 assert_equal('foo', Lambda2('foo'))
1498 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001499 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaara9931532021-06-12 15:58:16 +02001500
1501 lines =<< trim END
1502 var Lambda = (x): string => {
1503 return x
1504 }
1505 echo Lambda(['foo'])
1506 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001507 v9.CheckDefExecAndScriptFailure(lines, 'E1012:')
Bram Moolenaar0346b792021-01-31 22:18:29 +01001508enddef
1509
Bram Moolenaar709664c2020-12-12 14:33:41 +01001510def Test_lambda_uses_assigned_var()
Bram Moolenaar62aec932022-01-29 21:45:34 +00001511 v9.CheckDefSuccess([
Bram Moolenaar2984ed32022-08-20 14:51:17 +01001512 'var x: any = "aaa"',
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001513 'x = filter(["bbb"], (_, v) => v =~ x)'])
Bram Moolenaar709664c2020-12-12 14:33:41 +01001514enddef
1515
Bram Moolenaarf5f4e852022-09-22 22:03:14 +01001516def Test_lambda_invalid_block()
1517 var lines =<< trim END
1518 timer_start(0, (_) => { # echo
1519 echo 'yes'
1520 })
1521 END
1522 v9.CheckDefAndScriptSuccess(lines)
1523
1524 lines =<< trim END
1525 timer_start(0, (_) => { " echo
1526 echo 'yes'
1527 })
1528 END
1529 v9.CheckDefAndScriptFailure(lines, 'E488: Trailing characters: " echo')
1530
1531 lines =<< trim END
1532 timer_start(0, (_) => { | echo
1533 echo 'yes'
1534 })
1535 END
1536 v9.CheckDefAndScriptFailure(lines, 'E488: Trailing characters: | echo')
1537enddef
1538
Bram Moolenaarf8addf12022-09-23 12:44:25 +01001539def Test_lambda_with_following_cmd()
1540 var lines =<< trim END
1541 set ts=2
1542 var Lambda = () => {
1543 set ts=4
1544 } | set ts=3
1545 assert_equal(3, &ts)
1546 Lambda()
1547 assert_equal(4, &ts)
1548 END
1549 v9.CheckDefAndScriptSuccess(lines)
1550 set ts=8
1551enddef
1552
Bram Moolenaar18062fc2021-03-05 21:35:47 +01001553def Test_pass_legacy_lambda_to_def_func()
1554 var lines =<< trim END
1555 vim9script
1556 func Foo()
1557 eval s:Bar({x -> 0})
1558 endfunc
1559 def Bar(y: any)
1560 enddef
1561 Foo()
1562 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001563 v9.CheckScriptSuccess(lines)
Bram Moolenaar831bdf82021-06-22 19:32:17 +02001564
1565 lines =<< trim END
1566 vim9script
Bram Moolenaar1d9cef72022-03-17 16:30:03 +00001567 def g:TestFunc(F: func)
Bram Moolenaar831bdf82021-06-22 19:32:17 +02001568 enddef
1569 legacy call g:TestFunc({-> 0})
1570 delfunc g:TestFunc
1571
Bram Moolenaar1d9cef72022-03-17 16:30:03 +00001572 def g:TestFunc(F: func(number))
Bram Moolenaar831bdf82021-06-22 19:32:17 +02001573 enddef
1574 legacy call g:TestFunc({nr -> 0})
1575 delfunc g:TestFunc
1576 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001577 v9.CheckScriptSuccess(lines)
Bram Moolenaar18062fc2021-03-05 21:35:47 +01001578enddef
1579
Bram Moolenaar844fb642021-10-23 13:32:30 +01001580def Test_lambda_in_reduce_line_break()
1581 # this was using freed memory
1582 var lines =<< trim END
1583 vim9script
1584 const result: dict<number> =
1585 ['Bob', 'Sam', 'Cat', 'Bob', 'Cat', 'Cat']
1586 ->reduce((acc, val) => {
1587 if has_key(acc, val)
1588 acc[val] += 1
1589 return acc
1590 else
1591 acc[val] = 1
1592 return acc
1593 endif
1594 }, {})
1595 assert_equal({Bob: 2, Sam: 1, Cat: 3}, result)
1596 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001597 v9.CheckScriptSuccess(lines)
Bram Moolenaar844fb642021-10-23 13:32:30 +01001598enddef
1599
Bram Moolenaardcb53be2021-12-09 14:23:43 +00001600def Test_set_opfunc_to_lambda()
1601 var lines =<< trim END
1602 vim9script
1603 nnoremap <expr> <F4> <SID>CountSpaces() .. '_'
1604 def CountSpaces(type = ''): string
1605 if type == ''
1606 &operatorfunc = (t) => CountSpaces(t)
1607 return 'g@'
1608 endif
1609 normal! '[V']y
1610 g:result = getreg('"')->count(' ')
1611 return ''
1612 enddef
1613 new
1614 'a b c d e'->setline(1)
1615 feedkeys("\<F4>", 'x')
1616 assert_equal(4, g:result)
1617 bwipe!
1618 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001619 v9.CheckScriptSuccess(lines)
Bram Moolenaardcb53be2021-12-09 14:23:43 +00001620enddef
1621
Bram Moolenaaref082e12021-12-12 21:02:03 +00001622def Test_set_opfunc_to_global_function()
1623 var lines =<< trim END
1624 vim9script
1625 def g:CountSpaces(type = ''): string
1626 normal! '[V']y
1627 g:result = getreg('"')->count(' ')
1628 return ''
1629 enddef
Bram Moolenaarb15cf442021-12-16 15:49:43 +00001630 # global function works at script level
Bram Moolenaaref082e12021-12-12 21:02:03 +00001631 &operatorfunc = g:CountSpaces
1632 new
1633 'a b c d e'->setline(1)
1634 feedkeys("g@_", 'x')
1635 assert_equal(4, g:result)
Bram Moolenaarb15cf442021-12-16 15:49:43 +00001636
1637 &operatorfunc = ''
1638 g:result = 0
1639 # global function works in :def function
1640 def Func()
1641 &operatorfunc = g:CountSpaces
1642 enddef
1643 Func()
1644 feedkeys("g@_", 'x')
1645 assert_equal(4, g:result)
1646
Bram Moolenaaref082e12021-12-12 21:02:03 +00001647 bwipe!
1648 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001649 v9.CheckScriptSuccess(lines)
Bram Moolenaaref082e12021-12-12 21:02:03 +00001650 &operatorfunc = ''
1651enddef
1652
Bram Moolenaar33b968d2021-12-13 11:31:04 +00001653def Test_use_script_func_name_with_prefix()
1654 var lines =<< trim END
1655 vim9script
Bram Moolenaara749a422022-02-12 19:52:25 +00001656 func g:Getit()
Bram Moolenaar33b968d2021-12-13 11:31:04 +00001657 return 'it'
1658 endfunc
Bram Moolenaara749a422022-02-12 19:52:25 +00001659 var Fn = g:Getit
Bram Moolenaar33b968d2021-12-13 11:31:04 +00001660 assert_equal('it', Fn())
1661 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001662 v9.CheckScriptSuccess(lines)
Bram Moolenaar33b968d2021-12-13 11:31:04 +00001663enddef
1664
Bram Moolenaardd297bc2021-12-10 10:37:38 +00001665def Test_lambda_type_allocated()
1666 # Check that unreferencing a partial using a lambda can use the variable type
1667 # after the lambda has been freed and does not leak memory.
1668 var lines =<< trim END
1669 vim9script
1670
1671 func MyomniFunc1(val, findstart, base)
1672 return a:findstart ? 0 : []
1673 endfunc
1674
1675 var Lambda = (a, b) => MyomniFunc1(19, a, b)
1676 &omnifunc = Lambda
1677 Lambda = (a, b) => MyomniFunc1(20, a, b)
1678 &omnifunc = string(Lambda)
1679 Lambda = (a, b) => strlen(a)
1680 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001681 v9.CheckScriptSuccess(lines)
Bram Moolenaardd297bc2021-12-10 10:37:38 +00001682enddef
1683
Bram Moolenaara7583c42022-05-07 21:14:05 +01001684def Test_define_lambda_in_execute()
1685 var lines =<< trim [CODE]
1686 vim9script
1687
1688 def BuildFuncMultiLine(): func
1689 var x =<< trim END
1690 g:SomeRandomFunc = (d: dict<any>) => {
1691 return d.k1 + d.k2
1692 }
1693 END
1694 execute(x)
1695 return g:SomeRandomFunc
1696 enddef
1697 var ResultPlus = BuildFuncMultiLine()
1698 assert_equal(7, ResultPlus({k1: 3, k2: 4}))
1699 [CODE]
1700 v9.CheckScriptSuccess(lines)
1701 unlet g:SomeRandomFunc
1702enddef
1703
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001704" Default arg and varargs
1705def MyDefVarargs(one: string, two = 'foo', ...rest: list<string>): string
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001706 var res = one .. ',' .. two
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001707 for s in rest
1708 res ..= ',' .. s
1709 endfor
1710 return res
1711enddef
1712
1713def Test_call_def_varargs()
Bram Moolenaar62aec932022-01-29 21:45:34 +00001714 assert_fails('g:MyDefVarargs()', 'E119:', '', 1, 'Test_call_def_varargs')
1715 g:MyDefVarargs('one')->assert_equal('one,foo')
1716 g:MyDefVarargs('one', 'two')->assert_equal('one,two')
1717 g:MyDefVarargs('one', 'two', 'three')->assert_equal('one,two,three')
1718 v9.CheckDefFailure(['g:MyDefVarargs("one", 22)'],
Bram Moolenaar77072282020-09-16 17:55:40 +02001719 'E1013: Argument 2: type mismatch, expected string but got number')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001720 v9.CheckDefFailure(['g:MyDefVarargs("one", "two", 123)'],
Bram Moolenaar77072282020-09-16 17:55:40 +02001721 'E1013: Argument 3: type mismatch, expected string but got number')
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001722
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001723 var lines =<< trim END
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001724 vim9script
1725 def Func(...l: list<string>)
1726 echo l
1727 enddef
1728 Func('a', 'b', 'c')
1729 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001730 v9.CheckScriptSuccess(lines)
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001731
1732 lines =<< trim END
1733 vim9script
1734 def Func(...l: list<string>)
1735 echo l
1736 enddef
1737 Func()
1738 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001739 v9.CheckScriptSuccess(lines)
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001740
1741 lines =<< trim END
1742 vim9script
Bram Moolenaar2a389082021-04-09 20:24:31 +02001743 def Func(...l: list<any>)
Bram Moolenaar2f8cbc42020-09-16 17:22:59 +02001744 echo l
1745 enddef
1746 Func(0)
1747 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001748 v9.CheckScriptSuccess(lines)
Bram Moolenaar2f8cbc42020-09-16 17:22:59 +02001749
1750 lines =<< trim END
1751 vim9script
Bram Moolenaar2a389082021-04-09 20:24:31 +02001752 def Func(...l: any)
1753 echo l
1754 enddef
1755 Func(0)
1756 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001757 v9.CheckScriptFailure(lines, 'E1180:', 2)
Bram Moolenaar2a389082021-04-09 20:24:31 +02001758
1759 lines =<< trim END
1760 vim9script
Bram Moolenaar28022722020-09-21 22:02:49 +02001761 def Func(..._l: list<string>)
1762 echo _l
1763 enddef
1764 Func('a', 'b', 'c')
1765 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001766 v9.CheckScriptSuccess(lines)
Bram Moolenaar28022722020-09-21 22:02:49 +02001767
1768 lines =<< trim END
1769 vim9script
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001770 def Func(...l: list<string>)
1771 echo l
1772 enddef
1773 Func(1, 2, 3)
1774 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001775 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch')
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001776
1777 lines =<< trim END
1778 vim9script
1779 def Func(...l: list<string>)
1780 echo l
1781 enddef
1782 Func('a', 9)
1783 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001784 v9.CheckScriptFailure(lines, 'E1013: Argument 2: type mismatch')
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001785
1786 lines =<< trim END
1787 vim9script
1788 def Func(...l: list<string>)
1789 echo l
1790 enddef
1791 Func(1, 'a')
1792 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001793 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch')
Bram Moolenaar4f53b792021-02-07 15:59:49 +01001794
1795 lines =<< trim END
1796 vim9script
1797 def Func( # some comment
1798 ...l = []
1799 )
1800 echo l
1801 enddef
1802 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001803 v9.CheckScriptFailure(lines, 'E1160:')
Bram Moolenaar6ce46b92021-08-07 15:35:36 +02001804
1805 lines =<< trim END
1806 vim9script
1807 def DoIt()
1808 g:Later('')
1809 enddef
1810 defcompile
1811 def g:Later(...l: list<number>)
1812 enddef
1813 DoIt()
1814 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001815 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected number but got string')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001816enddef
1817
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001818let s:value = ''
1819
1820def FuncOneDefArg(opt = 'text')
1821 s:value = opt
1822enddef
1823
1824def FuncTwoDefArg(nr = 123, opt = 'text'): string
1825 return nr .. opt
1826enddef
1827
1828def FuncVarargs(...arg: list<string>): string
1829 return join(arg, ',')
1830enddef
1831
1832def Test_func_type_varargs()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001833 var RefDefArg: func(?string)
Bram Moolenaar848fadd2022-01-30 15:28:30 +00001834 RefDefArg = g:FuncOneDefArg
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001835 RefDefArg()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001836 s:value->assert_equal('text')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001837 RefDefArg('some')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001838 s:value->assert_equal('some')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001839
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001840 var RefDef2Arg: func(?number, ?string): string
Bram Moolenaar848fadd2022-01-30 15:28:30 +00001841 RefDef2Arg = g:FuncTwoDefArg
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001842 RefDef2Arg()->assert_equal('123text')
1843 RefDef2Arg(99)->assert_equal('99text')
1844 RefDef2Arg(77, 'some')->assert_equal('77some')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001845
Bram Moolenaar62aec932022-01-29 21:45:34 +00001846 v9.CheckDefFailure(['var RefWrong: func(string?)'], 'E1010:')
1847 v9.CheckDefFailure(['var RefWrong: func(?string, string)'], 'E1007:')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001848
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001849 var RefVarargs: func(...list<string>): string
Bram Moolenaar848fadd2022-01-30 15:28:30 +00001850 RefVarargs = g:FuncVarargs
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001851 RefVarargs()->assert_equal('')
1852 RefVarargs('one')->assert_equal('one')
1853 RefVarargs('one', 'two')->assert_equal('one,two')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001854
Bram Moolenaar62aec932022-01-29 21:45:34 +00001855 v9.CheckDefFailure(['var RefWrong: func(...list<string>, string)'], 'E110:')
1856 v9.CheckDefFailure(['var RefWrong: func(...list<string>, ?string)'], 'E110:')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001857enddef
1858
Bram Moolenaar0b76b422020-04-07 22:05:08 +02001859" Only varargs
1860def MyVarargsOnly(...args: list<string>): string
1861 return join(args, ',')
1862enddef
1863
1864def Test_call_varargs_only()
Bram Moolenaar62aec932022-01-29 21:45:34 +00001865 g:MyVarargsOnly()->assert_equal('')
1866 g:MyVarargsOnly('one')->assert_equal('one')
1867 g:MyVarargsOnly('one', 'two')->assert_equal('one,two')
1868 v9.CheckDefFailure(['g:MyVarargsOnly(1)'], 'E1013: Argument 1: type mismatch, expected string but got number')
1869 v9.CheckDefFailure(['g:MyVarargsOnly("one", 2)'], 'E1013: Argument 2: type mismatch, expected string but got number')
Bram Moolenaar0b76b422020-04-07 22:05:08 +02001870enddef
1871
Bram Moolenaar36818a92023-01-03 12:33:26 +00001872def Test_varargs_mismatch()
1873 var lines =<< trim END
1874 vim9script
1875
1876 def Map(Fn: func(...any): number): number
1877 return Fn('12')
1878 enddef
1879
1880 var res = Map((v) => str2nr(v))
1881 assert_equal(12, res)
1882 END
1883 v9.CheckScriptSuccess(lines)
1884enddef
1885
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001886def Test_using_var_as_arg()
Bram Moolenaard2939812021-12-30 17:09:05 +00001887 var lines =<< trim END
1888 def Func(x: number)
1889 var x = 234
1890 enddef
1891 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001892 v9.CheckDefFailure(lines, 'E1006:')
Bram Moolenaard2939812021-12-30 17:09:05 +00001893
1894 lines =<< trim END
1895 def Func(Ref: number)
1896 def Ref()
1897 enddef
1898 enddef
1899 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001900 v9.CheckDefFailure(lines, 'E1073:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001901enddef
1902
Bram Moolenaar62aec932022-01-29 21:45:34 +00001903def s:DictArg(arg: dict<string>)
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +02001904 arg['key'] = 'value'
1905enddef
1906
Bram Moolenaar62aec932022-01-29 21:45:34 +00001907def s:ListArg(arg: list<string>)
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +02001908 arg[0] = 'value'
1909enddef
1910
1911def Test_assign_to_argument()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001912 # works for dict and list
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001913 var d: dict<string> = {}
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +02001914 DictArg(d)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001915 d['key']->assert_equal('value')
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001916 var l: list<string> = []
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +02001917 ListArg(l)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001918 l[0]->assert_equal('value')
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +02001919
Bram Moolenaar62aec932022-01-29 21:45:34 +00001920 v9.CheckScriptFailure(['def Func(arg: number)', 'arg = 3', 'enddef', 'defcompile'], 'E1090:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001921 delfunc! g:Func
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +02001922enddef
1923
Bram Moolenaarb816dae2020-09-20 22:04:00 +02001924" These argument names are reserved in legacy functions.
Bram Moolenaar62aec932022-01-29 21:45:34 +00001925def s:WithReservedNames(firstline: string, lastline: string): string
Bram Moolenaarb816dae2020-09-20 22:04:00 +02001926 return firstline .. lastline
1927enddef
1928
1929def Test_argument_names()
1930 assert_equal('OK', WithReservedNames('O', 'K'))
1931enddef
1932
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001933def Test_call_func_defined_later()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001934 g:DefinedLater('one')->assert_equal('one')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +02001935 assert_fails('NotDefined("one")', 'E117:', '', 2, 'Test_call_func_defined_later')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001936enddef
1937
Bram Moolenaar1df8b3f2020-04-23 18:13:23 +02001938func DefinedLater(arg)
1939 return a:arg
1940endfunc
1941
1942def Test_call_funcref()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001943 g:SomeFunc('abc')->assert_equal(3)
Bram Moolenaar9bd5d872020-09-06 21:47:48 +02001944 assert_fails('NotAFunc()', 'E117:', '', 2, 'Test_call_funcref') # comment after call
Bram Moolenaar2ef91562021-12-11 16:14:07 +00001945 assert_fails('g:NotAFunc()', 'E1085:', '', 3, 'Test_call_funcref')
Bram Moolenaar2f1980f2020-07-22 19:30:06 +02001946
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001947 var lines =<< trim END
Bram Moolenaar2f1980f2020-07-22 19:30:06 +02001948 vim9script
1949 def RetNumber(): number
1950 return 123
1951 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001952 var Funcref: func: number = function('RetNumber')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001953 Funcref()->assert_equal(123)
Bram Moolenaar2f1980f2020-07-22 19:30:06 +02001954 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001955 v9.CheckScriptSuccess(lines)
Bram Moolenaar0f60e802020-07-22 20:16:11 +02001956
1957 lines =<< trim END
1958 vim9script
1959 def RetNumber(): number
1960 return 123
1961 enddef
1962 def Bar(F: func: number): number
1963 return F()
1964 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001965 var Funcref = function('RetNumber')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001966 Bar(Funcref)->assert_equal(123)
Bram Moolenaar0f60e802020-07-22 20:16:11 +02001967 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001968 v9.CheckScriptSuccess(lines)
Bram Moolenaarbfba8652020-07-23 20:09:10 +02001969
1970 lines =<< trim END
1971 vim9script
1972 def UseNumber(nr: number)
1973 echo nr
1974 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001975 var Funcref: func(number) = function('UseNumber')
Bram Moolenaarbfba8652020-07-23 20:09:10 +02001976 Funcref(123)
1977 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001978 v9.CheckScriptSuccess(lines)
Bram Moolenaarb8070e32020-07-23 20:56:04 +02001979
1980 lines =<< trim END
1981 vim9script
1982 def UseNumber(nr: number)
1983 echo nr
1984 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001985 var Funcref: func(string) = function('UseNumber')
Bram Moolenaarb8070e32020-07-23 20:56:04 +02001986 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001987 v9.CheckScriptFailure(lines, 'E1012: Type mismatch; expected func(string) but got func(number)')
Bram Moolenaar4fc224c2020-07-26 17:56:25 +02001988
1989 lines =<< trim END
1990 vim9script
1991 def EchoNr(nr = 34)
1992 g:echo = nr
1993 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001994 var Funcref: func(?number) = function('EchoNr')
Bram Moolenaar4fc224c2020-07-26 17:56:25 +02001995 Funcref()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001996 g:echo->assert_equal(34)
Bram Moolenaar4fc224c2020-07-26 17:56:25 +02001997 Funcref(123)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001998 g:echo->assert_equal(123)
Bram Moolenaar4fc224c2020-07-26 17:56:25 +02001999 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002000 v9.CheckScriptSuccess(lines)
Bram Moolenaarace61322020-07-26 18:16:58 +02002001
2002 lines =<< trim END
2003 vim9script
2004 def EchoList(...l: list<number>)
2005 g:echo = l
2006 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002007 var Funcref: func(...list<number>) = function('EchoList')
Bram Moolenaarace61322020-07-26 18:16:58 +02002008 Funcref()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002009 g:echo->assert_equal([])
Bram Moolenaarace61322020-07-26 18:16:58 +02002010 Funcref(1, 2, 3)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002011 g:echo->assert_equal([1, 2, 3])
Bram Moolenaarace61322020-07-26 18:16:58 +02002012 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002013 v9.CheckScriptSuccess(lines)
Bram Moolenaar01865ad2020-07-26 18:33:09 +02002014
2015 lines =<< trim END
2016 vim9script
2017 def OptAndVar(nr: number, opt = 12, ...l: list<number>): number
2018 g:optarg = opt
2019 g:listarg = l
2020 return nr
2021 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002022 var Funcref: func(number, ?number, ...list<number>): number = function('OptAndVar')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002023 Funcref(10)->assert_equal(10)
2024 g:optarg->assert_equal(12)
2025 g:listarg->assert_equal([])
Bram Moolenaar01865ad2020-07-26 18:33:09 +02002026
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002027 Funcref(11, 22)->assert_equal(11)
2028 g:optarg->assert_equal(22)
2029 g:listarg->assert_equal([])
Bram Moolenaar01865ad2020-07-26 18:33:09 +02002030
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002031 Funcref(17, 18, 1, 2, 3)->assert_equal(17)
2032 g:optarg->assert_equal(18)
2033 g:listarg->assert_equal([1, 2, 3])
Bram Moolenaar01865ad2020-07-26 18:33:09 +02002034 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002035 v9.CheckScriptSuccess(lines)
Kota Kato948a3892022-08-16 16:09:59 +01002036
2037 lines =<< trim END
2038 function s:func(num)
2039 return a:num * 2
2040 endfunction
2041
2042 def s:CallFuncref()
2043 var Funcref = function('s:func')
2044 Funcref(3)->assert_equal(6)
2045 enddef
2046 call s:CallFuncref()
2047 END
2048 v9.CheckScriptSuccess(lines)
2049
2050 lines =<< trim END
2051 function s:func(num)
2052 return a:num * 2
2053 endfunction
2054
2055 def s:CallFuncref()
2056 var Funcref = function(s:func)
2057 Funcref(3)->assert_equal(6)
2058 enddef
2059 call s:CallFuncref()
2060 END
2061 v9.CheckScriptSuccess(lines)
2062
2063 lines =<< trim END
2064 function s:func(num)
2065 return a:num * 2
2066 endfunction
2067
2068 def s:CallFuncref()
2069 var Funcref = s:func
2070 Funcref(3)->assert_equal(6)
2071 enddef
2072 call s:CallFuncref()
2073 END
2074 v9.CheckScriptSuccess(lines)
Bram Moolenaar1df8b3f2020-04-23 18:13:23 +02002075enddef
2076
2077let SomeFunc = function('len')
2078let NotAFunc = 'text'
2079
Bram Moolenaar99aaf0c2020-04-12 14:39:53 +02002080def CombineFuncrefTypes()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002081 # same arguments, different return type
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002082 var Ref1: func(bool): string
2083 var Ref2: func(bool): number
2084 var Ref3: func(bool): any
Bram Moolenaar99aaf0c2020-04-12 14:39:53 +02002085 Ref3 = g:cond ? Ref1 : Ref2
2086
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002087 # different number of arguments
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002088 var Refa1: func(bool): number
2089 var Refa2: func(bool, number): number
2090 var Refa3: func: number
Bram Moolenaar99aaf0c2020-04-12 14:39:53 +02002091 Refa3 = g:cond ? Refa1 : Refa2
2092
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002093 # different argument types
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002094 var Refb1: func(bool, string): number
2095 var Refb2: func(string, number): number
2096 var Refb3: func(any, any): number
Bram Moolenaar99aaf0c2020-04-12 14:39:53 +02002097 Refb3 = g:cond ? Refb1 : Refb2
2098enddef
2099
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002100def FuncWithForwardCall()
Bram Moolenaar1df8b3f2020-04-23 18:13:23 +02002101 return g:DefinedEvenLater("yes")
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002102enddef
2103
2104def DefinedEvenLater(arg: string): string
2105 return arg
2106enddef
2107
2108def Test_error_in_nested_function()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002109 # Error in called function requires unwinding the call stack.
Bram Moolenaar848fadd2022-01-30 15:28:30 +00002110 assert_fails('g:FuncWithForwardCall()', 'E1096:', '', 1, 'FuncWithForwardCall')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002111enddef
2112
Bram Moolenaar4bf10062021-12-28 17:23:12 +00002113def Test_nested_function_with_nextcmd()
Bram Moolenaar9c23f9b2021-12-26 14:23:22 +00002114 var lines =<< trim END
2115 vim9script
2116 # Define an outer function
2117 def FirstFunction()
2118 # Define an inner function
2119 def SecondFunction()
2120 # the function has a body, a double free is detected.
2121 AAAAA
2122
2123 # enddef followed by | or } followed by # one or more characters
2124 enddef|BBBB
2125 enddef
2126
2127 # Compile all functions
2128 defcompile
2129 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002130 v9.CheckScriptFailure(lines, 'E1173: Text found after enddef: BBBB')
Bram Moolenaar9c23f9b2021-12-26 14:23:22 +00002131enddef
2132
Bram Moolenaar4bf10062021-12-28 17:23:12 +00002133def Test_nested_function_with_args_split()
2134 var lines =<< trim END
2135 vim9script
2136 def FirstFunction()
2137 def SecondFunction(
2138 )
2139 # had a double free if the right parenthesis of the nested function is
2140 # on the next line
2141
2142 enddef|BBBB
2143 enddef
2144 # Compile all functions
2145 defcompile
2146 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002147 v9.CheckScriptFailure(lines, 'E1173: Text found after enddef: BBBB')
Bram Moolenaar7473a842021-12-28 17:55:26 +00002148
2149 lines =<< trim END
2150 vim9script
2151 def FirstFunction()
2152 func SecondFunction()
2153 endfunc|BBBB
2154 enddef
2155 defcompile
2156 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002157 v9.CheckScriptFailure(lines, 'E1173: Text found after endfunction: BBBB')
Bram Moolenaar4bf10062021-12-28 17:23:12 +00002158enddef
2159
Bram Moolenaar9f1a39a2022-01-08 15:39:39 +00002160def Test_error_in_function_args()
2161 var lines =<< trim END
2162 def FirstFunction()
2163 def SecondFunction(J =
2164 # Nois
2165 # one
2166
2167 enddef|BBBB
2168 enddef
2169 # Compile all functions
2170 defcompile
2171 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002172 v9.CheckScriptFailure(lines, 'E488:')
Bram Moolenaar9f1a39a2022-01-08 15:39:39 +00002173enddef
2174
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002175def Test_return_type_wrong()
Bram Moolenaar62aec932022-01-29 21:45:34 +00002176 v9.CheckScriptFailure([
Bram Moolenaar5a849da2020-08-08 16:47:30 +02002177 'def Func(): number',
2178 'return "a"',
2179 'enddef',
2180 'defcompile'], 'expected number but got string')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002181 delfunc! g:Func
Bram Moolenaar62aec932022-01-29 21:45:34 +00002182 v9.CheckScriptFailure([
Bram Moolenaar5a849da2020-08-08 16:47:30 +02002183 'def Func(): string',
2184 'return 1',
2185 'enddef',
2186 'defcompile'], 'expected string but got number')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002187 delfunc! g:Func
Bram Moolenaar62aec932022-01-29 21:45:34 +00002188 v9.CheckScriptFailure([
Bram Moolenaar5a849da2020-08-08 16:47:30 +02002189 'def Func(): void',
2190 'return "a"',
2191 'enddef',
2192 'defcompile'],
2193 'E1096: Returning a value in a function without a return type')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002194 delfunc! g:Func
Bram Moolenaar62aec932022-01-29 21:45:34 +00002195 v9.CheckScriptFailure([
Bram Moolenaar5a849da2020-08-08 16:47:30 +02002196 'def Func()',
2197 'return "a"',
2198 'enddef',
2199 'defcompile'],
2200 'E1096: Returning a value in a function without a return type')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002201 delfunc! g:Func
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002202
Bram Moolenaar62aec932022-01-29 21:45:34 +00002203 v9.CheckScriptFailure([
Bram Moolenaar5a849da2020-08-08 16:47:30 +02002204 'def Func(): number',
2205 'return',
2206 'enddef',
2207 'defcompile'], 'E1003:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002208 delfunc! g:Func
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002209
Bram Moolenaar62aec932022-01-29 21:45:34 +00002210 v9.CheckScriptFailure([
Bram Moolenaar33ea9fd2021-08-08 19:07:37 +02002211 'def Func():number',
2212 'return 123',
2213 'enddef',
2214 'defcompile'], 'E1069:')
2215 delfunc! g:Func
2216
Bram Moolenaar62aec932022-01-29 21:45:34 +00002217 v9.CheckScriptFailure([
Bram Moolenaar33ea9fd2021-08-08 19:07:37 +02002218 'def Func() :number',
2219 'return 123',
2220 'enddef',
2221 'defcompile'], 'E1059:')
2222 delfunc! g:Func
2223
Bram Moolenaar62aec932022-01-29 21:45:34 +00002224 v9.CheckScriptFailure([
Bram Moolenaar33ea9fd2021-08-08 19:07:37 +02002225 'def Func() : number',
2226 'return 123',
2227 'enddef',
2228 'defcompile'], 'E1059:')
2229 delfunc! g:Func
2230
Bram Moolenaar62e0e2e2022-08-20 12:07:58 +01002231 v9.CheckScriptFailure(['def Func(): list', 'return []', 'enddef'], 'E1008: Missing <type> after list')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002232 delfunc! g:Func
Bram Moolenaar62e0e2e2022-08-20 12:07:58 +01002233 v9.CheckScriptFailure(['def Func(): dict', 'return {}', 'enddef'], 'E1008: Missing <type> after dict')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002234 delfunc! g:Func
Bram Moolenaar62aec932022-01-29 21:45:34 +00002235 v9.CheckScriptFailure(['def Func()', 'return 1'], 'E1057:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002236 delfunc! g:Func
Bram Moolenaar5a849da2020-08-08 16:47:30 +02002237
Bram Moolenaar62aec932022-01-29 21:45:34 +00002238 v9.CheckScriptFailure([
Bram Moolenaar5a849da2020-08-08 16:47:30 +02002239 'vim9script',
2240 'def FuncB()',
2241 ' return 123',
2242 'enddef',
2243 'def FuncA()',
2244 ' FuncB()',
2245 'enddef',
2246 'defcompile'], 'E1096:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002247enddef
2248
2249def Test_arg_type_wrong()
Bram Moolenaar62e0e2e2022-08-20 12:07:58 +01002250 v9.CheckScriptFailure(['def Func3(items: list)', 'echo "a"', 'enddef'], 'E1008: Missing <type> after list')
Bram Moolenaar62aec932022-01-29 21:45:34 +00002251 v9.CheckScriptFailure(['def Func4(...)', 'echo "a"', 'enddef'], 'E1055: Missing name after ...')
2252 v9.CheckScriptFailure(['def Func5(items:string)', 'echo "a"'], 'E1069:')
2253 v9.CheckScriptFailure(['def Func5(items)', 'echo "a"'], 'E1077:')
2254 v9.CheckScriptFailure(['def Func6(...x:list<number>)', 'echo "a"', 'enddef'], 'E1069:')
2255 v9.CheckScriptFailure(['def Func7(...x: int)', 'echo "a"', 'enddef'], 'E1010:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002256enddef
2257
Bram Moolenaar86cdb8a2021-04-06 19:01:03 +02002258def Test_white_space_before_comma()
2259 var lines =<< trim END
2260 vim9script
2261 def Func(a: number , b: number)
2262 enddef
2263 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002264 v9.CheckScriptFailure(lines, 'E1068:')
Yegappan Lakshmanan611728f2021-05-24 15:15:47 +02002265 call assert_fails('vim9cmd echo stridx("a" .. "b" , "a")', 'E1068:')
Bram Moolenaar86cdb8a2021-04-06 19:01:03 +02002266enddef
2267
Bram Moolenaar608d78f2021-03-06 22:33:12 +01002268def Test_white_space_after_comma()
2269 var lines =<< trim END
2270 vim9script
2271 def Func(a: number,b: number)
2272 enddef
2273 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002274 v9.CheckScriptFailure(lines, 'E1069:')
Bram Moolenaar608d78f2021-03-06 22:33:12 +01002275
2276 # OK in legacy function
2277 lines =<< trim END
2278 vim9script
2279 func Func(a,b)
2280 endfunc
2281 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002282 v9.CheckScriptSuccess(lines)
Bram Moolenaar608d78f2021-03-06 22:33:12 +01002283enddef
2284
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002285def Test_vim9script_call()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002286 var lines =<< trim END
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002287 vim9script
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002288 var name = ''
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002289 def MyFunc(arg: string)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002290 name = arg
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002291 enddef
2292 MyFunc('foobar')
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002293 name->assert_equal('foobar')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002294
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002295 var str = 'barfoo'
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002296 str->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002297 name->assert_equal('barfoo')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002298
Bram Moolenaar67979662020-06-20 22:50:47 +02002299 g:value = 'value'
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002300 g:value->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002301 name->assert_equal('value')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002302
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002303 var listvar = []
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002304 def ListFunc(arg: list<number>)
2305 listvar = arg
2306 enddef
2307 [1, 2, 3]->ListFunc()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002308 listvar->assert_equal([1, 2, 3])
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002309
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002310 var dictvar = {}
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002311 def DictFunc(arg: dict<number>)
2312 dictvar = arg
2313 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +01002314 {a: 1, b: 2}->DictFunc()
2315 dictvar->assert_equal({a: 1, b: 2})
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002316 def CompiledDict()
Bram Moolenaare0de1712020-12-02 17:36:54 +01002317 {a: 3, b: 4}->DictFunc()
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002318 enddef
2319 CompiledDict()
Bram Moolenaare0de1712020-12-02 17:36:54 +01002320 dictvar->assert_equal({a: 3, b: 4})
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002321
Bram Moolenaare0de1712020-12-02 17:36:54 +01002322 {a: 3, b: 4}->DictFunc()
2323 dictvar->assert_equal({a: 3, b: 4})
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002324
2325 ('text')->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002326 name->assert_equal('text')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002327 ("some")->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002328 name->assert_equal('some')
Bram Moolenaare6b53242020-07-01 17:28:33 +02002329
Bram Moolenaar13e12b82020-07-24 18:47:22 +02002330 # line starting with single quote is not a mark
Bram Moolenaar10409562020-07-29 20:00:38 +02002331 # line starting with double quote can be a method call
Bram Moolenaar3d48e252020-07-15 14:15:52 +02002332 'asdfasdf'->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002333 name->assert_equal('asdfasdf')
Bram Moolenaar10409562020-07-29 20:00:38 +02002334 "xyz"->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002335 name->assert_equal('xyz')
Bram Moolenaar3d48e252020-07-15 14:15:52 +02002336
2337 def UseString()
2338 'xyork'->MyFunc()
2339 enddef
2340 UseString()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002341 name->assert_equal('xyork')
Bram Moolenaar3d48e252020-07-15 14:15:52 +02002342
Bram Moolenaar10409562020-07-29 20:00:38 +02002343 def UseString2()
2344 "knife"->MyFunc()
2345 enddef
2346 UseString2()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002347 name->assert_equal('knife')
Bram Moolenaar10409562020-07-29 20:00:38 +02002348
Bram Moolenaar13e12b82020-07-24 18:47:22 +02002349 # prepending a colon makes it a mark
2350 new
2351 setline(1, ['aaa', 'bbb', 'ccc'])
2352 normal! 3Gmt1G
2353 :'t
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002354 getcurpos()[1]->assert_equal(3)
Bram Moolenaar13e12b82020-07-24 18:47:22 +02002355 bwipe!
2356
Bram Moolenaare6b53242020-07-01 17:28:33 +02002357 MyFunc(
2358 'continued'
2359 )
2360 assert_equal('continued',
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002361 name
Bram Moolenaare6b53242020-07-01 17:28:33 +02002362 )
2363
2364 call MyFunc(
2365 'more'
2366 ..
2367 'lines'
2368 )
2369 assert_equal(
2370 'morelines',
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002371 name)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002372 END
Bram Moolenaarf5fec052022-09-11 11:49:22 +01002373 writefile(lines, 'Xcall.vim', 'D')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002374 source Xcall.vim
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002375enddef
2376
2377def Test_vim9script_call_fail_decl()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002378 var lines =<< trim END
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002379 vim9script
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002380 var name = ''
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002381 def MyFunc(arg: string)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002382 var name = 123
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002383 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +02002384 defcompile
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002385 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002386 v9.CheckScriptFailure(lines, 'E1054:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002387enddef
2388
Bram Moolenaar65b95452020-07-19 14:03:09 +02002389def Test_vim9script_call_fail_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002390 var lines =<< trim END
Bram Moolenaar65b95452020-07-19 14:03:09 +02002391 vim9script
2392 def MyFunc(arg: string)
2393 echo arg
2394 enddef
2395 MyFunc(1234)
2396 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002397 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected string but got number')
Bram Moolenaar65b95452020-07-19 14:03:09 +02002398enddef
2399
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002400def Test_vim9script_call_fail_const()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002401 var lines =<< trim END
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002402 vim9script
2403 const var = ''
2404 def MyFunc(arg: string)
2405 var = 'asdf'
2406 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +02002407 defcompile
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002408 END
Bram Moolenaarf5fec052022-09-11 11:49:22 +01002409 writefile(lines, 'Xcall_const.vim', 'D')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +02002410 assert_fails('source Xcall_const.vim', 'E46:', '', 1, 'MyFunc')
Bram Moolenaar3bdc90b2020-12-22 20:35:40 +01002411
2412 lines =<< trim END
2413 const g:Aconst = 77
2414 def Change()
2415 # comment
2416 g:Aconst = 99
2417 enddef
2418 call Change()
2419 unlet g:Aconst
2420 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002421 v9.CheckScriptFailure(lines, 'E741: Value is locked: Aconst', 2)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002422enddef
2423
2424" Test that inside :function a Python function can be defined, :def is not
2425" recognized.
2426func Test_function_python()
2427 CheckFeature python3
Bram Moolenaar727345e2020-09-27 23:33:59 +02002428 let py = 'python3'
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002429 execute py "<< EOF"
2430def do_something():
2431 return 1
2432EOF
2433endfunc
2434
2435def Test_delfunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002436 var lines =<< trim END
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002437 vim9script
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02002438 def g:GoneSoon()
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002439 echo 'hello'
2440 enddef
2441
2442 def CallGoneSoon()
Bram Moolenaar62aec932022-01-29 21:45:34 +00002443 g:GoneSoon()
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002444 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +02002445 defcompile
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002446
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02002447 delfunc g:GoneSoon
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002448 CallGoneSoon()
2449 END
Bram Moolenaarf5fec052022-09-11 11:49:22 +01002450 writefile(lines, 'XToDelFunc', 'D')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +02002451 assert_fails('so XToDelFunc', 'E933:', '', 1, 'CallGoneSoon')
2452 assert_fails('so XToDelFunc', 'E933:', '', 1, 'CallGoneSoon')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002453enddef
2454
Bram Moolenaar7509ad82021-12-14 18:14:37 +00002455func Test_free_dict_while_in_funcstack()
2456 " relies on the sleep command
2457 CheckUnix
2458 call Run_Test_free_dict_while_in_funcstack()
2459endfunc
2460
2461def Run_Test_free_dict_while_in_funcstack()
Bram Moolenaar7509ad82021-12-14 18:14:37 +00002462 # this was freeing the TermRun() default argument dictionary while it was
2463 # still referenced in a funcstack_T
2464 var lines =<< trim END
2465 vim9script
2466
2467 &updatetime = 400
2468 def TermRun(_ = {})
2469 def Post()
2470 enddef
2471 def Exec()
2472 term_start('sleep 1', {
2473 term_finish: 'close',
2474 exit_cb: (_, _) => Post(),
2475 })
2476 enddef
2477 Exec()
2478 enddef
2479 nnoremap <F4> <Cmd>call <SID>TermRun()<CR>
2480 timer_start(100, (_) => feedkeys("\<F4>"))
2481 timer_start(1000, (_) => feedkeys("\<F4>"))
2482 sleep 1500m
2483 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002484 v9.CheckScriptSuccess(lines)
Bram Moolenaar7509ad82021-12-14 18:14:37 +00002485 nunmap <F4>
2486 set updatetime&
2487enddef
2488
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002489def Test_redef_failure()
Bram Moolenaard2c61702020-09-06 15:58:36 +02002490 writefile(['def Func0(): string', 'return "Func0"', 'enddef'], 'Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002491 so Xdef
Bram Moolenaard2c61702020-09-06 15:58:36 +02002492 writefile(['def Func1(): string', 'return "Func1"', 'enddef'], 'Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002493 so Xdef
Bram Moolenaard2c61702020-09-06 15:58:36 +02002494 writefile(['def! Func0(): string', 'enddef', 'defcompile'], 'Xdef')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +02002495 assert_fails('so Xdef', 'E1027:', '', 1, 'Func0')
Bram Moolenaard2c61702020-09-06 15:58:36 +02002496 writefile(['def Func2(): string', 'return "Func2"', 'enddef'], 'Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002497 so Xdef
Bram Moolenaard2c61702020-09-06 15:58:36 +02002498 delete('Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002499
Bram Moolenaar701cc6c2021-04-10 13:33:48 +02002500 assert_fails('g:Func0()', 'E1091:')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002501 g:Func1()->assert_equal('Func1')
2502 g:Func2()->assert_equal('Func2')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002503
2504 delfunc! Func0
2505 delfunc! Func1
2506 delfunc! Func2
2507enddef
2508
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02002509def Test_vim9script_func()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002510 var lines =<< trim END
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02002511 vim9script
2512 func Func(arg)
2513 echo a:arg
2514 endfunc
2515 Func('text')
2516 END
Bram Moolenaarf5fec052022-09-11 11:49:22 +01002517 writefile(lines, 'XVim9Func', 'D')
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02002518 so XVim9Func
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02002519enddef
2520
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002521let s:funcResult = 0
2522
2523def FuncNoArgNoRet()
Bram Moolenaar53900992020-08-22 19:02:02 +02002524 s:funcResult = 11
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002525enddef
2526
2527def FuncNoArgRetNumber(): number
Bram Moolenaar53900992020-08-22 19:02:02 +02002528 s:funcResult = 22
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002529 return 1234
2530enddef
2531
Bram Moolenaarec5929d2020-04-07 20:53:39 +02002532def FuncNoArgRetString(): string
Bram Moolenaar53900992020-08-22 19:02:02 +02002533 s:funcResult = 45
Bram Moolenaarec5929d2020-04-07 20:53:39 +02002534 return 'text'
2535enddef
2536
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002537def FuncOneArgNoRet(arg: number)
Bram Moolenaar53900992020-08-22 19:02:02 +02002538 s:funcResult = arg
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002539enddef
2540
2541def FuncOneArgRetNumber(arg: number): number
Bram Moolenaar53900992020-08-22 19:02:02 +02002542 s:funcResult = arg
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002543 return arg
2544enddef
2545
Bram Moolenaar08938ee2020-04-11 23:17:17 +02002546def FuncTwoArgNoRet(one: bool, two: number)
Bram Moolenaar53900992020-08-22 19:02:02 +02002547 s:funcResult = two
Bram Moolenaar08938ee2020-04-11 23:17:17 +02002548enddef
2549
Bram Moolenaar62aec932022-01-29 21:45:34 +00002550def s:FuncOneArgRetString(arg: string): string
Bram Moolenaarec5929d2020-04-07 20:53:39 +02002551 return arg
2552enddef
2553
Bram Moolenaar62aec932022-01-29 21:45:34 +00002554def s:FuncOneArgRetAny(arg: any): any
Bram Moolenaar89228602020-04-05 22:14:54 +02002555 return arg
2556enddef
2557
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002558def Test_func_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002559 var Ref1: func()
Bram Moolenaar53900992020-08-22 19:02:02 +02002560 s:funcResult = 0
Bram Moolenaar62aec932022-01-29 21:45:34 +00002561 Ref1 = g:FuncNoArgNoRet
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002562 Ref1()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002563 s:funcResult->assert_equal(11)
Bram Moolenaar4c683752020-04-05 21:38:23 +02002564
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002565 var Ref2: func
Bram Moolenaar53900992020-08-22 19:02:02 +02002566 s:funcResult = 0
Bram Moolenaar62aec932022-01-29 21:45:34 +00002567 Ref2 = g:FuncNoArgNoRet
Bram Moolenaar4c683752020-04-05 21:38:23 +02002568 Ref2()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002569 s:funcResult->assert_equal(11)
Bram Moolenaar4c683752020-04-05 21:38:23 +02002570
Bram Moolenaar53900992020-08-22 19:02:02 +02002571 s:funcResult = 0
Bram Moolenaar62aec932022-01-29 21:45:34 +00002572 Ref2 = g:FuncOneArgNoRet
Bram Moolenaar4c683752020-04-05 21:38:23 +02002573 Ref2(12)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002574 s:funcResult->assert_equal(12)
Bram Moolenaar4c683752020-04-05 21:38:23 +02002575
Bram Moolenaar53900992020-08-22 19:02:02 +02002576 s:funcResult = 0
Bram Moolenaar62aec932022-01-29 21:45:34 +00002577 Ref2 = g:FuncNoArgRetNumber
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002578 Ref2()->assert_equal(1234)
2579 s:funcResult->assert_equal(22)
Bram Moolenaar4c683752020-04-05 21:38:23 +02002580
Bram Moolenaar53900992020-08-22 19:02:02 +02002581 s:funcResult = 0
Bram Moolenaar848fadd2022-01-30 15:28:30 +00002582 Ref2 = g:FuncOneArgRetNumber
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002583 Ref2(13)->assert_equal(13)
2584 s:funcResult->assert_equal(13)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002585enddef
2586
Bram Moolenaar9978d472020-07-05 16:01:56 +02002587def Test_repeat_return_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002588 var res = 0
Bram Moolenaar9978d472020-07-05 16:01:56 +02002589 for n in repeat([1], 3)
2590 res += n
2591 endfor
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002592 res->assert_equal(3)
Bram Moolenaarfce82b32020-07-05 16:07:21 +02002593
2594 res = 0
Bakudankun375141e2022-09-09 18:46:47 +01002595 for n in repeat(0z01, 3)->blob2list()
2596 res += n
2597 endfor
2598 res->assert_equal(3)
2599
2600 res = 0
Bram Moolenaarfce82b32020-07-05 16:07:21 +02002601 for n in add([1, 2], 3)
2602 res += n
2603 endfor
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002604 res->assert_equal(6)
Bram Moolenaar9978d472020-07-05 16:01:56 +02002605enddef
2606
Bram Moolenaar846178a2020-07-05 17:04:13 +02002607def Test_argv_return_type()
2608 next fileone filetwo
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002609 var res = ''
Bram Moolenaar846178a2020-07-05 17:04:13 +02002610 for name in argv()
2611 res ..= name
2612 endfor
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002613 res->assert_equal('fileonefiletwo')
Bram Moolenaar846178a2020-07-05 17:04:13 +02002614enddef
2615
Bram Moolenaarec5929d2020-04-07 20:53:39 +02002616def Test_func_type_part()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002617 var RefVoid: func: void
Bram Moolenaar62aec932022-01-29 21:45:34 +00002618 RefVoid = g:FuncNoArgNoRet
2619 RefVoid = g:FuncOneArgNoRet
2620 v9.CheckDefFailure(['var RefVoid: func: void', 'RefVoid = g:FuncNoArgRetNumber'], 'E1012: Type mismatch; expected func(...) but got func(): number')
Bram Moolenaar848fadd2022-01-30 15:28:30 +00002621 v9.CheckDefFailure(['var RefVoid: func: void', 'RefVoid = g:FuncNoArgRetString'], 'E1012: Type mismatch; expected func(...) but got func(): string')
Bram Moolenaarec5929d2020-04-07 20:53:39 +02002622
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002623 var RefAny: func(): any
Bram Moolenaar62aec932022-01-29 21:45:34 +00002624 RefAny = g:FuncNoArgRetNumber
Bram Moolenaar848fadd2022-01-30 15:28:30 +00002625 RefAny = g:FuncNoArgRetString
Bram Moolenaar62aec932022-01-29 21:45:34 +00002626 v9.CheckDefFailure(['var RefAny: func(): any', 'RefAny = g:FuncNoArgNoRet'], 'E1012: Type mismatch; expected func(): any but got func()')
2627 v9.CheckDefFailure(['var RefAny: func(): any', 'RefAny = g:FuncOneArgNoRet'], 'E1012: Type mismatch; expected func(): any but got func(number)')
Bram Moolenaarec5929d2020-04-07 20:53:39 +02002628
Bram Moolenaar6abd3dc2020-10-04 14:17:32 +02002629 var RefAnyNoArgs: func: any = RefAny
2630
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002631 var RefNr: func: number
Bram Moolenaar62aec932022-01-29 21:45:34 +00002632 RefNr = g:FuncNoArgRetNumber
Bram Moolenaar848fadd2022-01-30 15:28:30 +00002633 RefNr = g:FuncOneArgRetNumber
Bram Moolenaar62aec932022-01-29 21:45:34 +00002634 v9.CheckDefFailure(['var RefNr: func: number', 'RefNr = g:FuncNoArgNoRet'], 'E1012: Type mismatch; expected func(...): number but got func()')
Bram Moolenaar848fadd2022-01-30 15:28:30 +00002635 v9.CheckDefFailure(['var RefNr: func: number', 'RefNr = g:FuncNoArgRetString'], 'E1012: Type mismatch; expected func(...): number but got func(): string')
Bram Moolenaarec5929d2020-04-07 20:53:39 +02002636
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002637 var RefStr: func: string
Bram Moolenaar848fadd2022-01-30 15:28:30 +00002638 RefStr = g:FuncNoArgRetString
Bram Moolenaarec5929d2020-04-07 20:53:39 +02002639 RefStr = FuncOneArgRetString
Bram Moolenaar62aec932022-01-29 21:45:34 +00002640 v9.CheckDefFailure(['var RefStr: func: string', 'RefStr = g:FuncNoArgNoRet'], 'E1012: Type mismatch; expected func(...): string but got func()')
2641 v9.CheckDefFailure(['var RefStr: func: string', 'RefStr = g:FuncNoArgRetNumber'], 'E1012: Type mismatch; expected func(...): string but got func(): number')
Bram Moolenaarec5929d2020-04-07 20:53:39 +02002642enddef
2643
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002644def Test_func_type_fails()
Bram Moolenaar62aec932022-01-29 21:45:34 +00002645 v9.CheckDefFailure(['var ref1: func()'], 'E704:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002646
Bram Moolenaar62aec932022-01-29 21:45:34 +00002647 v9.CheckDefFailure(['var Ref1: func()', 'Ref1 = g:FuncNoArgRetNumber'], 'E1012: Type mismatch; expected func() but got func(): number')
2648 v9.CheckDefFailure(['var Ref1: func()', 'Ref1 = g:FuncOneArgNoRet'], 'E1012: Type mismatch; expected func() but got func(number)')
Bram Moolenaar848fadd2022-01-30 15:28:30 +00002649 v9.CheckDefFailure(['var Ref1: func()', 'Ref1 = g:FuncOneArgRetNumber'], 'E1012: Type mismatch; expected func() but got func(number): number')
Bram Moolenaar62aec932022-01-29 21:45:34 +00002650 v9.CheckDefFailure(['var Ref1: func(bool)', 'Ref1 = g:FuncTwoArgNoRet'], 'E1012: Type mismatch; expected func(bool) but got func(bool, number)')
2651 v9.CheckDefFailure(['var Ref1: func(?bool)', 'Ref1 = g:FuncTwoArgNoRet'], 'E1012: Type mismatch; expected func(?bool) but got func(bool, number)')
2652 v9.CheckDefFailure(['var Ref1: func(...bool)', 'Ref1 = g:FuncTwoArgNoRet'], 'E1012: Type mismatch; expected func(...bool) but got func(bool, number)')
Bram Moolenaar08938ee2020-04-11 23:17:17 +02002653
Bram Moolenaar62aec932022-01-29 21:45:34 +00002654 v9.CheckDefFailure(['var RefWrong: func(string ,number)'], 'E1068:')
2655 v9.CheckDefFailure(['var RefWrong: func(string,number)'], 'E1069:')
2656 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:')
2657 v9.CheckDefFailure(['var RefWrong: func(bool):string'], 'E1069:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002658enddef
2659
Bram Moolenaar89228602020-04-05 22:14:54 +02002660def Test_func_return_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002661 var nr: number
Bram Moolenaar62aec932022-01-29 21:45:34 +00002662 nr = g:FuncNoArgRetNumber()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002663 nr->assert_equal(1234)
Bram Moolenaar89228602020-04-05 22:14:54 +02002664
2665 nr = FuncOneArgRetAny(122)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002666 nr->assert_equal(122)
Bram Moolenaar89228602020-04-05 22:14:54 +02002667
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002668 var str: string
Bram Moolenaar89228602020-04-05 22:14:54 +02002669 str = FuncOneArgRetAny('yes')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002670 str->assert_equal('yes')
Bram Moolenaar89228602020-04-05 22:14:54 +02002671
Bram Moolenaar62aec932022-01-29 21:45:34 +00002672 v9.CheckDefFailure(['var str: string', 'str = g:FuncNoArgRetNumber()'], 'E1012: Type mismatch; expected string but got number')
Bram Moolenaar89228602020-04-05 22:14:54 +02002673enddef
2674
Bram Moolenaar6abd3dc2020-10-04 14:17:32 +02002675def Test_func_common_type()
2676 def FuncOne(n: number): number
2677 return n
2678 enddef
2679 def FuncTwo(s: string): number
2680 return len(s)
2681 enddef
2682 def FuncThree(n: number, s: string): number
2683 return n + len(s)
2684 enddef
2685 var list = [FuncOne, FuncTwo, FuncThree]
2686 assert_equal(8, list[0](8))
2687 assert_equal(4, list[1]('word'))
2688 assert_equal(7, list[2](3, 'word'))
2689enddef
2690
Bram Moolenaar62aec932022-01-29 21:45:34 +00002691def s:MultiLine(
Bram Moolenaar5e774c72020-04-12 21:53:00 +02002692 arg1: string,
2693 arg2 = 1234,
2694 ...rest: list<string>
2695 ): string
2696 return arg1 .. arg2 .. join(rest, '-')
2697enddef
2698
Bram Moolenaar2c330432020-04-13 14:41:35 +02002699def MultiLineComment(
2700 arg1: string, # comment
2701 arg2 = 1234, # comment
2702 ...rest: list<string> # comment
2703 ): string # comment
2704 return arg1 .. arg2 .. join(rest, '-')
2705enddef
2706
Bram Moolenaar5e774c72020-04-12 21:53:00 +02002707def Test_multiline()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002708 MultiLine('text')->assert_equal('text1234')
2709 MultiLine('text', 777)->assert_equal('text777')
2710 MultiLine('text', 777, 'one')->assert_equal('text777one')
2711 MultiLine('text', 777, 'one', 'two')->assert_equal('text777one-two')
Bram Moolenaar5e774c72020-04-12 21:53:00 +02002712enddef
2713
Bram Moolenaar23e03252020-04-12 22:22:31 +02002714func Test_multiline_not_vim9()
Bram Moolenaar62aec932022-01-29 21:45:34 +00002715 call s:MultiLine('text')->assert_equal('text1234')
2716 call s:MultiLine('text', 777)->assert_equal('text777')
2717 call s:MultiLine('text', 777, 'one')->assert_equal('text777one')
2718 call s:MultiLine('text', 777, 'one', 'two')->assert_equal('text777one-two')
Bram Moolenaar23e03252020-04-12 22:22:31 +02002719endfunc
2720
Bram Moolenaar5e774c72020-04-12 21:53:00 +02002721
Bram Moolenaaree4e0c12020-04-06 21:35:05 +02002722" When using CheckScriptFailure() for the below test, E1010 is generated instead
2723" of E1056.
2724func Test_E1056_1059()
2725 let caught_1056 = 0
2726 try
2727 def F():
2728 return 1
2729 enddef
2730 catch /E1056:/
2731 let caught_1056 = 1
2732 endtry
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002733 eval caught_1056->assert_equal(1)
Bram Moolenaaree4e0c12020-04-06 21:35:05 +02002734
2735 let caught_1059 = 0
2736 try
2737 def F5(items : list)
2738 echo 'a'
2739 enddef
2740 catch /E1059:/
2741 let caught_1059 = 1
2742 endtry
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002743 eval caught_1059->assert_equal(1)
Bram Moolenaaree4e0c12020-04-06 21:35:05 +02002744endfunc
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002745
Bram Moolenaar015f4262020-05-05 21:25:22 +02002746func DelMe()
2747 echo 'DelMe'
2748endfunc
2749
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002750def Test_error_reporting()
2751 # comment lines at the start of the function
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002752 var lines =<< trim END
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002753 " comment
2754 def Func()
2755 # comment
2756 # comment
2757 invalid
2758 enddef
2759 defcompile
2760 END
Bram Moolenaarf5fec052022-09-11 11:49:22 +01002761 writefile(lines, 'Xdef', 'D')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002762 try
2763 source Xdef
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02002764 assert_report('should have failed')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002765 catch /E476:/
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002766 v:exception->assert_match('Invalid command: invalid')
2767 v:throwpoint->assert_match(', line 3$')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002768 endtry
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002769 delfunc! g:Func
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002770
2771 # comment lines after the start of the function
2772 lines =<< trim END
2773 " comment
2774 def Func()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002775 var x = 1234
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002776 # comment
2777 # comment
2778 invalid
2779 enddef
2780 defcompile
2781 END
Bram Moolenaar08052222020-09-14 17:04:31 +02002782 writefile(lines, 'Xdef')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002783 try
2784 source Xdef
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02002785 assert_report('should have failed')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002786 catch /E476:/
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002787 v:exception->assert_match('Invalid command: invalid')
2788 v:throwpoint->assert_match(', line 4$')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002789 endtry
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002790 delfunc! g:Func
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002791
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02002792 lines =<< trim END
2793 vim9script
2794 def Func()
Bram Moolenaare0de1712020-12-02 17:36:54 +01002795 var db = {foo: 1, bar: 2}
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02002796 # comment
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002797 var x = db.asdf
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02002798 enddef
2799 defcompile
2800 Func()
2801 END
Bram Moolenaar08052222020-09-14 17:04:31 +02002802 writefile(lines, 'Xdef')
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02002803 try
2804 source Xdef
2805 assert_report('should have failed')
2806 catch /E716:/
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002807 v:throwpoint->assert_match('_Func, line 3$')
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02002808 endtry
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002809 delfunc! g:Func
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002810enddef
2811
Bram Moolenaar015f4262020-05-05 21:25:22 +02002812def Test_deleted_function()
Bram Moolenaar62aec932022-01-29 21:45:34 +00002813 v9.CheckDefExecFailure([
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002814 'var RefMe: func = function("g:DelMe")',
Bram Moolenaar015f4262020-05-05 21:25:22 +02002815 'delfunc g:DelMe',
2816 'echo RefMe()'], 'E117:')
2817enddef
2818
2819def Test_unknown_function()
Bram Moolenaar62aec932022-01-29 21:45:34 +00002820 v9.CheckDefExecFailure([
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002821 'var Ref: func = function("NotExist")',
Bram Moolenaar9b7bf9e2020-07-11 22:14:59 +02002822 'delfunc g:NotExist'], 'E700:')
Bram Moolenaar015f4262020-05-05 21:25:22 +02002823enddef
2824
Bram Moolenaar62aec932022-01-29 21:45:34 +00002825def s:RefFunc(Ref: func(any): any): string
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02002826 return Ref('more')
2827enddef
2828
2829def Test_closure_simple()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002830 var local = 'some '
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002831 RefFunc((s) => local .. s)->assert_equal('some more')
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02002832enddef
2833
Bram Moolenaar62aec932022-01-29 21:45:34 +00002834def s:MakeRef()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002835 var local = 'some '
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002836 g:Ref = (s) => local .. s
Bram Moolenaarbf67ea12020-05-02 17:52:42 +02002837enddef
2838
2839def Test_closure_ref_after_return()
2840 MakeRef()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002841 g:Ref('thing')->assert_equal('some thing')
Bram Moolenaarbf67ea12020-05-02 17:52:42 +02002842 unlet g:Ref
2843enddef
2844
Bram Moolenaar62aec932022-01-29 21:45:34 +00002845def s:MakeTwoRefs()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002846 var local = ['some']
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002847 g:Extend = (s) => local->add(s)
2848 g:Read = () => local
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002849enddef
2850
2851def Test_closure_two_refs()
2852 MakeTwoRefs()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002853 join(g:Read(), ' ')->assert_equal('some')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002854 g:Extend('more')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002855 join(g:Read(), ' ')->assert_equal('some more')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002856 g:Extend('even')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002857 join(g:Read(), ' ')->assert_equal('some more even')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002858
2859 unlet g:Extend
2860 unlet g:Read
2861enddef
2862
Bram Moolenaar62aec932022-01-29 21:45:34 +00002863def s:ReadRef(Ref: func(): list<string>): string
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002864 return join(Ref(), ' ')
2865enddef
2866
Bram Moolenaar62aec932022-01-29 21:45:34 +00002867def s:ExtendRef(Ref: func(string): list<string>, add: string)
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002868 Ref(add)
2869enddef
2870
2871def Test_closure_two_indirect_refs()
Bram Moolenaarf7779c62020-05-03 15:38:16 +02002872 MakeTwoRefs()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002873 ReadRef(g:Read)->assert_equal('some')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002874 ExtendRef(g:Extend, 'more')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002875 ReadRef(g:Read)->assert_equal('some more')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002876 ExtendRef(g:Extend, 'even')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002877 ReadRef(g:Read)->assert_equal('some more even')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002878
2879 unlet g:Extend
2880 unlet g:Read
2881enddef
Bram Moolenaarbf67ea12020-05-02 17:52:42 +02002882
Bram Moolenaar62aec932022-01-29 21:45:34 +00002883def s:MakeArgRefs(theArg: string)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002884 var local = 'loc_val'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002885 g:UseArg = (s) => theArg .. '/' .. local .. '/' .. s
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02002886enddef
2887
Bram Moolenaar62aec932022-01-29 21:45:34 +00002888def s:MakeArgRefsVarargs(theArg: string, ...rest: list<string>)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002889 var local = 'the_loc'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002890 g:UseVararg = (s) => theArg .. '/' .. local .. '/' .. s .. '/' .. join(rest)
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02002891enddef
2892
2893def Test_closure_using_argument()
2894 MakeArgRefs('arg_val')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002895 g:UseArg('call_val')->assert_equal('arg_val/loc_val/call_val')
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02002896
2897 MakeArgRefsVarargs('arg_val', 'one', 'two')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002898 g:UseVararg('call_val')->assert_equal('arg_val/the_loc/call_val/one two')
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02002899
2900 unlet g:UseArg
2901 unlet g:UseVararg
Bram Moolenaar44ec21c2021-02-12 21:50:57 +01002902
2903 var lines =<< trim END
2904 vim9script
2905 def Test(Fun: func(number): number): list<number>
2906 return map([1, 2, 3], (_, i) => Fun(i))
2907 enddef
2908 def Inc(nr: number): number
2909 return nr + 2
2910 enddef
2911 assert_equal([3, 4, 5], Test(Inc))
2912 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002913 v9.CheckScriptSuccess(lines)
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02002914enddef
2915
Bram Moolenaar62aec932022-01-29 21:45:34 +00002916def s:MakeGetAndAppendRefs()
Bram Moolenaar85d5e2b2020-10-10 14:13:01 +02002917 var local = 'a'
2918
2919 def Append(arg: string)
2920 local ..= arg
2921 enddef
2922 g:Append = Append
2923
2924 def Get(): string
2925 return local
2926 enddef
2927 g:Get = Get
2928enddef
2929
2930def Test_closure_append_get()
2931 MakeGetAndAppendRefs()
2932 g:Get()->assert_equal('a')
2933 g:Append('-b')
2934 g:Get()->assert_equal('a-b')
2935 g:Append('-c')
2936 g:Get()->assert_equal('a-b-c')
2937
2938 unlet g:Append
2939 unlet g:Get
2940enddef
Bram Moolenaarb68b3462020-05-06 21:06:30 +02002941
Bram Moolenaar04b12692020-05-04 23:24:44 +02002942def Test_nested_closure()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002943 var local = 'text'
Bram Moolenaar04b12692020-05-04 23:24:44 +02002944 def Closure(arg: string): string
2945 return local .. arg
2946 enddef
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002947 Closure('!!!')->assert_equal('text!!!')
Bram Moolenaar04b12692020-05-04 23:24:44 +02002948enddef
2949
Bram Moolenaar62aec932022-01-29 21:45:34 +00002950func s:GetResult(Ref)
Bram Moolenaar6f5b6df2020-05-16 21:20:12 +02002951 return a:Ref('some')
2952endfunc
2953
2954def Test_call_closure_not_compiled()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002955 var text = 'text'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002956 g:Ref = (s) => s .. text
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002957 GetResult(g:Ref)->assert_equal('sometext')
Bram Moolenaar6f5b6df2020-05-16 21:20:12 +02002958enddef
2959
Bram Moolenaar7cbfaa52020-09-18 21:25:32 +02002960def Test_double_closure_fails()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002961 var lines =<< trim END
Bram Moolenaar7cbfaa52020-09-18 21:25:32 +02002962 vim9script
2963 def Func()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002964 var name = 0
2965 for i in range(2)
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002966 timer_start(0, () => name)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002967 endfor
Bram Moolenaar7cbfaa52020-09-18 21:25:32 +02002968 enddef
2969 Func()
2970 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002971 v9.CheckScriptSuccess(lines)
Bram Moolenaar7cbfaa52020-09-18 21:25:32 +02002972enddef
2973
Bram Moolenaar85d5e2b2020-10-10 14:13:01 +02002974def Test_nested_closure_used()
2975 var lines =<< trim END
2976 vim9script
2977 def Func()
2978 var x = 'hello'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002979 var Closure = () => x
2980 g:Myclosure = () => Closure()
Bram Moolenaar85d5e2b2020-10-10 14:13:01 +02002981 enddef
2982 Func()
2983 assert_equal('hello', g:Myclosure())
2984 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002985 v9.CheckScriptSuccess(lines)
Bram Moolenaar85d5e2b2020-10-10 14:13:01 +02002986enddef
Bram Moolenaar0876c782020-10-07 19:08:04 +02002987
Bram Moolenaarc70bdab2020-09-26 19:59:38 +02002988def Test_nested_closure_fails()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002989 var lines =<< trim END
Bram Moolenaarc70bdab2020-09-26 19:59:38 +02002990 vim9script
2991 def FuncA()
2992 FuncB(0)
2993 enddef
2994 def FuncB(n: number): list<string>
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002995 return map([0], (_, v) => n)
Bram Moolenaarc70bdab2020-09-26 19:59:38 +02002996 enddef
2997 FuncA()
2998 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002999 v9.CheckScriptFailure(lines, 'E1012:')
Bram Moolenaarc70bdab2020-09-26 19:59:38 +02003000enddef
3001
Bram Moolenaar6de22962022-09-09 21:35:36 +01003002def Run_Test_closure_in_for_loop_fails()
3003 var lines =<< trim END
3004 vim9script
Bram Moolenaar766ae5b2022-09-14 00:30:51 +01003005 redraw
Bram Moolenaar6de22962022-09-09 21:35:36 +01003006 for n in [0]
Bram Moolenaar766ae5b2022-09-14 00:30:51 +01003007 # time should be enough for startup to finish
3008 timer_start(200, (_) => {
Bram Moolenaar6de22962022-09-09 21:35:36 +01003009 echo n
3010 })
3011 endfor
3012 END
3013 writefile(lines, 'XTest_closure_fails', 'D')
3014
3015 # Check that an error shows
Bram Moolenaarc069ede2022-09-11 12:01:04 +01003016 var buf = g:RunVimInTerminal('-S XTest_closure_fails', {rows: 6, wait_for_ruler: 0})
Bram Moolenaar766ae5b2022-09-14 00:30:51 +01003017 g:VerifyScreenDump(buf, 'Test_vim9_closure_fails', {wait: 3000})
Bram Moolenaar6de22962022-09-09 21:35:36 +01003018
3019 # clean up
3020 g:StopVimInTerminal(buf)
3021enddef
3022
3023func Test_closure_in_for_loop_fails()
3024 CheckScreendump
3025 call Run_Test_closure_in_for_loop_fails()
3026endfunc
3027
Bram Moolenaarf112f302020-12-20 17:47:52 +01003028def Test_global_closure()
3029 var lines =<< trim END
3030 vim9script
3031 def ReverseEveryNLines(n: number, line1: number, line2: number)
3032 var mods = 'sil keepj keepp lockm '
3033 var range = ':' .. line1 .. ',' .. line2
3034 def g:Offset(): number
3035 var offset = (line('.') - line1 + 1) % n
3036 return offset != 0 ? offset : n
3037 enddef
3038 exe mods .. range .. 'g/^/exe "m .-" .. g:Offset()'
3039 enddef
3040
3041 new
3042 repeat(['aaa', 'bbb', 'ccc'], 3)->setline(1)
3043 ReverseEveryNLines(3, 1, 9)
3044 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003045 v9.CheckScriptSuccess(lines)
Bram Moolenaarf112f302020-12-20 17:47:52 +01003046 var expected = repeat(['ccc', 'bbb', 'aaa'], 3)
3047 assert_equal(expected, getline(1, 9))
3048 bwipe!
3049enddef
3050
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01003051def Test_global_closure_called_directly()
3052 var lines =<< trim END
3053 vim9script
3054 def Outer()
3055 var x = 1
3056 def g:Inner()
3057 var y = x
3058 x += 1
3059 assert_equal(1, y)
3060 enddef
3061 g:Inner()
3062 assert_equal(2, x)
3063 enddef
3064 Outer()
3065 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003066 v9.CheckScriptSuccess(lines)
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01003067 delfunc g:Inner
3068enddef
3069
Bram Moolenaar69c76172021-12-02 16:38:52 +00003070def Test_closure_called_from_legacy()
3071 var lines =<< trim END
3072 vim9script
3073 def Func()
3074 var outer = 'foo'
3075 var F = () => {
3076 outer = 'bar'
3077 }
3078 execute printf('call %s()', string(F))
3079 enddef
3080 Func()
3081 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003082 v9.CheckScriptFailure(lines, 'E1248')
Bram Moolenaar69c76172021-12-02 16:38:52 +00003083enddef
3084
Bram Moolenaar34c54eb2020-11-25 19:15:19 +01003085def Test_failure_in_called_function()
3086 # this was using the frame index as the return value
3087 var lines =<< trim END
3088 vim9script
3089 au TerminalWinOpen * eval [][0]
3090 def PopupTerm(a: any)
3091 # make sure typvals on stack are string
3092 ['a', 'b', 'c', 'd', 'e', 'f', 'g']->join()
3093 FireEvent()
3094 enddef
3095 def FireEvent()
3096 do TerminalWinOpen
3097 enddef
3098 # use try/catch to make eval fail
3099 try
3100 call PopupTerm(0)
3101 catch
3102 endtry
3103 au! TerminalWinOpen
3104 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003105 v9.CheckScriptSuccess(lines)
Bram Moolenaar34c54eb2020-11-25 19:15:19 +01003106enddef
3107
Bram Moolenaar5366e1a2020-10-01 13:01:34 +02003108def Test_nested_lambda()
3109 var lines =<< trim END
3110 vim9script
3111 def Func()
3112 var x = 4
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01003113 var Lambda1 = () => 7
3114 var Lambda2 = () => [Lambda1(), x]
Bram Moolenaar5366e1a2020-10-01 13:01:34 +02003115 var res = Lambda2()
3116 assert_equal([7, 4], res)
3117 enddef
3118 Func()
3119 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003120 v9.CheckScriptSuccess(lines)
Bram Moolenaar5366e1a2020-10-01 13:01:34 +02003121enddef
3122
Bram Moolenaarc04f2a42021-06-09 19:30:03 +02003123def Test_double_nested_lambda()
3124 var lines =<< trim END
3125 vim9script
3126 def F(head: string): func(string): func(string): string
3127 return (sep: string): func(string): string => ((tail: string): string => {
3128 return head .. sep .. tail
3129 })
3130 enddef
3131 assert_equal('hello-there', F('hello')('-')('there'))
3132 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003133 v9.CheckScriptSuccess(lines)
Bram Moolenaarc04f2a42021-06-09 19:30:03 +02003134enddef
3135
Bram Moolenaar074f84c2021-05-18 11:47:44 +02003136def Test_nested_inline_lambda()
Bram Moolenaar074f84c2021-05-18 11:47:44 +02003137 var lines =<< trim END
3138 vim9script
3139 def F(text: string): func(string): func(string): string
3140 return (arg: string): func(string): string => ((sep: string): string => {
Bram Moolenaar23e2e112021-08-03 21:16:18 +02003141 return sep .. arg .. text
Bram Moolenaar074f84c2021-05-18 11:47:44 +02003142 })
3143 enddef
Bram Moolenaar23e2e112021-08-03 21:16:18 +02003144 assert_equal('--there++', F('++')('there')('--'))
Bram Moolenaar074f84c2021-05-18 11:47:44 +02003145 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003146 v9.CheckScriptSuccess(lines)
Bram Moolenaar5245beb2021-07-15 22:03:50 +02003147
3148 lines =<< trim END
3149 vim9script
3150 echo range(4)->mapnew((_, v) => {
3151 return range(v) ->mapnew((_, s) => {
3152 return string(s)
3153 })
3154 })
3155 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003156 v9.CheckScriptSuccess(lines)
Bram Moolenaarc6ba2f92021-07-18 13:42:29 +02003157
3158 lines =<< trim END
3159 vim9script
3160
Bram Moolenaara749a422022-02-12 19:52:25 +00003161 def Func()
Bram Moolenaarc6ba2f92021-07-18 13:42:29 +02003162 range(10)
3163 ->mapnew((_, _) => ({
3164 key: range(10)->mapnew((_, _) => {
3165 return ' '
3166 }),
3167 }))
3168 enddef
3169
3170 defcomp
3171 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003172 v9.CheckScriptSuccess(lines)
Bram Moolenaar074f84c2021-05-18 11:47:44 +02003173enddef
3174
Bram Moolenaar52bf81c2020-11-17 18:50:44 +01003175def Shadowed(): list<number>
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01003176 var FuncList: list<func: number> = [() => 42]
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01003177 return FuncList->mapnew((_, Shadowed) => Shadowed())
Bram Moolenaar52bf81c2020-11-17 18:50:44 +01003178enddef
3179
3180def Test_lambda_arg_shadows_func()
Bram Moolenaar62aec932022-01-29 21:45:34 +00003181 assert_equal([42], g:Shadowed())
Bram Moolenaar52bf81c2020-11-17 18:50:44 +01003182enddef
3183
Bram Moolenaar21dc8f12022-03-16 17:54:17 +00003184def Test_compiling_referenced_func_no_shadow()
3185 var lines =<< trim END
3186 vim9script
3187
3188 def InitializeReply(lspserver: dict<any>)
3189 enddef
3190
3191 def ProcessReply(lspserver: dict<any>)
3192 var lsp_reply_handlers: dict<func> =
3193 { 'initialize': InitializeReply }
3194 lsp_reply_handlers['initialize'](lspserver)
3195 enddef
3196
3197 call ProcessReply({})
3198 END
3199 v9.CheckScriptSuccess(lines)
3200enddef
3201
Bram Moolenaar62aec932022-01-29 21:45:34 +00003202def s:Line_continuation_in_def(dir: string = ''): string
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02003203 var path: string = empty(dir)
3204 \ ? 'empty'
3205 \ : 'full'
3206 return path
Bram Moolenaaracd4c5e2020-06-22 19:39:03 +02003207enddef
3208
3209def Test_line_continuation_in_def()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02003210 Line_continuation_in_def('.')->assert_equal('full')
Bram Moolenaaracd4c5e2020-06-22 19:39:03 +02003211enddef
3212
Bram Moolenaar2ea95b62020-11-19 21:47:56 +01003213def Test_script_var_in_lambda()
3214 var lines =<< trim END
3215 vim9script
3216 var script = 'test'
Bram Moolenaarbb8a7ce2021-04-10 20:10:26 +02003217 assert_equal(['test'], map(['one'], (_, _) => script))
Bram Moolenaar2ea95b62020-11-19 21:47:56 +01003218 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003219 v9.CheckScriptSuccess(lines)
Bram Moolenaar2ea95b62020-11-19 21:47:56 +01003220enddef
3221
Bram Moolenaar62aec932022-01-29 21:45:34 +00003222def s:Line_continuation_in_lambda(): list<string>
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02003223 var x = range(97, 100)
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01003224 ->mapnew((_, v) => nr2char(v)
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01003225 ->toupper())
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02003226 ->reverse()
3227 return x
3228enddef
3229
3230def Test_line_continuation_in_lambda()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02003231 Line_continuation_in_lambda()->assert_equal(['D', 'C', 'B', 'A'])
Bram Moolenaarf898f7c2021-01-16 18:09:52 +01003232
3233 var lines =<< trim END
3234 vim9script
3235 var res = [{n: 1, m: 2, s: 'xxx'}]
3236 ->mapnew((_, v: dict<any>): string => printf('%d:%d:%s',
3237 v.n,
3238 v.m,
3239 substitute(v.s, '.*', 'yyy', '')
3240 ))
3241 assert_equal(['1:2:yyy'], res)
3242 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003243 v9.CheckScriptSuccess(lines)
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02003244enddef
3245
Bram Moolenaarb6571982021-01-08 22:24:19 +01003246def Test_list_lambda()
3247 timer_start(1000, (_) => 0)
3248 var body = execute(timer_info()[0].callback
3249 ->string()
3250 ->substitute("('", ' ', '')
3251 ->substitute("')", '', '')
3252 ->substitute('function\zs', ' ', ''))
Bram Moolenaar767034c2021-04-09 17:24:52 +02003253 assert_match('def <lambda>\d\+(_: any): number\n1 return 0\n enddef', body)
Bram Moolenaarb6571982021-01-08 22:24:19 +01003254enddef
3255
Bram Moolenaar3c77b6a2021-07-25 18:07:00 +02003256def Test_lambda_block_variable()
Bram Moolenaar88421d62021-07-24 14:14:52 +02003257 var lines =<< trim END
3258 vim9script
3259 var flist: list<func>
3260 for i in range(10)
3261 var inloop = i
3262 flist[i] = () => inloop
3263 endfor
3264 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003265 v9.CheckScriptSuccess(lines)
Bram Moolenaar88421d62021-07-24 14:14:52 +02003266
3267 lines =<< trim END
3268 vim9script
3269 if true
3270 var outloop = 5
3271 var flist: list<func>
3272 for i in range(10)
3273 flist[i] = () => outloop
3274 endfor
3275 endif
3276 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003277 v9.CheckScriptSuccess(lines)
Bram Moolenaar88421d62021-07-24 14:14:52 +02003278
3279 lines =<< trim END
3280 vim9script
3281 if true
3282 var outloop = 5
3283 endif
3284 var flist: list<func>
3285 for i in range(10)
3286 flist[i] = () => outloop
3287 endfor
3288 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003289 v9.CheckScriptFailure(lines, 'E1001: Variable not found: outloop', 1)
Bram Moolenaar3c77b6a2021-07-25 18:07:00 +02003290
3291 lines =<< trim END
3292 vim9script
3293 for i in range(10)
3294 var Ref = () => 0
3295 endfor
3296 assert_equal(0, ((i) => 0)(0))
3297 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003298 v9.CheckScriptSuccess(lines)
Bram Moolenaar88421d62021-07-24 14:14:52 +02003299enddef
3300
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02003301def Test_legacy_lambda()
3302 legacy echo {x -> 'hello ' .. x}('foo')
Bram Moolenaardc4c2302021-04-25 13:54:42 +02003303
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02003304 var lines =<< trim END
3305 echo {x -> 'hello ' .. x}('foo')
3306 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003307 v9.CheckDefAndScriptFailure(lines, 'E720:')
Bram Moolenaardc4c2302021-04-25 13:54:42 +02003308
3309 lines =<< trim END
3310 vim9script
3311 def Func()
3312 echo (() => 'no error')()
3313 enddef
3314 legacy call s:Func()
3315 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003316 v9.CheckScriptSuccess(lines)
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02003317enddef
3318
Bram Moolenaarce024c32021-06-26 13:00:49 +02003319def Test_legacy()
3320 var lines =<< trim END
3321 vim9script
3322 func g:LegacyFunction()
3323 let g:legacyvar = 1
3324 endfunc
3325 def Testit()
3326 legacy call g:LegacyFunction()
3327 enddef
3328 Testit()
3329 assert_equal(1, g:legacyvar)
3330 unlet g:legacyvar
3331 delfunc g:LegacyFunction
3332 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003333 v9.CheckScriptSuccess(lines)
Bram Moolenaarce024c32021-06-26 13:00:49 +02003334enddef
3335
Bram Moolenaarc3cb1c92021-06-02 16:47:53 +02003336def Test_legacy_errors()
3337 for cmd in ['if', 'elseif', 'else', 'endif',
3338 'for', 'endfor', 'continue', 'break',
3339 'while', 'endwhile',
3340 'try', 'catch', 'finally', 'endtry']
Bram Moolenaar62aec932022-01-29 21:45:34 +00003341 v9.CheckDefFailure(['legacy ' .. cmd .. ' expr'], 'E1189:')
Bram Moolenaarc3cb1c92021-06-02 16:47:53 +02003342 endfor
3343enddef
3344
Bram Moolenaarb1b6f4d2021-09-13 18:25:54 +02003345def Test_call_legacy_with_dict()
3346 var lines =<< trim END
3347 vim9script
3348 func Legacy() dict
3349 let g:result = self.value
3350 endfunc
3351 def TestDirect()
3352 var d = {value: 'yes', func: Legacy}
3353 d.func()
3354 enddef
3355 TestDirect()
3356 assert_equal('yes', g:result)
3357 unlet g:result
3358
3359 def TestIndirect()
3360 var d = {value: 'foo', func: Legacy}
3361 var Fi = d.func
3362 Fi()
3363 enddef
3364 TestIndirect()
3365 assert_equal('foo', g:result)
3366 unlet g:result
3367
3368 var d = {value: 'bar', func: Legacy}
3369 d.func()
3370 assert_equal('bar', g:result)
3371 unlet g:result
3372 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003373 v9.CheckScriptSuccess(lines)
Bram Moolenaarb1b6f4d2021-09-13 18:25:54 +02003374enddef
3375
Bram Moolenaar62aec932022-01-29 21:45:34 +00003376def s:DoFilterThis(a: string): list<string>
Bram Moolenaarab360522021-01-10 14:02:28 +01003377 # closure nested inside another closure using argument
3378 var Filter = (l) => filter(l, (_, v) => stridx(v, a) == 0)
3379 return ['x', 'y', 'a', 'x2', 'c']->Filter()
3380enddef
3381
3382def Test_nested_closure_using_argument()
3383 assert_equal(['x', 'x2'], DoFilterThis('x'))
3384enddef
3385
Bram Moolenaar0186e582021-01-10 18:33:11 +01003386def Test_triple_nested_closure()
3387 var what = 'x'
3388 var Match = (val: string, cmp: string): bool => stridx(val, cmp) == 0
3389 var Filter = (l) => filter(l, (_, v) => Match(v, what))
3390 assert_equal(['x', 'x2'], ['x', 'y', 'a', 'x2', 'c']->Filter())
3391enddef
3392
Bram Moolenaar8f510af2020-07-05 18:48:23 +02003393func Test_silent_echo()
Bram Moolenaar47e7d702020-07-05 18:18:42 +02003394 CheckScreendump
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003395 call Run_Test_silent_echo()
3396endfunc
Bram Moolenaar47e7d702020-07-05 18:18:42 +02003397
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003398def Run_Test_silent_echo()
3399 var lines =<< trim END
Bram Moolenaar47e7d702020-07-05 18:18:42 +02003400 vim9script
3401 def EchoNothing()
3402 silent echo ''
3403 enddef
3404 defcompile
3405 END
Bram Moolenaar6de22962022-09-09 21:35:36 +01003406 writefile(lines, 'XTest_silent_echo', 'D')
Bram Moolenaar47e7d702020-07-05 18:18:42 +02003407
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003408 # Check that the balloon shows up after a mouse move
Bram Moolenaar62aec932022-01-29 21:45:34 +00003409 var buf = g:RunVimInTerminal('-S XTest_silent_echo', {'rows': 6})
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003410 term_sendkeys(buf, ":abc")
Bram Moolenaar62aec932022-01-29 21:45:34 +00003411 g:VerifyScreenDump(buf, 'Test_vim9_silent_echo', {})
Bram Moolenaar47e7d702020-07-05 18:18:42 +02003412
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003413 # clean up
Bram Moolenaar62aec932022-01-29 21:45:34 +00003414 g:StopVimInTerminal(buf)
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003415enddef
Bram Moolenaar47e7d702020-07-05 18:18:42 +02003416
Bram Moolenaar171fb922020-10-28 16:54:47 +01003417def SilentlyError()
3418 execute('silent! invalid')
3419 g:did_it = 'yes'
3420enddef
3421
Bram Moolenaar62aec932022-01-29 21:45:34 +00003422func s:UserError()
Bram Moolenaar28ee8922020-10-28 20:20:00 +01003423 silent! invalid
3424endfunc
3425
3426def SilentlyUserError()
3427 UserError()
3428 g:did_it = 'yes'
3429enddef
Bram Moolenaar171fb922020-10-28 16:54:47 +01003430
3431" This can't be a :def function, because the assert would not be reached.
Bram Moolenaar171fb922020-10-28 16:54:47 +01003432func Test_ignore_silent_error()
3433 let g:did_it = 'no'
3434 call SilentlyError()
3435 call assert_equal('yes', g:did_it)
3436
Bram Moolenaar28ee8922020-10-28 20:20:00 +01003437 let g:did_it = 'no'
3438 call SilentlyUserError()
3439 call assert_equal('yes', g:did_it)
Bram Moolenaar171fb922020-10-28 16:54:47 +01003440
3441 unlet g:did_it
3442endfunc
3443
Bram Moolenaarcd030c42020-10-30 21:49:40 +01003444def Test_ignore_silent_error_in_filter()
3445 var lines =<< trim END
3446 vim9script
3447 def Filter(winid: number, key: string): bool
3448 if key == 'o'
3449 silent! eval [][0]
3450 return true
3451 endif
3452 return popup_filter_menu(winid, key)
3453 enddef
3454
Bram Moolenaare0de1712020-12-02 17:36:54 +01003455 popup_create('popup', {filter: Filter})
Bram Moolenaarcd030c42020-10-30 21:49:40 +01003456 feedkeys("o\r", 'xnt')
3457 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003458 v9.CheckScriptSuccess(lines)
Bram Moolenaarcd030c42020-10-30 21:49:40 +01003459enddef
3460
Bram Moolenaar62aec932022-01-29 21:45:34 +00003461def s:Fibonacci(n: number): number
Bram Moolenaar4b9bd692020-09-05 21:57:53 +02003462 if n < 2
3463 return n
3464 else
3465 return Fibonacci(n - 1) + Fibonacci(n - 2)
3466 endif
3467enddef
3468
Bram Moolenaar985116a2020-07-12 17:31:09 +02003469def Test_recursive_call()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02003470 Fibonacci(20)->assert_equal(6765)
Bram Moolenaar985116a2020-07-12 17:31:09 +02003471enddef
3472
Bram Moolenaar62aec932022-01-29 21:45:34 +00003473def s:TreeWalk(dir: string): list<any>
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01003474 return readdir(dir)->mapnew((_, val) =>
Bram Moolenaar08f7a412020-07-13 20:41:08 +02003475 fnamemodify(dir .. '/' .. val, ':p')->isdirectory()
Bram Moolenaar2bede172020-11-19 18:53:18 +01003476 ? {[val]: TreeWalk(dir .. '/' .. val)}
Bram Moolenaar08f7a412020-07-13 20:41:08 +02003477 : val
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01003478 )
Bram Moolenaar08f7a412020-07-13 20:41:08 +02003479enddef
3480
3481def Test_closure_in_map()
Bram Moolenaarf5fec052022-09-11 11:49:22 +01003482 mkdir('XclosureDir/tdir', 'pR')
Bram Moolenaar08f7a412020-07-13 20:41:08 +02003483 writefile(['111'], 'XclosureDir/file1')
3484 writefile(['222'], 'XclosureDir/file2')
3485 writefile(['333'], 'XclosureDir/tdir/file3')
3486
Bram Moolenaare0de1712020-12-02 17:36:54 +01003487 TreeWalk('XclosureDir')->assert_equal(['file1', 'file2', {tdir: ['file3']}])
Bram Moolenaar08f7a412020-07-13 20:41:08 +02003488enddef
3489
Bram Moolenaar7b5d5442020-10-04 13:42:34 +02003490def Test_invalid_function_name()
3491 var lines =<< trim END
3492 vim9script
3493 def s: list<string>
3494 END
Bram Moolenaara749a422022-02-12 19:52:25 +00003495 v9.CheckScriptFailure(lines, 'E1268:')
Bram Moolenaar7b5d5442020-10-04 13:42:34 +02003496
3497 lines =<< trim END
3498 vim9script
3499 def g: list<string>
3500 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003501 v9.CheckScriptFailure(lines, 'E129:')
Bram Moolenaar7b5d5442020-10-04 13:42:34 +02003502
3503 lines =<< trim END
3504 vim9script
3505 def <SID>: list<string>
3506 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003507 v9.CheckScriptFailure(lines, 'E884:')
Bram Moolenaar7b5d5442020-10-04 13:42:34 +02003508
3509 lines =<< trim END
3510 vim9script
3511 def F list<string>
3512 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003513 v9.CheckScriptFailure(lines, 'E488:')
Bram Moolenaar7b5d5442020-10-04 13:42:34 +02003514enddef
3515
Bram Moolenaara90afb92020-07-15 22:38:56 +02003516def Test_partial_call()
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02003517 var lines =<< trim END
3518 var Xsetlist: func
3519 Xsetlist = function('setloclist', [0])
3520 Xsetlist([], ' ', {title: 'test'})
3521 getloclist(0, {title: 1})->assert_equal({title: 'test'})
Bram Moolenaara90afb92020-07-15 22:38:56 +02003522
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02003523 Xsetlist = function('setloclist', [0, [], ' '])
3524 Xsetlist({title: 'test'})
3525 getloclist(0, {title: 1})->assert_equal({title: 'test'})
Bram Moolenaara90afb92020-07-15 22:38:56 +02003526
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02003527 Xsetlist = function('setqflist')
3528 Xsetlist([], ' ', {title: 'test'})
3529 getqflist({title: 1})->assert_equal({title: 'test'})
Bram Moolenaara90afb92020-07-15 22:38:56 +02003530
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02003531 Xsetlist = function('setqflist', [[], ' '])
3532 Xsetlist({title: 'test'})
3533 getqflist({title: 1})->assert_equal({title: 'test'})
Bram Moolenaar6abd3dc2020-10-04 14:17:32 +02003534
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02003535 var Len: func: number = function('len', ['word'])
3536 assert_equal(4, Len())
3537
3538 var RepeatFunc = function('repeat', ['o'])
3539 assert_equal('ooooo', RepeatFunc(5))
3540 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003541 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarc66f6452021-08-19 21:08:30 +02003542
3543 lines =<< trim END
3544 vim9script
3545 def Foo(Parser: any)
3546 enddef
3547 var Expr: func(dict<any>): dict<any>
3548 const Call = Foo(Expr)
3549 END
Bram Moolenaar8acb9cc2022-03-08 13:18:55 +00003550 v9.CheckScriptFailure(lines, 'E1031:')
Bram Moolenaara90afb92020-07-15 22:38:56 +02003551enddef
3552
Bram Moolenaarcd1cda22022-02-16 21:48:25 +00003553def Test_partial_double_nested()
3554 var idx = 123
3555 var Get = () => idx
3556 var Ref = function(Get, [])
3557 var RefRef = function(Ref, [])
3558 assert_equal(123, RefRef())
3559enddef
3560
Bram Moolenaar673bcb12022-03-08 16:52:24 +00003561def Test_partial_null_function()
3562 var lines =<< trim END
3563 var d: dict<func> = {f: null_function}
3564 var Ref = d.f
Bram Moolenaared0c62e2022-03-08 19:43:55 +00003565 assert_equal('func(...): unknown', typename(Ref))
Bram Moolenaar673bcb12022-03-08 16:52:24 +00003566 END
3567 v9.CheckDefAndScriptSuccess(lines)
3568enddef
3569
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02003570def Test_cmd_modifier()
3571 tab echo '0'
Bram Moolenaar62aec932022-01-29 21:45:34 +00003572 v9.CheckDefFailure(['5tab echo 3'], 'E16:')
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02003573enddef
3574
3575def Test_restore_modifiers()
3576 # check that when compiling a :def function command modifiers are not messed
3577 # up.
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02003578 var lines =<< trim END
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02003579 vim9script
3580 set eventignore=
3581 autocmd QuickFixCmdPost * copen
3582 def AutocmdsDisabled()
Bram Moolenaarc3235272021-07-10 19:42:03 +02003583 eval 1 + 2
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02003584 enddef
3585 func Func()
3586 noautocmd call s:AutocmdsDisabled()
3587 let g:ei_after = &eventignore
3588 endfunc
3589 Func()
3590 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003591 v9.CheckScriptSuccess(lines)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02003592 g:ei_after->assert_equal('')
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02003593enddef
3594
Bram Moolenaardfa3d552020-09-10 22:05:08 +02003595def StackTop()
Bram Moolenaarc3235272021-07-10 19:42:03 +02003596 eval 1 + 2
3597 eval 2 + 3
Bram Moolenaardfa3d552020-09-10 22:05:08 +02003598 # call not on fourth line
Bram Moolenaar62aec932022-01-29 21:45:34 +00003599 g:StackBot()
Bram Moolenaardfa3d552020-09-10 22:05:08 +02003600enddef
3601
3602def StackBot()
3603 # throw an error
3604 eval [][0]
3605enddef
3606
3607def Test_callstack_def()
3608 try
Bram Moolenaar62aec932022-01-29 21:45:34 +00003609 g:StackTop()
Bram Moolenaardfa3d552020-09-10 22:05:08 +02003610 catch
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02003611 v:throwpoint->assert_match('Test_callstack_def\[2\]..StackTop\[4\]..StackBot, line 2')
Bram Moolenaardfa3d552020-09-10 22:05:08 +02003612 endtry
3613enddef
3614
Bram Moolenaare8211a32020-10-09 22:04:29 +02003615" Re-using spot for variable used in block
3616def Test_block_scoped_var()
3617 var lines =<< trim END
3618 vim9script
3619 def Func()
3620 var x = ['a', 'b', 'c']
3621 if 1
3622 var y = 'x'
Bram Moolenaarbb8a7ce2021-04-10 20:10:26 +02003623 map(x, (_, _) => y)
Bram Moolenaare8211a32020-10-09 22:04:29 +02003624 endif
3625 var z = x
3626 assert_equal(['x', 'x', 'x'], z)
3627 enddef
3628 Func()
3629 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003630 v9.CheckScriptSuccess(lines)
Bram Moolenaare8211a32020-10-09 22:04:29 +02003631enddef
3632
Bram Moolenaareeece9e2020-11-20 19:26:48 +01003633def Test_reset_did_emsg()
3634 var lines =<< trim END
3635 @s = 'blah'
3636 au BufWinLeave * #
3637 def Func()
3638 var winid = popup_create('popup', {})
3639 exe '*s'
3640 popup_close(winid)
3641 enddef
3642 Func()
3643 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003644 v9.CheckScriptFailure(lines, 'E492:', 8)
Bram Moolenaar2d870f82020-12-05 13:41:01 +01003645 delfunc! g:Func
Bram Moolenaareeece9e2020-11-20 19:26:48 +01003646enddef
3647
Bram Moolenaar57f799e2020-12-12 20:42:19 +01003648def Test_did_emsg_reset()
3649 # executing an autocommand resets did_emsg, this should not result in a
3650 # builtin function considered failing
3651 var lines =<< trim END
3652 vim9script
3653 au BufWinLeave * #
3654 def Func()
Bram Moolenaar767034c2021-04-09 17:24:52 +02003655 popup_menu('', {callback: (a, b) => popup_create('', {})->popup_close()})
Bram Moolenaar57f799e2020-12-12 20:42:19 +01003656 eval [][0]
3657 enddef
3658 nno <F3> <cmd>call <sid>Func()<cr>
3659 feedkeys("\<F3>\e", 'xt')
3660 END
Bram Moolenaarf5fec052022-09-11 11:49:22 +01003661 writefile(lines, 'XemsgReset', 'D')
Bram Moolenaar57f799e2020-12-12 20:42:19 +01003662 assert_fails('so XemsgReset', ['E684:', 'E684:'], lines, 2)
Bram Moolenaarf5fec052022-09-11 11:49:22 +01003663
Bram Moolenaar57f799e2020-12-12 20:42:19 +01003664 nunmap <F3>
3665 au! BufWinLeave
3666enddef
3667
Bram Moolenaar56602ba2020-12-05 21:22:08 +01003668def Test_abort_with_silent_call()
3669 var lines =<< trim END
3670 vim9script
3671 g:result = 'none'
3672 def Func()
3673 g:result += 3
3674 g:result = 'yes'
3675 enddef
3676 # error is silenced, but function aborts on error
3677 silent! Func()
3678 assert_equal('none', g:result)
3679 unlet g:result
3680 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003681 v9.CheckScriptSuccess(lines)
Bram Moolenaar56602ba2020-12-05 21:22:08 +01003682enddef
3683
Bram Moolenaarf665e972020-12-05 19:17:16 +01003684def Test_continues_with_silent_error()
3685 var lines =<< trim END
3686 vim9script
3687 g:result = 'none'
3688 def Func()
3689 silent! g:result += 3
3690 g:result = 'yes'
3691 enddef
3692 # error is silenced, function does not abort
3693 Func()
3694 assert_equal('yes', g:result)
3695 unlet g:result
3696 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003697 v9.CheckScriptSuccess(lines)
Bram Moolenaarf665e972020-12-05 19:17:16 +01003698enddef
3699
Bram Moolenaaraf0df472020-12-02 20:51:22 +01003700def Test_abort_even_with_silent()
3701 var lines =<< trim END
3702 vim9script
3703 g:result = 'none'
3704 def Func()
3705 eval {-> ''}() .. '' .. {}['X']
3706 g:result = 'yes'
3707 enddef
Bram Moolenaarf665e972020-12-05 19:17:16 +01003708 silent! Func()
Bram Moolenaaraf0df472020-12-02 20:51:22 +01003709 assert_equal('none', g:result)
Bram Moolenaar4029cab2020-12-05 18:13:27 +01003710 unlet g:result
3711 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003712 v9.CheckScriptSuccess(lines)
Bram Moolenaar4029cab2020-12-05 18:13:27 +01003713enddef
3714
Bram Moolenaarf665e972020-12-05 19:17:16 +01003715def Test_cmdmod_silent_restored()
3716 var lines =<< trim END
3717 vim9script
3718 def Func()
3719 g:result = 'none'
3720 silent! g:result += 3
3721 g:result = 'none'
3722 g:result += 3
3723 enddef
3724 Func()
3725 END
3726 # can't use CheckScriptFailure, it ignores the :silent!
3727 var fname = 'Xdefsilent'
Bram Moolenaarf5fec052022-09-11 11:49:22 +01003728 writefile(lines, fname, 'D')
Bram Moolenaarf665e972020-12-05 19:17:16 +01003729 var caught = 'no'
3730 try
3731 exe 'source ' .. fname
3732 catch /E1030:/
3733 caught = 'yes'
3734 assert_match('Func, line 4', v:throwpoint)
3735 endtry
3736 assert_equal('yes', caught)
Bram Moolenaarf665e972020-12-05 19:17:16 +01003737enddef
3738
Bram Moolenaar2fecb532021-03-24 22:00:56 +01003739def Test_cmdmod_silent_nested()
3740 var lines =<< trim END
3741 vim9script
3742 var result = ''
3743
3744 def Error()
3745 result ..= 'Eb'
3746 eval [][0]
3747 result ..= 'Ea'
3748 enddef
3749
3750 def Crash()
3751 result ..= 'Cb'
3752 sil! Error()
3753 result ..= 'Ca'
3754 enddef
3755
3756 Crash()
3757 assert_equal('CbEbEaCa', result)
3758 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003759 v9.CheckScriptSuccess(lines)
Bram Moolenaar2fecb532021-03-24 22:00:56 +01003760enddef
3761
Bram Moolenaar4029cab2020-12-05 18:13:27 +01003762def Test_dict_member_with_silent()
3763 var lines =<< trim END
3764 vim9script
3765 g:result = 'none'
3766 var d: dict<any>
3767 def Func()
3768 try
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01003769 g:result = map([], (_, v) => ({}[v]))->join() .. d['']
Bram Moolenaar4029cab2020-12-05 18:13:27 +01003770 catch
3771 endtry
3772 enddef
3773 silent! Func()
3774 assert_equal('0', g:result)
3775 unlet g:result
Bram Moolenaaraf0df472020-12-02 20:51:22 +01003776 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003777 v9.CheckScriptSuccess(lines)
Bram Moolenaaraf0df472020-12-02 20:51:22 +01003778enddef
3779
Bram Moolenaarf9041332021-01-21 19:41:16 +01003780def Test_skip_cmds_with_silent()
3781 var lines =<< trim END
3782 vim9script
3783
3784 def Func(b: bool)
3785 Crash()
3786 enddef
3787
3788 def Crash()
3789 sil! :/not found/d _
3790 sil! :/not found/put _
3791 enddef
3792
3793 Func(true)
3794 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003795 v9.CheckScriptSuccess(lines)
Bram Moolenaarf9041332021-01-21 19:41:16 +01003796enddef
3797
Bram Moolenaar5b3d1bb2020-12-22 12:20:08 +01003798def Test_opfunc()
Bram Moolenaar848fadd2022-01-30 15:28:30 +00003799 nnoremap <F3> <cmd>set opfunc=g:Opfunc<cr>g@
Bram Moolenaar5b3d1bb2020-12-22 12:20:08 +01003800 def g:Opfunc(_: any): string
3801 setline(1, 'ASDF')
3802 return ''
3803 enddef
3804 new
3805 setline(1, 'asdf')
3806 feedkeys("\<F3>$", 'x')
3807 assert_equal('ASDF', getline(1))
3808
3809 bwipe!
3810 nunmap <F3>
3811enddef
3812
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003813func Test_opfunc_error()
3814 CheckScreendump
3815 call Run_Test_opfunc_error()
3816endfunc
3817
3818def Run_Test_opfunc_error()
3819 # test that the error from Opfunc() is displayed right away
3820 var lines =<< trim END
3821 vim9script
3822
3823 def Opfunc(type: string)
3824 try
3825 eval [][0]
3826 catch /nothing/ # error not caught
3827 endtry
3828 enddef
3829 &operatorfunc = Opfunc
3830 nnoremap <expr> l <SID>L()
3831 def L(): string
3832 return 'l'
3833 enddef
3834 'x'->repeat(10)->setline(1)
3835 feedkeys('g@l', 'n')
3836 feedkeys('llll')
3837 END
Bram Moolenaarf5fec052022-09-11 11:49:22 +01003838 call writefile(lines, 'XTest_opfunc_error', 'D')
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003839
Bram Moolenaar62aec932022-01-29 21:45:34 +00003840 var buf = g:RunVimInTerminal('-S XTest_opfunc_error', {rows: 6, wait_for_ruler: 0})
3841 g:WaitForAssert(() => assert_match('Press ENTER', term_getline(buf, 6)))
Bram Moolenaarec892232022-05-06 17:53:06 +01003842 g:WaitForAssert(() => assert_match('E684: List index out of range: 0', term_getline(buf, 5)))
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003843
3844 # clean up
Bram Moolenaar62aec932022-01-29 21:45:34 +00003845 g:StopVimInTerminal(buf)
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003846enddef
3847
Bram Moolenaar077a4232020-12-22 18:33:27 +01003848" this was crashing on exit
3849def Test_nested_lambda_in_closure()
3850 var lines =<< trim END
3851 vim9script
Bram Moolenaar227c58a2021-04-28 20:40:44 +02003852 command WriteDone writefile(['Done'], 'XnestedDone')
Bram Moolenaar077a4232020-12-22 18:33:27 +01003853 def Outer()
3854 def g:Inner()
3855 echo map([1, 2, 3], {_, v -> v + 1})
3856 enddef
3857 g:Inner()
3858 enddef
3859 defcompile
Bram Moolenaar227c58a2021-04-28 20:40:44 +02003860 # not reached
Bram Moolenaar077a4232020-12-22 18:33:27 +01003861 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003862 if !g:RunVim([], lines, '--clean -c WriteDone -c quit')
Bram Moolenaar077a4232020-12-22 18:33:27 +01003863 return
3864 endif
3865 assert_equal(['Done'], readfile('XnestedDone'))
3866 delete('XnestedDone')
3867enddef
3868
Bram Moolenaar92368aa2022-02-07 17:50:39 +00003869def Test_nested_closure_funcref()
3870 var lines =<< trim END
3871 vim9script
3872 def Func()
3873 var n: number
3874 def Nested()
3875 ++n
3876 enddef
3877 Nested()
3878 g:result_one = n
3879 var Ref = function(Nested)
3880 Ref()
3881 g:result_two = n
3882 enddef
3883 Func()
3884 END
3885 v9.CheckScriptSuccess(lines)
3886 assert_equal(1, g:result_one)
3887 assert_equal(2, g:result_two)
3888 unlet g:result_one g:result_two
3889enddef
3890
Bram Moolenaar7aca5ca2022-02-07 19:56:43 +00003891def Test_nested_closure_in_dict()
3892 var lines =<< trim END
3893 vim9script
3894 def Func(): dict<any>
3895 var n: number
3896 def Inc(): number
3897 ++n
3898 return n
3899 enddef
3900 return {inc: function(Inc)}
3901 enddef
3902 disas Func
3903 var d = Func()
3904 assert_equal(1, d.inc())
3905 assert_equal(2, d.inc())
3906 END
3907 v9.CheckScriptSuccess(lines)
3908enddef
3909
Bram Moolenaarfb43cfc2022-03-11 18:54:17 +00003910def Test_script_local_other_script()
3911 var lines =<< trim END
3912 function LegacyJob()
3913 let FuncRef = function('s:close_cb')
3914 endfunction
3915 function s:close_cb(...)
3916 endfunction
3917 END
Bram Moolenaarf5fec052022-09-11 11:49:22 +01003918 lines->writefile('Xlegacy.vim', 'D')
Bram Moolenaarfb43cfc2022-03-11 18:54:17 +00003919 source Xlegacy.vim
3920 g:LegacyJob()
3921 g:LegacyJob()
3922 g:LegacyJob()
3923
3924 delfunc g:LegacyJob
Bram Moolenaarfb43cfc2022-03-11 18:54:17 +00003925enddef
3926
Bram Moolenaar04947cc2021-03-06 19:26:46 +01003927def Test_check_func_arg_types()
3928 var lines =<< trim END
3929 vim9script
3930 def F1(x: string): string
3931 return x
3932 enddef
3933
3934 def F2(x: number): number
3935 return x + 1
3936 enddef
3937
Bram Moolenaar1d9cef72022-03-17 16:30:03 +00003938 def G(Fg: func): dict<func>
3939 return {f: Fg}
Bram Moolenaar04947cc2021-03-06 19:26:46 +01003940 enddef
3941
3942 def H(d: dict<func>): string
3943 return d.f('a')
3944 enddef
3945 END
3946
Bram Moolenaar62aec932022-01-29 21:45:34 +00003947 v9.CheckScriptSuccess(lines + ['echo H(G(F1))'])
3948 v9.CheckScriptFailure(lines + ['echo H(G(F2))'], 'E1013:')
Bram Moolenaar1d9cef72022-03-17 16:30:03 +00003949
3950 v9.CheckScriptFailure(lines + ['def SomeFunc(ff: func)', 'enddef'], 'E704:')
Bram Moolenaar04947cc2021-03-06 19:26:46 +01003951enddef
3952
Bram Moolenaarbadf04f2022-03-12 21:28:22 +00003953def Test_call_func_with_null()
3954 var lines =<< trim END
3955 def Fstring(v: string)
3956 assert_equal(null_string, v)
3957 enddef
3958 Fstring(null_string)
3959 def Fblob(v: blob)
3960 assert_equal(null_blob, v)
3961 enddef
3962 Fblob(null_blob)
3963 def Flist(v: list<number>)
3964 assert_equal(null_list, v)
3965 enddef
3966 Flist(null_list)
3967 def Fdict(v: dict<number>)
3968 assert_equal(null_dict, v)
3969 enddef
3970 Fdict(null_dict)
3971 def Ffunc(Fv: func(number): number)
3972 assert_equal(null_function, Fv)
3973 enddef
3974 Ffunc(null_function)
3975 if has('channel')
3976 def Fchannel(v: channel)
3977 assert_equal(null_channel, v)
3978 enddef
3979 Fchannel(null_channel)
3980 def Fjob(v: job)
3981 assert_equal(null_job, v)
3982 enddef
3983 Fjob(null_job)
3984 endif
3985 END
3986 v9.CheckDefAndScriptSuccess(lines)
3987enddef
3988
3989def Test_null_default_argument()
3990 var lines =<< trim END
3991 def Fstring(v: string = null_string)
3992 assert_equal(null_string, v)
3993 enddef
3994 Fstring()
3995 def Fblob(v: blob = null_blob)
3996 assert_equal(null_blob, v)
3997 enddef
3998 Fblob()
3999 def Flist(v: list<number> = null_list)
4000 assert_equal(null_list, v)
4001 enddef
4002 Flist()
4003 def Fdict(v: dict<number> = null_dict)
4004 assert_equal(null_dict, v)
4005 enddef
4006 Fdict()
4007 def Ffunc(Fv: func(number): number = null_function)
4008 assert_equal(null_function, Fv)
4009 enddef
4010 Ffunc()
4011 if has('channel')
4012 def Fchannel(v: channel = null_channel)
4013 assert_equal(null_channel, v)
4014 enddef
4015 Fchannel()
4016 def Fjob(v: job = null_job)
4017 assert_equal(null_job, v)
4018 enddef
4019 Fjob()
4020 endif
4021 END
4022 v9.CheckDefAndScriptSuccess(lines)
4023enddef
4024
4025def Test_null_return()
4026 var lines =<< trim END
4027 def Fstring(): string
4028 return null_string
4029 enddef
4030 assert_equal(null_string, Fstring())
4031 def Fblob(): blob
4032 return null_blob
4033 enddef
4034 assert_equal(null_blob, Fblob())
4035 def Flist(): list<number>
4036 return null_list
4037 enddef
4038 assert_equal(null_list, Flist())
4039 def Fdict(): dict<number>
4040 return null_dict
4041 enddef
4042 assert_equal(null_dict, Fdict())
4043 def Ffunc(): func(number): number
4044 return null_function
4045 enddef
4046 assert_equal(null_function, Ffunc())
4047 if has('channel')
4048 def Fchannel(): channel
4049 return null_channel
4050 enddef
4051 assert_equal(null_channel, Fchannel())
4052 def Fjob(): job
4053 return null_job
4054 enddef
4055 assert_equal(null_job, Fjob())
4056 endif
4057 END
4058 v9.CheckDefAndScriptSuccess(lines)
4059enddef
4060
Bram Moolenaar6e48b842021-08-10 22:52:02 +02004061def Test_list_any_type_checked()
4062 var lines =<< trim END
4063 vim9script
4064 def Foo()
4065 --decl--
4066 Bar(l)
4067 enddef
4068 def Bar(ll: list<dict<any>>)
4069 enddef
4070 Foo()
4071 END
Bram Moolenaar2d3ac2e2022-02-03 12:34:05 +00004072 # "any" could be "dict<any>", thus OK
Bram Moolenaar6e48b842021-08-10 22:52:02 +02004073 lines[2] = 'var l: list<any>'
Bram Moolenaar2d3ac2e2022-02-03 12:34:05 +00004074 v9.CheckScriptSuccess(lines)
Bram Moolenaar6e48b842021-08-10 22:52:02 +02004075 lines[2] = 'var l: list<any> = []'
Bram Moolenaar2d3ac2e2022-02-03 12:34:05 +00004076 v9.CheckScriptSuccess(lines)
Bram Moolenaar6e48b842021-08-10 22:52:02 +02004077
4078 lines[2] = 'var l: list<any> = [11]'
Bram Moolenaar62aec932022-01-29 21:45:34 +00004079 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected list<dict<any>> but got list<number>', 2)
Bram Moolenaar6e48b842021-08-10 22:52:02 +02004080enddef
4081
Bram Moolenaar701cc6c2021-04-10 13:33:48 +02004082def Test_compile_error()
4083 var lines =<< trim END
4084 def g:Broken()
4085 echo 'a' + {}
4086 enddef
4087 call g:Broken()
4088 END
4089 # First call: compilation error
Bram Moolenaar62aec932022-01-29 21:45:34 +00004090 v9.CheckScriptFailure(lines, 'E1051: Wrong argument type for +')
Bram Moolenaar701cc6c2021-04-10 13:33:48 +02004091
4092 # Second call won't try compiling again
4093 assert_fails('call g:Broken()', 'E1091: Function is not compiled: Broken')
Bram Moolenaar599410c2021-04-10 14:03:43 +02004094 delfunc g:Broken
4095
4096 # No error when compiling with :silent!
4097 lines =<< trim END
4098 def g:Broken()
4099 echo 'a' + []
4100 enddef
4101 silent! defcompile
4102 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004103 v9.CheckScriptSuccess(lines)
Bram Moolenaar599410c2021-04-10 14:03:43 +02004104
4105 # Calling the function won't try compiling again
4106 assert_fails('call g:Broken()', 'E1091: Function is not compiled: Broken')
4107 delfunc g:Broken
Bram Moolenaar701cc6c2021-04-10 13:33:48 +02004108enddef
4109
Bram Moolenaar962c43b2021-04-10 17:18:09 +02004110def Test_ignored_argument()
4111 var lines =<< trim END
4112 vim9script
4113 def Ignore(_, _): string
4114 return 'yes'
4115 enddef
4116 assert_equal('yes', Ignore(1, 2))
4117
4118 func Ok(_)
4119 return a:_
4120 endfunc
4121 assert_equal('ok', Ok('ok'))
4122
4123 func Oktoo()
4124 let _ = 'too'
4125 return _
4126 endfunc
4127 assert_equal('too', Oktoo())
Bram Moolenaarda479c72021-04-10 21:01:38 +02004128
4129 assert_equal([[1], [2], [3]], range(3)->mapnew((_, v) => [v]->map((_, w) => w + 1)))
Bram Moolenaar962c43b2021-04-10 17:18:09 +02004130 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004131 v9.CheckScriptSuccess(lines)
Bram Moolenaar962c43b2021-04-10 17:18:09 +02004132
4133 lines =<< trim END
4134 def Ignore(_: string): string
4135 return _
4136 enddef
4137 defcompile
4138 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004139 v9.CheckScriptFailure(lines, 'E1181:', 1)
Bram Moolenaar962c43b2021-04-10 17:18:09 +02004140
4141 lines =<< trim END
4142 var _ = 1
4143 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004144 v9.CheckDefAndScriptFailure(lines, 'E1181:', 1)
Yegappan Lakshmanan34fcb692021-05-25 20:14:00 +02004145
4146 lines =<< trim END
4147 var x = _
4148 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004149 v9.CheckDefAndScriptFailure(lines, 'E1181:', 1)
Bram Moolenaar962c43b2021-04-10 17:18:09 +02004150enddef
4151
Bram Moolenaarbb8a7ce2021-04-10 20:10:26 +02004152def Test_too_many_arguments()
4153 var lines =<< trim END
4154 echo [0, 1, 2]->map(() => 123)
4155 END
Bram Moolenaareddd4fc2022-02-20 15:52:28 +00004156 v9.CheckDefAndScriptFailure(lines, ['E176:', 'E1106: 2 arguments too many'], 1)
Bram Moolenaarbb8a7ce2021-04-10 20:10:26 +02004157
4158 lines =<< trim END
4159 echo [0, 1, 2]->map((_) => 123)
4160 END
Bram Moolenaareddd4fc2022-02-20 15:52:28 +00004161 v9.CheckDefAndScriptFailure(lines, ['E176', 'E1106: One argument too many'], 1)
Bram Moolenaar31d99482022-05-26 22:24:43 +01004162
4163 lines =<< trim END
4164 vim9script
4165 def OneArgument(arg: string)
4166 echo arg
4167 enddef
4168 var Ref = OneArgument
4169 Ref('a', 'b')
4170 END
4171 v9.CheckScriptFailure(lines, 'E118:')
4172enddef
4173
4174def Test_funcref_with_base()
4175 var lines =<< trim END
4176 vim9script
4177 def TwoArguments(str: string, nr: number)
4178 echo str nr
4179 enddef
4180 var Ref = TwoArguments
4181 Ref('a', 12)
4182 'b'->Ref(34)
4183 END
4184 v9.CheckScriptSuccess(lines)
4185
4186 lines =<< trim END
4187 vim9script
4188 def TwoArguments(str: string, nr: number)
4189 echo str nr
4190 enddef
4191 var Ref = TwoArguments
4192 'a'->Ref('b')
4193 END
4194 v9.CheckScriptFailure(lines, 'E1013: Argument 2: type mismatch, expected number but got string', 6)
4195
4196 lines =<< trim END
4197 vim9script
4198 def TwoArguments(str: string, nr: number)
4199 echo str nr
4200 enddef
4201 var Ref = TwoArguments
4202 123->Ref(456)
4203 END
4204 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected string but got number')
4205
4206 lines =<< trim END
4207 vim9script
4208 def TwoArguments(nr: number, str: string)
4209 echo str nr
4210 enddef
4211 var Ref = TwoArguments
4212 123->Ref('b')
4213 def AndNowCompiled()
4214 456->Ref('x')
4215 enddef
4216 AndNowCompiled()
4217 END
4218 v9.CheckScriptSuccess(lines)
Bram Moolenaarbb8a7ce2021-04-10 20:10:26 +02004219enddef
Bram Moolenaar077a4232020-12-22 18:33:27 +01004220
Bram Moolenaara6aa1642021-04-23 19:32:23 +02004221def Test_closing_brace_at_start_of_line()
4222 var lines =<< trim END
4223 def Func()
4224 enddef
4225 Func(
4226 )
4227 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004228 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaara6aa1642021-04-23 19:32:23 +02004229enddef
4230
Bram Moolenaar62aec932022-01-29 21:45:34 +00004231func s:CreateMydict()
Bram Moolenaarb033ee22021-08-15 16:08:36 +02004232 let g:mydict = {}
4233 func g:mydict.afunc()
4234 let g:result = self.key
4235 endfunc
4236endfunc
4237
4238def Test_numbered_function_reference()
4239 CreateMydict()
4240 var output = execute('legacy func g:mydict.afunc')
4241 var funcName = 'g:' .. substitute(output, '.*function \(\d\+\).*', '\1', '')
4242 execute 'function(' .. funcName .. ', [], {key: 42})()'
4243 # check that the function still exists
4244 assert_equal(output, execute('legacy func g:mydict.afunc'))
4245 unlet g:mydict
4246enddef
4247
Bram Moolenaarcfb4d4f2022-09-30 19:19:04 +01004248def Test_numbered_function_call()
4249 var lines =<< trim END
4250 let s:legacyscript = {}
4251 func s:legacyscript.Helper() abort
4252 return "Success"
4253 endfunc
4254 let g:legacyscript = deepcopy(s:legacyscript)
4255
4256 let g:legacy_result = eval("g:legacyscript.Helper()")
4257 vim9cmd g:vim9_result = eval("g:legacyscript.Helper()")
4258 END
4259 v9.CheckScriptSuccess(lines)
4260 assert_equal('Success', g:legacy_result)
4261 assert_equal('Success', g:vim9_result)
4262
4263 unlet g:legacy_result
4264 unlet g:vim9_result
4265enddef
4266
Bram Moolenaard3a11782022-01-05 16:50:40 +00004267def Test_go_beyond_end_of_cmd()
4268 # this was reading the byte after the end of the line
4269 var lines =<< trim END
4270 def F()
4271 cal
4272 enddef
4273 defcompile
4274 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004275 v9.CheckScriptFailure(lines, 'E476:')
Bram Moolenaard3a11782022-01-05 16:50:40 +00004276enddef
4277
Yegappan Lakshmanan7c7e19c2022-04-09 11:09:07 +01004278" Test for memory allocation failure when defining a new lambda
4279func Test_lambda_allocation_failure()
4280 new
4281 let lines =<< trim END
4282 vim9script
4283 g:Xlambda = (x): number => {
4284 return x + 1
4285 }
4286 END
4287 call setline(1, lines)
4288 call test_alloc_fail(GetAllocId('get_func'), 0, 0)
4289 call assert_fails('source', 'E342:')
4290 call assert_false(exists('g:Xlambda'))
4291 bw!
4292endfunc
4293
Bram Moolenaar0d89d8a2022-12-31 14:01:24 +00004294def Test_lambda_argument_type_check()
4295 var lines =<< trim END
4296 vim9script
4297
4298 def Scan(ll: list<any>): func(func(any))
4299 return (Emit: func(any)) => {
4300 for e in ll
4301 Emit(e)
4302 endfor
4303 }
4304 enddef
4305
4306 def Sum(Cont: func(func(any))): any
4307 var sum = 0.0
4308 Cont((v: float) => { # <== NOTE: the lambda expects a float
4309 sum += v
4310 })
4311 return sum
4312 enddef
4313
4314 const ml = [3.0, 2, 7]
4315 echo Scan(ml)->Sum()
4316 END
4317 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected float but got number')
4318enddef
4319
Bram Moolenaarbce69d62022-05-22 13:45:52 +01004320def Test_multiple_funcref()
4321 # This was using a NULL pointer
4322 var lines =<< trim END
4323 vim9script
4324 def A(F: func, ...args: list<any>): func
4325 return funcref(F, args)
4326 enddef
4327
4328 def B(F: func): func
4329 return funcref(A, [F])
4330 enddef
4331
4332 def Test(n: number)
4333 enddef
4334
4335 const X = B(Test)
4336 X(1)
4337 END
4338 v9.CheckScriptSuccess(lines)
4339
4340 # slightly different case
4341 lines =<< trim END
4342 vim9script
4343
4344 def A(F: func, ...args: list<any>): any
4345 return call(F, args)
4346 enddef
4347
4348 def B(F: func): func
4349 return funcref(A, [F])
4350 enddef
4351
4352 def Test(n: number)
4353 enddef
4354
4355 const X = B(Test)
4356 X(1)
4357 END
4358 v9.CheckScriptSuccess(lines)
4359enddef
4360
Bram Moolenaarbd683e32022-07-18 17:49:03 +01004361def Test_cexpr_errmsg_line_number()
4362 var lines =<< trim END
4363 vim9script
4364 def Func()
4365 var qfl = {}
4366 cexpr qfl
4367 enddef
4368 Func()
4369 END
4370 v9.CheckScriptFailure(lines, 'E777', 2)
4371enddef
4372
Bram Moolenaar1d84f762022-09-03 21:35:53 +01004373def AddDefer(s: string)
4374 g:deferred->extend([s])
4375enddef
4376
4377def DeferTwo()
4378 g:deferred->extend(['in Two'])
4379 for n in range(3)
4380 defer g:AddDefer('two' .. n)
4381 endfor
4382 g:deferred->extend(['end Two'])
4383enddef
4384
4385def DeferOne()
4386 g:deferred->extend(['in One'])
4387 defer g:AddDefer('one')
4388 g:DeferTwo()
4389 g:deferred->extend(['end One'])
4390
4391 writefile(['text'], 'XdeferFile')
4392 defer delete('XdeferFile')
4393enddef
4394
4395def Test_defer()
4396 g:deferred = []
4397 g:DeferOne()
4398 assert_equal(['in One', 'in Two', 'end Two', 'two2', 'two1', 'two0', 'end One', 'one'], g:deferred)
4399 unlet g:deferred
4400 assert_equal('', glob('XdeferFile'))
4401enddef
4402
Bram Moolenaar3558afe2022-10-13 16:12:57 +01004403def Test_invalid_redir()
4404 var lines =<< trim END
4405 def Tone()
4406 if 1
4407 redi =>@�0
4408 redi END
4409 endif
4410 enddef
4411 defcompile
4412 END
4413 v9.CheckScriptFailure(lines, 'E354:')
4414 delfunc g:Tone
4415
4416 # this was reading past the end of the line
4417 lines =<< trim END
4418 def Ttwo()
4419 if 0
4420 redi =>@�0
4421 redi END
4422 endif
4423 enddef
4424 defcompile
4425 END
4426 v9.CheckScriptFailure(lines, 'E354:')
4427 delfunc g:Ttwo
4428enddef
4429
Bram Moolenaar39c82ea2023-01-02 13:08:01 +00004430func Test_keytyped_in_nested_function()
4431 CheckRunVimInTerminal
4432
4433 call Run_Test_keytyped_in_nested_function()
4434endfunc
4435
4436def Run_Test_keytyped_in_nested_function()
4437 var lines =<< trim END
4438 vim9script
4439 autocmd CmdlineEnter * sample#Init()
4440
4441 exe 'set rtp=' .. getcwd() .. '/Xrtpdir'
4442 END
4443 writefile(lines, 'Xkeytyped', 'D')
4444
4445 var dir = 'Xrtpdir/autoload'
4446 mkdir(dir, 'pR')
4447
4448 lines =<< trim END
4449 vim9script
4450 export def Init(): void
4451 cnoremap <expr>" <SID>Quote('"')
4452 enddef
4453 def Quote(str: string): string
4454 def InPair(): number
4455 return 0
4456 enddef
4457 return str
4458 enddef
4459 END
4460 writefile(lines, dir .. '/sample.vim')
4461
4462 var buf = g:RunVimInTerminal('-S Xkeytyped', {rows: 6})
4463
4464 term_sendkeys(buf, ':"')
4465 g:VerifyScreenDump(buf, 'Test_keytyped_in_nested_func', {})
4466
4467 # clean up
4468 term_sendkeys(buf, "\<Esc>")
4469 g:StopVimInTerminal(buf)
4470enddef
4471
Bram Moolenaar8b716f52022-02-15 21:17:56 +00004472" The following messes up syntax highlight, keep near the end.
Bram Moolenaar20677332021-06-06 17:02:53 +02004473if has('python3')
Bram Moolenaar8b716f52022-02-15 21:17:56 +00004474 def Test_python3_command()
4475 py3 import vim
Bram Moolenaarf5288c52022-02-15 21:33:29 +00004476 py3 vim.command("g:done = 'yes'")
Bram Moolenaar8b716f52022-02-15 21:17:56 +00004477 assert_equal('yes', g:done)
4478 unlet g:done
4479 enddef
4480
Bram Moolenaar20677332021-06-06 17:02:53 +02004481 def Test_python3_heredoc()
4482 py3 << trim EOF
4483 import vim
4484 vim.vars['didit'] = 'yes'
4485 EOF
4486 assert_equal('yes', g:didit)
4487
4488 python3 << trim EOF
4489 import vim
4490 vim.vars['didit'] = 'again'
4491 EOF
4492 assert_equal('again', g:didit)
4493 enddef
4494endif
4495
Bram Moolenaar20677332021-06-06 17:02:53 +02004496if has('lua')
4497 def Test_lua_heredoc()
4498 g:d = {}
4499 lua << trim EOF
4500 x = vim.eval('g:d')
4501 x['key'] = 'val'
4502 EOF
4503 assert_equal('val', g:d.key)
4504 enddef
Bram Moolenaarefd73ae2022-03-20 18:51:00 +00004505
4506 def Test_lua_heredoc_fails()
4507 var lines = [
4508 'vim9script',
4509 'def ExeLua()',
4510 'lua << trim EOLUA',
4511 "x = vim.eval('g:nodict')",
4512 'EOLUA',
4513 'enddef',
4514 'ExeLua()',
4515 ]
4516 v9.CheckScriptFailure(lines, 'E121: Undefined variable: g:nodict')
4517 enddef
Bram Moolenaar20677332021-06-06 17:02:53 +02004518endif
4519
Bram Moolenaard881d152022-05-13 13:50:36 +01004520if has('perl')
4521 def Test_perl_heredoc_nested()
4522 var lines =<< trim END
4523 vim9script
4524 def F(): string
4525 def G(): string
4526 perl << EOF
4527 EOF
4528 return 'done'
4529 enddef
4530 return G()
4531 enddef
4532 assert_equal('done', F())
4533 END
4534 v9.CheckScriptSuccess(lines)
4535 enddef
4536endif
4537
Bram Moolenaarf7779c62020-05-03 15:38:16 +02004538
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02004539" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker