blob: f9ff3bc3e6c1c5a4c2d26bb333bb6f823678b88c [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)
Bram Moolenaar94722c52023-01-28 19:19:03 +0000610 echo a:a a:b
Bram Moolenaar1983f1a2022-02-28 20:55:02 +0000611 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 Moolenaar47bba532023-01-20 18:49:46 +0000730def Test_convert_number_to_float()
731 var lines =<< trim END
732 vim9script
733 def Foo(a: float, b: float): float
734 return a + b
735 enddef
736
737 assert_equal(5.3, Foo(3.3, 2))
738 END
739 v9.CheckScriptSuccess(lines)
740enddef
741
Bram Moolenaar62aec932022-01-29 21:45:34 +0000742def s:FuncWithComment( # comment
Bram Moolenaarcef12702021-01-04 14:09:43 +0100743 a: number, #comment
744 b: bool, # comment
745 c: string) #comment
746 assert_equal(4, a)
747 assert_equal(true, b)
748 assert_equal('yes', c)
749enddef
750
751def Test_func_with_comments()
752 FuncWithComment(4, true, 'yes')
753
754 var lines =<< trim END
755 def Func(# comment
756 arg: string)
757 enddef
758 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000759 v9.CheckScriptFailure(lines, 'E125:', 1)
Bram Moolenaarcef12702021-01-04 14:09:43 +0100760
761 lines =<< trim END
762 def Func(
763 arg: string# comment
764 )
765 enddef
766 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000767 v9.CheckScriptFailure(lines, 'E475:', 2)
Bram Moolenaarcef12702021-01-04 14:09:43 +0100768
769 lines =<< trim END
770 def Func(
771 arg: string
772 )# comment
773 enddef
774 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000775 v9.CheckScriptFailure(lines, 'E488:', 3)
Bram Moolenaarcef12702021-01-04 14:09:43 +0100776enddef
777
Bram Moolenaar04b12692020-05-04 23:24:44 +0200778def Test_nested_function()
Bram Moolenaar38453522021-11-28 22:00:12 +0000779 def NestedDef(arg: string): string
Bram Moolenaar04b12692020-05-04 23:24:44 +0200780 return 'nested ' .. arg
781 enddef
Bram Moolenaar38453522021-11-28 22:00:12 +0000782 NestedDef(':def')->assert_equal('nested :def')
783
784 func NestedFunc(arg)
785 return 'nested ' .. a:arg
786 endfunc
787 NestedFunc(':func')->assert_equal('nested :func')
Bram Moolenaar04b12692020-05-04 23:24:44 +0200788
Bram Moolenaar62aec932022-01-29 21:45:34 +0000789 v9.CheckDefFailure(['def Nested()', 'enddef', 'Nested(66)'], 'E118:')
790 v9.CheckDefFailure(['def Nested(arg: string)', 'enddef', 'Nested()'], 'E119:')
Bram Moolenaar0e65d3d2020-05-05 17:53:16 +0200791
Bram Moolenaar62aec932022-01-29 21:45:34 +0000792 v9.CheckDefFailure(['def s:Nested()', 'enddef'], 'E1075:')
793 v9.CheckDefFailure(['def b:Nested()', 'enddef'], 'E1075:')
Bram Moolenaar8b848ca2020-09-10 22:28:01 +0200794
Bram Moolenaar54021752020-12-06 18:50:36 +0100795 var lines =<< trim END
796 def Outer()
797 def Inner()
798 # comment
799 enddef
800 def Inner()
801 enddef
802 enddef
803 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000804 v9.CheckDefFailure(lines, 'E1073:')
Bram Moolenaar54021752020-12-06 18:50:36 +0100805
806 lines =<< trim END
807 def Outer()
808 def Inner()
809 # comment
810 enddef
811 def! Inner()
812 enddef
813 enddef
814 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000815 v9.CheckDefFailure(lines, 'E1117:')
Bram Moolenaar54021752020-12-06 18:50:36 +0100816
Bram Moolenaardb8e5c22021-12-25 19:58:22 +0000817 lines =<< trim END
818 vim9script
819 def Outer()
820 def Inner()
821 g:result = 'ok'
822 enddef
823 Inner()
824 enddef
825 Outer()
826 Inner()
827 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000828 v9.CheckScriptFailure(lines, 'E117: Unknown function: Inner')
Bram Moolenaardb8e5c22021-12-25 19:58:22 +0000829 assert_equal('ok', g:result)
830 unlet g:result
831
Bram Moolenaarf681cfb2022-02-07 20:30:57 +0000832 lines =<< trim END
833 vim9script
834 def Outer()
835 def _Inner()
836 echo 'bad'
837 enddef
Bram Moolenaar3787f262022-02-07 21:54:01 +0000838 _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:')
Bram Moolenaarf681cfb2022-02-07 20:30:57 +0000843
844 lines =<< trim END
845 vim9script
846 def Outer()
847 def g:inner()
848 echo 'bad'
849 enddef
Bram Moolenaar3787f262022-02-07 21:54:01 +0000850 g:inner()
Bram Moolenaarf681cfb2022-02-07 20:30:57 +0000851 enddef
852 defcompile
853 END
Bram Moolenaar3787f262022-02-07 21:54:01 +0000854 v9.CheckScriptFailure(lines, 'E1267:')
855
856 lines =<< trim END
857 vim9script
858 def g:_Func()
859 echo 'bad'
860 enddef
861 END
862 v9.CheckScriptFailure(lines, 'E1267:')
863
864 lines =<< trim END
865 vim9script
Bram Moolenaara749a422022-02-12 19:52:25 +0000866 def _Func()
Bram Moolenaar3787f262022-02-07 21:54:01 +0000867 echo 'bad'
868 enddef
869 END
870 v9.CheckScriptFailure(lines, 'E1267:')
Bram Moolenaarf681cfb2022-02-07 20:30:57 +0000871
Bram Moolenaar54021752020-12-06 18:50:36 +0100872 # nested function inside conditional
Bram Moolenaar54021752020-12-06 18:50:36 +0100873 lines =<< trim END
874 vim9script
875 var thecount = 0
876 if true
877 def Test(): number
878 def TheFunc(): number
879 thecount += 1
880 return thecount
881 enddef
882 return TheFunc()
883 enddef
884 endif
885 defcompile
886 assert_equal(1, Test())
887 assert_equal(2, Test())
888 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000889 v9.CheckScriptSuccess(lines)
Bram Moolenaar8863bda2021-03-17 18:42:08 +0100890
891 # also works when "thecount" is inside the "if" block
892 lines =<< trim END
893 vim9script
894 if true
895 var thecount = 0
896 def Test(): number
897 def TheFunc(): number
898 thecount += 1
899 return thecount
900 enddef
901 return TheFunc()
902 enddef
903 endif
904 defcompile
905 assert_equal(1, Test())
906 assert_equal(2, Test())
907 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000908 v9.CheckScriptSuccess(lines)
Bram Moolenaar4bba16d2021-08-15 19:28:05 +0200909
Bram Moolenaara915fa02022-03-23 11:29:15 +0000910 # nested function with recursive call
911 lines =<< trim END
912 vim9script
913
914 def MyFunc(): number
915 def Fib(n: number): number
916 if n < 2
917 return 1
918 endif
919 return Fib(n - 2) + Fib(n - 1)
920 enddef
921
922 return Fib(5)
923 enddef
924
925 assert_equal(8, MyFunc())
926 END
927 v9.CheckScriptSuccess(lines)
928
Bram Moolenaar4bba16d2021-08-15 19:28:05 +0200929 lines =<< trim END
930 vim9script
931 def Outer()
932 def Inner()
933 echo 'hello'
934 enddef burp
935 enddef
936 defcompile
937 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000938 v9.CheckScriptFailure(lines, 'E1173: Text found after enddef: burp', 3)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200939enddef
940
Bram Moolenaar1889f492022-08-16 19:34:44 +0100941def Test_nested_function_fails()
942 var lines =<< trim END
943 def T()
944 def Func(g: string):string
945 enddef
946 Func()
947 enddef
948 silent! defcompile
949 END
950 v9.CheckScriptFailure(lines, 'E1069:')
951enddef
952
Bram Moolenaaradc8e442020-12-31 18:28:18 +0100953def Test_not_nested_function()
954 echo printf('%d',
955 function('len')('xxx'))
956enddef
957
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200958func Test_call_default_args_from_func()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200959 call MyDefaultArgs()->assert_equal('string')
960 call MyDefaultArgs('one')->assert_equal('one')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +0200961 call assert_fails('call MyDefaultArgs("one", "two")', 'E118:', '', 3, 'Test_call_default_args_from_func')
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200962endfunc
963
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200964def Test_nested_global_function()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200965 var lines =<< trim END
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200966 vim9script
967 def Outer()
968 def g:Inner(): string
969 return 'inner'
970 enddef
971 enddef
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200972 defcompile
973 Outer()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200974 g:Inner()->assert_equal('inner')
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200975 delfunc g:Inner
976 Outer()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200977 g:Inner()->assert_equal('inner')
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200978 delfunc g:Inner
979 Outer()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200980 g:Inner()->assert_equal('inner')
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200981 delfunc g:Inner
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200982 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000983 v9.CheckScriptSuccess(lines)
Bram Moolenaar2c79e9d2020-08-01 18:57:52 +0200984
985 lines =<< trim END
986 vim9script
987 def Outer()
Bram Moolenaar38453522021-11-28 22:00:12 +0000988 func g:Inner()
989 return 'inner'
990 endfunc
991 enddef
992 defcompile
993 Outer()
994 g:Inner()->assert_equal('inner')
995 delfunc g:Inner
996 Outer()
997 g:Inner()->assert_equal('inner')
998 delfunc g:Inner
999 Outer()
1000 g:Inner()->assert_equal('inner')
1001 delfunc g:Inner
1002 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001003 v9.CheckScriptSuccess(lines)
Bram Moolenaar38453522021-11-28 22:00:12 +00001004
1005 lines =<< trim END
1006 vim9script
1007 def Outer()
Bram Moolenaar2c79e9d2020-08-01 18:57:52 +02001008 def g:Inner(): string
1009 return 'inner'
1010 enddef
1011 enddef
1012 defcompile
1013 Outer()
1014 Outer()
1015 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001016 v9.CheckScriptFailure(lines, "E122:")
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01001017 delfunc g:Inner
Bram Moolenaarad486a02020-08-01 23:22:18 +02001018
1019 lines =<< trim END
1020 vim9script
Bram Moolenaar58a52f22020-12-22 18:56:55 +01001021 def Outer()
1022 def g:Inner()
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001023 echo map([1, 2, 3], (_, v) => v + 1)
Bram Moolenaar58a52f22020-12-22 18:56:55 +01001024 enddef
1025 g:Inner()
1026 enddef
1027 Outer()
1028 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001029 v9.CheckScriptSuccess(lines)
Bram Moolenaar58a52f22020-12-22 18:56:55 +01001030 delfunc g:Inner
1031
1032 lines =<< trim END
1033 vim9script
Bram Moolenaarad486a02020-08-01 23:22:18 +02001034 def Func()
1035 echo 'script'
1036 enddef
1037 def Outer()
1038 def Func()
1039 echo 'inner'
1040 enddef
1041 enddef
1042 defcompile
1043 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001044 v9.CheckScriptFailure(lines, "E1073:", 1)
Bram Moolenaard604d782021-11-20 21:46:20 +00001045
1046 lines =<< trim END
1047 vim9script
1048 def Func()
1049 echo 'script'
1050 enddef
1051 def Func()
1052 echo 'script'
1053 enddef
1054 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001055 v9.CheckScriptFailure(lines, "E1073:", 5)
Bram Moolenaar38ddf332020-07-31 22:05:04 +02001056enddef
1057
Bram Moolenaar6abdcf82020-11-22 18:15:44 +01001058def DefListAll()
1059 def
1060enddef
1061
1062def DefListOne()
1063 def DefListOne
1064enddef
1065
1066def DefListMatches()
1067 def /DefList
1068enddef
1069
1070def Test_nested_def_list()
1071 var funcs = split(execute('call DefListAll()'), "\n")
1072 assert_true(len(funcs) > 10)
1073 assert_true(funcs->index('def DefListAll()') >= 0)
1074
1075 funcs = split(execute('call DefListOne()'), "\n")
1076 assert_equal([' def DefListOne()', '1 def DefListOne', ' enddef'], funcs)
1077
1078 funcs = split(execute('call DefListMatches()'), "\n")
1079 assert_true(len(funcs) >= 3)
1080 assert_true(funcs->index('def DefListAll()') >= 0)
1081 assert_true(funcs->index('def DefListOne()') >= 0)
1082 assert_true(funcs->index('def DefListMatches()') >= 0)
Bram Moolenaar54021752020-12-06 18:50:36 +01001083
1084 var lines =<< trim END
1085 vim9script
1086 def Func()
1087 def +Func+
1088 enddef
1089 defcompile
1090 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001091 v9.CheckScriptFailure(lines, 'E476:', 1)
Bram Moolenaar6abdcf82020-11-22 18:15:44 +01001092enddef
1093
Bram Moolenaare08be092022-02-17 13:08:26 +00001094def Test_global_function_not_found()
1095 var lines =<< trim END
1096 g:Ref = 123
1097 call g:Ref()
1098 END
1099 v9.CheckDefExecAndScriptFailure(lines, ['E117:', 'E1085:'], 2)
1100enddef
1101
Bram Moolenaar333894b2020-08-01 18:53:07 +02001102def Test_global_local_function()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001103 var lines =<< trim END
Bram Moolenaar333894b2020-08-01 18:53:07 +02001104 vim9script
1105 def g:Func(): string
1106 return 'global'
1107 enddef
1108 def Func(): string
1109 return 'local'
1110 enddef
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001111 g:Func()->assert_equal('global')
1112 Func()->assert_equal('local')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001113 delfunc g:Func
Bram Moolenaar333894b2020-08-01 18:53:07 +02001114 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001115 v9.CheckScriptSuccess(lines)
Bram Moolenaar035d6e92020-08-11 22:30:42 +02001116
1117 lines =<< trim END
1118 vim9script
1119 def g:Funcy()
1120 echo 'funcy'
1121 enddef
Bram Moolenaara749a422022-02-12 19:52:25 +00001122 Funcy()
Bram Moolenaar035d6e92020-08-11 22:30:42 +02001123 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001124 v9.CheckScriptFailure(lines, 'E117:')
Bram Moolenaar333894b2020-08-01 18:53:07 +02001125enddef
1126
Bram Moolenaar0f769812020-09-12 18:32:34 +02001127def Test_local_function_shadows_global()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001128 var lines =<< trim END
Bram Moolenaar0f769812020-09-12 18:32:34 +02001129 vim9script
1130 def g:Gfunc(): string
1131 return 'global'
1132 enddef
1133 def AnotherFunc(): number
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001134 var Gfunc = function('len')
Bram Moolenaar0f769812020-09-12 18:32:34 +02001135 return Gfunc('testing')
1136 enddef
1137 g:Gfunc()->assert_equal('global')
1138 AnotherFunc()->assert_equal(7)
1139 delfunc g:Gfunc
1140 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001141 v9.CheckScriptSuccess(lines)
Bram Moolenaar0f769812020-09-12 18:32:34 +02001142
1143 lines =<< trim END
1144 vim9script
1145 def g:Func(): string
1146 return 'global'
1147 enddef
1148 def AnotherFunc()
1149 g:Func = function('len')
1150 enddef
1151 AnotherFunc()
1152 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001153 v9.CheckScriptFailure(lines, 'E705:')
Bram Moolenaar0f769812020-09-12 18:32:34 +02001154 delfunc g:Func
Bram Moolenaar0865b152021-04-05 15:38:51 +02001155
Bram Moolenaar62aec932022-01-29 21:45:34 +00001156 # global function is not found with g: prefix
Bram Moolenaar0865b152021-04-05 15:38:51 +02001157 lines =<< trim END
1158 vim9script
1159 def g:Func(): string
1160 return 'global'
1161 enddef
1162 def AnotherFunc(): string
1163 return Func()
1164 enddef
1165 assert_equal('global', AnotherFunc())
Bram Moolenaar0865b152021-04-05 15:38:51 +02001166 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001167 v9.CheckScriptFailure(lines, 'E117:')
1168 delfunc g:Func
Bram Moolenaar0865b152021-04-05 15:38:51 +02001169
1170 lines =<< trim END
1171 vim9script
1172 def g:Func(): string
1173 return 'global'
1174 enddef
Bram Moolenaar848fadd2022-01-30 15:28:30 +00001175 assert_equal('global', g:Func())
Bram Moolenaar0865b152021-04-05 15:38:51 +02001176 delfunc g:Func
1177 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001178 v9.CheckScriptSuccess(lines)
Bram Moolenaar58493cf2022-01-06 12:23:30 +00001179
1180 # This does not shadow "i" which is visible only inside the for loop
1181 lines =<< trim END
1182 vim9script
1183
1184 def Foo(i: number)
1185 echo i
1186 enddef
1187
1188 for i in range(3)
1189 # Foo() is compiled here
1190 Foo(i)
1191 endfor
1192 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001193 v9.CheckScriptSuccess(lines)
Bram Moolenaar0f769812020-09-12 18:32:34 +02001194enddef
1195
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001196func TakesOneArg(arg)
1197 echo a:arg
1198endfunc
1199
1200def Test_call_wrong_args()
Bram Moolenaar62aec932022-01-29 21:45:34 +00001201 v9.CheckDefFailure(['g:TakesOneArg()'], 'E119:')
1202 v9.CheckDefFailure(['g:TakesOneArg(11, 22)'], 'E118:')
1203 v9.CheckDefFailure(['bufnr(xxx)'], 'E1001:')
1204 v9.CheckScriptFailure(['def Func(Ref: func(s: string))'], 'E475:')
Bram Moolenaaree8580e2020-08-28 17:19:07 +02001205
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001206 var lines =<< trim END
Bram Moolenaaree8580e2020-08-28 17:19:07 +02001207 vim9script
1208 def Func(s: string)
1209 echo s
1210 enddef
1211 Func([])
1212 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001213 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected string but got list<unknown>', 5)
Bram Moolenaarb185a402020-09-18 22:42:00 +02001214
Bram Moolenaar9a015112021-12-31 14:06:45 +00001215 # argument name declared earlier is found when declaring a function
Bram Moolenaarb185a402020-09-18 22:42:00 +02001216 lines =<< trim END
1217 vim9script
Bram Moolenaarb4893b82021-02-21 22:20:24 +01001218 var name = 'piet'
1219 def FuncOne(name: string)
Bram Moolenaar3a5988c2022-02-08 19:23:35 +00001220 echo name
Bram Moolenaarb4893b82021-02-21 22:20:24 +01001221 enddef
1222 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001223 v9.CheckScriptFailure(lines, 'E1168:')
Bram Moolenaarb4893b82021-02-21 22:20:24 +01001224
Bram Moolenaar3a5988c2022-02-08 19:23:35 +00001225 # same, inside the same block
1226 lines =<< trim END
1227 vim9script
1228 if true
1229 var name = 'piet'
1230 def FuncOne(name: string)
1231 echo name
1232 enddef
1233 endif
1234 END
1235 v9.CheckScriptFailure(lines, 'E1168:')
1236
1237 # variable in other block is OK
1238 lines =<< trim END
1239 vim9script
1240 if true
1241 var name = 'piet'
1242 endif
1243 def FuncOne(name: string)
1244 echo name
1245 enddef
1246 END
1247 v9.CheckScriptSuccess(lines)
1248
Bram Moolenaardce24412022-02-08 20:35:30 +00001249 # with another variable in another block
1250 lines =<< trim END
1251 vim9script
1252 if true
1253 var name = 'piet'
1254 # define a function so that the variable isn't cleared
1255 def GetItem(): string
1256 return item
1257 enddef
1258 endif
1259 if true
1260 var name = 'peter'
1261 def FuncOne(name: string)
1262 echo name
1263 enddef
1264 endif
1265 END
1266 v9.CheckScriptFailure(lines, 'E1168:')
1267
1268 # only variable in another block is OK
1269 lines =<< trim END
1270 vim9script
1271 if true
1272 var name = 'piet'
1273 # define a function so that the variable isn't cleared
1274 def GetItem(): string
1275 return item
1276 enddef
1277 endif
1278 if true
1279 def FuncOne(name: string)
1280 echo name
1281 enddef
1282 endif
1283 END
1284 v9.CheckScriptSuccess(lines)
1285
Bram Moolenaar9a015112021-12-31 14:06:45 +00001286 # argument name declared later is only found when compiling
1287 lines =<< trim END
1288 vim9script
1289 def FuncOne(name: string)
1290 echo nr
1291 enddef
1292 var name = 'piet'
1293 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001294 v9.CheckScriptSuccess(lines)
1295 v9.CheckScriptFailure(lines + ['defcompile'], 'E1168:')
Bram Moolenaar9a015112021-12-31 14:06:45 +00001296
Bram Moolenaarb4893b82021-02-21 22:20:24 +01001297 lines =<< trim END
1298 vim9script
Bram Moolenaarb185a402020-09-18 22:42:00 +02001299 def FuncOne(nr: number)
1300 echo nr
1301 enddef
1302 def FuncTwo()
1303 FuncOne()
1304 enddef
1305 defcompile
1306 END
1307 writefile(lines, 'Xscript')
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001308 var didCatch = false
Bram Moolenaarb185a402020-09-18 22:42:00 +02001309 try
1310 source Xscript
1311 catch
1312 assert_match('E119: Not enough arguments for function: <SNR>\d\+_FuncOne', v:exception)
1313 assert_match('Xscript\[8\]..function <SNR>\d\+_FuncTwo, line 1', v:throwpoint)
1314 didCatch = true
1315 endtry
1316 assert_true(didCatch)
1317
1318 lines =<< trim END
1319 vim9script
1320 def FuncOne(nr: number)
1321 echo nr
1322 enddef
1323 def FuncTwo()
1324 FuncOne(1, 2)
1325 enddef
1326 defcompile
1327 END
Bram Moolenaarf5fec052022-09-11 11:49:22 +01001328 writefile(lines, 'Xscript', 'D')
Bram Moolenaarb185a402020-09-18 22:42:00 +02001329 didCatch = false
1330 try
1331 source Xscript
1332 catch
1333 assert_match('E118: Too many arguments for function: <SNR>\d\+_FuncOne', v:exception)
1334 assert_match('Xscript\[8\]..function <SNR>\d\+_FuncTwo, line 1', v:throwpoint)
1335 didCatch = true
1336 endtry
1337 assert_true(didCatch)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001338enddef
1339
Bram Moolenaar50824712020-12-20 21:10:17 +01001340def Test_call_funcref_wrong_args()
1341 var head =<< trim END
1342 vim9script
1343 def Func3(a1: string, a2: number, a3: list<number>)
1344 echo a1 .. a2 .. a3[0]
1345 enddef
1346 def Testme()
1347 var funcMap: dict<func> = {func: Func3}
1348 END
1349 var tail =<< trim END
1350 enddef
1351 Testme()
1352 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001353 v9.CheckScriptSuccess(head + ["funcMap['func']('str', 123, [1, 2, 3])"] + tail)
Bram Moolenaar50824712020-12-20 21:10:17 +01001354
Bram Moolenaar62aec932022-01-29 21:45:34 +00001355 v9.CheckScriptFailure(head + ["funcMap['func']('str', 123)"] + tail, 'E119:')
1356 v9.CheckScriptFailure(head + ["funcMap['func']('str', 123, [1], 4)"] + tail, 'E118:')
Bram Moolenaar32b3f822021-01-06 21:59:39 +01001357
1358 var lines =<< trim END
1359 vim9script
1360 var Ref: func(number): any
1361 Ref = (j) => !j
1362 echo Ref(false)
1363 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001364 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected number but got bool', 4)
Bram Moolenaar32b3f822021-01-06 21:59:39 +01001365
1366 lines =<< trim END
1367 vim9script
1368 var Ref: func(number): any
1369 Ref = (j) => !j
1370 call Ref(false)
1371 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001372 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected number but got bool', 4)
Bram Moolenaar50824712020-12-20 21:10:17 +01001373enddef
1374
Bram Moolenaarb4d16cb2020-11-05 18:45:46 +01001375def Test_call_lambda_args()
Bram Moolenaar2a389082021-04-09 20:24:31 +02001376 var lines =<< trim END
1377 var Callback = (..._) => 'anything'
1378 assert_equal('anything', Callback())
1379 assert_equal('anything', Callback(1))
1380 assert_equal('anything', Callback('a', 2))
Bram Moolenaar1088b692021-04-09 22:12:44 +02001381
1382 assert_equal('xyz', ((a: string): string => a)('xyz'))
Bram Moolenaar2a389082021-04-09 20:24:31 +02001383 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001384 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar2a389082021-04-09 20:24:31 +02001385
Bram Moolenaar62aec932022-01-29 21:45:34 +00001386 v9.CheckDefFailure(['echo ((i) => 0)()'],
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001387 'E119: Not enough arguments for function: ((i) => 0)()')
Bram Moolenaarb4d16cb2020-11-05 18:45:46 +01001388
Bram Moolenaar2a389082021-04-09 20:24:31 +02001389 lines =<< trim END
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001390 var Ref = (x: number, y: number) => x + y
Bram Moolenaarb4d16cb2020-11-05 18:45:46 +01001391 echo Ref(1, 'x')
1392 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001393 v9.CheckDefFailure(lines, 'E1013: Argument 2: type mismatch, expected number but got string')
Bram Moolenaare68b02a2021-01-03 13:09:51 +01001394
1395 lines =<< trim END
1396 var Ref: func(job, string, number)
1397 Ref = (x, y) => 0
1398 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001399 v9.CheckDefAndScriptFailure(lines, 'E1012:')
Bram Moolenaare68b02a2021-01-03 13:09:51 +01001400
1401 lines =<< trim END
1402 var Ref: func(job, string)
1403 Ref = (x, y, z) => 0
1404 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001405 v9.CheckDefAndScriptFailure(lines, 'E1012:')
Bram Moolenaar057e84a2021-02-28 16:55:11 +01001406
1407 lines =<< trim END
1408 var one = 1
1409 var l = [1, 2, 3]
1410 echo map(l, (one) => one)
1411 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001412 v9.CheckDefFailure(lines, 'E1167:')
1413 v9.CheckScriptFailure(['vim9script'] + lines, 'E1168:')
Bram Moolenaar057e84a2021-02-28 16:55:11 +01001414
1415 lines =<< trim END
Bram Moolenaar14ded112021-06-26 19:25:49 +02001416 var Ref: func(any, ?any): bool
1417 Ref = (_, y = 1) => false
1418 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001419 v9.CheckDefAndScriptFailure(lines, 'E1172:')
Bram Moolenaar14ded112021-06-26 19:25:49 +02001420
1421 lines =<< trim END
Bram Moolenaar015cf102021-06-26 21:52:02 +02001422 var a = 0
1423 var b = (a == 0 ? 1 : 2)
1424 assert_equal(1, b)
Bram Moolenaar98f9a5f2021-06-26 22:22:38 +02001425 var txt = 'a'
1426 b = (txt =~ 'x' ? 1 : 2)
1427 assert_equal(2, b)
Bram Moolenaar015cf102021-06-26 21:52:02 +02001428 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001429 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar015cf102021-06-26 21:52:02 +02001430
1431 lines =<< trim END
Bram Moolenaar057e84a2021-02-28 16:55:11 +01001432 def ShadowLocal()
1433 var one = 1
1434 var l = [1, 2, 3]
1435 echo map(l, (one) => one)
1436 enddef
1437 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001438 v9.CheckDefFailure(lines, 'E1167:')
Bram Moolenaar057e84a2021-02-28 16:55:11 +01001439
1440 lines =<< trim END
1441 def Shadowarg(one: number)
1442 var l = [1, 2, 3]
1443 echo map(l, (one) => one)
1444 enddef
1445 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001446 v9.CheckDefFailure(lines, 'E1167:')
Bram Moolenaar767034c2021-04-09 17:24:52 +02001447
1448 lines =<< trim END
1449 echo ((a) => a)('aa', 'bb')
1450 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001451 v9.CheckDefAndScriptFailure(lines, 'E118:', 1)
Bram Moolenaarc4c56422021-07-21 20:38:46 +02001452
1453 lines =<< trim END
1454 echo 'aa'->((a) => a)('bb')
1455 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001456 v9.CheckDefFailure(lines, 'E118: Too many arguments for function: ->((a) => a)(''bb'')', 1)
1457 v9.CheckScriptFailure(['vim9script'] + lines, 'E118: Too many arguments for function: <lambda>', 2)
Bram Moolenaarb4d16cb2020-11-05 18:45:46 +01001458enddef
1459
Bram Moolenaara755fdb2021-11-20 21:35:41 +00001460def Test_lambda_line_nr()
1461 var lines =<< trim END
1462 vim9script
1463 # comment
1464 # comment
1465 var id = timer_start(1'000, (_) => 0)
1466 var out = execute('verbose ' .. timer_info(id)[0].callback
1467 ->string()
1468 ->substitute("('\\|')", ' ', 'g'))
1469 assert_match('Last set from .* line 4', out)
1470 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001471 v9.CheckScriptSuccess(lines)
Bram Moolenaara755fdb2021-11-20 21:35:41 +00001472enddef
1473
Bram Moolenaar5f91e742021-03-17 21:29:29 +01001474def FilterWithCond(x: string, Cond: func(string): bool): bool
1475 return Cond(x)
1476enddef
1477
Bram Moolenaar0346b792021-01-31 22:18:29 +01001478def Test_lambda_return_type()
1479 var lines =<< trim END
1480 var Ref = (): => 123
1481 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001482 v9.CheckDefAndScriptFailure(lines, 'E1157:', 1)
Bram Moolenaar5f91e742021-03-17 21:29:29 +01001483
Yegappan Lakshmanan611728f2021-05-24 15:15:47 +02001484 # no space before the return type
1485 lines =<< trim END
1486 var Ref = (x):number => x + 1
1487 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001488 v9.CheckDefAndScriptFailure(lines, 'E1069:', 1)
Yegappan Lakshmanan611728f2021-05-24 15:15:47 +02001489
Bram Moolenaar5f91e742021-03-17 21:29:29 +01001490 # this works
1491 for x in ['foo', 'boo']
Bram Moolenaar62aec932022-01-29 21:45:34 +00001492 echo g:FilterWithCond(x, (v) => v =~ '^b')
Bram Moolenaar5f91e742021-03-17 21:29:29 +01001493 endfor
1494
1495 # this fails
1496 lines =<< trim END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001497 echo g:FilterWithCond('foo', (v) => v .. '^b')
Bram Moolenaar5f91e742021-03-17 21:29:29 +01001498 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001499 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 +02001500
1501 lines =<< trim END
1502 var Lambda1 = (x) => {
1503 return x
1504 }
1505 assert_equal('asdf', Lambda1('asdf'))
1506 var Lambda2 = (x): string => {
1507 return x
1508 }
1509 assert_equal('foo', Lambda2('foo'))
1510 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001511 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaara9931532021-06-12 15:58:16 +02001512
1513 lines =<< trim END
1514 var Lambda = (x): string => {
1515 return x
1516 }
1517 echo Lambda(['foo'])
1518 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001519 v9.CheckDefExecAndScriptFailure(lines, 'E1012:')
Bram Moolenaar0346b792021-01-31 22:18:29 +01001520enddef
1521
Bram Moolenaar709664c2020-12-12 14:33:41 +01001522def Test_lambda_uses_assigned_var()
Bram Moolenaar62aec932022-01-29 21:45:34 +00001523 v9.CheckDefSuccess([
Bram Moolenaar2984ed32022-08-20 14:51:17 +01001524 'var x: any = "aaa"',
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001525 'x = filter(["bbb"], (_, v) => v =~ x)'])
Bram Moolenaar709664c2020-12-12 14:33:41 +01001526enddef
1527
Bram Moolenaarf5f4e852022-09-22 22:03:14 +01001528def Test_lambda_invalid_block()
1529 var lines =<< trim END
1530 timer_start(0, (_) => { # echo
1531 echo 'yes'
1532 })
1533 END
1534 v9.CheckDefAndScriptSuccess(lines)
1535
1536 lines =<< trim END
1537 timer_start(0, (_) => { " echo
1538 echo 'yes'
1539 })
1540 END
1541 v9.CheckDefAndScriptFailure(lines, 'E488: Trailing characters: " echo')
1542
1543 lines =<< trim END
1544 timer_start(0, (_) => { | echo
1545 echo 'yes'
1546 })
1547 END
1548 v9.CheckDefAndScriptFailure(lines, 'E488: Trailing characters: | echo')
1549enddef
1550
Bram Moolenaarf8addf12022-09-23 12:44:25 +01001551def Test_lambda_with_following_cmd()
1552 var lines =<< trim END
1553 set ts=2
1554 var Lambda = () => {
1555 set ts=4
1556 } | set ts=3
1557 assert_equal(3, &ts)
1558 Lambda()
1559 assert_equal(4, &ts)
1560 END
1561 v9.CheckDefAndScriptSuccess(lines)
1562 set ts=8
1563enddef
1564
Bram Moolenaar18062fc2021-03-05 21:35:47 +01001565def Test_pass_legacy_lambda_to_def_func()
1566 var lines =<< trim END
1567 vim9script
1568 func Foo()
1569 eval s:Bar({x -> 0})
1570 endfunc
1571 def Bar(y: any)
1572 enddef
1573 Foo()
1574 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001575 v9.CheckScriptSuccess(lines)
Bram Moolenaar831bdf82021-06-22 19:32:17 +02001576
1577 lines =<< trim END
1578 vim9script
Bram Moolenaar1d9cef72022-03-17 16:30:03 +00001579 def g:TestFunc(F: func)
Bram Moolenaar831bdf82021-06-22 19:32:17 +02001580 enddef
1581 legacy call g:TestFunc({-> 0})
1582 delfunc g:TestFunc
1583
Bram Moolenaar1d9cef72022-03-17 16:30:03 +00001584 def g:TestFunc(F: func(number))
Bram Moolenaar831bdf82021-06-22 19:32:17 +02001585 enddef
1586 legacy call g:TestFunc({nr -> 0})
1587 delfunc g:TestFunc
1588 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001589 v9.CheckScriptSuccess(lines)
Bram Moolenaar18062fc2021-03-05 21:35:47 +01001590enddef
1591
Bram Moolenaar844fb642021-10-23 13:32:30 +01001592def Test_lambda_in_reduce_line_break()
1593 # this was using freed memory
1594 var lines =<< trim END
1595 vim9script
1596 const result: dict<number> =
1597 ['Bob', 'Sam', 'Cat', 'Bob', 'Cat', 'Cat']
1598 ->reduce((acc, val) => {
1599 if has_key(acc, val)
1600 acc[val] += 1
1601 return acc
1602 else
1603 acc[val] = 1
1604 return acc
1605 endif
1606 }, {})
1607 assert_equal({Bob: 2, Sam: 1, Cat: 3}, result)
1608 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001609 v9.CheckScriptSuccess(lines)
Bram Moolenaar844fb642021-10-23 13:32:30 +01001610enddef
1611
Bram Moolenaardcb53be2021-12-09 14:23:43 +00001612def Test_set_opfunc_to_lambda()
1613 var lines =<< trim END
1614 vim9script
1615 nnoremap <expr> <F4> <SID>CountSpaces() .. '_'
1616 def CountSpaces(type = ''): string
1617 if type == ''
1618 &operatorfunc = (t) => CountSpaces(t)
1619 return 'g@'
1620 endif
1621 normal! '[V']y
1622 g:result = getreg('"')->count(' ')
1623 return ''
1624 enddef
1625 new
1626 'a b c d e'->setline(1)
1627 feedkeys("\<F4>", 'x')
1628 assert_equal(4, g:result)
1629 bwipe!
1630 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001631 v9.CheckScriptSuccess(lines)
Bram Moolenaardcb53be2021-12-09 14:23:43 +00001632enddef
1633
Bram Moolenaaref082e12021-12-12 21:02:03 +00001634def Test_set_opfunc_to_global_function()
1635 var lines =<< trim END
1636 vim9script
1637 def g:CountSpaces(type = ''): string
1638 normal! '[V']y
1639 g:result = getreg('"')->count(' ')
1640 return ''
1641 enddef
Bram Moolenaarb15cf442021-12-16 15:49:43 +00001642 # global function works at script level
Bram Moolenaaref082e12021-12-12 21:02:03 +00001643 &operatorfunc = g:CountSpaces
1644 new
1645 'a b c d e'->setline(1)
1646 feedkeys("g@_", 'x')
1647 assert_equal(4, g:result)
Bram Moolenaarb15cf442021-12-16 15:49:43 +00001648
1649 &operatorfunc = ''
1650 g:result = 0
1651 # global function works in :def function
1652 def Func()
1653 &operatorfunc = g:CountSpaces
1654 enddef
1655 Func()
1656 feedkeys("g@_", 'x')
1657 assert_equal(4, g:result)
1658
Bram Moolenaaref082e12021-12-12 21:02:03 +00001659 bwipe!
1660 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001661 v9.CheckScriptSuccess(lines)
Bram Moolenaaref082e12021-12-12 21:02:03 +00001662 &operatorfunc = ''
1663enddef
1664
Bram Moolenaar33b968d2021-12-13 11:31:04 +00001665def Test_use_script_func_name_with_prefix()
1666 var lines =<< trim END
1667 vim9script
Bram Moolenaara749a422022-02-12 19:52:25 +00001668 func g:Getit()
Bram Moolenaar33b968d2021-12-13 11:31:04 +00001669 return 'it'
1670 endfunc
Bram Moolenaara749a422022-02-12 19:52:25 +00001671 var Fn = g:Getit
Bram Moolenaar33b968d2021-12-13 11:31:04 +00001672 assert_equal('it', Fn())
1673 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001674 v9.CheckScriptSuccess(lines)
Bram Moolenaar33b968d2021-12-13 11:31:04 +00001675enddef
1676
Bram Moolenaardd297bc2021-12-10 10:37:38 +00001677def Test_lambda_type_allocated()
1678 # Check that unreferencing a partial using a lambda can use the variable type
1679 # after the lambda has been freed and does not leak memory.
1680 var lines =<< trim END
1681 vim9script
1682
1683 func MyomniFunc1(val, findstart, base)
1684 return a:findstart ? 0 : []
1685 endfunc
1686
1687 var Lambda = (a, b) => MyomniFunc1(19, a, b)
1688 &omnifunc = Lambda
1689 Lambda = (a, b) => MyomniFunc1(20, a, b)
1690 &omnifunc = string(Lambda)
1691 Lambda = (a, b) => strlen(a)
1692 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001693 v9.CheckScriptSuccess(lines)
Bram Moolenaardd297bc2021-12-10 10:37:38 +00001694enddef
1695
Bram Moolenaara7583c42022-05-07 21:14:05 +01001696def Test_define_lambda_in_execute()
1697 var lines =<< trim [CODE]
1698 vim9script
1699
1700 def BuildFuncMultiLine(): func
1701 var x =<< trim END
1702 g:SomeRandomFunc = (d: dict<any>) => {
1703 return d.k1 + d.k2
1704 }
1705 END
1706 execute(x)
1707 return g:SomeRandomFunc
1708 enddef
1709 var ResultPlus = BuildFuncMultiLine()
1710 assert_equal(7, ResultPlus({k1: 3, k2: 4}))
1711 [CODE]
1712 v9.CheckScriptSuccess(lines)
1713 unlet g:SomeRandomFunc
1714enddef
1715
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001716" Default arg and varargs
1717def MyDefVarargs(one: string, two = 'foo', ...rest: list<string>): string
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001718 var res = one .. ',' .. two
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001719 for s in rest
1720 res ..= ',' .. s
1721 endfor
1722 return res
1723enddef
1724
1725def Test_call_def_varargs()
Bram Moolenaar62aec932022-01-29 21:45:34 +00001726 assert_fails('g:MyDefVarargs()', 'E119:', '', 1, 'Test_call_def_varargs')
1727 g:MyDefVarargs('one')->assert_equal('one,foo')
1728 g:MyDefVarargs('one', 'two')->assert_equal('one,two')
1729 g:MyDefVarargs('one', 'two', 'three')->assert_equal('one,two,three')
1730 v9.CheckDefFailure(['g:MyDefVarargs("one", 22)'],
Bram Moolenaar77072282020-09-16 17:55:40 +02001731 'E1013: Argument 2: type mismatch, expected string but got number')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001732 v9.CheckDefFailure(['g:MyDefVarargs("one", "two", 123)'],
Bram Moolenaar77072282020-09-16 17:55:40 +02001733 'E1013: Argument 3: type mismatch, expected string but got number')
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001734
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001735 var lines =<< trim END
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001736 vim9script
1737 def Func(...l: list<string>)
1738 echo l
1739 enddef
1740 Func('a', 'b', 'c')
1741 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001742 v9.CheckScriptSuccess(lines)
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001743
1744 lines =<< trim END
1745 vim9script
1746 def Func(...l: list<string>)
1747 echo l
1748 enddef
1749 Func()
1750 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001751 v9.CheckScriptSuccess(lines)
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001752
1753 lines =<< trim END
1754 vim9script
Bram Moolenaar2a389082021-04-09 20:24:31 +02001755 def Func(...l: list<any>)
Bram Moolenaar2f8cbc42020-09-16 17:22:59 +02001756 echo l
1757 enddef
1758 Func(0)
1759 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001760 v9.CheckScriptSuccess(lines)
Bram Moolenaar2f8cbc42020-09-16 17:22:59 +02001761
1762 lines =<< trim END
1763 vim9script
Bram Moolenaar2a389082021-04-09 20:24:31 +02001764 def Func(...l: any)
1765 echo l
1766 enddef
1767 Func(0)
1768 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001769 v9.CheckScriptFailure(lines, 'E1180:', 2)
Bram Moolenaar2a389082021-04-09 20:24:31 +02001770
1771 lines =<< trim END
1772 vim9script
Bram Moolenaar28022722020-09-21 22:02:49 +02001773 def Func(..._l: list<string>)
1774 echo _l
1775 enddef
1776 Func('a', 'b', 'c')
1777 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001778 v9.CheckScriptSuccess(lines)
Bram Moolenaar28022722020-09-21 22:02:49 +02001779
1780 lines =<< trim END
1781 vim9script
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001782 def Func(...l: list<string>)
1783 echo l
1784 enddef
1785 Func(1, 2, 3)
1786 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001787 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch')
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001788
1789 lines =<< trim END
1790 vim9script
1791 def Func(...l: list<string>)
1792 echo l
1793 enddef
1794 Func('a', 9)
1795 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001796 v9.CheckScriptFailure(lines, 'E1013: Argument 2: type mismatch')
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001797
1798 lines =<< trim END
1799 vim9script
1800 def Func(...l: list<string>)
1801 echo l
1802 enddef
1803 Func(1, 'a')
1804 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001805 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch')
Bram Moolenaar4f53b792021-02-07 15:59:49 +01001806
1807 lines =<< trim END
1808 vim9script
1809 def Func( # some comment
1810 ...l = []
1811 )
1812 echo l
1813 enddef
1814 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001815 v9.CheckScriptFailure(lines, 'E1160:')
Bram Moolenaar6ce46b92021-08-07 15:35:36 +02001816
1817 lines =<< trim END
1818 vim9script
1819 def DoIt()
1820 g:Later('')
1821 enddef
1822 defcompile
1823 def g:Later(...l: list<number>)
1824 enddef
1825 DoIt()
1826 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001827 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected number but got string')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001828enddef
1829
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001830let s:value = ''
1831
1832def FuncOneDefArg(opt = 'text')
1833 s:value = opt
1834enddef
1835
1836def FuncTwoDefArg(nr = 123, opt = 'text'): string
1837 return nr .. opt
1838enddef
1839
1840def FuncVarargs(...arg: list<string>): string
1841 return join(arg, ',')
1842enddef
1843
1844def Test_func_type_varargs()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001845 var RefDefArg: func(?string)
Bram Moolenaar848fadd2022-01-30 15:28:30 +00001846 RefDefArg = g:FuncOneDefArg
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001847 RefDefArg()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001848 s:value->assert_equal('text')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001849 RefDefArg('some')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001850 s:value->assert_equal('some')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001851
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001852 var RefDef2Arg: func(?number, ?string): string
Bram Moolenaar848fadd2022-01-30 15:28:30 +00001853 RefDef2Arg = g:FuncTwoDefArg
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001854 RefDef2Arg()->assert_equal('123text')
1855 RefDef2Arg(99)->assert_equal('99text')
1856 RefDef2Arg(77, 'some')->assert_equal('77some')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001857
Bram Moolenaar62aec932022-01-29 21:45:34 +00001858 v9.CheckDefFailure(['var RefWrong: func(string?)'], 'E1010:')
1859 v9.CheckDefFailure(['var RefWrong: func(?string, string)'], 'E1007:')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001860
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001861 var RefVarargs: func(...list<string>): string
Bram Moolenaar848fadd2022-01-30 15:28:30 +00001862 RefVarargs = g:FuncVarargs
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001863 RefVarargs()->assert_equal('')
1864 RefVarargs('one')->assert_equal('one')
1865 RefVarargs('one', 'two')->assert_equal('one,two')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001866
Bram Moolenaar62aec932022-01-29 21:45:34 +00001867 v9.CheckDefFailure(['var RefWrong: func(...list<string>, string)'], 'E110:')
1868 v9.CheckDefFailure(['var RefWrong: func(...list<string>, ?string)'], 'E110:')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001869enddef
1870
Bram Moolenaar0b76b422020-04-07 22:05:08 +02001871" Only varargs
1872def MyVarargsOnly(...args: list<string>): string
1873 return join(args, ',')
1874enddef
1875
1876def Test_call_varargs_only()
Bram Moolenaar62aec932022-01-29 21:45:34 +00001877 g:MyVarargsOnly()->assert_equal('')
1878 g:MyVarargsOnly('one')->assert_equal('one')
1879 g:MyVarargsOnly('one', 'two')->assert_equal('one,two')
1880 v9.CheckDefFailure(['g:MyVarargsOnly(1)'], 'E1013: Argument 1: type mismatch, expected string but got number')
1881 v9.CheckDefFailure(['g:MyVarargsOnly("one", 2)'], 'E1013: Argument 2: type mismatch, expected string but got number')
Bram Moolenaar0b76b422020-04-07 22:05:08 +02001882enddef
1883
Bram Moolenaar36818a92023-01-03 12:33:26 +00001884def Test_varargs_mismatch()
1885 var lines =<< trim END
1886 vim9script
1887
1888 def Map(Fn: func(...any): number): number
1889 return Fn('12')
1890 enddef
1891
1892 var res = Map((v) => str2nr(v))
1893 assert_equal(12, res)
1894 END
1895 v9.CheckScriptSuccess(lines)
1896enddef
1897
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001898def Test_using_var_as_arg()
Bram Moolenaard2939812021-12-30 17:09:05 +00001899 var lines =<< trim END
1900 def Func(x: number)
1901 var x = 234
1902 enddef
1903 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001904 v9.CheckDefFailure(lines, 'E1006:')
Bram Moolenaard2939812021-12-30 17:09:05 +00001905
1906 lines =<< trim END
1907 def Func(Ref: number)
1908 def Ref()
1909 enddef
1910 enddef
1911 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001912 v9.CheckDefFailure(lines, 'E1073:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001913enddef
1914
Bram Moolenaar62aec932022-01-29 21:45:34 +00001915def s:DictArg(arg: dict<string>)
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +02001916 arg['key'] = 'value'
1917enddef
1918
Bram Moolenaar62aec932022-01-29 21:45:34 +00001919def s:ListArg(arg: list<string>)
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +02001920 arg[0] = 'value'
1921enddef
1922
1923def Test_assign_to_argument()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001924 # works for dict and list
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001925 var d: dict<string> = {}
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +02001926 DictArg(d)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001927 d['key']->assert_equal('value')
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001928 var l: list<string> = []
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +02001929 ListArg(l)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001930 l[0]->assert_equal('value')
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +02001931
Bram Moolenaar62aec932022-01-29 21:45:34 +00001932 v9.CheckScriptFailure(['def Func(arg: number)', 'arg = 3', 'enddef', 'defcompile'], 'E1090:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001933 delfunc! g:Func
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +02001934enddef
1935
Bram Moolenaarb816dae2020-09-20 22:04:00 +02001936" These argument names are reserved in legacy functions.
Bram Moolenaar62aec932022-01-29 21:45:34 +00001937def s:WithReservedNames(firstline: string, lastline: string): string
Bram Moolenaarb816dae2020-09-20 22:04:00 +02001938 return firstline .. lastline
1939enddef
1940
1941def Test_argument_names()
1942 assert_equal('OK', WithReservedNames('O', 'K'))
1943enddef
1944
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001945def Test_call_func_defined_later()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001946 g:DefinedLater('one')->assert_equal('one')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +02001947 assert_fails('NotDefined("one")', 'E117:', '', 2, 'Test_call_func_defined_later')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001948enddef
1949
Bram Moolenaar1df8b3f2020-04-23 18:13:23 +02001950func DefinedLater(arg)
1951 return a:arg
1952endfunc
1953
1954def Test_call_funcref()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001955 g:SomeFunc('abc')->assert_equal(3)
Bram Moolenaar9bd5d872020-09-06 21:47:48 +02001956 assert_fails('NotAFunc()', 'E117:', '', 2, 'Test_call_funcref') # comment after call
Bram Moolenaar2ef91562021-12-11 16:14:07 +00001957 assert_fails('g:NotAFunc()', 'E1085:', '', 3, 'Test_call_funcref')
Bram Moolenaar2f1980f2020-07-22 19:30:06 +02001958
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001959 var lines =<< trim END
Bram Moolenaar2f1980f2020-07-22 19:30:06 +02001960 vim9script
1961 def RetNumber(): number
1962 return 123
1963 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001964 var Funcref: func: number = function('RetNumber')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001965 Funcref()->assert_equal(123)
Bram Moolenaar2f1980f2020-07-22 19:30:06 +02001966 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001967 v9.CheckScriptSuccess(lines)
Bram Moolenaar0f60e802020-07-22 20:16:11 +02001968
1969 lines =<< trim END
1970 vim9script
1971 def RetNumber(): number
1972 return 123
1973 enddef
1974 def Bar(F: func: number): number
1975 return F()
1976 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001977 var Funcref = function('RetNumber')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001978 Bar(Funcref)->assert_equal(123)
Bram Moolenaar0f60e802020-07-22 20:16:11 +02001979 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001980 v9.CheckScriptSuccess(lines)
Bram Moolenaarbfba8652020-07-23 20:09:10 +02001981
1982 lines =<< trim END
1983 vim9script
1984 def UseNumber(nr: number)
1985 echo nr
1986 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001987 var Funcref: func(number) = function('UseNumber')
Bram Moolenaarbfba8652020-07-23 20:09:10 +02001988 Funcref(123)
1989 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001990 v9.CheckScriptSuccess(lines)
Bram Moolenaarb8070e32020-07-23 20:56:04 +02001991
1992 lines =<< trim END
1993 vim9script
1994 def UseNumber(nr: number)
1995 echo nr
1996 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001997 var Funcref: func(string) = function('UseNumber')
Bram Moolenaarb8070e32020-07-23 20:56:04 +02001998 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001999 v9.CheckScriptFailure(lines, 'E1012: Type mismatch; expected func(string) but got func(number)')
Bram Moolenaar4fc224c2020-07-26 17:56:25 +02002000
2001 lines =<< trim END
2002 vim9script
2003 def EchoNr(nr = 34)
2004 g:echo = nr
2005 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002006 var Funcref: func(?number) = function('EchoNr')
Bram Moolenaar4fc224c2020-07-26 17:56:25 +02002007 Funcref()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002008 g:echo->assert_equal(34)
Bram Moolenaar4fc224c2020-07-26 17:56:25 +02002009 Funcref(123)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002010 g:echo->assert_equal(123)
Bram Moolenaar4fc224c2020-07-26 17:56:25 +02002011 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002012 v9.CheckScriptSuccess(lines)
Bram Moolenaarace61322020-07-26 18:16:58 +02002013
2014 lines =<< trim END
2015 vim9script
2016 def EchoList(...l: list<number>)
2017 g:echo = l
2018 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002019 var Funcref: func(...list<number>) = function('EchoList')
Bram Moolenaarace61322020-07-26 18:16:58 +02002020 Funcref()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002021 g:echo->assert_equal([])
Bram Moolenaarace61322020-07-26 18:16:58 +02002022 Funcref(1, 2, 3)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002023 g:echo->assert_equal([1, 2, 3])
Bram Moolenaarace61322020-07-26 18:16:58 +02002024 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002025 v9.CheckScriptSuccess(lines)
Bram Moolenaar01865ad2020-07-26 18:33:09 +02002026
2027 lines =<< trim END
2028 vim9script
2029 def OptAndVar(nr: number, opt = 12, ...l: list<number>): number
2030 g:optarg = opt
2031 g:listarg = l
2032 return nr
2033 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002034 var Funcref: func(number, ?number, ...list<number>): number = function('OptAndVar')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002035 Funcref(10)->assert_equal(10)
2036 g:optarg->assert_equal(12)
2037 g:listarg->assert_equal([])
Bram Moolenaar01865ad2020-07-26 18:33:09 +02002038
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002039 Funcref(11, 22)->assert_equal(11)
2040 g:optarg->assert_equal(22)
2041 g:listarg->assert_equal([])
Bram Moolenaar01865ad2020-07-26 18:33:09 +02002042
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002043 Funcref(17, 18, 1, 2, 3)->assert_equal(17)
2044 g:optarg->assert_equal(18)
2045 g:listarg->assert_equal([1, 2, 3])
Bram Moolenaar01865ad2020-07-26 18:33:09 +02002046 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002047 v9.CheckScriptSuccess(lines)
Kota Kato948a3892022-08-16 16:09:59 +01002048
2049 lines =<< trim END
2050 function s:func(num)
2051 return a:num * 2
2052 endfunction
2053
2054 def s:CallFuncref()
2055 var Funcref = function('s:func')
2056 Funcref(3)->assert_equal(6)
2057 enddef
2058 call s:CallFuncref()
2059 END
2060 v9.CheckScriptSuccess(lines)
2061
2062 lines =<< trim END
2063 function s:func(num)
2064 return a:num * 2
2065 endfunction
2066
2067 def s:CallFuncref()
2068 var Funcref = function(s:func)
2069 Funcref(3)->assert_equal(6)
2070 enddef
2071 call s:CallFuncref()
2072 END
2073 v9.CheckScriptSuccess(lines)
2074
2075 lines =<< trim END
2076 function s:func(num)
2077 return a:num * 2
2078 endfunction
2079
2080 def s:CallFuncref()
2081 var Funcref = s:func
2082 Funcref(3)->assert_equal(6)
2083 enddef
2084 call s:CallFuncref()
2085 END
2086 v9.CheckScriptSuccess(lines)
Bram Moolenaar1df8b3f2020-04-23 18:13:23 +02002087enddef
2088
2089let SomeFunc = function('len')
2090let NotAFunc = 'text'
2091
Bram Moolenaar99aaf0c2020-04-12 14:39:53 +02002092def CombineFuncrefTypes()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002093 # same arguments, different return type
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002094 var Ref1: func(bool): string
2095 var Ref2: func(bool): number
2096 var Ref3: func(bool): any
Bram Moolenaar99aaf0c2020-04-12 14:39:53 +02002097 Ref3 = g:cond ? Ref1 : Ref2
2098
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002099 # different number of arguments
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002100 var Refa1: func(bool): number
2101 var Refa2: func(bool, number): number
2102 var Refa3: func: number
Bram Moolenaar99aaf0c2020-04-12 14:39:53 +02002103 Refa3 = g:cond ? Refa1 : Refa2
2104
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002105 # different argument types
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002106 var Refb1: func(bool, string): number
2107 var Refb2: func(string, number): number
2108 var Refb3: func(any, any): number
Bram Moolenaar99aaf0c2020-04-12 14:39:53 +02002109 Refb3 = g:cond ? Refb1 : Refb2
2110enddef
2111
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002112def FuncWithForwardCall()
Bram Moolenaar1df8b3f2020-04-23 18:13:23 +02002113 return g:DefinedEvenLater("yes")
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002114enddef
2115
2116def DefinedEvenLater(arg: string): string
2117 return arg
2118enddef
2119
2120def Test_error_in_nested_function()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002121 # Error in called function requires unwinding the call stack.
Bram Moolenaar848fadd2022-01-30 15:28:30 +00002122 assert_fails('g:FuncWithForwardCall()', 'E1096:', '', 1, 'FuncWithForwardCall')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002123enddef
2124
Bram Moolenaar4bf10062021-12-28 17:23:12 +00002125def Test_nested_function_with_nextcmd()
Bram Moolenaar9c23f9b2021-12-26 14:23:22 +00002126 var lines =<< trim END
2127 vim9script
2128 # Define an outer function
2129 def FirstFunction()
2130 # Define an inner function
2131 def SecondFunction()
2132 # the function has a body, a double free is detected.
2133 AAAAA
2134
2135 # enddef followed by | or } followed by # one or more characters
2136 enddef|BBBB
2137 enddef
2138
2139 # Compile all functions
2140 defcompile
2141 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002142 v9.CheckScriptFailure(lines, 'E1173: Text found after enddef: BBBB')
Bram Moolenaar9c23f9b2021-12-26 14:23:22 +00002143enddef
2144
Bram Moolenaar4bf10062021-12-28 17:23:12 +00002145def Test_nested_function_with_args_split()
2146 var lines =<< trim END
2147 vim9script
2148 def FirstFunction()
2149 def SecondFunction(
2150 )
2151 # had a double free if the right parenthesis of the nested function is
2152 # on the next line
Bram Moolenaar94722c52023-01-28 19:19:03 +00002153
Bram Moolenaar4bf10062021-12-28 17:23:12 +00002154 enddef|BBBB
2155 enddef
2156 # Compile all functions
2157 defcompile
2158 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002159 v9.CheckScriptFailure(lines, 'E1173: Text found after enddef: BBBB')
Bram Moolenaar7473a842021-12-28 17:55:26 +00002160
2161 lines =<< trim END
2162 vim9script
2163 def FirstFunction()
2164 func SecondFunction()
2165 endfunc|BBBB
2166 enddef
2167 defcompile
2168 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002169 v9.CheckScriptFailure(lines, 'E1173: Text found after endfunction: BBBB')
Bram Moolenaar4bf10062021-12-28 17:23:12 +00002170enddef
2171
Bram Moolenaar9f1a39a2022-01-08 15:39:39 +00002172def Test_error_in_function_args()
2173 var lines =<< trim END
2174 def FirstFunction()
2175 def SecondFunction(J =
2176 # Nois
2177 # one
Bram Moolenaar94722c52023-01-28 19:19:03 +00002178
2179 enddef|BBBB
Bram Moolenaar9f1a39a2022-01-08 15:39:39 +00002180 enddef
2181 # Compile all functions
2182 defcompile
2183 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002184 v9.CheckScriptFailure(lines, 'E488:')
Bram Moolenaar9f1a39a2022-01-08 15:39:39 +00002185enddef
2186
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002187def Test_return_type_wrong()
Bram Moolenaar62aec932022-01-29 21:45:34 +00002188 v9.CheckScriptFailure([
Bram Moolenaar5a849da2020-08-08 16:47:30 +02002189 'def Func(): number',
2190 'return "a"',
2191 'enddef',
2192 'defcompile'], 'expected number but got string')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002193 delfunc! g:Func
Bram Moolenaar62aec932022-01-29 21:45:34 +00002194 v9.CheckScriptFailure([
Bram Moolenaar5a849da2020-08-08 16:47:30 +02002195 'def Func(): string',
2196 'return 1',
2197 'enddef',
2198 'defcompile'], 'expected string but got number')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002199 delfunc! g:Func
Bram Moolenaar62aec932022-01-29 21:45:34 +00002200 v9.CheckScriptFailure([
Bram Moolenaar5a849da2020-08-08 16:47:30 +02002201 'def Func(): void',
2202 'return "a"',
2203 'enddef',
2204 'defcompile'],
2205 'E1096: Returning a value in a function without a return type')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002206 delfunc! g:Func
Bram Moolenaar62aec932022-01-29 21:45:34 +00002207 v9.CheckScriptFailure([
Bram Moolenaar5a849da2020-08-08 16:47:30 +02002208 'def Func()',
2209 'return "a"',
2210 'enddef',
2211 'defcompile'],
2212 'E1096: Returning a value in a function without a return type')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002213 delfunc! g:Func
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002214
Bram Moolenaar62aec932022-01-29 21:45:34 +00002215 v9.CheckScriptFailure([
Bram Moolenaar5a849da2020-08-08 16:47:30 +02002216 'def Func(): number',
2217 'return',
2218 'enddef',
2219 'defcompile'], 'E1003:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002220 delfunc! g:Func
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002221
Bram Moolenaar62aec932022-01-29 21:45:34 +00002222 v9.CheckScriptFailure([
Bram Moolenaar33ea9fd2021-08-08 19:07:37 +02002223 'def Func():number',
2224 'return 123',
2225 'enddef',
2226 'defcompile'], 'E1069:')
2227 delfunc! g:Func
2228
Bram Moolenaar62aec932022-01-29 21:45:34 +00002229 v9.CheckScriptFailure([
Bram Moolenaar33ea9fd2021-08-08 19:07:37 +02002230 'def Func() :number',
2231 'return 123',
2232 'enddef',
2233 'defcompile'], 'E1059:')
2234 delfunc! g:Func
2235
Bram Moolenaar62aec932022-01-29 21:45:34 +00002236 v9.CheckScriptFailure([
Bram Moolenaar33ea9fd2021-08-08 19:07:37 +02002237 'def Func() : number',
2238 'return 123',
2239 'enddef',
2240 'defcompile'], 'E1059:')
2241 delfunc! g:Func
2242
Bram Moolenaar62e0e2e2022-08-20 12:07:58 +01002243 v9.CheckScriptFailure(['def Func(): list', 'return []', 'enddef'], 'E1008: Missing <type> after list')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002244 delfunc! g:Func
Bram Moolenaar62e0e2e2022-08-20 12:07:58 +01002245 v9.CheckScriptFailure(['def Func(): dict', 'return {}', 'enddef'], 'E1008: Missing <type> after dict')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002246 delfunc! g:Func
Bram Moolenaar62aec932022-01-29 21:45:34 +00002247 v9.CheckScriptFailure(['def Func()', 'return 1'], 'E1057:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002248 delfunc! g:Func
Bram Moolenaar5a849da2020-08-08 16:47:30 +02002249
Bram Moolenaar62aec932022-01-29 21:45:34 +00002250 v9.CheckScriptFailure([
Bram Moolenaar5a849da2020-08-08 16:47:30 +02002251 'vim9script',
2252 'def FuncB()',
2253 ' return 123',
2254 'enddef',
2255 'def FuncA()',
2256 ' FuncB()',
2257 'enddef',
2258 'defcompile'], 'E1096:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002259enddef
2260
2261def Test_arg_type_wrong()
Bram Moolenaar62e0e2e2022-08-20 12:07:58 +01002262 v9.CheckScriptFailure(['def Func3(items: list)', 'echo "a"', 'enddef'], 'E1008: Missing <type> after list')
Bram Moolenaar62aec932022-01-29 21:45:34 +00002263 v9.CheckScriptFailure(['def Func4(...)', 'echo "a"', 'enddef'], 'E1055: Missing name after ...')
2264 v9.CheckScriptFailure(['def Func5(items:string)', 'echo "a"'], 'E1069:')
2265 v9.CheckScriptFailure(['def Func5(items)', 'echo "a"'], 'E1077:')
2266 v9.CheckScriptFailure(['def Func6(...x:list<number>)', 'echo "a"', 'enddef'], 'E1069:')
2267 v9.CheckScriptFailure(['def Func7(...x: int)', 'echo "a"', 'enddef'], 'E1010:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002268enddef
2269
Bram Moolenaar86cdb8a2021-04-06 19:01:03 +02002270def Test_white_space_before_comma()
2271 var lines =<< trim END
2272 vim9script
2273 def Func(a: number , b: number)
2274 enddef
2275 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002276 v9.CheckScriptFailure(lines, 'E1068:')
Yegappan Lakshmanan611728f2021-05-24 15:15:47 +02002277 call assert_fails('vim9cmd echo stridx("a" .. "b" , "a")', 'E1068:')
Bram Moolenaar86cdb8a2021-04-06 19:01:03 +02002278enddef
2279
Bram Moolenaar608d78f2021-03-06 22:33:12 +01002280def Test_white_space_after_comma()
2281 var lines =<< trim END
2282 vim9script
2283 def Func(a: number,b: number)
2284 enddef
2285 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002286 v9.CheckScriptFailure(lines, 'E1069:')
Bram Moolenaar608d78f2021-03-06 22:33:12 +01002287
2288 # OK in legacy function
2289 lines =<< trim END
2290 vim9script
2291 func Func(a,b)
2292 endfunc
2293 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002294 v9.CheckScriptSuccess(lines)
Bram Moolenaar608d78f2021-03-06 22:33:12 +01002295enddef
2296
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002297def Test_vim9script_call()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002298 var lines =<< trim END
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002299 vim9script
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002300 var name = ''
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002301 def MyFunc(arg: string)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002302 name = arg
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002303 enddef
2304 MyFunc('foobar')
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002305 name->assert_equal('foobar')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002306
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002307 var str = 'barfoo'
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002308 str->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002309 name->assert_equal('barfoo')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002310
Bram Moolenaar67979662020-06-20 22:50:47 +02002311 g:value = 'value'
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002312 g:value->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002313 name->assert_equal('value')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002314
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002315 var listvar = []
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002316 def ListFunc(arg: list<number>)
2317 listvar = arg
2318 enddef
2319 [1, 2, 3]->ListFunc()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002320 listvar->assert_equal([1, 2, 3])
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002321
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002322 var dictvar = {}
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002323 def DictFunc(arg: dict<number>)
2324 dictvar = arg
2325 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +01002326 {a: 1, b: 2}->DictFunc()
2327 dictvar->assert_equal({a: 1, b: 2})
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002328 def CompiledDict()
Bram Moolenaare0de1712020-12-02 17:36:54 +01002329 {a: 3, b: 4}->DictFunc()
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002330 enddef
2331 CompiledDict()
Bram Moolenaare0de1712020-12-02 17:36:54 +01002332 dictvar->assert_equal({a: 3, b: 4})
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002333
Bram Moolenaare0de1712020-12-02 17:36:54 +01002334 {a: 3, b: 4}->DictFunc()
2335 dictvar->assert_equal({a: 3, b: 4})
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002336
2337 ('text')->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002338 name->assert_equal('text')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002339 ("some")->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002340 name->assert_equal('some')
Bram Moolenaare6b53242020-07-01 17:28:33 +02002341
Bram Moolenaar13e12b82020-07-24 18:47:22 +02002342 # line starting with single quote is not a mark
Bram Moolenaar10409562020-07-29 20:00:38 +02002343 # line starting with double quote can be a method call
Bram Moolenaar3d48e252020-07-15 14:15:52 +02002344 'asdfasdf'->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002345 name->assert_equal('asdfasdf')
Bram Moolenaar10409562020-07-29 20:00:38 +02002346 "xyz"->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002347 name->assert_equal('xyz')
Bram Moolenaar3d48e252020-07-15 14:15:52 +02002348
2349 def UseString()
2350 'xyork'->MyFunc()
2351 enddef
2352 UseString()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002353 name->assert_equal('xyork')
Bram Moolenaar3d48e252020-07-15 14:15:52 +02002354
Bram Moolenaar10409562020-07-29 20:00:38 +02002355 def UseString2()
2356 "knife"->MyFunc()
2357 enddef
2358 UseString2()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002359 name->assert_equal('knife')
Bram Moolenaar10409562020-07-29 20:00:38 +02002360
Bram Moolenaar13e12b82020-07-24 18:47:22 +02002361 # prepending a colon makes it a mark
2362 new
2363 setline(1, ['aaa', 'bbb', 'ccc'])
2364 normal! 3Gmt1G
2365 :'t
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002366 getcurpos()[1]->assert_equal(3)
Bram Moolenaar13e12b82020-07-24 18:47:22 +02002367 bwipe!
2368
Bram Moolenaare6b53242020-07-01 17:28:33 +02002369 MyFunc(
2370 'continued'
2371 )
2372 assert_equal('continued',
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002373 name
Bram Moolenaare6b53242020-07-01 17:28:33 +02002374 )
2375
2376 call MyFunc(
2377 'more'
2378 ..
2379 'lines'
2380 )
2381 assert_equal(
2382 'morelines',
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002383 name)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002384 END
Bram Moolenaarf5fec052022-09-11 11:49:22 +01002385 writefile(lines, 'Xcall.vim', 'D')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002386 source Xcall.vim
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002387enddef
2388
2389def Test_vim9script_call_fail_decl()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002390 var lines =<< trim END
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002391 vim9script
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002392 var name = ''
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002393 def MyFunc(arg: string)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002394 var name = 123
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002395 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +02002396 defcompile
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002397 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002398 v9.CheckScriptFailure(lines, 'E1054:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002399enddef
2400
Bram Moolenaar65b95452020-07-19 14:03:09 +02002401def Test_vim9script_call_fail_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002402 var lines =<< trim END
Bram Moolenaar65b95452020-07-19 14:03:09 +02002403 vim9script
2404 def MyFunc(arg: string)
2405 echo arg
2406 enddef
2407 MyFunc(1234)
2408 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002409 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected string but got number')
Bram Moolenaar65b95452020-07-19 14:03:09 +02002410enddef
2411
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002412def Test_vim9script_call_fail_const()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002413 var lines =<< trim END
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002414 vim9script
2415 const var = ''
2416 def MyFunc(arg: string)
2417 var = 'asdf'
2418 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +02002419 defcompile
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002420 END
Bram Moolenaarf5fec052022-09-11 11:49:22 +01002421 writefile(lines, 'Xcall_const.vim', 'D')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +02002422 assert_fails('source Xcall_const.vim', 'E46:', '', 1, 'MyFunc')
Bram Moolenaar3bdc90b2020-12-22 20:35:40 +01002423
2424 lines =<< trim END
2425 const g:Aconst = 77
2426 def Change()
2427 # comment
2428 g:Aconst = 99
2429 enddef
2430 call Change()
2431 unlet g:Aconst
2432 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002433 v9.CheckScriptFailure(lines, 'E741: Value is locked: Aconst', 2)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002434enddef
2435
2436" Test that inside :function a Python function can be defined, :def is not
2437" recognized.
2438func Test_function_python()
2439 CheckFeature python3
Bram Moolenaar727345e2020-09-27 23:33:59 +02002440 let py = 'python3'
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002441 execute py "<< EOF"
2442def do_something():
2443 return 1
2444EOF
2445endfunc
2446
2447def Test_delfunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002448 var lines =<< trim END
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002449 vim9script
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02002450 def g:GoneSoon()
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002451 echo 'hello'
2452 enddef
2453
2454 def CallGoneSoon()
Bram Moolenaar62aec932022-01-29 21:45:34 +00002455 g:GoneSoon()
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002456 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +02002457 defcompile
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002458
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02002459 delfunc g:GoneSoon
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002460 CallGoneSoon()
2461 END
Bram Moolenaarf5fec052022-09-11 11:49:22 +01002462 writefile(lines, 'XToDelFunc', 'D')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +02002463 assert_fails('so XToDelFunc', 'E933:', '', 1, 'CallGoneSoon')
2464 assert_fails('so XToDelFunc', 'E933:', '', 1, 'CallGoneSoon')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002465enddef
2466
Bram Moolenaar7509ad82021-12-14 18:14:37 +00002467func Test_free_dict_while_in_funcstack()
2468 " relies on the sleep command
2469 CheckUnix
2470 call Run_Test_free_dict_while_in_funcstack()
2471endfunc
2472
2473def Run_Test_free_dict_while_in_funcstack()
Bram Moolenaar7509ad82021-12-14 18:14:37 +00002474 # this was freeing the TermRun() default argument dictionary while it was
2475 # still referenced in a funcstack_T
2476 var lines =<< trim END
2477 vim9script
2478
2479 &updatetime = 400
2480 def TermRun(_ = {})
2481 def Post()
2482 enddef
2483 def Exec()
2484 term_start('sleep 1', {
2485 term_finish: 'close',
2486 exit_cb: (_, _) => Post(),
2487 })
2488 enddef
2489 Exec()
2490 enddef
2491 nnoremap <F4> <Cmd>call <SID>TermRun()<CR>
2492 timer_start(100, (_) => feedkeys("\<F4>"))
2493 timer_start(1000, (_) => feedkeys("\<F4>"))
2494 sleep 1500m
2495 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002496 v9.CheckScriptSuccess(lines)
Bram Moolenaar7509ad82021-12-14 18:14:37 +00002497 nunmap <F4>
2498 set updatetime&
2499enddef
2500
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002501def Test_redef_failure()
Bram Moolenaard2c61702020-09-06 15:58:36 +02002502 writefile(['def Func0(): string', 'return "Func0"', 'enddef'], 'Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002503 so Xdef
Bram Moolenaard2c61702020-09-06 15:58:36 +02002504 writefile(['def Func1(): string', 'return "Func1"', 'enddef'], 'Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002505 so Xdef
Bram Moolenaard2c61702020-09-06 15:58:36 +02002506 writefile(['def! Func0(): string', 'enddef', 'defcompile'], 'Xdef')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +02002507 assert_fails('so Xdef', 'E1027:', '', 1, 'Func0')
Bram Moolenaard2c61702020-09-06 15:58:36 +02002508 writefile(['def Func2(): string', 'return "Func2"', 'enddef'], 'Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002509 so Xdef
Bram Moolenaard2c61702020-09-06 15:58:36 +02002510 delete('Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002511
Bram Moolenaar701cc6c2021-04-10 13:33:48 +02002512 assert_fails('g:Func0()', 'E1091:')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002513 g:Func1()->assert_equal('Func1')
2514 g:Func2()->assert_equal('Func2')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002515
2516 delfunc! Func0
2517 delfunc! Func1
2518 delfunc! Func2
2519enddef
2520
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02002521def Test_vim9script_func()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002522 var lines =<< trim END
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02002523 vim9script
2524 func Func(arg)
2525 echo a:arg
2526 endfunc
2527 Func('text')
2528 END
Bram Moolenaarf5fec052022-09-11 11:49:22 +01002529 writefile(lines, 'XVim9Func', 'D')
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02002530 so XVim9Func
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02002531enddef
2532
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002533let s:funcResult = 0
2534
2535def FuncNoArgNoRet()
Bram Moolenaar53900992020-08-22 19:02:02 +02002536 s:funcResult = 11
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002537enddef
2538
2539def FuncNoArgRetNumber(): number
Bram Moolenaar53900992020-08-22 19:02:02 +02002540 s:funcResult = 22
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002541 return 1234
2542enddef
2543
Bram Moolenaarec5929d2020-04-07 20:53:39 +02002544def FuncNoArgRetString(): string
Bram Moolenaar53900992020-08-22 19:02:02 +02002545 s:funcResult = 45
Bram Moolenaarec5929d2020-04-07 20:53:39 +02002546 return 'text'
2547enddef
2548
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002549def FuncOneArgNoRet(arg: number)
Bram Moolenaar53900992020-08-22 19:02:02 +02002550 s:funcResult = arg
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002551enddef
2552
2553def FuncOneArgRetNumber(arg: number): number
Bram Moolenaar53900992020-08-22 19:02:02 +02002554 s:funcResult = arg
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002555 return arg
2556enddef
2557
Bram Moolenaar08938ee2020-04-11 23:17:17 +02002558def FuncTwoArgNoRet(one: bool, two: number)
Bram Moolenaar53900992020-08-22 19:02:02 +02002559 s:funcResult = two
Bram Moolenaar08938ee2020-04-11 23:17:17 +02002560enddef
2561
Bram Moolenaar62aec932022-01-29 21:45:34 +00002562def s:FuncOneArgRetString(arg: string): string
Bram Moolenaarec5929d2020-04-07 20:53:39 +02002563 return arg
2564enddef
2565
Bram Moolenaar62aec932022-01-29 21:45:34 +00002566def s:FuncOneArgRetAny(arg: any): any
Bram Moolenaar89228602020-04-05 22:14:54 +02002567 return arg
2568enddef
2569
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002570def Test_func_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002571 var Ref1: func()
Bram Moolenaar53900992020-08-22 19:02:02 +02002572 s:funcResult = 0
Bram Moolenaar62aec932022-01-29 21:45:34 +00002573 Ref1 = g:FuncNoArgNoRet
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002574 Ref1()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002575 s:funcResult->assert_equal(11)
Bram Moolenaar4c683752020-04-05 21:38:23 +02002576
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002577 var Ref2: func
Bram Moolenaar53900992020-08-22 19:02:02 +02002578 s:funcResult = 0
Bram Moolenaar62aec932022-01-29 21:45:34 +00002579 Ref2 = g:FuncNoArgNoRet
Bram Moolenaar4c683752020-04-05 21:38:23 +02002580 Ref2()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002581 s:funcResult->assert_equal(11)
Bram Moolenaar4c683752020-04-05 21:38:23 +02002582
Bram Moolenaar53900992020-08-22 19:02:02 +02002583 s:funcResult = 0
Bram Moolenaar62aec932022-01-29 21:45:34 +00002584 Ref2 = g:FuncOneArgNoRet
Bram Moolenaar4c683752020-04-05 21:38:23 +02002585 Ref2(12)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002586 s:funcResult->assert_equal(12)
Bram Moolenaar4c683752020-04-05 21:38:23 +02002587
Bram Moolenaar53900992020-08-22 19:02:02 +02002588 s:funcResult = 0
Bram Moolenaar62aec932022-01-29 21:45:34 +00002589 Ref2 = g:FuncNoArgRetNumber
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002590 Ref2()->assert_equal(1234)
2591 s:funcResult->assert_equal(22)
Bram Moolenaar4c683752020-04-05 21:38:23 +02002592
Bram Moolenaar53900992020-08-22 19:02:02 +02002593 s:funcResult = 0
Bram Moolenaar848fadd2022-01-30 15:28:30 +00002594 Ref2 = g:FuncOneArgRetNumber
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002595 Ref2(13)->assert_equal(13)
2596 s:funcResult->assert_equal(13)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002597enddef
2598
Bram Moolenaar9978d472020-07-05 16:01:56 +02002599def Test_repeat_return_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002600 var res = 0
Bram Moolenaar9978d472020-07-05 16:01:56 +02002601 for n in repeat([1], 3)
2602 res += n
2603 endfor
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002604 res->assert_equal(3)
Bram Moolenaarfce82b32020-07-05 16:07:21 +02002605
2606 res = 0
Bakudankun375141e2022-09-09 18:46:47 +01002607 for n in repeat(0z01, 3)->blob2list()
2608 res += n
2609 endfor
2610 res->assert_equal(3)
2611
2612 res = 0
Bram Moolenaarfce82b32020-07-05 16:07:21 +02002613 for n in add([1, 2], 3)
2614 res += n
2615 endfor
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002616 res->assert_equal(6)
Bram Moolenaar9978d472020-07-05 16:01:56 +02002617enddef
2618
Bram Moolenaar846178a2020-07-05 17:04:13 +02002619def Test_argv_return_type()
2620 next fileone filetwo
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002621 var res = ''
Bram Moolenaar846178a2020-07-05 17:04:13 +02002622 for name in argv()
2623 res ..= name
2624 endfor
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002625 res->assert_equal('fileonefiletwo')
Bram Moolenaar846178a2020-07-05 17:04:13 +02002626enddef
2627
Bram Moolenaarec5929d2020-04-07 20:53:39 +02002628def Test_func_type_part()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002629 var RefVoid: func: void
Bram Moolenaar62aec932022-01-29 21:45:34 +00002630 RefVoid = g:FuncNoArgNoRet
2631 RefVoid = g:FuncOneArgNoRet
2632 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 +00002633 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 +02002634
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002635 var RefAny: func(): any
Bram Moolenaar62aec932022-01-29 21:45:34 +00002636 RefAny = g:FuncNoArgRetNumber
Bram Moolenaar848fadd2022-01-30 15:28:30 +00002637 RefAny = g:FuncNoArgRetString
Bram Moolenaar62aec932022-01-29 21:45:34 +00002638 v9.CheckDefFailure(['var RefAny: func(): any', 'RefAny = g:FuncNoArgNoRet'], 'E1012: Type mismatch; expected func(): any but got func()')
2639 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 +02002640
Bram Moolenaar6abd3dc2020-10-04 14:17:32 +02002641 var RefAnyNoArgs: func: any = RefAny
2642
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002643 var RefNr: func: number
Bram Moolenaar62aec932022-01-29 21:45:34 +00002644 RefNr = g:FuncNoArgRetNumber
Bram Moolenaar848fadd2022-01-30 15:28:30 +00002645 RefNr = g:FuncOneArgRetNumber
Bram Moolenaar62aec932022-01-29 21:45:34 +00002646 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 +00002647 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 +02002648
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002649 var RefStr: func: string
Bram Moolenaar848fadd2022-01-30 15:28:30 +00002650 RefStr = g:FuncNoArgRetString
Bram Moolenaarec5929d2020-04-07 20:53:39 +02002651 RefStr = FuncOneArgRetString
Bram Moolenaar62aec932022-01-29 21:45:34 +00002652 v9.CheckDefFailure(['var RefStr: func: string', 'RefStr = g:FuncNoArgNoRet'], 'E1012: Type mismatch; expected func(...): string but got func()')
2653 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 +02002654enddef
2655
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002656def Test_func_type_fails()
Bram Moolenaar62aec932022-01-29 21:45:34 +00002657 v9.CheckDefFailure(['var ref1: func()'], 'E704:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002658
Bram Moolenaar62aec932022-01-29 21:45:34 +00002659 v9.CheckDefFailure(['var Ref1: func()', 'Ref1 = g:FuncNoArgRetNumber'], 'E1012: Type mismatch; expected func() but got func(): number')
2660 v9.CheckDefFailure(['var Ref1: func()', 'Ref1 = g:FuncOneArgNoRet'], 'E1012: Type mismatch; expected func() but got func(number)')
Bram Moolenaar848fadd2022-01-30 15:28:30 +00002661 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 +00002662 v9.CheckDefFailure(['var Ref1: func(bool)', 'Ref1 = g:FuncTwoArgNoRet'], 'E1012: Type mismatch; expected func(bool) but got func(bool, number)')
2663 v9.CheckDefFailure(['var Ref1: func(?bool)', 'Ref1 = g:FuncTwoArgNoRet'], 'E1012: Type mismatch; expected func(?bool) but got func(bool, number)')
2664 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 +02002665
Bram Moolenaar62aec932022-01-29 21:45:34 +00002666 v9.CheckDefFailure(['var RefWrong: func(string ,number)'], 'E1068:')
2667 v9.CheckDefFailure(['var RefWrong: func(string,number)'], 'E1069:')
2668 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:')
2669 v9.CheckDefFailure(['var RefWrong: func(bool):string'], 'E1069:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002670enddef
2671
Bram Moolenaar89228602020-04-05 22:14:54 +02002672def Test_func_return_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002673 var nr: number
Bram Moolenaar62aec932022-01-29 21:45:34 +00002674 nr = g:FuncNoArgRetNumber()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002675 nr->assert_equal(1234)
Bram Moolenaar89228602020-04-05 22:14:54 +02002676
2677 nr = FuncOneArgRetAny(122)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002678 nr->assert_equal(122)
Bram Moolenaar89228602020-04-05 22:14:54 +02002679
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002680 var str: string
Bram Moolenaar89228602020-04-05 22:14:54 +02002681 str = FuncOneArgRetAny('yes')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002682 str->assert_equal('yes')
Bram Moolenaar89228602020-04-05 22:14:54 +02002683
Bram Moolenaar62aec932022-01-29 21:45:34 +00002684 v9.CheckDefFailure(['var str: string', 'str = g:FuncNoArgRetNumber()'], 'E1012: Type mismatch; expected string but got number')
Bram Moolenaar89228602020-04-05 22:14:54 +02002685enddef
2686
Bram Moolenaar6abd3dc2020-10-04 14:17:32 +02002687def Test_func_common_type()
2688 def FuncOne(n: number): number
2689 return n
2690 enddef
2691 def FuncTwo(s: string): number
2692 return len(s)
2693 enddef
2694 def FuncThree(n: number, s: string): number
2695 return n + len(s)
2696 enddef
2697 var list = [FuncOne, FuncTwo, FuncThree]
2698 assert_equal(8, list[0](8))
2699 assert_equal(4, list[1]('word'))
2700 assert_equal(7, list[2](3, 'word'))
2701enddef
2702
Bram Moolenaar62aec932022-01-29 21:45:34 +00002703def s:MultiLine(
Bram Moolenaar5e774c72020-04-12 21:53:00 +02002704 arg1: string,
2705 arg2 = 1234,
2706 ...rest: list<string>
2707 ): string
2708 return arg1 .. arg2 .. join(rest, '-')
2709enddef
2710
Bram Moolenaar2c330432020-04-13 14:41:35 +02002711def MultiLineComment(
2712 arg1: string, # comment
2713 arg2 = 1234, # comment
2714 ...rest: list<string> # comment
2715 ): string # comment
2716 return arg1 .. arg2 .. join(rest, '-')
2717enddef
2718
Bram Moolenaar5e774c72020-04-12 21:53:00 +02002719def Test_multiline()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002720 MultiLine('text')->assert_equal('text1234')
2721 MultiLine('text', 777)->assert_equal('text777')
2722 MultiLine('text', 777, 'one')->assert_equal('text777one')
2723 MultiLine('text', 777, 'one', 'two')->assert_equal('text777one-two')
Bram Moolenaar5e774c72020-04-12 21:53:00 +02002724enddef
2725
Bram Moolenaar23e03252020-04-12 22:22:31 +02002726func Test_multiline_not_vim9()
Bram Moolenaar62aec932022-01-29 21:45:34 +00002727 call s:MultiLine('text')->assert_equal('text1234')
2728 call s:MultiLine('text', 777)->assert_equal('text777')
2729 call s:MultiLine('text', 777, 'one')->assert_equal('text777one')
2730 call s:MultiLine('text', 777, 'one', 'two')->assert_equal('text777one-two')
Bram Moolenaar23e03252020-04-12 22:22:31 +02002731endfunc
2732
Bram Moolenaar5e774c72020-04-12 21:53:00 +02002733
Bram Moolenaaree4e0c12020-04-06 21:35:05 +02002734" When using CheckScriptFailure() for the below test, E1010 is generated instead
2735" of E1056.
2736func Test_E1056_1059()
2737 let caught_1056 = 0
2738 try
2739 def F():
2740 return 1
2741 enddef
2742 catch /E1056:/
2743 let caught_1056 = 1
2744 endtry
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002745 eval caught_1056->assert_equal(1)
Bram Moolenaaree4e0c12020-04-06 21:35:05 +02002746
2747 let caught_1059 = 0
2748 try
2749 def F5(items : list)
2750 echo 'a'
2751 enddef
2752 catch /E1059:/
2753 let caught_1059 = 1
2754 endtry
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002755 eval caught_1059->assert_equal(1)
Bram Moolenaaree4e0c12020-04-06 21:35:05 +02002756endfunc
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002757
Bram Moolenaar015f4262020-05-05 21:25:22 +02002758func DelMe()
2759 echo 'DelMe'
2760endfunc
2761
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002762def Test_error_reporting()
2763 # comment lines at the start of the function
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002764 var lines =<< trim END
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002765 " comment
2766 def Func()
2767 # comment
2768 # comment
2769 invalid
2770 enddef
2771 defcompile
2772 END
Bram Moolenaarf5fec052022-09-11 11:49:22 +01002773 writefile(lines, 'Xdef', 'D')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002774 try
2775 source Xdef
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02002776 assert_report('should have failed')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002777 catch /E476:/
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002778 v:exception->assert_match('Invalid command: invalid')
2779 v:throwpoint->assert_match(', line 3$')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002780 endtry
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002781 delfunc! g:Func
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002782
2783 # comment lines after the start of the function
2784 lines =<< trim END
2785 " comment
2786 def Func()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002787 var x = 1234
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002788 # comment
2789 # comment
2790 invalid
2791 enddef
2792 defcompile
2793 END
Bram Moolenaar08052222020-09-14 17:04:31 +02002794 writefile(lines, 'Xdef')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002795 try
2796 source Xdef
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02002797 assert_report('should have failed')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002798 catch /E476:/
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002799 v:exception->assert_match('Invalid command: invalid')
2800 v:throwpoint->assert_match(', line 4$')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002801 endtry
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002802 delfunc! g:Func
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002803
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02002804 lines =<< trim END
2805 vim9script
2806 def Func()
Bram Moolenaare0de1712020-12-02 17:36:54 +01002807 var db = {foo: 1, bar: 2}
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02002808 # comment
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002809 var x = db.asdf
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02002810 enddef
2811 defcompile
2812 Func()
2813 END
Bram Moolenaar08052222020-09-14 17:04:31 +02002814 writefile(lines, 'Xdef')
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02002815 try
2816 source Xdef
2817 assert_report('should have failed')
2818 catch /E716:/
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002819 v:throwpoint->assert_match('_Func, line 3$')
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02002820 endtry
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002821 delfunc! g:Func
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002822enddef
2823
Bram Moolenaar015f4262020-05-05 21:25:22 +02002824def Test_deleted_function()
Bram Moolenaar62aec932022-01-29 21:45:34 +00002825 v9.CheckDefExecFailure([
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002826 'var RefMe: func = function("g:DelMe")',
Bram Moolenaar015f4262020-05-05 21:25:22 +02002827 'delfunc g:DelMe',
2828 'echo RefMe()'], 'E117:')
2829enddef
2830
2831def Test_unknown_function()
Bram Moolenaar62aec932022-01-29 21:45:34 +00002832 v9.CheckDefExecFailure([
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002833 'var Ref: func = function("NotExist")',
Bram Moolenaar9b7bf9e2020-07-11 22:14:59 +02002834 'delfunc g:NotExist'], 'E700:')
Bram Moolenaar015f4262020-05-05 21:25:22 +02002835enddef
2836
Bram Moolenaar62aec932022-01-29 21:45:34 +00002837def s:RefFunc(Ref: func(any): any): string
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02002838 return Ref('more')
2839enddef
2840
2841def Test_closure_simple()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002842 var local = 'some '
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002843 RefFunc((s) => local .. s)->assert_equal('some more')
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02002844enddef
2845
Bram Moolenaar62aec932022-01-29 21:45:34 +00002846def s:MakeRef()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002847 var local = 'some '
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002848 g:Ref = (s) => local .. s
Bram Moolenaarbf67ea12020-05-02 17:52:42 +02002849enddef
2850
2851def Test_closure_ref_after_return()
2852 MakeRef()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002853 g:Ref('thing')->assert_equal('some thing')
Bram Moolenaarbf67ea12020-05-02 17:52:42 +02002854 unlet g:Ref
2855enddef
2856
Bram Moolenaar62aec932022-01-29 21:45:34 +00002857def s:MakeTwoRefs()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002858 var local = ['some']
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002859 g:Extend = (s) => local->add(s)
2860 g:Read = () => local
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002861enddef
2862
2863def Test_closure_two_refs()
2864 MakeTwoRefs()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002865 join(g:Read(), ' ')->assert_equal('some')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002866 g:Extend('more')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002867 join(g:Read(), ' ')->assert_equal('some more')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002868 g:Extend('even')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002869 join(g:Read(), ' ')->assert_equal('some more even')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002870
2871 unlet g:Extend
2872 unlet g:Read
2873enddef
2874
Bram Moolenaar62aec932022-01-29 21:45:34 +00002875def s:ReadRef(Ref: func(): list<string>): string
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002876 return join(Ref(), ' ')
2877enddef
2878
Bram Moolenaar62aec932022-01-29 21:45:34 +00002879def s:ExtendRef(Ref: func(string): list<string>, add: string)
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002880 Ref(add)
2881enddef
2882
2883def Test_closure_two_indirect_refs()
Bram Moolenaarf7779c62020-05-03 15:38:16 +02002884 MakeTwoRefs()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002885 ReadRef(g:Read)->assert_equal('some')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002886 ExtendRef(g:Extend, 'more')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002887 ReadRef(g:Read)->assert_equal('some more')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002888 ExtendRef(g:Extend, 'even')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002889 ReadRef(g:Read)->assert_equal('some more even')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002890
2891 unlet g:Extend
2892 unlet g:Read
2893enddef
Bram Moolenaarbf67ea12020-05-02 17:52:42 +02002894
Bram Moolenaar62aec932022-01-29 21:45:34 +00002895def s:MakeArgRefs(theArg: string)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002896 var local = 'loc_val'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002897 g:UseArg = (s) => theArg .. '/' .. local .. '/' .. s
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02002898enddef
2899
Bram Moolenaar62aec932022-01-29 21:45:34 +00002900def s:MakeArgRefsVarargs(theArg: string, ...rest: list<string>)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002901 var local = 'the_loc'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002902 g:UseVararg = (s) => theArg .. '/' .. local .. '/' .. s .. '/' .. join(rest)
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02002903enddef
2904
2905def Test_closure_using_argument()
2906 MakeArgRefs('arg_val')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002907 g:UseArg('call_val')->assert_equal('arg_val/loc_val/call_val')
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02002908
2909 MakeArgRefsVarargs('arg_val', 'one', 'two')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002910 g:UseVararg('call_val')->assert_equal('arg_val/the_loc/call_val/one two')
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02002911
2912 unlet g:UseArg
2913 unlet g:UseVararg
Bram Moolenaar44ec21c2021-02-12 21:50:57 +01002914
2915 var lines =<< trim END
2916 vim9script
2917 def Test(Fun: func(number): number): list<number>
2918 return map([1, 2, 3], (_, i) => Fun(i))
2919 enddef
2920 def Inc(nr: number): number
2921 return nr + 2
2922 enddef
2923 assert_equal([3, 4, 5], Test(Inc))
2924 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002925 v9.CheckScriptSuccess(lines)
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02002926enddef
2927
Bram Moolenaar62aec932022-01-29 21:45:34 +00002928def s:MakeGetAndAppendRefs()
Bram Moolenaar85d5e2b2020-10-10 14:13:01 +02002929 var local = 'a'
2930
2931 def Append(arg: string)
2932 local ..= arg
2933 enddef
2934 g:Append = Append
2935
2936 def Get(): string
2937 return local
2938 enddef
2939 g:Get = Get
2940enddef
2941
2942def Test_closure_append_get()
2943 MakeGetAndAppendRefs()
2944 g:Get()->assert_equal('a')
2945 g:Append('-b')
2946 g:Get()->assert_equal('a-b')
2947 g:Append('-c')
2948 g:Get()->assert_equal('a-b-c')
2949
2950 unlet g:Append
2951 unlet g:Get
2952enddef
Bram Moolenaarb68b3462020-05-06 21:06:30 +02002953
Bram Moolenaar04b12692020-05-04 23:24:44 +02002954def Test_nested_closure()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002955 var local = 'text'
Bram Moolenaar04b12692020-05-04 23:24:44 +02002956 def Closure(arg: string): string
2957 return local .. arg
2958 enddef
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002959 Closure('!!!')->assert_equal('text!!!')
Bram Moolenaar04b12692020-05-04 23:24:44 +02002960enddef
2961
Bram Moolenaar62aec932022-01-29 21:45:34 +00002962func s:GetResult(Ref)
Bram Moolenaar6f5b6df2020-05-16 21:20:12 +02002963 return a:Ref('some')
2964endfunc
2965
2966def Test_call_closure_not_compiled()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002967 var text = 'text'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002968 g:Ref = (s) => s .. text
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002969 GetResult(g:Ref)->assert_equal('sometext')
Bram Moolenaar6f5b6df2020-05-16 21:20:12 +02002970enddef
2971
Bram Moolenaar7cbfaa52020-09-18 21:25:32 +02002972def Test_double_closure_fails()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002973 var lines =<< trim END
Bram Moolenaar7cbfaa52020-09-18 21:25:32 +02002974 vim9script
2975 def Func()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002976 var name = 0
2977 for i in range(2)
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002978 timer_start(0, () => name)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002979 endfor
Bram Moolenaar7cbfaa52020-09-18 21:25:32 +02002980 enddef
2981 Func()
2982 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002983 v9.CheckScriptSuccess(lines)
Bram Moolenaar7cbfaa52020-09-18 21:25:32 +02002984enddef
2985
Bram Moolenaar85d5e2b2020-10-10 14:13:01 +02002986def Test_nested_closure_used()
2987 var lines =<< trim END
2988 vim9script
2989 def Func()
2990 var x = 'hello'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002991 var Closure = () => x
2992 g:Myclosure = () => Closure()
Bram Moolenaar85d5e2b2020-10-10 14:13:01 +02002993 enddef
2994 Func()
2995 assert_equal('hello', g:Myclosure())
2996 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002997 v9.CheckScriptSuccess(lines)
Bram Moolenaar85d5e2b2020-10-10 14:13:01 +02002998enddef
Bram Moolenaar0876c782020-10-07 19:08:04 +02002999
Bram Moolenaarc70bdab2020-09-26 19:59:38 +02003000def Test_nested_closure_fails()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02003001 var lines =<< trim END
Bram Moolenaarc70bdab2020-09-26 19:59:38 +02003002 vim9script
3003 def FuncA()
3004 FuncB(0)
3005 enddef
3006 def FuncB(n: number): list<string>
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01003007 return map([0], (_, v) => n)
Bram Moolenaarc70bdab2020-09-26 19:59:38 +02003008 enddef
3009 FuncA()
3010 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003011 v9.CheckScriptFailure(lines, 'E1012:')
Bram Moolenaarc70bdab2020-09-26 19:59:38 +02003012enddef
3013
Bram Moolenaar6de22962022-09-09 21:35:36 +01003014def Run_Test_closure_in_for_loop_fails()
3015 var lines =<< trim END
3016 vim9script
Bram Moolenaar766ae5b2022-09-14 00:30:51 +01003017 redraw
Bram Moolenaar6de22962022-09-09 21:35:36 +01003018 for n in [0]
Bram Moolenaar766ae5b2022-09-14 00:30:51 +01003019 # time should be enough for startup to finish
3020 timer_start(200, (_) => {
Bram Moolenaar6de22962022-09-09 21:35:36 +01003021 echo n
3022 })
3023 endfor
3024 END
3025 writefile(lines, 'XTest_closure_fails', 'D')
3026
3027 # Check that an error shows
Bram Moolenaarc069ede2022-09-11 12:01:04 +01003028 var buf = g:RunVimInTerminal('-S XTest_closure_fails', {rows: 6, wait_for_ruler: 0})
Bram Moolenaar766ae5b2022-09-14 00:30:51 +01003029 g:VerifyScreenDump(buf, 'Test_vim9_closure_fails', {wait: 3000})
Bram Moolenaar6de22962022-09-09 21:35:36 +01003030
3031 # clean up
3032 g:StopVimInTerminal(buf)
3033enddef
3034
3035func Test_closure_in_for_loop_fails()
3036 CheckScreendump
3037 call Run_Test_closure_in_for_loop_fails()
3038endfunc
3039
Bram Moolenaarf112f302020-12-20 17:47:52 +01003040def Test_global_closure()
3041 var lines =<< trim END
3042 vim9script
3043 def ReverseEveryNLines(n: number, line1: number, line2: number)
3044 var mods = 'sil keepj keepp lockm '
3045 var range = ':' .. line1 .. ',' .. line2
3046 def g:Offset(): number
3047 var offset = (line('.') - line1 + 1) % n
3048 return offset != 0 ? offset : n
3049 enddef
3050 exe mods .. range .. 'g/^/exe "m .-" .. g:Offset()'
3051 enddef
3052
3053 new
3054 repeat(['aaa', 'bbb', 'ccc'], 3)->setline(1)
3055 ReverseEveryNLines(3, 1, 9)
3056 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003057 v9.CheckScriptSuccess(lines)
Bram Moolenaarf112f302020-12-20 17:47:52 +01003058 var expected = repeat(['ccc', 'bbb', 'aaa'], 3)
3059 assert_equal(expected, getline(1, 9))
3060 bwipe!
3061enddef
3062
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01003063def Test_global_closure_called_directly()
3064 var lines =<< trim END
3065 vim9script
3066 def Outer()
3067 var x = 1
3068 def g:Inner()
3069 var y = x
3070 x += 1
3071 assert_equal(1, y)
3072 enddef
3073 g:Inner()
3074 assert_equal(2, x)
3075 enddef
3076 Outer()
3077 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003078 v9.CheckScriptSuccess(lines)
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01003079 delfunc g:Inner
3080enddef
3081
Bram Moolenaar69c76172021-12-02 16:38:52 +00003082def Test_closure_called_from_legacy()
3083 var lines =<< trim END
3084 vim9script
3085 def Func()
3086 var outer = 'foo'
3087 var F = () => {
3088 outer = 'bar'
3089 }
3090 execute printf('call %s()', string(F))
3091 enddef
3092 Func()
3093 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003094 v9.CheckScriptFailure(lines, 'E1248')
Bram Moolenaar69c76172021-12-02 16:38:52 +00003095enddef
3096
Bram Moolenaar34c54eb2020-11-25 19:15:19 +01003097def Test_failure_in_called_function()
3098 # this was using the frame index as the return value
3099 var lines =<< trim END
3100 vim9script
3101 au TerminalWinOpen * eval [][0]
3102 def PopupTerm(a: any)
3103 # make sure typvals on stack are string
3104 ['a', 'b', 'c', 'd', 'e', 'f', 'g']->join()
3105 FireEvent()
3106 enddef
3107 def FireEvent()
3108 do TerminalWinOpen
3109 enddef
3110 # use try/catch to make eval fail
3111 try
3112 call PopupTerm(0)
3113 catch
3114 endtry
3115 au! TerminalWinOpen
3116 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003117 v9.CheckScriptSuccess(lines)
Bram Moolenaar34c54eb2020-11-25 19:15:19 +01003118enddef
3119
Bram Moolenaar5366e1a2020-10-01 13:01:34 +02003120def Test_nested_lambda()
3121 var lines =<< trim END
3122 vim9script
3123 def Func()
3124 var x = 4
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01003125 var Lambda1 = () => 7
3126 var Lambda2 = () => [Lambda1(), x]
Bram Moolenaar5366e1a2020-10-01 13:01:34 +02003127 var res = Lambda2()
3128 assert_equal([7, 4], res)
3129 enddef
3130 Func()
3131 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003132 v9.CheckScriptSuccess(lines)
Bram Moolenaar5366e1a2020-10-01 13:01:34 +02003133enddef
3134
Bram Moolenaarc04f2a42021-06-09 19:30:03 +02003135def Test_double_nested_lambda()
3136 var lines =<< trim END
3137 vim9script
3138 def F(head: string): func(string): func(string): string
3139 return (sep: string): func(string): string => ((tail: string): string => {
3140 return head .. sep .. tail
3141 })
3142 enddef
3143 assert_equal('hello-there', F('hello')('-')('there'))
3144 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003145 v9.CheckScriptSuccess(lines)
Bram Moolenaarc04f2a42021-06-09 19:30:03 +02003146enddef
3147
Bram Moolenaar074f84c2021-05-18 11:47:44 +02003148def Test_nested_inline_lambda()
Bram Moolenaar074f84c2021-05-18 11:47:44 +02003149 var lines =<< trim END
3150 vim9script
3151 def F(text: string): func(string): func(string): string
3152 return (arg: string): func(string): string => ((sep: string): string => {
Bram Moolenaar23e2e112021-08-03 21:16:18 +02003153 return sep .. arg .. text
Bram Moolenaar074f84c2021-05-18 11:47:44 +02003154 })
3155 enddef
Bram Moolenaar23e2e112021-08-03 21:16:18 +02003156 assert_equal('--there++', F('++')('there')('--'))
Bram Moolenaar074f84c2021-05-18 11:47:44 +02003157 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003158 v9.CheckScriptSuccess(lines)
Bram Moolenaar5245beb2021-07-15 22:03:50 +02003159
3160 lines =<< trim END
3161 vim9script
3162 echo range(4)->mapnew((_, v) => {
3163 return range(v) ->mapnew((_, s) => {
3164 return string(s)
3165 })
3166 })
3167 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003168 v9.CheckScriptSuccess(lines)
Bram Moolenaarc6ba2f92021-07-18 13:42:29 +02003169
3170 lines =<< trim END
3171 vim9script
3172
Bram Moolenaara749a422022-02-12 19:52:25 +00003173 def Func()
Bram Moolenaarc6ba2f92021-07-18 13:42:29 +02003174 range(10)
3175 ->mapnew((_, _) => ({
3176 key: range(10)->mapnew((_, _) => {
3177 return ' '
3178 }),
3179 }))
3180 enddef
3181
3182 defcomp
3183 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003184 v9.CheckScriptSuccess(lines)
Bram Moolenaar074f84c2021-05-18 11:47:44 +02003185enddef
3186
Bram Moolenaar52bf81c2020-11-17 18:50:44 +01003187def Shadowed(): list<number>
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01003188 var FuncList: list<func: number> = [() => 42]
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01003189 return FuncList->mapnew((_, Shadowed) => Shadowed())
Bram Moolenaar52bf81c2020-11-17 18:50:44 +01003190enddef
3191
3192def Test_lambda_arg_shadows_func()
Bram Moolenaar62aec932022-01-29 21:45:34 +00003193 assert_equal([42], g:Shadowed())
Bram Moolenaar52bf81c2020-11-17 18:50:44 +01003194enddef
3195
Bram Moolenaar21dc8f12022-03-16 17:54:17 +00003196def Test_compiling_referenced_func_no_shadow()
3197 var lines =<< trim END
3198 vim9script
3199
3200 def InitializeReply(lspserver: dict<any>)
3201 enddef
3202
3203 def ProcessReply(lspserver: dict<any>)
3204 var lsp_reply_handlers: dict<func> =
3205 { 'initialize': InitializeReply }
3206 lsp_reply_handlers['initialize'](lspserver)
3207 enddef
3208
3209 call ProcessReply({})
3210 END
3211 v9.CheckScriptSuccess(lines)
3212enddef
3213
Bram Moolenaar62aec932022-01-29 21:45:34 +00003214def s:Line_continuation_in_def(dir: string = ''): string
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02003215 var path: string = empty(dir)
3216 \ ? 'empty'
3217 \ : 'full'
3218 return path
Bram Moolenaaracd4c5e2020-06-22 19:39:03 +02003219enddef
3220
3221def Test_line_continuation_in_def()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02003222 Line_continuation_in_def('.')->assert_equal('full')
Bram Moolenaaracd4c5e2020-06-22 19:39:03 +02003223enddef
3224
Bram Moolenaar2ea95b62020-11-19 21:47:56 +01003225def Test_script_var_in_lambda()
3226 var lines =<< trim END
3227 vim9script
3228 var script = 'test'
Bram Moolenaarbb8a7ce2021-04-10 20:10:26 +02003229 assert_equal(['test'], map(['one'], (_, _) => script))
Bram Moolenaar2ea95b62020-11-19 21:47:56 +01003230 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003231 v9.CheckScriptSuccess(lines)
Bram Moolenaar2ea95b62020-11-19 21:47:56 +01003232enddef
3233
Bram Moolenaar62aec932022-01-29 21:45:34 +00003234def s:Line_continuation_in_lambda(): list<string>
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02003235 var x = range(97, 100)
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01003236 ->mapnew((_, v) => nr2char(v)
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01003237 ->toupper())
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02003238 ->reverse()
3239 return x
3240enddef
3241
3242def Test_line_continuation_in_lambda()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02003243 Line_continuation_in_lambda()->assert_equal(['D', 'C', 'B', 'A'])
Bram Moolenaarf898f7c2021-01-16 18:09:52 +01003244
3245 var lines =<< trim END
3246 vim9script
3247 var res = [{n: 1, m: 2, s: 'xxx'}]
3248 ->mapnew((_, v: dict<any>): string => printf('%d:%d:%s',
3249 v.n,
3250 v.m,
3251 substitute(v.s, '.*', 'yyy', '')
3252 ))
3253 assert_equal(['1:2:yyy'], res)
3254 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003255 v9.CheckScriptSuccess(lines)
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02003256enddef
3257
Bram Moolenaarb6571982021-01-08 22:24:19 +01003258def Test_list_lambda()
3259 timer_start(1000, (_) => 0)
3260 var body = execute(timer_info()[0].callback
3261 ->string()
3262 ->substitute("('", ' ', '')
3263 ->substitute("')", '', '')
3264 ->substitute('function\zs', ' ', ''))
Bram Moolenaar767034c2021-04-09 17:24:52 +02003265 assert_match('def <lambda>\d\+(_: any): number\n1 return 0\n enddef', body)
Bram Moolenaarb6571982021-01-08 22:24:19 +01003266enddef
3267
Bram Moolenaar3c77b6a2021-07-25 18:07:00 +02003268def Test_lambda_block_variable()
Bram Moolenaar88421d62021-07-24 14:14:52 +02003269 var lines =<< trim END
3270 vim9script
3271 var flist: list<func>
3272 for i in range(10)
3273 var inloop = i
3274 flist[i] = () => inloop
3275 endfor
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 var flist: list<func>
3284 for i in range(10)
3285 flist[i] = () => outloop
3286 endfor
3287 endif
3288 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003289 v9.CheckScriptSuccess(lines)
Bram Moolenaar88421d62021-07-24 14:14:52 +02003290
3291 lines =<< trim END
3292 vim9script
3293 if true
3294 var outloop = 5
3295 endif
3296 var flist: list<func>
3297 for i in range(10)
3298 flist[i] = () => outloop
3299 endfor
3300 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003301 v9.CheckScriptFailure(lines, 'E1001: Variable not found: outloop', 1)
Bram Moolenaar3c77b6a2021-07-25 18:07:00 +02003302
3303 lines =<< trim END
3304 vim9script
3305 for i in range(10)
3306 var Ref = () => 0
3307 endfor
3308 assert_equal(0, ((i) => 0)(0))
3309 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003310 v9.CheckScriptSuccess(lines)
Bram Moolenaar88421d62021-07-24 14:14:52 +02003311enddef
3312
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02003313def Test_legacy_lambda()
3314 legacy echo {x -> 'hello ' .. x}('foo')
Bram Moolenaardc4c2302021-04-25 13:54:42 +02003315
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02003316 var lines =<< trim END
3317 echo {x -> 'hello ' .. x}('foo')
3318 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003319 v9.CheckDefAndScriptFailure(lines, 'E720:')
Bram Moolenaardc4c2302021-04-25 13:54:42 +02003320
3321 lines =<< trim END
3322 vim9script
3323 def Func()
3324 echo (() => 'no error')()
3325 enddef
3326 legacy call s:Func()
3327 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003328 v9.CheckScriptSuccess(lines)
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02003329enddef
3330
Bram Moolenaarce024c32021-06-26 13:00:49 +02003331def Test_legacy()
3332 var lines =<< trim END
3333 vim9script
3334 func g:LegacyFunction()
3335 let g:legacyvar = 1
3336 endfunc
3337 def Testit()
3338 legacy call g:LegacyFunction()
3339 enddef
3340 Testit()
3341 assert_equal(1, g:legacyvar)
3342 unlet g:legacyvar
3343 delfunc g:LegacyFunction
3344 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003345 v9.CheckScriptSuccess(lines)
Bram Moolenaarce024c32021-06-26 13:00:49 +02003346enddef
3347
Bram Moolenaarc3cb1c92021-06-02 16:47:53 +02003348def Test_legacy_errors()
3349 for cmd in ['if', 'elseif', 'else', 'endif',
3350 'for', 'endfor', 'continue', 'break',
3351 'while', 'endwhile',
3352 'try', 'catch', 'finally', 'endtry']
Bram Moolenaar62aec932022-01-29 21:45:34 +00003353 v9.CheckDefFailure(['legacy ' .. cmd .. ' expr'], 'E1189:')
Bram Moolenaarc3cb1c92021-06-02 16:47:53 +02003354 endfor
3355enddef
3356
Bram Moolenaarb1b6f4d2021-09-13 18:25:54 +02003357def Test_call_legacy_with_dict()
3358 var lines =<< trim END
3359 vim9script
3360 func Legacy() dict
3361 let g:result = self.value
3362 endfunc
3363 def TestDirect()
3364 var d = {value: 'yes', func: Legacy}
3365 d.func()
3366 enddef
3367 TestDirect()
3368 assert_equal('yes', g:result)
3369 unlet g:result
3370
3371 def TestIndirect()
3372 var d = {value: 'foo', func: Legacy}
3373 var Fi = d.func
3374 Fi()
3375 enddef
3376 TestIndirect()
3377 assert_equal('foo', g:result)
3378 unlet g:result
3379
3380 var d = {value: 'bar', func: Legacy}
3381 d.func()
3382 assert_equal('bar', g:result)
3383 unlet g:result
3384 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003385 v9.CheckScriptSuccess(lines)
Bram Moolenaarb1b6f4d2021-09-13 18:25:54 +02003386enddef
3387
Bram Moolenaar62aec932022-01-29 21:45:34 +00003388def s:DoFilterThis(a: string): list<string>
Bram Moolenaarab360522021-01-10 14:02:28 +01003389 # closure nested inside another closure using argument
3390 var Filter = (l) => filter(l, (_, v) => stridx(v, a) == 0)
3391 return ['x', 'y', 'a', 'x2', 'c']->Filter()
3392enddef
3393
3394def Test_nested_closure_using_argument()
3395 assert_equal(['x', 'x2'], DoFilterThis('x'))
3396enddef
3397
Bram Moolenaar0186e582021-01-10 18:33:11 +01003398def Test_triple_nested_closure()
3399 var what = 'x'
3400 var Match = (val: string, cmp: string): bool => stridx(val, cmp) == 0
3401 var Filter = (l) => filter(l, (_, v) => Match(v, what))
3402 assert_equal(['x', 'x2'], ['x', 'y', 'a', 'x2', 'c']->Filter())
3403enddef
3404
Bram Moolenaar8f510af2020-07-05 18:48:23 +02003405func Test_silent_echo()
Bram Moolenaar47e7d702020-07-05 18:18:42 +02003406 CheckScreendump
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003407 call Run_Test_silent_echo()
3408endfunc
Bram Moolenaar47e7d702020-07-05 18:18:42 +02003409
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003410def Run_Test_silent_echo()
3411 var lines =<< trim END
Bram Moolenaar47e7d702020-07-05 18:18:42 +02003412 vim9script
3413 def EchoNothing()
3414 silent echo ''
3415 enddef
3416 defcompile
3417 END
Bram Moolenaar6de22962022-09-09 21:35:36 +01003418 writefile(lines, 'XTest_silent_echo', 'D')
Bram Moolenaar47e7d702020-07-05 18:18:42 +02003419
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003420 # Check that the balloon shows up after a mouse move
Bram Moolenaar62aec932022-01-29 21:45:34 +00003421 var buf = g:RunVimInTerminal('-S XTest_silent_echo', {'rows': 6})
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003422 term_sendkeys(buf, ":abc")
Bram Moolenaar62aec932022-01-29 21:45:34 +00003423 g:VerifyScreenDump(buf, 'Test_vim9_silent_echo', {})
Bram Moolenaar47e7d702020-07-05 18:18:42 +02003424
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003425 # clean up
Bram Moolenaar62aec932022-01-29 21:45:34 +00003426 g:StopVimInTerminal(buf)
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003427enddef
Bram Moolenaar47e7d702020-07-05 18:18:42 +02003428
Bram Moolenaar171fb922020-10-28 16:54:47 +01003429def SilentlyError()
3430 execute('silent! invalid')
3431 g:did_it = 'yes'
3432enddef
3433
Bram Moolenaar62aec932022-01-29 21:45:34 +00003434func s:UserError()
Bram Moolenaar28ee8922020-10-28 20:20:00 +01003435 silent! invalid
3436endfunc
3437
3438def SilentlyUserError()
3439 UserError()
3440 g:did_it = 'yes'
3441enddef
Bram Moolenaar171fb922020-10-28 16:54:47 +01003442
3443" This can't be a :def function, because the assert would not be reached.
Bram Moolenaar171fb922020-10-28 16:54:47 +01003444func Test_ignore_silent_error()
3445 let g:did_it = 'no'
3446 call SilentlyError()
3447 call assert_equal('yes', g:did_it)
3448
Bram Moolenaar28ee8922020-10-28 20:20:00 +01003449 let g:did_it = 'no'
3450 call SilentlyUserError()
3451 call assert_equal('yes', g:did_it)
Bram Moolenaar171fb922020-10-28 16:54:47 +01003452
3453 unlet g:did_it
3454endfunc
3455
Bram Moolenaarcd030c42020-10-30 21:49:40 +01003456def Test_ignore_silent_error_in_filter()
3457 var lines =<< trim END
3458 vim9script
3459 def Filter(winid: number, key: string): bool
3460 if key == 'o'
3461 silent! eval [][0]
3462 return true
3463 endif
3464 return popup_filter_menu(winid, key)
3465 enddef
3466
Bram Moolenaare0de1712020-12-02 17:36:54 +01003467 popup_create('popup', {filter: Filter})
Bram Moolenaarcd030c42020-10-30 21:49:40 +01003468 feedkeys("o\r", 'xnt')
3469 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003470 v9.CheckScriptSuccess(lines)
Bram Moolenaarcd030c42020-10-30 21:49:40 +01003471enddef
3472
Bram Moolenaar62aec932022-01-29 21:45:34 +00003473def s:Fibonacci(n: number): number
Bram Moolenaar4b9bd692020-09-05 21:57:53 +02003474 if n < 2
3475 return n
3476 else
3477 return Fibonacci(n - 1) + Fibonacci(n - 2)
3478 endif
3479enddef
3480
Bram Moolenaar985116a2020-07-12 17:31:09 +02003481def Test_recursive_call()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02003482 Fibonacci(20)->assert_equal(6765)
Bram Moolenaar985116a2020-07-12 17:31:09 +02003483enddef
3484
Bram Moolenaar62aec932022-01-29 21:45:34 +00003485def s:TreeWalk(dir: string): list<any>
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01003486 return readdir(dir)->mapnew((_, val) =>
Bram Moolenaar08f7a412020-07-13 20:41:08 +02003487 fnamemodify(dir .. '/' .. val, ':p')->isdirectory()
Bram Moolenaar2bede172020-11-19 18:53:18 +01003488 ? {[val]: TreeWalk(dir .. '/' .. val)}
Bram Moolenaar08f7a412020-07-13 20:41:08 +02003489 : val
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01003490 )
Bram Moolenaar08f7a412020-07-13 20:41:08 +02003491enddef
3492
3493def Test_closure_in_map()
Bram Moolenaarf5fec052022-09-11 11:49:22 +01003494 mkdir('XclosureDir/tdir', 'pR')
Bram Moolenaar08f7a412020-07-13 20:41:08 +02003495 writefile(['111'], 'XclosureDir/file1')
3496 writefile(['222'], 'XclosureDir/file2')
3497 writefile(['333'], 'XclosureDir/tdir/file3')
3498
Bram Moolenaare0de1712020-12-02 17:36:54 +01003499 TreeWalk('XclosureDir')->assert_equal(['file1', 'file2', {tdir: ['file3']}])
Bram Moolenaar08f7a412020-07-13 20:41:08 +02003500enddef
3501
Bram Moolenaar7b5d5442020-10-04 13:42:34 +02003502def Test_invalid_function_name()
3503 var lines =<< trim END
3504 vim9script
3505 def s: list<string>
3506 END
Bram Moolenaara749a422022-02-12 19:52:25 +00003507 v9.CheckScriptFailure(lines, 'E1268:')
Bram Moolenaar7b5d5442020-10-04 13:42:34 +02003508
3509 lines =<< trim END
3510 vim9script
3511 def g: list<string>
3512 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003513 v9.CheckScriptFailure(lines, 'E129:')
Bram Moolenaar7b5d5442020-10-04 13:42:34 +02003514
3515 lines =<< trim END
3516 vim9script
3517 def <SID>: list<string>
3518 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003519 v9.CheckScriptFailure(lines, 'E884:')
Bram Moolenaar7b5d5442020-10-04 13:42:34 +02003520
3521 lines =<< trim END
3522 vim9script
3523 def F list<string>
3524 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003525 v9.CheckScriptFailure(lines, 'E488:')
Bram Moolenaar7b5d5442020-10-04 13:42:34 +02003526enddef
3527
Bram Moolenaara90afb92020-07-15 22:38:56 +02003528def Test_partial_call()
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02003529 var lines =<< trim END
3530 var Xsetlist: func
3531 Xsetlist = function('setloclist', [0])
3532 Xsetlist([], ' ', {title: 'test'})
3533 getloclist(0, {title: 1})->assert_equal({title: 'test'})
Bram Moolenaara90afb92020-07-15 22:38:56 +02003534
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02003535 Xsetlist = function('setloclist', [0, [], ' '])
3536 Xsetlist({title: 'test'})
3537 getloclist(0, {title: 1})->assert_equal({title: 'test'})
Bram Moolenaara90afb92020-07-15 22:38:56 +02003538
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02003539 Xsetlist = function('setqflist')
3540 Xsetlist([], ' ', {title: 'test'})
3541 getqflist({title: 1})->assert_equal({title: 'test'})
Bram Moolenaara90afb92020-07-15 22:38:56 +02003542
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02003543 Xsetlist = function('setqflist', [[], ' '])
3544 Xsetlist({title: 'test'})
3545 getqflist({title: 1})->assert_equal({title: 'test'})
Bram Moolenaar6abd3dc2020-10-04 14:17:32 +02003546
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02003547 var Len: func: number = function('len', ['word'])
3548 assert_equal(4, Len())
3549
3550 var RepeatFunc = function('repeat', ['o'])
3551 assert_equal('ooooo', RepeatFunc(5))
3552 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003553 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarc66f6452021-08-19 21:08:30 +02003554
3555 lines =<< trim END
3556 vim9script
3557 def Foo(Parser: any)
3558 enddef
3559 var Expr: func(dict<any>): dict<any>
3560 const Call = Foo(Expr)
3561 END
Bram Moolenaar8acb9cc2022-03-08 13:18:55 +00003562 v9.CheckScriptFailure(lines, 'E1031:')
Bram Moolenaara90afb92020-07-15 22:38:56 +02003563enddef
3564
Bram Moolenaarcd1cda22022-02-16 21:48:25 +00003565def Test_partial_double_nested()
3566 var idx = 123
3567 var Get = () => idx
3568 var Ref = function(Get, [])
3569 var RefRef = function(Ref, [])
3570 assert_equal(123, RefRef())
3571enddef
3572
Bram Moolenaar673bcb12022-03-08 16:52:24 +00003573def Test_partial_null_function()
3574 var lines =<< trim END
3575 var d: dict<func> = {f: null_function}
3576 var Ref = d.f
Bram Moolenaared0c62e2022-03-08 19:43:55 +00003577 assert_equal('func(...): unknown', typename(Ref))
Bram Moolenaar673bcb12022-03-08 16:52:24 +00003578 END
3579 v9.CheckDefAndScriptSuccess(lines)
3580enddef
3581
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02003582def Test_cmd_modifier()
3583 tab echo '0'
Bram Moolenaar62aec932022-01-29 21:45:34 +00003584 v9.CheckDefFailure(['5tab echo 3'], 'E16:')
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02003585enddef
3586
3587def Test_restore_modifiers()
3588 # check that when compiling a :def function command modifiers are not messed
3589 # up.
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02003590 var lines =<< trim END
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02003591 vim9script
3592 set eventignore=
3593 autocmd QuickFixCmdPost * copen
3594 def AutocmdsDisabled()
Bram Moolenaarc3235272021-07-10 19:42:03 +02003595 eval 1 + 2
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02003596 enddef
3597 func Func()
3598 noautocmd call s:AutocmdsDisabled()
3599 let g:ei_after = &eventignore
3600 endfunc
3601 Func()
3602 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003603 v9.CheckScriptSuccess(lines)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02003604 g:ei_after->assert_equal('')
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02003605enddef
3606
Bram Moolenaardfa3d552020-09-10 22:05:08 +02003607def StackTop()
Bram Moolenaarc3235272021-07-10 19:42:03 +02003608 eval 1 + 2
3609 eval 2 + 3
Bram Moolenaardfa3d552020-09-10 22:05:08 +02003610 # call not on fourth line
Bram Moolenaar62aec932022-01-29 21:45:34 +00003611 g:StackBot()
Bram Moolenaardfa3d552020-09-10 22:05:08 +02003612enddef
3613
3614def StackBot()
3615 # throw an error
3616 eval [][0]
3617enddef
3618
3619def Test_callstack_def()
3620 try
Bram Moolenaar62aec932022-01-29 21:45:34 +00003621 g:StackTop()
Bram Moolenaardfa3d552020-09-10 22:05:08 +02003622 catch
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02003623 v:throwpoint->assert_match('Test_callstack_def\[2\]..StackTop\[4\]..StackBot, line 2')
Bram Moolenaardfa3d552020-09-10 22:05:08 +02003624 endtry
3625enddef
3626
Bram Moolenaare8211a32020-10-09 22:04:29 +02003627" Re-using spot for variable used in block
3628def Test_block_scoped_var()
3629 var lines =<< trim END
3630 vim9script
3631 def Func()
3632 var x = ['a', 'b', 'c']
3633 if 1
3634 var y = 'x'
Bram Moolenaarbb8a7ce2021-04-10 20:10:26 +02003635 map(x, (_, _) => y)
Bram Moolenaare8211a32020-10-09 22:04:29 +02003636 endif
3637 var z = x
3638 assert_equal(['x', 'x', 'x'], z)
3639 enddef
3640 Func()
3641 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003642 v9.CheckScriptSuccess(lines)
Bram Moolenaare8211a32020-10-09 22:04:29 +02003643enddef
3644
Bram Moolenaareeece9e2020-11-20 19:26:48 +01003645def Test_reset_did_emsg()
3646 var lines =<< trim END
3647 @s = 'blah'
3648 au BufWinLeave * #
3649 def Func()
3650 var winid = popup_create('popup', {})
3651 exe '*s'
3652 popup_close(winid)
3653 enddef
3654 Func()
3655 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003656 v9.CheckScriptFailure(lines, 'E492:', 8)
Bram Moolenaar2d870f82020-12-05 13:41:01 +01003657 delfunc! g:Func
Bram Moolenaareeece9e2020-11-20 19:26:48 +01003658enddef
3659
Bram Moolenaar57f799e2020-12-12 20:42:19 +01003660def Test_did_emsg_reset()
3661 # executing an autocommand resets did_emsg, this should not result in a
3662 # builtin function considered failing
3663 var lines =<< trim END
3664 vim9script
3665 au BufWinLeave * #
3666 def Func()
Bram Moolenaar767034c2021-04-09 17:24:52 +02003667 popup_menu('', {callback: (a, b) => popup_create('', {})->popup_close()})
Bram Moolenaar57f799e2020-12-12 20:42:19 +01003668 eval [][0]
3669 enddef
3670 nno <F3> <cmd>call <sid>Func()<cr>
3671 feedkeys("\<F3>\e", 'xt')
3672 END
Bram Moolenaarf5fec052022-09-11 11:49:22 +01003673 writefile(lines, 'XemsgReset', 'D')
Bram Moolenaar57f799e2020-12-12 20:42:19 +01003674 assert_fails('so XemsgReset', ['E684:', 'E684:'], lines, 2)
Bram Moolenaarf5fec052022-09-11 11:49:22 +01003675
Bram Moolenaar57f799e2020-12-12 20:42:19 +01003676 nunmap <F3>
3677 au! BufWinLeave
3678enddef
3679
Bram Moolenaar56602ba2020-12-05 21:22:08 +01003680def Test_abort_with_silent_call()
3681 var lines =<< trim END
3682 vim9script
3683 g:result = 'none'
3684 def Func()
3685 g:result += 3
3686 g:result = 'yes'
3687 enddef
3688 # error is silenced, but function aborts on error
3689 silent! Func()
3690 assert_equal('none', g:result)
3691 unlet g:result
3692 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003693 v9.CheckScriptSuccess(lines)
Bram Moolenaar56602ba2020-12-05 21:22:08 +01003694enddef
3695
Bram Moolenaarf665e972020-12-05 19:17:16 +01003696def Test_continues_with_silent_error()
3697 var lines =<< trim END
3698 vim9script
3699 g:result = 'none'
3700 def Func()
3701 silent! g:result += 3
3702 g:result = 'yes'
3703 enddef
3704 # error is silenced, function does not abort
3705 Func()
3706 assert_equal('yes', g:result)
3707 unlet g:result
3708 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003709 v9.CheckScriptSuccess(lines)
Bram Moolenaarf665e972020-12-05 19:17:16 +01003710enddef
3711
Bram Moolenaaraf0df472020-12-02 20:51:22 +01003712def Test_abort_even_with_silent()
3713 var lines =<< trim END
3714 vim9script
3715 g:result = 'none'
3716 def Func()
3717 eval {-> ''}() .. '' .. {}['X']
3718 g:result = 'yes'
3719 enddef
Bram Moolenaarf665e972020-12-05 19:17:16 +01003720 silent! Func()
Bram Moolenaaraf0df472020-12-02 20:51:22 +01003721 assert_equal('none', g:result)
Bram Moolenaar4029cab2020-12-05 18:13:27 +01003722 unlet g:result
3723 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003724 v9.CheckScriptSuccess(lines)
Bram Moolenaar4029cab2020-12-05 18:13:27 +01003725enddef
3726
Bram Moolenaarf665e972020-12-05 19:17:16 +01003727def Test_cmdmod_silent_restored()
3728 var lines =<< trim END
3729 vim9script
3730 def Func()
3731 g:result = 'none'
3732 silent! g:result += 3
3733 g:result = 'none'
3734 g:result += 3
3735 enddef
3736 Func()
3737 END
3738 # can't use CheckScriptFailure, it ignores the :silent!
3739 var fname = 'Xdefsilent'
Bram Moolenaarf5fec052022-09-11 11:49:22 +01003740 writefile(lines, fname, 'D')
Bram Moolenaarf665e972020-12-05 19:17:16 +01003741 var caught = 'no'
3742 try
3743 exe 'source ' .. fname
3744 catch /E1030:/
3745 caught = 'yes'
3746 assert_match('Func, line 4', v:throwpoint)
3747 endtry
3748 assert_equal('yes', caught)
Bram Moolenaarf665e972020-12-05 19:17:16 +01003749enddef
3750
Bram Moolenaar2fecb532021-03-24 22:00:56 +01003751def Test_cmdmod_silent_nested()
3752 var lines =<< trim END
3753 vim9script
3754 var result = ''
3755
3756 def Error()
3757 result ..= 'Eb'
3758 eval [][0]
3759 result ..= 'Ea'
3760 enddef
3761
3762 def Crash()
3763 result ..= 'Cb'
3764 sil! Error()
3765 result ..= 'Ca'
3766 enddef
3767
3768 Crash()
3769 assert_equal('CbEbEaCa', result)
3770 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003771 v9.CheckScriptSuccess(lines)
Bram Moolenaar2fecb532021-03-24 22:00:56 +01003772enddef
3773
Bram Moolenaar4029cab2020-12-05 18:13:27 +01003774def Test_dict_member_with_silent()
3775 var lines =<< trim END
3776 vim9script
3777 g:result = 'none'
3778 var d: dict<any>
3779 def Func()
3780 try
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01003781 g:result = map([], (_, v) => ({}[v]))->join() .. d['']
Bram Moolenaar4029cab2020-12-05 18:13:27 +01003782 catch
3783 endtry
3784 enddef
3785 silent! Func()
3786 assert_equal('0', g:result)
3787 unlet g:result
Bram Moolenaaraf0df472020-12-02 20:51:22 +01003788 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003789 v9.CheckScriptSuccess(lines)
Bram Moolenaaraf0df472020-12-02 20:51:22 +01003790enddef
3791
Bram Moolenaarf9041332021-01-21 19:41:16 +01003792def Test_skip_cmds_with_silent()
3793 var lines =<< trim END
3794 vim9script
3795
3796 def Func(b: bool)
3797 Crash()
3798 enddef
3799
3800 def Crash()
3801 sil! :/not found/d _
3802 sil! :/not found/put _
3803 enddef
3804
3805 Func(true)
3806 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003807 v9.CheckScriptSuccess(lines)
Bram Moolenaarf9041332021-01-21 19:41:16 +01003808enddef
3809
Bram Moolenaar5b3d1bb2020-12-22 12:20:08 +01003810def Test_opfunc()
Bram Moolenaar848fadd2022-01-30 15:28:30 +00003811 nnoremap <F3> <cmd>set opfunc=g:Opfunc<cr>g@
Bram Moolenaar5b3d1bb2020-12-22 12:20:08 +01003812 def g:Opfunc(_: any): string
3813 setline(1, 'ASDF')
3814 return ''
3815 enddef
3816 new
3817 setline(1, 'asdf')
3818 feedkeys("\<F3>$", 'x')
3819 assert_equal('ASDF', getline(1))
3820
3821 bwipe!
3822 nunmap <F3>
3823enddef
3824
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003825func Test_opfunc_error()
3826 CheckScreendump
3827 call Run_Test_opfunc_error()
3828endfunc
3829
3830def Run_Test_opfunc_error()
3831 # test that the error from Opfunc() is displayed right away
3832 var lines =<< trim END
3833 vim9script
3834
3835 def Opfunc(type: string)
3836 try
3837 eval [][0]
3838 catch /nothing/ # error not caught
3839 endtry
3840 enddef
3841 &operatorfunc = Opfunc
3842 nnoremap <expr> l <SID>L()
3843 def L(): string
3844 return 'l'
3845 enddef
3846 'x'->repeat(10)->setline(1)
3847 feedkeys('g@l', 'n')
3848 feedkeys('llll')
3849 END
Bram Moolenaarf5fec052022-09-11 11:49:22 +01003850 call writefile(lines, 'XTest_opfunc_error', 'D')
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003851
Bram Moolenaar62aec932022-01-29 21:45:34 +00003852 var buf = g:RunVimInTerminal('-S XTest_opfunc_error', {rows: 6, wait_for_ruler: 0})
3853 g:WaitForAssert(() => assert_match('Press ENTER', term_getline(buf, 6)))
Bram Moolenaarec892232022-05-06 17:53:06 +01003854 g:WaitForAssert(() => assert_match('E684: List index out of range: 0', term_getline(buf, 5)))
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003855
3856 # clean up
Bram Moolenaar62aec932022-01-29 21:45:34 +00003857 g:StopVimInTerminal(buf)
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003858enddef
3859
Bram Moolenaar077a4232020-12-22 18:33:27 +01003860" this was crashing on exit
3861def Test_nested_lambda_in_closure()
3862 var lines =<< trim END
3863 vim9script
Bram Moolenaar227c58a2021-04-28 20:40:44 +02003864 command WriteDone writefile(['Done'], 'XnestedDone')
Bram Moolenaar077a4232020-12-22 18:33:27 +01003865 def Outer()
3866 def g:Inner()
3867 echo map([1, 2, 3], {_, v -> v + 1})
3868 enddef
3869 g:Inner()
3870 enddef
3871 defcompile
Bram Moolenaar227c58a2021-04-28 20:40:44 +02003872 # not reached
Bram Moolenaar077a4232020-12-22 18:33:27 +01003873 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003874 if !g:RunVim([], lines, '--clean -c WriteDone -c quit')
Bram Moolenaar077a4232020-12-22 18:33:27 +01003875 return
3876 endif
3877 assert_equal(['Done'], readfile('XnestedDone'))
3878 delete('XnestedDone')
3879enddef
3880
Bram Moolenaar92368aa2022-02-07 17:50:39 +00003881def Test_nested_closure_funcref()
3882 var lines =<< trim END
3883 vim9script
3884 def Func()
3885 var n: number
3886 def Nested()
3887 ++n
3888 enddef
3889 Nested()
3890 g:result_one = n
3891 var Ref = function(Nested)
3892 Ref()
3893 g:result_two = n
3894 enddef
3895 Func()
3896 END
3897 v9.CheckScriptSuccess(lines)
3898 assert_equal(1, g:result_one)
3899 assert_equal(2, g:result_two)
3900 unlet g:result_one g:result_two
3901enddef
3902
Bram Moolenaar7aca5ca2022-02-07 19:56:43 +00003903def Test_nested_closure_in_dict()
3904 var lines =<< trim END
3905 vim9script
3906 def Func(): dict<any>
3907 var n: number
3908 def Inc(): number
3909 ++n
3910 return n
3911 enddef
3912 return {inc: function(Inc)}
3913 enddef
3914 disas Func
3915 var d = Func()
3916 assert_equal(1, d.inc())
3917 assert_equal(2, d.inc())
3918 END
3919 v9.CheckScriptSuccess(lines)
3920enddef
3921
Bram Moolenaarfb43cfc2022-03-11 18:54:17 +00003922def Test_script_local_other_script()
3923 var lines =<< trim END
3924 function LegacyJob()
3925 let FuncRef = function('s:close_cb')
3926 endfunction
3927 function s:close_cb(...)
3928 endfunction
3929 END
Bram Moolenaarf5fec052022-09-11 11:49:22 +01003930 lines->writefile('Xlegacy.vim', 'D')
Bram Moolenaarfb43cfc2022-03-11 18:54:17 +00003931 source Xlegacy.vim
3932 g:LegacyJob()
3933 g:LegacyJob()
3934 g:LegacyJob()
3935
3936 delfunc g:LegacyJob
Bram Moolenaarfb43cfc2022-03-11 18:54:17 +00003937enddef
3938
Bram Moolenaar04947cc2021-03-06 19:26:46 +01003939def Test_check_func_arg_types()
3940 var lines =<< trim END
3941 vim9script
3942 def F1(x: string): string
3943 return x
3944 enddef
3945
3946 def F2(x: number): number
3947 return x + 1
3948 enddef
3949
Bram Moolenaar1d9cef72022-03-17 16:30:03 +00003950 def G(Fg: func): dict<func>
3951 return {f: Fg}
Bram Moolenaar04947cc2021-03-06 19:26:46 +01003952 enddef
3953
3954 def H(d: dict<func>): string
3955 return d.f('a')
3956 enddef
3957 END
3958
Bram Moolenaar62aec932022-01-29 21:45:34 +00003959 v9.CheckScriptSuccess(lines + ['echo H(G(F1))'])
3960 v9.CheckScriptFailure(lines + ['echo H(G(F2))'], 'E1013:')
Bram Moolenaar1d9cef72022-03-17 16:30:03 +00003961
3962 v9.CheckScriptFailure(lines + ['def SomeFunc(ff: func)', 'enddef'], 'E704:')
Bram Moolenaar04947cc2021-03-06 19:26:46 +01003963enddef
3964
Bram Moolenaarbadf04f2022-03-12 21:28:22 +00003965def Test_call_func_with_null()
3966 var lines =<< trim END
3967 def Fstring(v: string)
3968 assert_equal(null_string, v)
3969 enddef
3970 Fstring(null_string)
3971 def Fblob(v: blob)
3972 assert_equal(null_blob, v)
3973 enddef
3974 Fblob(null_blob)
3975 def Flist(v: list<number>)
3976 assert_equal(null_list, v)
3977 enddef
3978 Flist(null_list)
3979 def Fdict(v: dict<number>)
3980 assert_equal(null_dict, v)
3981 enddef
3982 Fdict(null_dict)
3983 def Ffunc(Fv: func(number): number)
3984 assert_equal(null_function, Fv)
3985 enddef
3986 Ffunc(null_function)
3987 if has('channel')
3988 def Fchannel(v: channel)
3989 assert_equal(null_channel, v)
3990 enddef
3991 Fchannel(null_channel)
3992 def Fjob(v: job)
3993 assert_equal(null_job, v)
3994 enddef
3995 Fjob(null_job)
3996 endif
3997 END
3998 v9.CheckDefAndScriptSuccess(lines)
3999enddef
4000
4001def Test_null_default_argument()
4002 var lines =<< trim END
4003 def Fstring(v: string = null_string)
4004 assert_equal(null_string, v)
4005 enddef
4006 Fstring()
4007 def Fblob(v: blob = null_blob)
4008 assert_equal(null_blob, v)
4009 enddef
4010 Fblob()
4011 def Flist(v: list<number> = null_list)
4012 assert_equal(null_list, v)
4013 enddef
4014 Flist()
4015 def Fdict(v: dict<number> = null_dict)
4016 assert_equal(null_dict, v)
4017 enddef
4018 Fdict()
4019 def Ffunc(Fv: func(number): number = null_function)
4020 assert_equal(null_function, Fv)
4021 enddef
4022 Ffunc()
4023 if has('channel')
4024 def Fchannel(v: channel = null_channel)
4025 assert_equal(null_channel, v)
4026 enddef
4027 Fchannel()
4028 def Fjob(v: job = null_job)
4029 assert_equal(null_job, v)
4030 enddef
4031 Fjob()
4032 endif
4033 END
4034 v9.CheckDefAndScriptSuccess(lines)
4035enddef
4036
4037def Test_null_return()
4038 var lines =<< trim END
4039 def Fstring(): string
4040 return null_string
4041 enddef
4042 assert_equal(null_string, Fstring())
4043 def Fblob(): blob
4044 return null_blob
4045 enddef
4046 assert_equal(null_blob, Fblob())
4047 def Flist(): list<number>
4048 return null_list
4049 enddef
4050 assert_equal(null_list, Flist())
4051 def Fdict(): dict<number>
4052 return null_dict
4053 enddef
4054 assert_equal(null_dict, Fdict())
4055 def Ffunc(): func(number): number
4056 return null_function
4057 enddef
4058 assert_equal(null_function, Ffunc())
4059 if has('channel')
4060 def Fchannel(): channel
4061 return null_channel
4062 enddef
4063 assert_equal(null_channel, Fchannel())
4064 def Fjob(): job
4065 return null_job
4066 enddef
4067 assert_equal(null_job, Fjob())
4068 endif
4069 END
4070 v9.CheckDefAndScriptSuccess(lines)
4071enddef
4072
Bram Moolenaar6e48b842021-08-10 22:52:02 +02004073def Test_list_any_type_checked()
4074 var lines =<< trim END
4075 vim9script
4076 def Foo()
4077 --decl--
4078 Bar(l)
4079 enddef
4080 def Bar(ll: list<dict<any>>)
4081 enddef
4082 Foo()
4083 END
Bram Moolenaar2d3ac2e2022-02-03 12:34:05 +00004084 # "any" could be "dict<any>", thus OK
Bram Moolenaar6e48b842021-08-10 22:52:02 +02004085 lines[2] = 'var l: list<any>'
Bram Moolenaar2d3ac2e2022-02-03 12:34:05 +00004086 v9.CheckScriptSuccess(lines)
Bram Moolenaar6e48b842021-08-10 22:52:02 +02004087 lines[2] = 'var l: list<any> = []'
Bram Moolenaar2d3ac2e2022-02-03 12:34:05 +00004088 v9.CheckScriptSuccess(lines)
Bram Moolenaar6e48b842021-08-10 22:52:02 +02004089
4090 lines[2] = 'var l: list<any> = [11]'
Bram Moolenaar62aec932022-01-29 21:45:34 +00004091 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected list<dict<any>> but got list<number>', 2)
Bram Moolenaar6e48b842021-08-10 22:52:02 +02004092enddef
4093
Bram Moolenaar701cc6c2021-04-10 13:33:48 +02004094def Test_compile_error()
4095 var lines =<< trim END
4096 def g:Broken()
4097 echo 'a' + {}
4098 enddef
4099 call g:Broken()
4100 END
4101 # First call: compilation error
Bram Moolenaar62aec932022-01-29 21:45:34 +00004102 v9.CheckScriptFailure(lines, 'E1051: Wrong argument type for +')
Bram Moolenaar701cc6c2021-04-10 13:33:48 +02004103
4104 # Second call won't try compiling again
4105 assert_fails('call g:Broken()', 'E1091: Function is not compiled: Broken')
Bram Moolenaar599410c2021-04-10 14:03:43 +02004106 delfunc g:Broken
4107
4108 # No error when compiling with :silent!
4109 lines =<< trim END
4110 def g:Broken()
4111 echo 'a' + []
4112 enddef
4113 silent! defcompile
4114 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004115 v9.CheckScriptSuccess(lines)
Bram Moolenaar599410c2021-04-10 14:03:43 +02004116
4117 # Calling the function won't try compiling again
4118 assert_fails('call g:Broken()', 'E1091: Function is not compiled: Broken')
4119 delfunc g:Broken
Bram Moolenaar701cc6c2021-04-10 13:33:48 +02004120enddef
4121
Bram Moolenaar962c43b2021-04-10 17:18:09 +02004122def Test_ignored_argument()
4123 var lines =<< trim END
4124 vim9script
4125 def Ignore(_, _): string
4126 return 'yes'
4127 enddef
4128 assert_equal('yes', Ignore(1, 2))
4129
4130 func Ok(_)
4131 return a:_
4132 endfunc
4133 assert_equal('ok', Ok('ok'))
4134
4135 func Oktoo()
4136 let _ = 'too'
4137 return _
4138 endfunc
4139 assert_equal('too', Oktoo())
Bram Moolenaarda479c72021-04-10 21:01:38 +02004140
4141 assert_equal([[1], [2], [3]], range(3)->mapnew((_, v) => [v]->map((_, w) => w + 1)))
Bram Moolenaar962c43b2021-04-10 17:18:09 +02004142 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004143 v9.CheckScriptSuccess(lines)
Bram Moolenaar962c43b2021-04-10 17:18:09 +02004144
4145 lines =<< trim END
4146 def Ignore(_: string): string
4147 return _
4148 enddef
4149 defcompile
4150 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004151 v9.CheckScriptFailure(lines, 'E1181:', 1)
Bram Moolenaar962c43b2021-04-10 17:18:09 +02004152
4153 lines =<< trim END
4154 var _ = 1
4155 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004156 v9.CheckDefAndScriptFailure(lines, 'E1181:', 1)
Yegappan Lakshmanan34fcb692021-05-25 20:14:00 +02004157
4158 lines =<< trim END
4159 var x = _
4160 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004161 v9.CheckDefAndScriptFailure(lines, 'E1181:', 1)
Bram Moolenaar962c43b2021-04-10 17:18:09 +02004162enddef
4163
Bram Moolenaarbb8a7ce2021-04-10 20:10:26 +02004164def Test_too_many_arguments()
4165 var lines =<< trim END
4166 echo [0, 1, 2]->map(() => 123)
4167 END
Bram Moolenaareddd4fc2022-02-20 15:52:28 +00004168 v9.CheckDefAndScriptFailure(lines, ['E176:', 'E1106: 2 arguments too many'], 1)
Bram Moolenaarbb8a7ce2021-04-10 20:10:26 +02004169
4170 lines =<< trim END
4171 echo [0, 1, 2]->map((_) => 123)
4172 END
Bram Moolenaareddd4fc2022-02-20 15:52:28 +00004173 v9.CheckDefAndScriptFailure(lines, ['E176', 'E1106: One argument too many'], 1)
Bram Moolenaar31d99482022-05-26 22:24:43 +01004174
4175 lines =<< trim END
4176 vim9script
4177 def OneArgument(arg: string)
4178 echo arg
4179 enddef
4180 var Ref = OneArgument
4181 Ref('a', 'b')
4182 END
4183 v9.CheckScriptFailure(lines, 'E118:')
4184enddef
4185
4186def Test_funcref_with_base()
4187 var lines =<< trim END
4188 vim9script
4189 def TwoArguments(str: string, nr: number)
4190 echo str nr
4191 enddef
4192 var Ref = TwoArguments
4193 Ref('a', 12)
4194 'b'->Ref(34)
4195 END
4196 v9.CheckScriptSuccess(lines)
4197
4198 lines =<< trim END
4199 vim9script
4200 def TwoArguments(str: string, nr: number)
4201 echo str nr
4202 enddef
4203 var Ref = TwoArguments
4204 'a'->Ref('b')
4205 END
4206 v9.CheckScriptFailure(lines, 'E1013: Argument 2: type mismatch, expected number but got string', 6)
4207
4208 lines =<< trim END
4209 vim9script
4210 def TwoArguments(str: string, nr: number)
4211 echo str nr
4212 enddef
4213 var Ref = TwoArguments
4214 123->Ref(456)
4215 END
4216 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected string but got number')
4217
4218 lines =<< trim END
4219 vim9script
4220 def TwoArguments(nr: number, str: string)
4221 echo str nr
4222 enddef
4223 var Ref = TwoArguments
4224 123->Ref('b')
4225 def AndNowCompiled()
4226 456->Ref('x')
4227 enddef
4228 AndNowCompiled()
4229 END
4230 v9.CheckScriptSuccess(lines)
Bram Moolenaarbb8a7ce2021-04-10 20:10:26 +02004231enddef
Bram Moolenaar077a4232020-12-22 18:33:27 +01004232
Bram Moolenaara6aa1642021-04-23 19:32:23 +02004233def Test_closing_brace_at_start_of_line()
4234 var lines =<< trim END
4235 def Func()
4236 enddef
4237 Func(
4238 )
4239 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004240 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaara6aa1642021-04-23 19:32:23 +02004241enddef
4242
Bram Moolenaar62aec932022-01-29 21:45:34 +00004243func s:CreateMydict()
Bram Moolenaarb033ee22021-08-15 16:08:36 +02004244 let g:mydict = {}
4245 func g:mydict.afunc()
4246 let g:result = self.key
4247 endfunc
4248endfunc
4249
4250def Test_numbered_function_reference()
4251 CreateMydict()
4252 var output = execute('legacy func g:mydict.afunc')
4253 var funcName = 'g:' .. substitute(output, '.*function \(\d\+\).*', '\1', '')
4254 execute 'function(' .. funcName .. ', [], {key: 42})()'
4255 # check that the function still exists
4256 assert_equal(output, execute('legacy func g:mydict.afunc'))
4257 unlet g:mydict
4258enddef
4259
Bram Moolenaarcfb4d4f2022-09-30 19:19:04 +01004260def Test_numbered_function_call()
4261 var lines =<< trim END
4262 let s:legacyscript = {}
4263 func s:legacyscript.Helper() abort
4264 return "Success"
4265 endfunc
4266 let g:legacyscript = deepcopy(s:legacyscript)
4267
4268 let g:legacy_result = eval("g:legacyscript.Helper()")
4269 vim9cmd g:vim9_result = eval("g:legacyscript.Helper()")
4270 END
4271 v9.CheckScriptSuccess(lines)
4272 assert_equal('Success', g:legacy_result)
4273 assert_equal('Success', g:vim9_result)
4274
4275 unlet g:legacy_result
4276 unlet g:vim9_result
4277enddef
4278
Bram Moolenaard3a11782022-01-05 16:50:40 +00004279def Test_go_beyond_end_of_cmd()
4280 # this was reading the byte after the end of the line
4281 var lines =<< trim END
4282 def F()
4283 cal
4284 enddef
4285 defcompile
4286 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004287 v9.CheckScriptFailure(lines, 'E476:')
Bram Moolenaard3a11782022-01-05 16:50:40 +00004288enddef
4289
Yegappan Lakshmanan7c7e19c2022-04-09 11:09:07 +01004290" Test for memory allocation failure when defining a new lambda
4291func Test_lambda_allocation_failure()
4292 new
4293 let lines =<< trim END
4294 vim9script
4295 g:Xlambda = (x): number => {
4296 return x + 1
4297 }
4298 END
4299 call setline(1, lines)
4300 call test_alloc_fail(GetAllocId('get_func'), 0, 0)
4301 call assert_fails('source', 'E342:')
4302 call assert_false(exists('g:Xlambda'))
4303 bw!
4304endfunc
4305
Bram Moolenaar0d89d8a2022-12-31 14:01:24 +00004306def Test_lambda_argument_type_check()
4307 var lines =<< trim END
4308 vim9script
4309
4310 def Scan(ll: list<any>): func(func(any))
4311 return (Emit: func(any)) => {
4312 for e in ll
4313 Emit(e)
4314 endfor
4315 }
4316 enddef
4317
4318 def Sum(Cont: func(func(any))): any
4319 var sum = 0.0
4320 Cont((v: float) => { # <== NOTE: the lambda expects a float
4321 sum += v
4322 })
4323 return sum
4324 enddef
4325
Bram Moolenaar47bba532023-01-20 18:49:46 +00004326 const ml = [3.0, 2, '7']
Bram Moolenaar0d89d8a2022-12-31 14:01:24 +00004327 echo Scan(ml)->Sum()
4328 END
Bram Moolenaar47bba532023-01-20 18:49:46 +00004329 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected float but got string')
Bram Moolenaar0d89d8a2022-12-31 14:01:24 +00004330enddef
4331
Bram Moolenaarbce69d62022-05-22 13:45:52 +01004332def Test_multiple_funcref()
4333 # This was using a NULL pointer
4334 var lines =<< trim END
4335 vim9script
4336 def A(F: func, ...args: list<any>): func
4337 return funcref(F, args)
4338 enddef
4339
4340 def B(F: func): func
4341 return funcref(A, [F])
4342 enddef
4343
4344 def Test(n: number)
4345 enddef
4346
4347 const X = B(Test)
4348 X(1)
4349 END
4350 v9.CheckScriptSuccess(lines)
4351
4352 # slightly different case
4353 lines =<< trim END
4354 vim9script
4355
4356 def A(F: func, ...args: list<any>): any
4357 return call(F, args)
4358 enddef
4359
4360 def B(F: func): func
4361 return funcref(A, [F])
4362 enddef
4363
4364 def Test(n: number)
4365 enddef
4366
4367 const X = B(Test)
4368 X(1)
4369 END
4370 v9.CheckScriptSuccess(lines)
4371enddef
4372
Bram Moolenaarbd683e32022-07-18 17:49:03 +01004373def Test_cexpr_errmsg_line_number()
4374 var lines =<< trim END
4375 vim9script
4376 def Func()
4377 var qfl = {}
4378 cexpr qfl
4379 enddef
4380 Func()
4381 END
4382 v9.CheckScriptFailure(lines, 'E777', 2)
4383enddef
4384
Bram Moolenaar1d84f762022-09-03 21:35:53 +01004385def AddDefer(s: string)
4386 g:deferred->extend([s])
4387enddef
4388
4389def DeferTwo()
4390 g:deferred->extend(['in Two'])
4391 for n in range(3)
4392 defer g:AddDefer('two' .. n)
4393 endfor
4394 g:deferred->extend(['end Two'])
4395enddef
4396
4397def DeferOne()
4398 g:deferred->extend(['in One'])
4399 defer g:AddDefer('one')
4400 g:DeferTwo()
4401 g:deferred->extend(['end One'])
4402
4403 writefile(['text'], 'XdeferFile')
4404 defer delete('XdeferFile')
4405enddef
4406
4407def Test_defer()
4408 g:deferred = []
4409 g:DeferOne()
4410 assert_equal(['in One', 'in Two', 'end Two', 'two2', 'two1', 'two0', 'end One', 'one'], g:deferred)
4411 unlet g:deferred
4412 assert_equal('', glob('XdeferFile'))
4413enddef
4414
Bram Moolenaar3558afe2022-10-13 16:12:57 +01004415def Test_invalid_redir()
4416 var lines =<< trim END
4417 def Tone()
4418 if 1
4419 redi =>@�0
4420 redi END
4421 endif
4422 enddef
4423 defcompile
4424 END
4425 v9.CheckScriptFailure(lines, 'E354:')
4426 delfunc g:Tone
4427
4428 # this was reading past the end of the line
4429 lines =<< trim END
4430 def Ttwo()
4431 if 0
4432 redi =>@�0
4433 redi END
4434 endif
4435 enddef
4436 defcompile
4437 END
4438 v9.CheckScriptFailure(lines, 'E354:')
4439 delfunc g:Ttwo
4440enddef
4441
Bram Moolenaar39c82ea2023-01-02 13:08:01 +00004442func Test_keytyped_in_nested_function()
4443 CheckRunVimInTerminal
4444
4445 call Run_Test_keytyped_in_nested_function()
4446endfunc
4447
4448def Run_Test_keytyped_in_nested_function()
4449 var lines =<< trim END
4450 vim9script
4451 autocmd CmdlineEnter * sample#Init()
4452
4453 exe 'set rtp=' .. getcwd() .. '/Xrtpdir'
4454 END
4455 writefile(lines, 'Xkeytyped', 'D')
4456
4457 var dir = 'Xrtpdir/autoload'
4458 mkdir(dir, 'pR')
4459
4460 lines =<< trim END
4461 vim9script
4462 export def Init(): void
4463 cnoremap <expr>" <SID>Quote('"')
4464 enddef
4465 def Quote(str: string): string
4466 def InPair(): number
4467 return 0
4468 enddef
4469 return str
4470 enddef
4471 END
4472 writefile(lines, dir .. '/sample.vim')
4473
4474 var buf = g:RunVimInTerminal('-S Xkeytyped', {rows: 6})
4475
4476 term_sendkeys(buf, ':"')
4477 g:VerifyScreenDump(buf, 'Test_keytyped_in_nested_func', {})
4478
4479 # clean up
4480 term_sendkeys(buf, "\<Esc>")
4481 g:StopVimInTerminal(buf)
4482enddef
4483
Bram Moolenaar8b716f52022-02-15 21:17:56 +00004484" The following messes up syntax highlight, keep near the end.
Bram Moolenaar20677332021-06-06 17:02:53 +02004485if has('python3')
Bram Moolenaar8b716f52022-02-15 21:17:56 +00004486 def Test_python3_command()
4487 py3 import vim
Bram Moolenaarf5288c52022-02-15 21:33:29 +00004488 py3 vim.command("g:done = 'yes'")
Bram Moolenaar8b716f52022-02-15 21:17:56 +00004489 assert_equal('yes', g:done)
4490 unlet g:done
4491 enddef
4492
Bram Moolenaar20677332021-06-06 17:02:53 +02004493 def Test_python3_heredoc()
4494 py3 << trim EOF
4495 import vim
4496 vim.vars['didit'] = 'yes'
4497 EOF
4498 assert_equal('yes', g:didit)
4499
4500 python3 << trim EOF
4501 import vim
4502 vim.vars['didit'] = 'again'
4503 EOF
4504 assert_equal('again', g:didit)
4505 enddef
4506endif
4507
Bram Moolenaar20677332021-06-06 17:02:53 +02004508if has('lua')
4509 def Test_lua_heredoc()
4510 g:d = {}
4511 lua << trim EOF
4512 x = vim.eval('g:d')
4513 x['key'] = 'val'
4514 EOF
4515 assert_equal('val', g:d.key)
4516 enddef
Bram Moolenaarefd73ae2022-03-20 18:51:00 +00004517
4518 def Test_lua_heredoc_fails()
4519 var lines = [
4520 'vim9script',
4521 'def ExeLua()',
4522 'lua << trim EOLUA',
4523 "x = vim.eval('g:nodict')",
4524 'EOLUA',
4525 'enddef',
4526 'ExeLua()',
4527 ]
4528 v9.CheckScriptFailure(lines, 'E121: Undefined variable: g:nodict')
4529 enddef
Bram Moolenaar20677332021-06-06 17:02:53 +02004530endif
4531
Bram Moolenaard881d152022-05-13 13:50:36 +01004532if has('perl')
4533 def Test_perl_heredoc_nested()
4534 var lines =<< trim END
4535 vim9script
4536 def F(): string
4537 def G(): string
4538 perl << EOF
4539 EOF
4540 return 'done'
4541 enddef
4542 return G()
4543 enddef
4544 assert_equal('done', F())
4545 END
4546 v9.CheckScriptSuccess(lines)
4547 enddef
4548endif
4549
Bram Moolenaarf7779c62020-05-03 15:38:16 +02004550
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02004551" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker