blob: 9287ed5f33cf261529e7510e98dfbbfe021a0b4b [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 Moolenaare8c46602021-04-05 22:27:37 +020032 writefile(lines, 'XTest_compile_error')
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 +020040 delete('XTest_compile_error')
41enddef
42
43def TestCompilingErrorInTry()
44 var dir = 'Xdir/autoload'
45 mkdir(dir, 'p')
46
47 var lines =<< trim END
48 vim9script
Bram Moolenaard8fe6d32022-01-30 18:40:44 +000049 export def OnlyCompiled()
Bram Moolenaare8c46602021-04-05 22:27:37 +020050 g:runtime = 'yes'
51 invalid
52 enddef
53 END
54 writefile(lines, dir .. '/script.vim')
55
56 lines =<< trim END
57 vim9script
58 todo
59 try
60 script#OnlyCompiled()
61 catch /nothing/
62 endtry
63 END
64 lines[1] = 'set rtp=' .. getcwd() .. '/Xdir'
65 writefile(lines, 'XTest_compile_error')
66
Bram Moolenaar62aec932022-01-29 21:45:34 +000067 var buf = g:RunVimInTerminal('-S XTest_compile_error', {rows: 10, wait_for_ruler: 0})
68 g:WaitForAssert(() => assert_match('Error detected while compiling command line.*function script#OnlyCompiled.*Invalid command: invalid',
69 g:Term_getlines(buf, range(1, 9))))
Bram Moolenaare8c46602021-04-05 22:27:37 +020070
71 # clean up
Bram Moolenaar62aec932022-01-29 21:45:34 +000072 g:StopVimInTerminal(buf)
Bram Moolenaare8c46602021-04-05 22:27:37 +020073 delete('XTest_compile_error')
74 delete('Xdir', 'rf')
Bram Moolenaarf4e8cdd2020-10-12 22:07:13 +020075enddef
76
Bram Moolenaarb55d6182021-06-08 22:01:53 +020077def Test_compile_error_in_called_function()
78 var lines =<< trim END
79 vim9script
80 var n: number
81 def Foo()
82 &hls = n
83 enddef
84 def Bar()
85 Foo()
86 enddef
87 silent! Foo()
88 Bar()
89 END
Bram Moolenaar62aec932022-01-29 21:45:34 +000090 v9.CheckScriptFailureList(lines, ['E1012:', 'E1191:'])
Bram Moolenaarb55d6182021-06-08 22:01:53 +020091enddef
92
Bram Moolenaar22f17a22021-06-21 20:48:58 +020093def Test_wrong_function_name()
94 var lines =<< trim END
95 vim9script
96 func _Foo()
97 echo 'foo'
98 endfunc
99 END
Bram Moolenaar3787f262022-02-07 21:54:01 +0000100 v9.CheckScriptFailure(lines, 'E1267:')
Bram Moolenaar22f17a22021-06-21 20:48:58 +0200101
102 lines =<< trim END
103 vim9script
104 def _Foo()
105 echo 'foo'
106 enddef
107 END
Bram Moolenaar3787f262022-02-07 21:54:01 +0000108 v9.CheckScriptFailure(lines, 'E1267:')
Bram Moolenaardea5ab02022-02-23 22:12:02 +0000109
110 lines =<< trim END
111 vim9script
112 var Object = {}
113 function Object.Method()
114 endfunction
115 END
116 v9.CheckScriptFailure(lines, 'E1182:')
117
118 lines =<< trim END
119 vim9script
120 var Object = {}
121 def Object.Method()
122 enddef
123 END
124 v9.CheckScriptFailure(lines, 'E1182:')
125
126 lines =<< trim END
127 vim9script
128 g:Object = {}
129 function g:Object.Method()
130 endfunction
131 END
132 v9.CheckScriptFailure(lines, 'E1182:')
133
134 lines =<< trim END
135 let s:Object = {}
136 def Define()
137 function s:Object.Method()
138 endfunction
139 enddef
140 defcompile
141 END
142 v9.CheckScriptFailure(lines, 'E1182:')
143 delfunc g:Define
144
145 lines =<< trim END
146 let s:Object = {}
147 def Define()
148 def Object.Method()
149 enddef
150 enddef
151 defcompile
152 END
153 v9.CheckScriptFailure(lines, 'E1182:')
154 delfunc g:Define
155
156 lines =<< trim END
157 let g:Object = {}
158 def Define()
159 function g:Object.Method()
160 endfunction
161 enddef
162 defcompile
163 END
164 v9.CheckScriptFailure(lines, 'E1182:')
165 delfunc g:Define
Bram Moolenaar22f17a22021-06-21 20:48:58 +0200166enddef
167
Bram Moolenaarf48b2fa2021-04-12 22:02:36 +0200168def Test_autoload_name_mismatch()
169 var dir = 'Xdir/autoload'
170 mkdir(dir, 'p')
171
172 var lines =<< trim END
173 vim9script
Bram Moolenaard8fe6d32022-01-30 18:40:44 +0000174 export def NoFunction()
Bram Moolenaarf48b2fa2021-04-12 22:02:36 +0200175 # comment
176 g:runtime = 'yes'
177 enddef
178 END
179 writefile(lines, dir .. '/script.vim')
180
181 var save_rtp = &rtp
182 exe 'set rtp=' .. getcwd() .. '/Xdir'
183 lines =<< trim END
184 call script#Function()
185 END
Bram Moolenaard8fe6d32022-01-30 18:40:44 +0000186 v9.CheckScriptFailure(lines, 'E117:', 1)
Bram Moolenaarf48b2fa2021-04-12 22:02:36 +0200187
188 &rtp = save_rtp
189 delete(dir, 'rf')
190enddef
191
Bram Moolenaarf0a40692021-06-11 22:05:47 +0200192def Test_autoload_names()
193 var dir = 'Xdir/autoload'
194 mkdir(dir, 'p')
195
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
205 exe 'set rtp=' .. getcwd() .. '/Xdir'
206
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
217 delete(dir, 'rf')
218enddef
219
Bram Moolenaar88c89c72021-08-14 14:01:05 +0200220def Test_autoload_error_in_script()
221 var dir = 'Xdir/autoload'
222 mkdir(dir, 'p')
223
224 var lines =<< trim END
225 func scripterror#function()
226 let g:called_function = 'yes'
227 endfunc
228 let 0 = 1
229 END
230 writefile(lines, dir .. '/scripterror.vim')
231
232 var save_rtp = &rtp
233 exe 'set rtp=' .. getcwd() .. '/Xdir'
234
235 g:called_function = 'no'
236 # The error in the autoload script cannot be checked with assert_fails(), use
237 # CheckDefSuccess() instead of CheckDefFailure()
238 try
Bram Moolenaar62aec932022-01-29 21:45:34 +0000239 v9.CheckDefSuccess(['scripterror#function()'])
Bram Moolenaar88c89c72021-08-14 14:01:05 +0200240 catch
241 assert_match('E121: Undefined variable: 0', v:exception)
242 endtry
243 assert_equal('no', g:called_function)
244
245 lines =<< trim END
246 func scriptcaught#function()
247 let g:called_function = 'yes'
248 endfunc
249 try
250 let 0 = 1
251 catch
252 let g:caught = v:exception
253 endtry
254 END
255 writefile(lines, dir .. '/scriptcaught.vim')
256
257 g:called_function = 'no'
Bram Moolenaar62aec932022-01-29 21:45:34 +0000258 v9.CheckDefSuccess(['scriptcaught#function()'])
Bram Moolenaar88c89c72021-08-14 14:01:05 +0200259 assert_match('E121: Undefined variable: 0', g:caught)
260 assert_equal('yes', g:called_function)
261
262 &rtp = save_rtp
263 delete(dir, 'rf')
264enddef
265
Bram Moolenaar62aec932022-01-29 21:45:34 +0000266def s:CallRecursive(n: number): number
Bram Moolenaar0ba48e82020-11-17 18:23:19 +0100267 return CallRecursive(n + 1)
268enddef
269
Bram Moolenaar62aec932022-01-29 21:45:34 +0000270def s:CallMapRecursive(l: list<number>): number
Bram Moolenaar2949cfd2020-12-31 21:28:47 +0100271 return map(l, (_, v) => CallMapRecursive([v]))[0]
Bram Moolenaar0ba48e82020-11-17 18:23:19 +0100272enddef
273
274def Test_funcdepth_error()
275 set maxfuncdepth=10
276
277 var caught = false
278 try
279 CallRecursive(1)
280 catch /E132:/
281 caught = true
282 endtry
283 assert_true(caught)
284
285 caught = false
286 try
287 CallMapRecursive([1])
288 catch /E132:/
289 caught = true
290 endtry
291 assert_true(caught)
292
293 set maxfuncdepth&
294enddef
295
Bram Moolenaar5178b1b2021-01-01 18:43:51 +0100296def Test_endfunc_enddef()
297 var lines =<< trim END
298 def Test()
299 echo 'test'
300 endfunc
301 enddef
302 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000303 v9.CheckScriptFailure(lines, 'E1151:', 3)
Bram Moolenaar5178b1b2021-01-01 18:43:51 +0100304
305 lines =<< trim END
306 def Test()
307 func Nested()
308 echo 'test'
309 enddef
310 enddef
311 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000312 v9.CheckScriptFailure(lines, 'E1152:', 4)
Bram Moolenaar49f1e9e2021-03-22 20:49:02 +0100313
314 lines =<< trim END
315 def Ok()
316 echo 'hello'
317 enddef | echo 'there'
318 def Bad()
319 echo 'hello'
320 enddef there
321 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000322 v9.CheckScriptFailure(lines, 'E1173: Text found after enddef: there', 6)
Bram Moolenaar5178b1b2021-01-01 18:43:51 +0100323enddef
324
Bram Moolenaarb8ba9b92021-01-01 18:54:34 +0100325def Test_missing_endfunc_enddef()
326 var lines =<< trim END
327 vim9script
328 def Test()
329 echo 'test'
330 endef
331 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000332 v9.CheckScriptFailure(lines, 'E1057:', 2)
Bram Moolenaarb8ba9b92021-01-01 18:54:34 +0100333
334 lines =<< trim END
335 vim9script
336 func Some()
337 echo 'test'
338 enfffunc
339 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000340 v9.CheckScriptFailure(lines, 'E126:', 2)
Bram Moolenaarb8ba9b92021-01-01 18:54:34 +0100341enddef
342
Bram Moolenaar4efd9942021-01-24 21:14:20 +0100343def Test_white_space_before_paren()
344 var lines =<< trim END
345 vim9script
346 def Test ()
347 echo 'test'
348 enddef
349 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000350 v9.CheckScriptFailure(lines, 'E1068:', 2)
Bram Moolenaar4efd9942021-01-24 21:14:20 +0100351
352 lines =<< trim END
353 vim9script
354 func Test ()
355 echo 'test'
356 endfunc
357 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000358 v9.CheckScriptFailure(lines, 'E1068:', 2)
Bram Moolenaar4efd9942021-01-24 21:14:20 +0100359
360 lines =<< trim END
361 def Test ()
362 echo 'test'
363 enddef
364 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000365 v9.CheckScriptFailure(lines, 'E1068:', 1)
Bram Moolenaar4efd9942021-01-24 21:14:20 +0100366
367 lines =<< trim END
368 func Test ()
369 echo 'test'
370 endfunc
371 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000372 v9.CheckScriptSuccess(lines)
Bram Moolenaar4efd9942021-01-24 21:14:20 +0100373enddef
374
Bram Moolenaar832ea892021-01-08 21:55:26 +0100375def Test_enddef_dict_key()
376 var d = {
377 enddef: 'x',
378 endfunc: 'y',
379 }
380 assert_equal({enddef: 'x', endfunc: 'y'}, d)
381enddef
382
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200383def ReturnString(): string
384 return 'string'
385enddef
386
387def ReturnNumber(): number
388 return 123
389enddef
390
391let g:notNumber = 'string'
392
393def ReturnGlobal(): number
394 return g:notNumber
395enddef
396
397def Test_return_something()
Bram Moolenaar62aec932022-01-29 21:45:34 +0000398 g:ReturnString()->assert_equal('string')
399 g:ReturnNumber()->assert_equal(123)
Bram Moolenaar848fadd2022-01-30 15:28:30 +0000400 assert_fails('g:ReturnGlobal()', 'E1012: Type mismatch; expected number but got string', '', 1, 'ReturnGlobal')
Bram Moolenaaref7aadb2022-01-18 18:46:07 +0000401
402 var lines =<< trim END
403 vim9script
404
405 def Msg()
406 echomsg 'in Msg()...'
407 enddef
408
409 def Func()
410 return Msg()
411 enddef
412 defcompile
413 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000414 v9.CheckScriptFailure(lines, 'E1096:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200415enddef
416
Bram Moolenaare32e5162021-01-21 20:21:29 +0100417def Test_check_argument_type()
418 var lines =<< trim END
419 vim9script
420 def Val(a: number, b: number): number
421 return 0
422 enddef
423 def Func()
424 var x: any = true
425 Val(0, x)
426 enddef
427 disass Func
428 Func()
429 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000430 v9.CheckScriptFailure(lines, 'E1013: Argument 2: type mismatch, expected number but got bool', 2)
Bram Moolenaare32e5162021-01-21 20:21:29 +0100431enddef
432
Bram Moolenaarefd88552020-06-18 20:50:10 +0200433def Test_missing_return()
Bram Moolenaar62aec932022-01-29 21:45:34 +0000434 v9.CheckDefFailure(['def Missing(): number',
Bram Moolenaarefd88552020-06-18 20:50:10 +0200435 ' if g:cond',
436 ' echo "no return"',
437 ' else',
438 ' return 0',
439 ' endif'
440 'enddef'], 'E1027:')
Bram Moolenaar62aec932022-01-29 21:45:34 +0000441 v9.CheckDefFailure(['def Missing(): number',
Bram Moolenaarefd88552020-06-18 20:50:10 +0200442 ' if g:cond',
443 ' return 1',
444 ' else',
445 ' echo "no return"',
446 ' endif'
447 'enddef'], 'E1027:')
Bram Moolenaar62aec932022-01-29 21:45:34 +0000448 v9.CheckDefFailure(['def Missing(): number',
Bram Moolenaarefd88552020-06-18 20:50:10 +0200449 ' if g:cond',
450 ' return 1',
451 ' else',
452 ' return 2',
453 ' endif'
454 ' return 3'
455 'enddef'], 'E1095:')
456enddef
457
Bram Moolenaar403dc312020-10-17 19:29:51 +0200458def Test_return_bool()
459 var lines =<< trim END
460 vim9script
461 def MenuFilter(id: number, key: string): bool
462 return popup_filter_menu(id, key)
463 enddef
464 def YesnoFilter(id: number, key: string): bool
465 return popup_filter_yesno(id, key)
466 enddef
467 defcompile
468 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000469 v9.CheckScriptSuccess(lines)
Bram Moolenaar403dc312020-10-17 19:29:51 +0200470enddef
471
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200472let s:nothing = 0
473def ReturnNothing()
474 s:nothing = 1
475 if true
476 return
477 endif
478 s:nothing = 2
479enddef
480
481def Test_return_nothing()
Bram Moolenaar62aec932022-01-29 21:45:34 +0000482 g:ReturnNothing()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200483 s:nothing->assert_equal(1)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200484enddef
485
Bram Moolenaar648ea762021-01-15 19:04:32 +0100486def Test_return_invalid()
487 var lines =<< trim END
488 vim9script
489 def Func(): invalid
490 return xxx
491 enddef
492 defcompile
493 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000494 v9.CheckScriptFailure(lines, 'E1010:', 2)
Bram Moolenaar31842cd2021-02-12 22:10:21 +0100495
496 lines =<< trim END
497 vim9script
498 def Test(Fun: func(number): number): list<number>
499 return map([1, 2, 3], (_, i) => Fun(i))
500 enddef
501 defcompile
502 def Inc(nr: number): nr
503 return nr + 2
504 enddef
505 echo Test(Inc)
506 END
507 # doing this twice was leaking memory
Bram Moolenaar62aec932022-01-29 21:45:34 +0000508 v9.CheckScriptFailure(lines, 'E1010:')
509 v9.CheckScriptFailure(lines, 'E1010:')
Bram Moolenaar648ea762021-01-15 19:04:32 +0100510enddef
511
Bram Moolenaarefc084e2021-09-09 22:30:52 +0200512def Test_return_list_any()
Bram Moolenaar114dbda2022-01-03 12:28:03 +0000513 # This used to fail but now the actual list type is checked, and since it has
514 # an item of type string it can be used as list<string>.
Bram Moolenaarefc084e2021-09-09 22:30:52 +0200515 var lines =<< trim END
516 vim9script
517 def Func(): list<string>
518 var l: list<any>
519 l->add('string')
520 return l
521 enddef
522 echo Func()
523 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000524 v9.CheckScriptSuccess(lines)
Bram Moolenaar114dbda2022-01-03 12:28:03 +0000525
Bram Moolenaarefc084e2021-09-09 22:30:52 +0200526 lines =<< trim END
527 vim9script
528 def Func(): list<string>
529 var l: list<any>
530 l += ['string']
531 return l
532 enddef
533 echo Func()
534 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000535 v9.CheckScriptSuccess(lines)
Bram Moolenaarefc084e2021-09-09 22:30:52 +0200536enddef
537
Bram Moolenaar1a572e92022-03-15 12:28:10 +0000538def Test_return_any_two_types()
539 var lines =<< trim END
540 vim9script
541
542 def G(Fn: func(string): any)
543 g:result = Fn("hello")
544 enddef
545
546 def F(a: number, b: string): any
547 echo b
548 if a > 0
549 return 1
550 else
551 return []
552 endif
553 enddef
554
555 G(function(F, [1]))
556 END
557 v9.CheckScriptSuccess(lines)
558 assert_equal(1, g:result)
559 unlet g:result
560enddef
561
Bram Moolenaar62aec932022-01-29 21:45:34 +0000562func s:Increment()
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200563 let g:counter += 1
564endfunc
565
566def Test_call_ufunc_count()
567 g:counter = 1
568 Increment()
569 Increment()
570 Increment()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200571 # works with and without :call
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200572 g:counter->assert_equal(4)
573 eval g:counter->assert_equal(4)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200574 unlet g:counter
575enddef
576
Bram Moolenaar1983f1a2022-02-28 20:55:02 +0000577def Test_call_ufunc_failure()
578 var lines =<< trim END
579 vim9script
580 def Tryit()
581 g:Global(1, 2, 3)
582 enddef
583
584 func g:Global(a, b, c)
585 echo a:a a:b a:c
586 endfunc
587
588 defcompile
589
590 func! g:Global(a, b)
591 echo a:a a:b
592 endfunc
593 Tryit()
594 END
595 v9.CheckScriptFailure(lines, 'E118: Too many arguments for function: Global')
596 delfunc g:Global
597
598 lines =<< trim END
599 vim9script
600
601 g:Ref = function('len')
602 def Tryit()
603 g:Ref('x')
604 enddef
605
606 defcompile
607
608 g:Ref = function('add')
609 Tryit()
610 END
611 v9.CheckScriptFailure(lines, 'E119: Not enough arguments for function: add')
612 unlet g:Ref
613enddef
614
Bram Moolenaar62aec932022-01-29 21:45:34 +0000615def s:MyVarargs(arg: string, ...rest: list<string>): string
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200616 var res = arg
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200617 for s in rest
618 res ..= ',' .. s
619 endfor
620 return res
621enddef
622
623def Test_call_varargs()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200624 MyVarargs('one')->assert_equal('one')
625 MyVarargs('one', 'two')->assert_equal('one,two')
626 MyVarargs('one', 'two', 'three')->assert_equal('one,two,three')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200627enddef
628
Bram Moolenaar01dd6c32021-09-05 16:36:23 +0200629def Test_call_white_space()
Bram Moolenaar62aec932022-01-29 21:45:34 +0000630 v9.CheckDefAndScriptFailure(["call Test ('text')"], ['E476:', 'E1068:'])
Bram Moolenaar01dd6c32021-09-05 16:36:23 +0200631enddef
632
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200633def MyDefaultArgs(name = 'string'): string
634 return name
635enddef
636
Bram Moolenaar62aec932022-01-29 21:45:34 +0000637def s:MyDefaultSecond(name: string, second: bool = true): string
Bram Moolenaare30f64b2020-07-15 19:48:20 +0200638 return second ? name : 'none'
639enddef
640
Bram Moolenaar38a3bfa2021-03-29 22:14:55 +0200641
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200642def Test_call_default_args()
Bram Moolenaar62aec932022-01-29 21:45:34 +0000643 g:MyDefaultArgs()->assert_equal('string')
644 g:MyDefaultArgs(v:none)->assert_equal('string')
645 g:MyDefaultArgs('one')->assert_equal('one')
646 assert_fails('g:MyDefaultArgs("one", "two")', 'E118:', '', 4, 'Test_call_default_args')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200647
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200648 MyDefaultSecond('test')->assert_equal('test')
649 MyDefaultSecond('test', true)->assert_equal('test')
650 MyDefaultSecond('test', false)->assert_equal('none')
Bram Moolenaare30f64b2020-07-15 19:48:20 +0200651
Bram Moolenaar38a3bfa2021-03-29 22:14:55 +0200652 var lines =<< trim END
653 def MyDefaultThird(name: string, aa = 'aa', bb = 'bb'): string
654 return name .. aa .. bb
655 enddef
656
657 MyDefaultThird('->')->assert_equal('->aabb')
658 MyDefaultThird('->', v:none)->assert_equal('->aabb')
659 MyDefaultThird('->', 'xx')->assert_equal('->xxbb')
660 MyDefaultThird('->', v:none, v:none)->assert_equal('->aabb')
661 MyDefaultThird('->', 'xx', v:none)->assert_equal('->xxbb')
662 MyDefaultThird('->', v:none, 'yy')->assert_equal('->aayy')
663 MyDefaultThird('->', 'xx', 'yy')->assert_equal('->xxyy')
Bram Moolenaare28d9b32021-07-03 18:56:53 +0200664
665 def DefArg(mandatory: any, optional = mandatory): string
666 return mandatory .. optional
667 enddef
668 DefArg(1234)->assert_equal('12341234')
669 DefArg("ok")->assert_equal('okok')
Bram Moolenaar38a3bfa2021-03-29 22:14:55 +0200670 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000671 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar38a3bfa2021-03-29 22:14:55 +0200672
Bram Moolenaar62aec932022-01-29 21:45:34 +0000673 v9.CheckScriptFailure(['def Func(arg: number = asdf)', 'enddef', 'defcompile'], 'E1001:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +0100674 delfunc g:Func
Bram Moolenaar62aec932022-01-29 21:45:34 +0000675 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 +0100676 delfunc g:Func
Bram Moolenaar62aec932022-01-29 21:45:34 +0000677 v9.CheckDefFailure(['def Func(x: number = )', 'enddef'], 'E15:')
Bram Moolenaar12bce952021-03-11 20:04:04 +0100678
Bram Moolenaar38a3bfa2021-03-29 22:14:55 +0200679 lines =<< trim END
Bram Moolenaar12bce952021-03-11 20:04:04 +0100680 vim9script
681 def Func(a = b == 0 ? 1 : 2, b = 0)
682 enddef
683 defcompile
684 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000685 v9.CheckScriptFailure(lines, 'E1001: Variable not found: b')
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000686
Bram Moolenaarfa46ead2021-12-22 13:18:39 +0000687 # using script variable requires matching type or type cast when executed
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000688 lines =<< trim END
689 vim9script
690 var a: any
691 def Func(arg: string = a)
692 echo arg
693 enddef
694 defcompile
695 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000696 v9.CheckScriptSuccess(lines + ['a = "text"', 'Func()'])
697 v9.CheckScriptFailure(lines + ['a = 123', 'Func()'], 'E1013: Argument 1: type mismatch, expected string but got number')
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000698
699 # using global variable does not require type cast
700 lines =<< trim END
701 vim9script
702 def Func(arg: string = g:str)
703 echo arg
704 enddef
705 g:str = 'works'
706 Func()
707 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000708 v9.CheckScriptSuccess(lines)
Bram Moolenaar04b12692020-05-04 23:24:44 +0200709enddef
710
Bram Moolenaar62aec932022-01-29 21:45:34 +0000711def s:FuncWithComment( # comment
Bram Moolenaarcef12702021-01-04 14:09:43 +0100712 a: number, #comment
713 b: bool, # comment
714 c: string) #comment
715 assert_equal(4, a)
716 assert_equal(true, b)
717 assert_equal('yes', c)
718enddef
719
720def Test_func_with_comments()
721 FuncWithComment(4, true, 'yes')
722
723 var lines =<< trim END
724 def Func(# comment
725 arg: string)
726 enddef
727 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000728 v9.CheckScriptFailure(lines, 'E125:', 1)
Bram Moolenaarcef12702021-01-04 14:09:43 +0100729
730 lines =<< trim END
731 def Func(
732 arg: string# comment
733 )
734 enddef
735 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000736 v9.CheckScriptFailure(lines, 'E475:', 2)
Bram Moolenaarcef12702021-01-04 14:09:43 +0100737
738 lines =<< trim END
739 def Func(
740 arg: string
741 )# comment
742 enddef
743 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000744 v9.CheckScriptFailure(lines, 'E488:', 3)
Bram Moolenaarcef12702021-01-04 14:09:43 +0100745enddef
746
Bram Moolenaar04b12692020-05-04 23:24:44 +0200747def Test_nested_function()
Bram Moolenaar38453522021-11-28 22:00:12 +0000748 def NestedDef(arg: string): string
Bram Moolenaar04b12692020-05-04 23:24:44 +0200749 return 'nested ' .. arg
750 enddef
Bram Moolenaar38453522021-11-28 22:00:12 +0000751 NestedDef(':def')->assert_equal('nested :def')
752
753 func NestedFunc(arg)
754 return 'nested ' .. a:arg
755 endfunc
756 NestedFunc(':func')->assert_equal('nested :func')
Bram Moolenaar04b12692020-05-04 23:24:44 +0200757
Bram Moolenaar62aec932022-01-29 21:45:34 +0000758 v9.CheckDefFailure(['def Nested()', 'enddef', 'Nested(66)'], 'E118:')
759 v9.CheckDefFailure(['def Nested(arg: string)', 'enddef', 'Nested()'], 'E119:')
Bram Moolenaar0e65d3d2020-05-05 17:53:16 +0200760
Bram Moolenaar62aec932022-01-29 21:45:34 +0000761 v9.CheckDefFailure(['def s:Nested()', 'enddef'], 'E1075:')
762 v9.CheckDefFailure(['def b:Nested()', 'enddef'], 'E1075:')
Bram Moolenaar8b848ca2020-09-10 22:28:01 +0200763
Bram Moolenaar54021752020-12-06 18:50:36 +0100764 var lines =<< trim END
765 def Outer()
766 def Inner()
767 # comment
768 enddef
769 def Inner()
770 enddef
771 enddef
772 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000773 v9.CheckDefFailure(lines, 'E1073:')
Bram Moolenaar54021752020-12-06 18:50:36 +0100774
775 lines =<< trim END
776 def Outer()
777 def Inner()
778 # comment
779 enddef
780 def! Inner()
781 enddef
782 enddef
783 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000784 v9.CheckDefFailure(lines, 'E1117:')
Bram Moolenaar54021752020-12-06 18:50:36 +0100785
Bram Moolenaardb8e5c22021-12-25 19:58:22 +0000786 lines =<< trim END
787 vim9script
788 def Outer()
789 def Inner()
790 g:result = 'ok'
791 enddef
792 Inner()
793 enddef
794 Outer()
795 Inner()
796 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000797 v9.CheckScriptFailure(lines, 'E117: Unknown function: Inner')
Bram Moolenaardb8e5c22021-12-25 19:58:22 +0000798 assert_equal('ok', g:result)
799 unlet g:result
800
Bram Moolenaarf681cfb2022-02-07 20:30:57 +0000801 lines =<< trim END
802 vim9script
803 def Outer()
804 def _Inner()
805 echo 'bad'
806 enddef
Bram Moolenaar3787f262022-02-07 21:54:01 +0000807 _Inner()
Bram Moolenaarf681cfb2022-02-07 20:30:57 +0000808 enddef
809 defcompile
810 END
Bram Moolenaar3787f262022-02-07 21:54:01 +0000811 v9.CheckScriptFailure(lines, 'E1267:')
Bram Moolenaarf681cfb2022-02-07 20:30:57 +0000812
813 lines =<< trim END
814 vim9script
815 def Outer()
816 def g:inner()
817 echo 'bad'
818 enddef
Bram Moolenaar3787f262022-02-07 21:54:01 +0000819 g:inner()
Bram Moolenaarf681cfb2022-02-07 20:30:57 +0000820 enddef
821 defcompile
822 END
Bram Moolenaar3787f262022-02-07 21:54:01 +0000823 v9.CheckScriptFailure(lines, 'E1267:')
824
825 lines =<< trim END
826 vim9script
827 def g:_Func()
828 echo 'bad'
829 enddef
830 END
831 v9.CheckScriptFailure(lines, 'E1267:')
832
833 lines =<< trim END
834 vim9script
Bram Moolenaara749a422022-02-12 19:52:25 +0000835 def _Func()
Bram Moolenaar3787f262022-02-07 21:54:01 +0000836 echo 'bad'
837 enddef
838 END
839 v9.CheckScriptFailure(lines, 'E1267:')
Bram Moolenaarf681cfb2022-02-07 20:30:57 +0000840
Bram Moolenaar54021752020-12-06 18:50:36 +0100841 # nested function inside conditional
Bram Moolenaar54021752020-12-06 18:50:36 +0100842 lines =<< trim END
843 vim9script
844 var thecount = 0
845 if true
846 def Test(): number
847 def TheFunc(): number
848 thecount += 1
849 return thecount
850 enddef
851 return TheFunc()
852 enddef
853 endif
854 defcompile
855 assert_equal(1, Test())
856 assert_equal(2, Test())
857 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000858 v9.CheckScriptSuccess(lines)
Bram Moolenaar8863bda2021-03-17 18:42:08 +0100859
860 # also works when "thecount" is inside the "if" block
861 lines =<< trim END
862 vim9script
863 if true
864 var thecount = 0
865 def Test(): number
866 def TheFunc(): number
867 thecount += 1
868 return thecount
869 enddef
870 return TheFunc()
871 enddef
872 endif
873 defcompile
874 assert_equal(1, Test())
875 assert_equal(2, Test())
876 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000877 v9.CheckScriptSuccess(lines)
Bram Moolenaar4bba16d2021-08-15 19:28:05 +0200878
Bram Moolenaara915fa02022-03-23 11:29:15 +0000879 # nested function with recursive call
880 lines =<< trim END
881 vim9script
882
883 def MyFunc(): number
884 def Fib(n: number): number
885 if n < 2
886 return 1
887 endif
888 return Fib(n - 2) + Fib(n - 1)
889 enddef
890
891 return Fib(5)
892 enddef
893
894 assert_equal(8, MyFunc())
895 END
896 v9.CheckScriptSuccess(lines)
897
Bram Moolenaar4bba16d2021-08-15 19:28:05 +0200898 lines =<< trim END
899 vim9script
900 def Outer()
901 def Inner()
902 echo 'hello'
903 enddef burp
904 enddef
905 defcompile
906 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000907 v9.CheckScriptFailure(lines, 'E1173: Text found after enddef: burp', 3)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200908enddef
909
Bram Moolenaaradc8e442020-12-31 18:28:18 +0100910def Test_not_nested_function()
911 echo printf('%d',
912 function('len')('xxx'))
913enddef
914
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200915func Test_call_default_args_from_func()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200916 call MyDefaultArgs()->assert_equal('string')
917 call MyDefaultArgs('one')->assert_equal('one')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +0200918 call assert_fails('call MyDefaultArgs("one", "two")', 'E118:', '', 3, 'Test_call_default_args_from_func')
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200919endfunc
920
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200921def Test_nested_global_function()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200922 var lines =<< trim END
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200923 vim9script
924 def Outer()
925 def g:Inner(): string
926 return 'inner'
927 enddef
928 enddef
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200929 defcompile
930 Outer()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200931 g:Inner()->assert_equal('inner')
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200932 delfunc g:Inner
933 Outer()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200934 g:Inner()->assert_equal('inner')
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200935 delfunc g:Inner
936 Outer()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200937 g:Inner()->assert_equal('inner')
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200938 delfunc g:Inner
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200939 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000940 v9.CheckScriptSuccess(lines)
Bram Moolenaar2c79e9d2020-08-01 18:57:52 +0200941
942 lines =<< trim END
943 vim9script
944 def Outer()
Bram Moolenaar38453522021-11-28 22:00:12 +0000945 func g:Inner()
946 return 'inner'
947 endfunc
948 enddef
949 defcompile
950 Outer()
951 g:Inner()->assert_equal('inner')
952 delfunc g:Inner
953 Outer()
954 g:Inner()->assert_equal('inner')
955 delfunc g:Inner
956 Outer()
957 g:Inner()->assert_equal('inner')
958 delfunc g:Inner
959 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000960 v9.CheckScriptSuccess(lines)
Bram Moolenaar38453522021-11-28 22:00:12 +0000961
962 lines =<< trim END
963 vim9script
964 def Outer()
Bram Moolenaar2c79e9d2020-08-01 18:57:52 +0200965 def g:Inner(): string
966 return 'inner'
967 enddef
968 enddef
969 defcompile
970 Outer()
971 Outer()
972 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000973 v9.CheckScriptFailure(lines, "E122:")
Bram Moolenaarcd45ed02020-12-22 17:35:54 +0100974 delfunc g:Inner
Bram Moolenaarad486a02020-08-01 23:22:18 +0200975
976 lines =<< trim END
977 vim9script
Bram Moolenaar58a52f22020-12-22 18:56:55 +0100978 def Outer()
979 def g:Inner()
Bram Moolenaar2949cfd2020-12-31 21:28:47 +0100980 echo map([1, 2, 3], (_, v) => v + 1)
Bram Moolenaar58a52f22020-12-22 18:56:55 +0100981 enddef
982 g:Inner()
983 enddef
984 Outer()
985 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000986 v9.CheckScriptSuccess(lines)
Bram Moolenaar58a52f22020-12-22 18:56:55 +0100987 delfunc g:Inner
988
989 lines =<< trim END
990 vim9script
Bram Moolenaarad486a02020-08-01 23:22:18 +0200991 def Func()
992 echo 'script'
993 enddef
994 def Outer()
995 def Func()
996 echo 'inner'
997 enddef
998 enddef
999 defcompile
1000 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001001 v9.CheckScriptFailure(lines, "E1073:", 1)
Bram Moolenaard604d782021-11-20 21:46:20 +00001002
1003 lines =<< trim END
1004 vim9script
1005 def Func()
1006 echo 'script'
1007 enddef
1008 def Func()
1009 echo 'script'
1010 enddef
1011 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001012 v9.CheckScriptFailure(lines, "E1073:", 5)
Bram Moolenaar38ddf332020-07-31 22:05:04 +02001013enddef
1014
Bram Moolenaar6abdcf82020-11-22 18:15:44 +01001015def DefListAll()
1016 def
1017enddef
1018
1019def DefListOne()
1020 def DefListOne
1021enddef
1022
1023def DefListMatches()
1024 def /DefList
1025enddef
1026
1027def Test_nested_def_list()
1028 var funcs = split(execute('call DefListAll()'), "\n")
1029 assert_true(len(funcs) > 10)
1030 assert_true(funcs->index('def DefListAll()') >= 0)
1031
1032 funcs = split(execute('call DefListOne()'), "\n")
1033 assert_equal([' def DefListOne()', '1 def DefListOne', ' enddef'], funcs)
1034
1035 funcs = split(execute('call DefListMatches()'), "\n")
1036 assert_true(len(funcs) >= 3)
1037 assert_true(funcs->index('def DefListAll()') >= 0)
1038 assert_true(funcs->index('def DefListOne()') >= 0)
1039 assert_true(funcs->index('def DefListMatches()') >= 0)
Bram Moolenaar54021752020-12-06 18:50:36 +01001040
1041 var lines =<< trim END
1042 vim9script
1043 def Func()
1044 def +Func+
1045 enddef
1046 defcompile
1047 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001048 v9.CheckScriptFailure(lines, 'E476:', 1)
Bram Moolenaar6abdcf82020-11-22 18:15:44 +01001049enddef
1050
Bram Moolenaare08be092022-02-17 13:08:26 +00001051def Test_global_function_not_found()
1052 var lines =<< trim END
1053 g:Ref = 123
1054 call g:Ref()
1055 END
1056 v9.CheckDefExecAndScriptFailure(lines, ['E117:', 'E1085:'], 2)
1057enddef
1058
Bram Moolenaar333894b2020-08-01 18:53:07 +02001059def Test_global_local_function()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001060 var lines =<< trim END
Bram Moolenaar333894b2020-08-01 18:53:07 +02001061 vim9script
1062 def g:Func(): string
1063 return 'global'
1064 enddef
1065 def Func(): string
1066 return 'local'
1067 enddef
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001068 g:Func()->assert_equal('global')
1069 Func()->assert_equal('local')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001070 delfunc g:Func
Bram Moolenaar333894b2020-08-01 18:53:07 +02001071 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001072 v9.CheckScriptSuccess(lines)
Bram Moolenaar035d6e92020-08-11 22:30:42 +02001073
1074 lines =<< trim END
1075 vim9script
1076 def g:Funcy()
1077 echo 'funcy'
1078 enddef
Bram Moolenaara749a422022-02-12 19:52:25 +00001079 Funcy()
Bram Moolenaar035d6e92020-08-11 22:30:42 +02001080 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001081 v9.CheckScriptFailure(lines, 'E117:')
Bram Moolenaar333894b2020-08-01 18:53:07 +02001082enddef
1083
Bram Moolenaar0f769812020-09-12 18:32:34 +02001084def Test_local_function_shadows_global()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001085 var lines =<< trim END
Bram Moolenaar0f769812020-09-12 18:32:34 +02001086 vim9script
1087 def g:Gfunc(): string
1088 return 'global'
1089 enddef
1090 def AnotherFunc(): number
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001091 var Gfunc = function('len')
Bram Moolenaar0f769812020-09-12 18:32:34 +02001092 return Gfunc('testing')
1093 enddef
1094 g:Gfunc()->assert_equal('global')
1095 AnotherFunc()->assert_equal(7)
1096 delfunc g:Gfunc
1097 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001098 v9.CheckScriptSuccess(lines)
Bram Moolenaar0f769812020-09-12 18:32:34 +02001099
1100 lines =<< trim END
1101 vim9script
1102 def g:Func(): string
1103 return 'global'
1104 enddef
1105 def AnotherFunc()
1106 g:Func = function('len')
1107 enddef
1108 AnotherFunc()
1109 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001110 v9.CheckScriptFailure(lines, 'E705:')
Bram Moolenaar0f769812020-09-12 18:32:34 +02001111 delfunc g:Func
Bram Moolenaar0865b152021-04-05 15:38:51 +02001112
Bram Moolenaar62aec932022-01-29 21:45:34 +00001113 # global function is not found with g: prefix
Bram Moolenaar0865b152021-04-05 15:38:51 +02001114 lines =<< trim END
1115 vim9script
1116 def g:Func(): string
1117 return 'global'
1118 enddef
1119 def AnotherFunc(): string
1120 return Func()
1121 enddef
1122 assert_equal('global', AnotherFunc())
Bram Moolenaar0865b152021-04-05 15:38:51 +02001123 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001124 v9.CheckScriptFailure(lines, 'E117:')
1125 delfunc g:Func
Bram Moolenaar0865b152021-04-05 15:38:51 +02001126
1127 lines =<< trim END
1128 vim9script
1129 def g:Func(): string
1130 return 'global'
1131 enddef
Bram Moolenaar848fadd2022-01-30 15:28:30 +00001132 assert_equal('global', g:Func())
Bram Moolenaar0865b152021-04-05 15:38:51 +02001133 delfunc g:Func
1134 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001135 v9.CheckScriptSuccess(lines)
Bram Moolenaar58493cf2022-01-06 12:23:30 +00001136
1137 # This does not shadow "i" which is visible only inside the for loop
1138 lines =<< trim END
1139 vim9script
1140
1141 def Foo(i: number)
1142 echo i
1143 enddef
1144
1145 for i in range(3)
1146 # Foo() is compiled here
1147 Foo(i)
1148 endfor
1149 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001150 v9.CheckScriptSuccess(lines)
Bram Moolenaar0f769812020-09-12 18:32:34 +02001151enddef
1152
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001153func TakesOneArg(arg)
1154 echo a:arg
1155endfunc
1156
1157def Test_call_wrong_args()
Bram Moolenaar62aec932022-01-29 21:45:34 +00001158 v9.CheckDefFailure(['g:TakesOneArg()'], 'E119:')
1159 v9.CheckDefFailure(['g:TakesOneArg(11, 22)'], 'E118:')
1160 v9.CheckDefFailure(['bufnr(xxx)'], 'E1001:')
1161 v9.CheckScriptFailure(['def Func(Ref: func(s: string))'], 'E475:')
Bram Moolenaaree8580e2020-08-28 17:19:07 +02001162
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001163 var lines =<< trim END
Bram Moolenaaree8580e2020-08-28 17:19:07 +02001164 vim9script
1165 def Func(s: string)
1166 echo s
1167 enddef
1168 Func([])
1169 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001170 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected string but got list<unknown>', 5)
Bram Moolenaarb185a402020-09-18 22:42:00 +02001171
Bram Moolenaar9a015112021-12-31 14:06:45 +00001172 # argument name declared earlier is found when declaring a function
Bram Moolenaarb185a402020-09-18 22:42:00 +02001173 lines =<< trim END
1174 vim9script
Bram Moolenaarb4893b82021-02-21 22:20:24 +01001175 var name = 'piet'
1176 def FuncOne(name: string)
Bram Moolenaar3a5988c2022-02-08 19:23:35 +00001177 echo name
Bram Moolenaarb4893b82021-02-21 22:20:24 +01001178 enddef
1179 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001180 v9.CheckScriptFailure(lines, 'E1168:')
Bram Moolenaarb4893b82021-02-21 22:20:24 +01001181
Bram Moolenaar3a5988c2022-02-08 19:23:35 +00001182 # same, inside the same block
1183 lines =<< trim END
1184 vim9script
1185 if true
1186 var name = 'piet'
1187 def FuncOne(name: string)
1188 echo name
1189 enddef
1190 endif
1191 END
1192 v9.CheckScriptFailure(lines, 'E1168:')
1193
1194 # variable in other block is OK
1195 lines =<< trim END
1196 vim9script
1197 if true
1198 var name = 'piet'
1199 endif
1200 def FuncOne(name: string)
1201 echo name
1202 enddef
1203 END
1204 v9.CheckScriptSuccess(lines)
1205
Bram Moolenaardce24412022-02-08 20:35:30 +00001206 # with another variable in another block
1207 lines =<< trim END
1208 vim9script
1209 if true
1210 var name = 'piet'
1211 # define a function so that the variable isn't cleared
1212 def GetItem(): string
1213 return item
1214 enddef
1215 endif
1216 if true
1217 var name = 'peter'
1218 def FuncOne(name: string)
1219 echo name
1220 enddef
1221 endif
1222 END
1223 v9.CheckScriptFailure(lines, 'E1168:')
1224
1225 # only variable in another block is OK
1226 lines =<< trim END
1227 vim9script
1228 if true
1229 var name = 'piet'
1230 # define a function so that the variable isn't cleared
1231 def GetItem(): string
1232 return item
1233 enddef
1234 endif
1235 if true
1236 def FuncOne(name: string)
1237 echo name
1238 enddef
1239 endif
1240 END
1241 v9.CheckScriptSuccess(lines)
1242
Bram Moolenaar9a015112021-12-31 14:06:45 +00001243 # argument name declared later is only found when compiling
1244 lines =<< trim END
1245 vim9script
1246 def FuncOne(name: string)
1247 echo nr
1248 enddef
1249 var name = 'piet'
1250 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001251 v9.CheckScriptSuccess(lines)
1252 v9.CheckScriptFailure(lines + ['defcompile'], 'E1168:')
Bram Moolenaar9a015112021-12-31 14:06:45 +00001253
Bram Moolenaarb4893b82021-02-21 22:20:24 +01001254 lines =<< trim END
1255 vim9script
Bram Moolenaarb185a402020-09-18 22:42:00 +02001256 def FuncOne(nr: number)
1257 echo nr
1258 enddef
1259 def FuncTwo()
1260 FuncOne()
1261 enddef
1262 defcompile
1263 END
1264 writefile(lines, 'Xscript')
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001265 var didCatch = false
Bram Moolenaarb185a402020-09-18 22:42:00 +02001266 try
1267 source Xscript
1268 catch
1269 assert_match('E119: Not enough arguments for function: <SNR>\d\+_FuncOne', v:exception)
1270 assert_match('Xscript\[8\]..function <SNR>\d\+_FuncTwo, line 1', v:throwpoint)
1271 didCatch = true
1272 endtry
1273 assert_true(didCatch)
1274
1275 lines =<< trim END
1276 vim9script
1277 def FuncOne(nr: number)
1278 echo nr
1279 enddef
1280 def FuncTwo()
1281 FuncOne(1, 2)
1282 enddef
1283 defcompile
1284 END
1285 writefile(lines, 'Xscript')
1286 didCatch = false
1287 try
1288 source Xscript
1289 catch
1290 assert_match('E118: Too many arguments for function: <SNR>\d\+_FuncOne', v:exception)
1291 assert_match('Xscript\[8\]..function <SNR>\d\+_FuncTwo, line 1', v:throwpoint)
1292 didCatch = true
1293 endtry
1294 assert_true(didCatch)
1295
1296 delete('Xscript')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001297enddef
1298
Bram Moolenaar50824712020-12-20 21:10:17 +01001299def Test_call_funcref_wrong_args()
1300 var head =<< trim END
1301 vim9script
1302 def Func3(a1: string, a2: number, a3: list<number>)
1303 echo a1 .. a2 .. a3[0]
1304 enddef
1305 def Testme()
1306 var funcMap: dict<func> = {func: Func3}
1307 END
1308 var tail =<< trim END
1309 enddef
1310 Testme()
1311 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001312 v9.CheckScriptSuccess(head + ["funcMap['func']('str', 123, [1, 2, 3])"] + tail)
Bram Moolenaar50824712020-12-20 21:10:17 +01001313
Bram Moolenaar62aec932022-01-29 21:45:34 +00001314 v9.CheckScriptFailure(head + ["funcMap['func']('str', 123)"] + tail, 'E119:')
1315 v9.CheckScriptFailure(head + ["funcMap['func']('str', 123, [1], 4)"] + tail, 'E118:')
Bram Moolenaar32b3f822021-01-06 21:59:39 +01001316
1317 var lines =<< trim END
1318 vim9script
1319 var Ref: func(number): any
1320 Ref = (j) => !j
1321 echo Ref(false)
1322 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001323 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected number but got bool', 4)
Bram Moolenaar32b3f822021-01-06 21:59:39 +01001324
1325 lines =<< trim END
1326 vim9script
1327 var Ref: func(number): any
1328 Ref = (j) => !j
1329 call Ref(false)
1330 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001331 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected number but got bool', 4)
Bram Moolenaar50824712020-12-20 21:10:17 +01001332enddef
1333
Bram Moolenaarb4d16cb2020-11-05 18:45:46 +01001334def Test_call_lambda_args()
Bram Moolenaar2a389082021-04-09 20:24:31 +02001335 var lines =<< trim END
1336 var Callback = (..._) => 'anything'
1337 assert_equal('anything', Callback())
1338 assert_equal('anything', Callback(1))
1339 assert_equal('anything', Callback('a', 2))
Bram Moolenaar1088b692021-04-09 22:12:44 +02001340
1341 assert_equal('xyz', ((a: string): string => a)('xyz'))
Bram Moolenaar2a389082021-04-09 20:24:31 +02001342 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001343 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar2a389082021-04-09 20:24:31 +02001344
Bram Moolenaar62aec932022-01-29 21:45:34 +00001345 v9.CheckDefFailure(['echo ((i) => 0)()'],
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001346 'E119: Not enough arguments for function: ((i) => 0)()')
Bram Moolenaarb4d16cb2020-11-05 18:45:46 +01001347
Bram Moolenaar2a389082021-04-09 20:24:31 +02001348 lines =<< trim END
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001349 var Ref = (x: number, y: number) => x + y
Bram Moolenaarb4d16cb2020-11-05 18:45:46 +01001350 echo Ref(1, 'x')
1351 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001352 v9.CheckDefFailure(lines, 'E1013: Argument 2: type mismatch, expected number but got string')
Bram Moolenaare68b02a2021-01-03 13:09:51 +01001353
1354 lines =<< trim END
1355 var Ref: func(job, string, number)
1356 Ref = (x, y) => 0
1357 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001358 v9.CheckDefAndScriptFailure(lines, 'E1012:')
Bram Moolenaare68b02a2021-01-03 13:09:51 +01001359
1360 lines =<< trim END
1361 var Ref: func(job, string)
1362 Ref = (x, y, z) => 0
1363 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001364 v9.CheckDefAndScriptFailure(lines, 'E1012:')
Bram Moolenaar057e84a2021-02-28 16:55:11 +01001365
1366 lines =<< trim END
1367 var one = 1
1368 var l = [1, 2, 3]
1369 echo map(l, (one) => one)
1370 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001371 v9.CheckDefFailure(lines, 'E1167:')
1372 v9.CheckScriptFailure(['vim9script'] + lines, 'E1168:')
Bram Moolenaar057e84a2021-02-28 16:55:11 +01001373
1374 lines =<< trim END
Bram Moolenaar14ded112021-06-26 19:25:49 +02001375 var Ref: func(any, ?any): bool
1376 Ref = (_, y = 1) => false
1377 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001378 v9.CheckDefAndScriptFailure(lines, 'E1172:')
Bram Moolenaar14ded112021-06-26 19:25:49 +02001379
1380 lines =<< trim END
Bram Moolenaar015cf102021-06-26 21:52:02 +02001381 var a = 0
1382 var b = (a == 0 ? 1 : 2)
1383 assert_equal(1, b)
Bram Moolenaar98f9a5f2021-06-26 22:22:38 +02001384 var txt = 'a'
1385 b = (txt =~ 'x' ? 1 : 2)
1386 assert_equal(2, b)
Bram Moolenaar015cf102021-06-26 21:52:02 +02001387 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001388 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar015cf102021-06-26 21:52:02 +02001389
1390 lines =<< trim END
Bram Moolenaar057e84a2021-02-28 16:55:11 +01001391 def ShadowLocal()
1392 var one = 1
1393 var l = [1, 2, 3]
1394 echo map(l, (one) => one)
1395 enddef
1396 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001397 v9.CheckDefFailure(lines, 'E1167:')
Bram Moolenaar057e84a2021-02-28 16:55:11 +01001398
1399 lines =<< trim END
1400 def Shadowarg(one: number)
1401 var l = [1, 2, 3]
1402 echo map(l, (one) => one)
1403 enddef
1404 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001405 v9.CheckDefFailure(lines, 'E1167:')
Bram Moolenaar767034c2021-04-09 17:24:52 +02001406
1407 lines =<< trim END
1408 echo ((a) => a)('aa', 'bb')
1409 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001410 v9.CheckDefAndScriptFailure(lines, 'E118:', 1)
Bram Moolenaarc4c56422021-07-21 20:38:46 +02001411
1412 lines =<< trim END
1413 echo 'aa'->((a) => a)('bb')
1414 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001415 v9.CheckDefFailure(lines, 'E118: Too many arguments for function: ->((a) => a)(''bb'')', 1)
1416 v9.CheckScriptFailure(['vim9script'] + lines, 'E118: Too many arguments for function: <lambda>', 2)
Bram Moolenaarb4d16cb2020-11-05 18:45:46 +01001417enddef
1418
Bram Moolenaara755fdb2021-11-20 21:35:41 +00001419def Test_lambda_line_nr()
1420 var lines =<< trim END
1421 vim9script
1422 # comment
1423 # comment
1424 var id = timer_start(1'000, (_) => 0)
1425 var out = execute('verbose ' .. timer_info(id)[0].callback
1426 ->string()
1427 ->substitute("('\\|')", ' ', 'g'))
1428 assert_match('Last set from .* line 4', out)
1429 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001430 v9.CheckScriptSuccess(lines)
Bram Moolenaara755fdb2021-11-20 21:35:41 +00001431enddef
1432
Bram Moolenaar5f91e742021-03-17 21:29:29 +01001433def FilterWithCond(x: string, Cond: func(string): bool): bool
1434 return Cond(x)
1435enddef
1436
Bram Moolenaar0346b792021-01-31 22:18:29 +01001437def Test_lambda_return_type()
1438 var lines =<< trim END
1439 var Ref = (): => 123
1440 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001441 v9.CheckDefAndScriptFailure(lines, 'E1157:', 1)
Bram Moolenaar5f91e742021-03-17 21:29:29 +01001442
Yegappan Lakshmanan611728f2021-05-24 15:15:47 +02001443 # no space before the return type
1444 lines =<< trim END
1445 var Ref = (x):number => x + 1
1446 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001447 v9.CheckDefAndScriptFailure(lines, 'E1069:', 1)
Yegappan Lakshmanan611728f2021-05-24 15:15:47 +02001448
Bram Moolenaar5f91e742021-03-17 21:29:29 +01001449 # this works
1450 for x in ['foo', 'boo']
Bram Moolenaar62aec932022-01-29 21:45:34 +00001451 echo g:FilterWithCond(x, (v) => v =~ '^b')
Bram Moolenaar5f91e742021-03-17 21:29:29 +01001452 endfor
1453
1454 # this fails
1455 lines =<< trim END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001456 echo g:FilterWithCond('foo', (v) => v .. '^b')
Bram Moolenaar5f91e742021-03-17 21:29:29 +01001457 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001458 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 +02001459
1460 lines =<< trim END
1461 var Lambda1 = (x) => {
1462 return x
1463 }
1464 assert_equal('asdf', Lambda1('asdf'))
1465 var Lambda2 = (x): string => {
1466 return x
1467 }
1468 assert_equal('foo', Lambda2('foo'))
1469 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001470 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaara9931532021-06-12 15:58:16 +02001471
1472 lines =<< trim END
1473 var Lambda = (x): string => {
1474 return x
1475 }
1476 echo Lambda(['foo'])
1477 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001478 v9.CheckDefExecAndScriptFailure(lines, 'E1012:')
Bram Moolenaar0346b792021-01-31 22:18:29 +01001479enddef
1480
Bram Moolenaar709664c2020-12-12 14:33:41 +01001481def Test_lambda_uses_assigned_var()
Bram Moolenaar62aec932022-01-29 21:45:34 +00001482 v9.CheckDefSuccess([
Bram Moolenaar709664c2020-12-12 14:33:41 +01001483 'var x: any = "aaa"'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001484 'x = filter(["bbb"], (_, v) => v =~ x)'])
Bram Moolenaar709664c2020-12-12 14:33:41 +01001485enddef
1486
Bram Moolenaar18062fc2021-03-05 21:35:47 +01001487def Test_pass_legacy_lambda_to_def_func()
1488 var lines =<< trim END
1489 vim9script
1490 func Foo()
1491 eval s:Bar({x -> 0})
1492 endfunc
1493 def Bar(y: any)
1494 enddef
1495 Foo()
1496 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001497 v9.CheckScriptSuccess(lines)
Bram Moolenaar831bdf82021-06-22 19:32:17 +02001498
1499 lines =<< trim END
1500 vim9script
Bram Moolenaar1d9cef72022-03-17 16:30:03 +00001501 def g:TestFunc(F: func)
Bram Moolenaar831bdf82021-06-22 19:32:17 +02001502 enddef
1503 legacy call g:TestFunc({-> 0})
1504 delfunc g:TestFunc
1505
Bram Moolenaar1d9cef72022-03-17 16:30:03 +00001506 def g:TestFunc(F: func(number))
Bram Moolenaar831bdf82021-06-22 19:32:17 +02001507 enddef
1508 legacy call g:TestFunc({nr -> 0})
1509 delfunc g:TestFunc
1510 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001511 v9.CheckScriptSuccess(lines)
Bram Moolenaar18062fc2021-03-05 21:35:47 +01001512enddef
1513
Bram Moolenaar844fb642021-10-23 13:32:30 +01001514def Test_lambda_in_reduce_line_break()
1515 # this was using freed memory
1516 var lines =<< trim END
1517 vim9script
1518 const result: dict<number> =
1519 ['Bob', 'Sam', 'Cat', 'Bob', 'Cat', 'Cat']
1520 ->reduce((acc, val) => {
1521 if has_key(acc, val)
1522 acc[val] += 1
1523 return acc
1524 else
1525 acc[val] = 1
1526 return acc
1527 endif
1528 }, {})
1529 assert_equal({Bob: 2, Sam: 1, Cat: 3}, result)
1530 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001531 v9.CheckScriptSuccess(lines)
Bram Moolenaar844fb642021-10-23 13:32:30 +01001532enddef
1533
Bram Moolenaardcb53be2021-12-09 14:23:43 +00001534def Test_set_opfunc_to_lambda()
1535 var lines =<< trim END
1536 vim9script
1537 nnoremap <expr> <F4> <SID>CountSpaces() .. '_'
1538 def CountSpaces(type = ''): string
1539 if type == ''
1540 &operatorfunc = (t) => CountSpaces(t)
1541 return 'g@'
1542 endif
1543 normal! '[V']y
1544 g:result = getreg('"')->count(' ')
1545 return ''
1546 enddef
1547 new
1548 'a b c d e'->setline(1)
1549 feedkeys("\<F4>", 'x')
1550 assert_equal(4, g:result)
1551 bwipe!
1552 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001553 v9.CheckScriptSuccess(lines)
Bram Moolenaardcb53be2021-12-09 14:23:43 +00001554enddef
1555
Bram Moolenaaref082e12021-12-12 21:02:03 +00001556def Test_set_opfunc_to_global_function()
1557 var lines =<< trim END
1558 vim9script
1559 def g:CountSpaces(type = ''): string
1560 normal! '[V']y
1561 g:result = getreg('"')->count(' ')
1562 return ''
1563 enddef
Bram Moolenaarb15cf442021-12-16 15:49:43 +00001564 # global function works at script level
Bram Moolenaaref082e12021-12-12 21:02:03 +00001565 &operatorfunc = g:CountSpaces
1566 new
1567 'a b c d e'->setline(1)
1568 feedkeys("g@_", 'x')
1569 assert_equal(4, g:result)
Bram Moolenaarb15cf442021-12-16 15:49:43 +00001570
1571 &operatorfunc = ''
1572 g:result = 0
1573 # global function works in :def function
1574 def Func()
1575 &operatorfunc = g:CountSpaces
1576 enddef
1577 Func()
1578 feedkeys("g@_", 'x')
1579 assert_equal(4, g:result)
1580
Bram Moolenaaref082e12021-12-12 21:02:03 +00001581 bwipe!
1582 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001583 v9.CheckScriptSuccess(lines)
Bram Moolenaaref082e12021-12-12 21:02:03 +00001584 &operatorfunc = ''
1585enddef
1586
Bram Moolenaar33b968d2021-12-13 11:31:04 +00001587def Test_use_script_func_name_with_prefix()
1588 var lines =<< trim END
1589 vim9script
Bram Moolenaara749a422022-02-12 19:52:25 +00001590 func g:Getit()
Bram Moolenaar33b968d2021-12-13 11:31:04 +00001591 return 'it'
1592 endfunc
Bram Moolenaara749a422022-02-12 19:52:25 +00001593 var Fn = g:Getit
Bram Moolenaar33b968d2021-12-13 11:31:04 +00001594 assert_equal('it', Fn())
1595 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001596 v9.CheckScriptSuccess(lines)
Bram Moolenaar33b968d2021-12-13 11:31:04 +00001597enddef
1598
Bram Moolenaardd297bc2021-12-10 10:37:38 +00001599def Test_lambda_type_allocated()
1600 # Check that unreferencing a partial using a lambda can use the variable type
1601 # after the lambda has been freed and does not leak memory.
1602 var lines =<< trim END
1603 vim9script
1604
1605 func MyomniFunc1(val, findstart, base)
1606 return a:findstart ? 0 : []
1607 endfunc
1608
1609 var Lambda = (a, b) => MyomniFunc1(19, a, b)
1610 &omnifunc = Lambda
1611 Lambda = (a, b) => MyomniFunc1(20, a, b)
1612 &omnifunc = string(Lambda)
1613 Lambda = (a, b) => strlen(a)
1614 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001615 v9.CheckScriptSuccess(lines)
Bram Moolenaardd297bc2021-12-10 10:37:38 +00001616enddef
1617
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001618" Default arg and varargs
1619def MyDefVarargs(one: string, two = 'foo', ...rest: list<string>): string
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001620 var res = one .. ',' .. two
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001621 for s in rest
1622 res ..= ',' .. s
1623 endfor
1624 return res
1625enddef
1626
1627def Test_call_def_varargs()
Bram Moolenaar62aec932022-01-29 21:45:34 +00001628 assert_fails('g:MyDefVarargs()', 'E119:', '', 1, 'Test_call_def_varargs')
1629 g:MyDefVarargs('one')->assert_equal('one,foo')
1630 g:MyDefVarargs('one', 'two')->assert_equal('one,two')
1631 g:MyDefVarargs('one', 'two', 'three')->assert_equal('one,two,three')
1632 v9.CheckDefFailure(['g:MyDefVarargs("one", 22)'],
Bram Moolenaar77072282020-09-16 17:55:40 +02001633 'E1013: Argument 2: type mismatch, expected string but got number')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001634 v9.CheckDefFailure(['g:MyDefVarargs("one", "two", 123)'],
Bram Moolenaar77072282020-09-16 17:55:40 +02001635 'E1013: Argument 3: type mismatch, expected string but got number')
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001636
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001637 var lines =<< trim END
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001638 vim9script
1639 def Func(...l: list<string>)
1640 echo l
1641 enddef
1642 Func('a', 'b', 'c')
1643 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001644 v9.CheckScriptSuccess(lines)
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001645
1646 lines =<< trim END
1647 vim9script
1648 def Func(...l: list<string>)
1649 echo l
1650 enddef
1651 Func()
1652 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001653 v9.CheckScriptSuccess(lines)
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001654
1655 lines =<< trim END
1656 vim9script
Bram Moolenaar2a389082021-04-09 20:24:31 +02001657 def Func(...l: list<any>)
Bram Moolenaar2f8cbc42020-09-16 17:22:59 +02001658 echo l
1659 enddef
1660 Func(0)
1661 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001662 v9.CheckScriptSuccess(lines)
Bram Moolenaar2f8cbc42020-09-16 17:22:59 +02001663
1664 lines =<< trim END
1665 vim9script
Bram Moolenaar2a389082021-04-09 20:24:31 +02001666 def Func(...l: any)
1667 echo l
1668 enddef
1669 Func(0)
1670 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001671 v9.CheckScriptFailure(lines, 'E1180:', 2)
Bram Moolenaar2a389082021-04-09 20:24:31 +02001672
1673 lines =<< trim END
1674 vim9script
Bram Moolenaar28022722020-09-21 22:02:49 +02001675 def Func(..._l: list<string>)
1676 echo _l
1677 enddef
1678 Func('a', 'b', 'c')
1679 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001680 v9.CheckScriptSuccess(lines)
Bram Moolenaar28022722020-09-21 22:02:49 +02001681
1682 lines =<< trim END
1683 vim9script
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001684 def Func(...l: list<string>)
1685 echo l
1686 enddef
1687 Func(1, 2, 3)
1688 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001689 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch')
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001690
1691 lines =<< trim END
1692 vim9script
1693 def Func(...l: list<string>)
1694 echo l
1695 enddef
1696 Func('a', 9)
1697 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001698 v9.CheckScriptFailure(lines, 'E1013: Argument 2: type mismatch')
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001699
1700 lines =<< trim END
1701 vim9script
1702 def Func(...l: list<string>)
1703 echo l
1704 enddef
1705 Func(1, 'a')
1706 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001707 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch')
Bram Moolenaar4f53b792021-02-07 15:59:49 +01001708
1709 lines =<< trim END
1710 vim9script
1711 def Func( # some comment
1712 ...l = []
1713 )
1714 echo l
1715 enddef
1716 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001717 v9.CheckScriptFailure(lines, 'E1160:')
Bram Moolenaar6ce46b92021-08-07 15:35:36 +02001718
1719 lines =<< trim END
1720 vim9script
1721 def DoIt()
1722 g:Later('')
1723 enddef
1724 defcompile
1725 def g:Later(...l: list<number>)
1726 enddef
1727 DoIt()
1728 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001729 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected number but got string')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001730enddef
1731
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001732let s:value = ''
1733
1734def FuncOneDefArg(opt = 'text')
1735 s:value = opt
1736enddef
1737
1738def FuncTwoDefArg(nr = 123, opt = 'text'): string
1739 return nr .. opt
1740enddef
1741
1742def FuncVarargs(...arg: list<string>): string
1743 return join(arg, ',')
1744enddef
1745
1746def Test_func_type_varargs()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001747 var RefDefArg: func(?string)
Bram Moolenaar848fadd2022-01-30 15:28:30 +00001748 RefDefArg = g:FuncOneDefArg
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001749 RefDefArg()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001750 s:value->assert_equal('text')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001751 RefDefArg('some')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001752 s:value->assert_equal('some')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001753
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001754 var RefDef2Arg: func(?number, ?string): string
Bram Moolenaar848fadd2022-01-30 15:28:30 +00001755 RefDef2Arg = g:FuncTwoDefArg
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001756 RefDef2Arg()->assert_equal('123text')
1757 RefDef2Arg(99)->assert_equal('99text')
1758 RefDef2Arg(77, 'some')->assert_equal('77some')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001759
Bram Moolenaar62aec932022-01-29 21:45:34 +00001760 v9.CheckDefFailure(['var RefWrong: func(string?)'], 'E1010:')
1761 v9.CheckDefFailure(['var RefWrong: func(?string, string)'], 'E1007:')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001762
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001763 var RefVarargs: func(...list<string>): string
Bram Moolenaar848fadd2022-01-30 15:28:30 +00001764 RefVarargs = g:FuncVarargs
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001765 RefVarargs()->assert_equal('')
1766 RefVarargs('one')->assert_equal('one')
1767 RefVarargs('one', 'two')->assert_equal('one,two')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001768
Bram Moolenaar62aec932022-01-29 21:45:34 +00001769 v9.CheckDefFailure(['var RefWrong: func(...list<string>, string)'], 'E110:')
1770 v9.CheckDefFailure(['var RefWrong: func(...list<string>, ?string)'], 'E110:')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001771enddef
1772
Bram Moolenaar0b76b422020-04-07 22:05:08 +02001773" Only varargs
1774def MyVarargsOnly(...args: list<string>): string
1775 return join(args, ',')
1776enddef
1777
1778def Test_call_varargs_only()
Bram Moolenaar62aec932022-01-29 21:45:34 +00001779 g:MyVarargsOnly()->assert_equal('')
1780 g:MyVarargsOnly('one')->assert_equal('one')
1781 g:MyVarargsOnly('one', 'two')->assert_equal('one,two')
1782 v9.CheckDefFailure(['g:MyVarargsOnly(1)'], 'E1013: Argument 1: type mismatch, expected string but got number')
1783 v9.CheckDefFailure(['g:MyVarargsOnly("one", 2)'], 'E1013: Argument 2: type mismatch, expected string but got number')
Bram Moolenaar0b76b422020-04-07 22:05:08 +02001784enddef
1785
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001786def Test_using_var_as_arg()
Bram Moolenaard2939812021-12-30 17:09:05 +00001787 var lines =<< trim END
1788 def Func(x: number)
1789 var x = 234
1790 enddef
1791 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001792 v9.CheckDefFailure(lines, 'E1006:')
Bram Moolenaard2939812021-12-30 17:09:05 +00001793
1794 lines =<< trim END
1795 def Func(Ref: number)
1796 def Ref()
1797 enddef
1798 enddef
1799 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001800 v9.CheckDefFailure(lines, 'E1073:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001801enddef
1802
Bram Moolenaar62aec932022-01-29 21:45:34 +00001803def s:DictArg(arg: dict<string>)
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +02001804 arg['key'] = 'value'
1805enddef
1806
Bram Moolenaar62aec932022-01-29 21:45:34 +00001807def s:ListArg(arg: list<string>)
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +02001808 arg[0] = 'value'
1809enddef
1810
1811def Test_assign_to_argument()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001812 # works for dict and list
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001813 var d: dict<string> = {}
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +02001814 DictArg(d)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001815 d['key']->assert_equal('value')
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001816 var l: list<string> = []
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +02001817 ListArg(l)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001818 l[0]->assert_equal('value')
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +02001819
Bram Moolenaar62aec932022-01-29 21:45:34 +00001820 v9.CheckScriptFailure(['def Func(arg: number)', 'arg = 3', 'enddef', 'defcompile'], 'E1090:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001821 delfunc! g:Func
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +02001822enddef
1823
Bram Moolenaarb816dae2020-09-20 22:04:00 +02001824" These argument names are reserved in legacy functions.
Bram Moolenaar62aec932022-01-29 21:45:34 +00001825def s:WithReservedNames(firstline: string, lastline: string): string
Bram Moolenaarb816dae2020-09-20 22:04:00 +02001826 return firstline .. lastline
1827enddef
1828
1829def Test_argument_names()
1830 assert_equal('OK', WithReservedNames('O', 'K'))
1831enddef
1832
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001833def Test_call_func_defined_later()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001834 g:DefinedLater('one')->assert_equal('one')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +02001835 assert_fails('NotDefined("one")', 'E117:', '', 2, 'Test_call_func_defined_later')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001836enddef
1837
Bram Moolenaar1df8b3f2020-04-23 18:13:23 +02001838func DefinedLater(arg)
1839 return a:arg
1840endfunc
1841
1842def Test_call_funcref()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001843 g:SomeFunc('abc')->assert_equal(3)
Bram Moolenaar9bd5d872020-09-06 21:47:48 +02001844 assert_fails('NotAFunc()', 'E117:', '', 2, 'Test_call_funcref') # comment after call
Bram Moolenaar2ef91562021-12-11 16:14:07 +00001845 assert_fails('g:NotAFunc()', 'E1085:', '', 3, 'Test_call_funcref')
Bram Moolenaar2f1980f2020-07-22 19:30:06 +02001846
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001847 var lines =<< trim END
Bram Moolenaar2f1980f2020-07-22 19:30:06 +02001848 vim9script
1849 def RetNumber(): number
1850 return 123
1851 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001852 var Funcref: func: number = function('RetNumber')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001853 Funcref()->assert_equal(123)
Bram Moolenaar2f1980f2020-07-22 19:30:06 +02001854 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001855 v9.CheckScriptSuccess(lines)
Bram Moolenaar0f60e802020-07-22 20:16:11 +02001856
1857 lines =<< trim END
1858 vim9script
1859 def RetNumber(): number
1860 return 123
1861 enddef
1862 def Bar(F: func: number): number
1863 return F()
1864 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001865 var Funcref = function('RetNumber')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001866 Bar(Funcref)->assert_equal(123)
Bram Moolenaar0f60e802020-07-22 20:16:11 +02001867 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001868 v9.CheckScriptSuccess(lines)
Bram Moolenaarbfba8652020-07-23 20:09:10 +02001869
1870 lines =<< trim END
1871 vim9script
1872 def UseNumber(nr: number)
1873 echo nr
1874 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001875 var Funcref: func(number) = function('UseNumber')
Bram Moolenaarbfba8652020-07-23 20:09:10 +02001876 Funcref(123)
1877 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001878 v9.CheckScriptSuccess(lines)
Bram Moolenaarb8070e32020-07-23 20:56:04 +02001879
1880 lines =<< trim END
1881 vim9script
1882 def UseNumber(nr: number)
1883 echo nr
1884 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001885 var Funcref: func(string) = function('UseNumber')
Bram Moolenaarb8070e32020-07-23 20:56:04 +02001886 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001887 v9.CheckScriptFailure(lines, 'E1012: Type mismatch; expected func(string) but got func(number)')
Bram Moolenaar4fc224c2020-07-26 17:56:25 +02001888
1889 lines =<< trim END
1890 vim9script
1891 def EchoNr(nr = 34)
1892 g:echo = nr
1893 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001894 var Funcref: func(?number) = function('EchoNr')
Bram Moolenaar4fc224c2020-07-26 17:56:25 +02001895 Funcref()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001896 g:echo->assert_equal(34)
Bram Moolenaar4fc224c2020-07-26 17:56:25 +02001897 Funcref(123)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001898 g:echo->assert_equal(123)
Bram Moolenaar4fc224c2020-07-26 17:56:25 +02001899 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001900 v9.CheckScriptSuccess(lines)
Bram Moolenaarace61322020-07-26 18:16:58 +02001901
1902 lines =<< trim END
1903 vim9script
1904 def EchoList(...l: list<number>)
1905 g:echo = l
1906 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001907 var Funcref: func(...list<number>) = function('EchoList')
Bram Moolenaarace61322020-07-26 18:16:58 +02001908 Funcref()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001909 g:echo->assert_equal([])
Bram Moolenaarace61322020-07-26 18:16:58 +02001910 Funcref(1, 2, 3)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001911 g:echo->assert_equal([1, 2, 3])
Bram Moolenaarace61322020-07-26 18:16:58 +02001912 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001913 v9.CheckScriptSuccess(lines)
Bram Moolenaar01865ad2020-07-26 18:33:09 +02001914
1915 lines =<< trim END
1916 vim9script
1917 def OptAndVar(nr: number, opt = 12, ...l: list<number>): number
1918 g:optarg = opt
1919 g:listarg = l
1920 return nr
1921 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001922 var Funcref: func(number, ?number, ...list<number>): number = function('OptAndVar')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001923 Funcref(10)->assert_equal(10)
1924 g:optarg->assert_equal(12)
1925 g:listarg->assert_equal([])
Bram Moolenaar01865ad2020-07-26 18:33:09 +02001926
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001927 Funcref(11, 22)->assert_equal(11)
1928 g:optarg->assert_equal(22)
1929 g:listarg->assert_equal([])
Bram Moolenaar01865ad2020-07-26 18:33:09 +02001930
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001931 Funcref(17, 18, 1, 2, 3)->assert_equal(17)
1932 g:optarg->assert_equal(18)
1933 g:listarg->assert_equal([1, 2, 3])
Bram Moolenaar01865ad2020-07-26 18:33:09 +02001934 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001935 v9.CheckScriptSuccess(lines)
Bram Moolenaar1df8b3f2020-04-23 18:13:23 +02001936enddef
1937
1938let SomeFunc = function('len')
1939let NotAFunc = 'text'
1940
Bram Moolenaar99aaf0c2020-04-12 14:39:53 +02001941def CombineFuncrefTypes()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001942 # same arguments, different return type
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001943 var Ref1: func(bool): string
1944 var Ref2: func(bool): number
1945 var Ref3: func(bool): any
Bram Moolenaar99aaf0c2020-04-12 14:39:53 +02001946 Ref3 = g:cond ? Ref1 : Ref2
1947
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001948 # different number of arguments
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001949 var Refa1: func(bool): number
1950 var Refa2: func(bool, number): number
1951 var Refa3: func: number
Bram Moolenaar99aaf0c2020-04-12 14:39:53 +02001952 Refa3 = g:cond ? Refa1 : Refa2
1953
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001954 # different argument types
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001955 var Refb1: func(bool, string): number
1956 var Refb2: func(string, number): number
1957 var Refb3: func(any, any): number
Bram Moolenaar99aaf0c2020-04-12 14:39:53 +02001958 Refb3 = g:cond ? Refb1 : Refb2
1959enddef
1960
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001961def FuncWithForwardCall()
Bram Moolenaar1df8b3f2020-04-23 18:13:23 +02001962 return g:DefinedEvenLater("yes")
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001963enddef
1964
1965def DefinedEvenLater(arg: string): string
1966 return arg
1967enddef
1968
1969def Test_error_in_nested_function()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001970 # Error in called function requires unwinding the call stack.
Bram Moolenaar848fadd2022-01-30 15:28:30 +00001971 assert_fails('g:FuncWithForwardCall()', 'E1096:', '', 1, 'FuncWithForwardCall')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001972enddef
1973
Bram Moolenaar4bf10062021-12-28 17:23:12 +00001974def Test_nested_function_with_nextcmd()
Bram Moolenaar9c23f9b2021-12-26 14:23:22 +00001975 var lines =<< trim END
1976 vim9script
1977 # Define an outer function
1978 def FirstFunction()
1979 # Define an inner function
1980 def SecondFunction()
1981 # the function has a body, a double free is detected.
1982 AAAAA
1983
1984 # enddef followed by | or } followed by # one or more characters
1985 enddef|BBBB
1986 enddef
1987
1988 # Compile all functions
1989 defcompile
1990 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001991 v9.CheckScriptFailure(lines, 'E1173: Text found after enddef: BBBB')
Bram Moolenaar9c23f9b2021-12-26 14:23:22 +00001992enddef
1993
Bram Moolenaar4bf10062021-12-28 17:23:12 +00001994def Test_nested_function_with_args_split()
1995 var lines =<< trim END
1996 vim9script
1997 def FirstFunction()
1998 def SecondFunction(
1999 )
2000 # had a double free if the right parenthesis of the nested function is
2001 # on the next line
2002
2003 enddef|BBBB
2004 enddef
2005 # Compile all functions
2006 defcompile
2007 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002008 v9.CheckScriptFailure(lines, 'E1173: Text found after enddef: BBBB')
Bram Moolenaar7473a842021-12-28 17:55:26 +00002009
2010 lines =<< trim END
2011 vim9script
2012 def FirstFunction()
2013 func SecondFunction()
2014 endfunc|BBBB
2015 enddef
2016 defcompile
2017 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002018 v9.CheckScriptFailure(lines, 'E1173: Text found after endfunction: BBBB')
Bram Moolenaar4bf10062021-12-28 17:23:12 +00002019enddef
2020
Bram Moolenaar9f1a39a2022-01-08 15:39:39 +00002021def Test_error_in_function_args()
2022 var lines =<< trim END
2023 def FirstFunction()
2024 def SecondFunction(J =
2025 # Nois
2026 # one
2027
2028 enddef|BBBB
2029 enddef
2030 # Compile all functions
2031 defcompile
2032 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002033 v9.CheckScriptFailure(lines, 'E488:')
Bram Moolenaar9f1a39a2022-01-08 15:39:39 +00002034enddef
2035
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002036def Test_return_type_wrong()
Bram Moolenaar62aec932022-01-29 21:45:34 +00002037 v9.CheckScriptFailure([
Bram Moolenaar5a849da2020-08-08 16:47:30 +02002038 'def Func(): number',
2039 'return "a"',
2040 'enddef',
2041 'defcompile'], 'expected number but got string')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002042 delfunc! g:Func
Bram Moolenaar62aec932022-01-29 21:45:34 +00002043 v9.CheckScriptFailure([
Bram Moolenaar5a849da2020-08-08 16:47:30 +02002044 'def Func(): string',
2045 'return 1',
2046 'enddef',
2047 'defcompile'], 'expected string but got number')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002048 delfunc! g:Func
Bram Moolenaar62aec932022-01-29 21:45:34 +00002049 v9.CheckScriptFailure([
Bram Moolenaar5a849da2020-08-08 16:47:30 +02002050 'def Func(): void',
2051 'return "a"',
2052 'enddef',
2053 'defcompile'],
2054 'E1096: Returning a value in a function without a return type')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002055 delfunc! g:Func
Bram Moolenaar62aec932022-01-29 21:45:34 +00002056 v9.CheckScriptFailure([
Bram Moolenaar5a849da2020-08-08 16:47:30 +02002057 'def Func()',
2058 'return "a"',
2059 'enddef',
2060 'defcompile'],
2061 'E1096: Returning a value in a function without a return type')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002062 delfunc! g:Func
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002063
Bram Moolenaar62aec932022-01-29 21:45:34 +00002064 v9.CheckScriptFailure([
Bram Moolenaar5a849da2020-08-08 16:47:30 +02002065 'def Func(): number',
2066 'return',
2067 'enddef',
2068 'defcompile'], 'E1003:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002069 delfunc! g:Func
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002070
Bram Moolenaar62aec932022-01-29 21:45:34 +00002071 v9.CheckScriptFailure([
Bram Moolenaar33ea9fd2021-08-08 19:07:37 +02002072 'def Func():number',
2073 'return 123',
2074 'enddef',
2075 'defcompile'], 'E1069:')
2076 delfunc! g:Func
2077
Bram Moolenaar62aec932022-01-29 21:45:34 +00002078 v9.CheckScriptFailure([
Bram Moolenaar33ea9fd2021-08-08 19:07:37 +02002079 'def Func() :number',
2080 'return 123',
2081 'enddef',
2082 'defcompile'], 'E1059:')
2083 delfunc! g:Func
2084
Bram Moolenaar62aec932022-01-29 21:45:34 +00002085 v9.CheckScriptFailure([
Bram Moolenaar33ea9fd2021-08-08 19:07:37 +02002086 'def Func() : number',
2087 'return 123',
2088 'enddef',
2089 'defcompile'], 'E1059:')
2090 delfunc! g:Func
2091
Bram Moolenaar62aec932022-01-29 21:45:34 +00002092 v9.CheckScriptFailure(['def Func(): list', 'return []', 'enddef'], 'E1008:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002093 delfunc! g:Func
Bram Moolenaar62aec932022-01-29 21:45:34 +00002094 v9.CheckScriptFailure(['def Func(): dict', 'return {}', 'enddef'], 'E1008:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002095 delfunc! g:Func
Bram Moolenaar62aec932022-01-29 21:45:34 +00002096 v9.CheckScriptFailure(['def Func()', 'return 1'], 'E1057:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002097 delfunc! g:Func
Bram Moolenaar5a849da2020-08-08 16:47:30 +02002098
Bram Moolenaar62aec932022-01-29 21:45:34 +00002099 v9.CheckScriptFailure([
Bram Moolenaar5a849da2020-08-08 16:47:30 +02002100 'vim9script',
2101 'def FuncB()',
2102 ' return 123',
2103 'enddef',
2104 'def FuncA()',
2105 ' FuncB()',
2106 'enddef',
2107 'defcompile'], 'E1096:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002108enddef
2109
2110def Test_arg_type_wrong()
Bram Moolenaar62aec932022-01-29 21:45:34 +00002111 v9.CheckScriptFailure(['def Func3(items: list)', 'echo "a"', 'enddef'], 'E1008: Missing <type>')
2112 v9.CheckScriptFailure(['def Func4(...)', 'echo "a"', 'enddef'], 'E1055: Missing name after ...')
2113 v9.CheckScriptFailure(['def Func5(items:string)', 'echo "a"'], 'E1069:')
2114 v9.CheckScriptFailure(['def Func5(items)', 'echo "a"'], 'E1077:')
2115 v9.CheckScriptFailure(['def Func6(...x:list<number>)', 'echo "a"', 'enddef'], 'E1069:')
2116 v9.CheckScriptFailure(['def Func7(...x: int)', 'echo "a"', 'enddef'], 'E1010:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002117enddef
2118
Bram Moolenaar86cdb8a2021-04-06 19:01:03 +02002119def Test_white_space_before_comma()
2120 var lines =<< trim END
2121 vim9script
2122 def Func(a: number , b: number)
2123 enddef
2124 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002125 v9.CheckScriptFailure(lines, 'E1068:')
Yegappan Lakshmanan611728f2021-05-24 15:15:47 +02002126 call assert_fails('vim9cmd echo stridx("a" .. "b" , "a")', 'E1068:')
Bram Moolenaar86cdb8a2021-04-06 19:01:03 +02002127enddef
2128
Bram Moolenaar608d78f2021-03-06 22:33:12 +01002129def Test_white_space_after_comma()
2130 var lines =<< trim END
2131 vim9script
2132 def Func(a: number,b: number)
2133 enddef
2134 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002135 v9.CheckScriptFailure(lines, 'E1069:')
Bram Moolenaar608d78f2021-03-06 22:33:12 +01002136
2137 # OK in legacy function
2138 lines =<< trim END
2139 vim9script
2140 func Func(a,b)
2141 endfunc
2142 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002143 v9.CheckScriptSuccess(lines)
Bram Moolenaar608d78f2021-03-06 22:33:12 +01002144enddef
2145
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002146def Test_vim9script_call()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002147 var lines =<< trim END
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002148 vim9script
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002149 var name = ''
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002150 def MyFunc(arg: string)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002151 name = arg
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002152 enddef
2153 MyFunc('foobar')
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002154 name->assert_equal('foobar')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002155
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002156 var str = 'barfoo'
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002157 str->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002158 name->assert_equal('barfoo')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002159
Bram Moolenaar67979662020-06-20 22:50:47 +02002160 g:value = 'value'
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002161 g:value->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002162 name->assert_equal('value')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002163
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002164 var listvar = []
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002165 def ListFunc(arg: list<number>)
2166 listvar = arg
2167 enddef
2168 [1, 2, 3]->ListFunc()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002169 listvar->assert_equal([1, 2, 3])
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002170
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002171 var dictvar = {}
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002172 def DictFunc(arg: dict<number>)
2173 dictvar = arg
2174 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +01002175 {a: 1, b: 2}->DictFunc()
2176 dictvar->assert_equal({a: 1, b: 2})
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002177 def CompiledDict()
Bram Moolenaare0de1712020-12-02 17:36:54 +01002178 {a: 3, b: 4}->DictFunc()
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002179 enddef
2180 CompiledDict()
Bram Moolenaare0de1712020-12-02 17:36:54 +01002181 dictvar->assert_equal({a: 3, b: 4})
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002182
Bram Moolenaare0de1712020-12-02 17:36:54 +01002183 {a: 3, b: 4}->DictFunc()
2184 dictvar->assert_equal({a: 3, b: 4})
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002185
2186 ('text')->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002187 name->assert_equal('text')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002188 ("some")->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002189 name->assert_equal('some')
Bram Moolenaare6b53242020-07-01 17:28:33 +02002190
Bram Moolenaar13e12b82020-07-24 18:47:22 +02002191 # line starting with single quote is not a mark
Bram Moolenaar10409562020-07-29 20:00:38 +02002192 # line starting with double quote can be a method call
Bram Moolenaar3d48e252020-07-15 14:15:52 +02002193 'asdfasdf'->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002194 name->assert_equal('asdfasdf')
Bram Moolenaar10409562020-07-29 20:00:38 +02002195 "xyz"->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002196 name->assert_equal('xyz')
Bram Moolenaar3d48e252020-07-15 14:15:52 +02002197
2198 def UseString()
2199 'xyork'->MyFunc()
2200 enddef
2201 UseString()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002202 name->assert_equal('xyork')
Bram Moolenaar3d48e252020-07-15 14:15:52 +02002203
Bram Moolenaar10409562020-07-29 20:00:38 +02002204 def UseString2()
2205 "knife"->MyFunc()
2206 enddef
2207 UseString2()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002208 name->assert_equal('knife')
Bram Moolenaar10409562020-07-29 20:00:38 +02002209
Bram Moolenaar13e12b82020-07-24 18:47:22 +02002210 # prepending a colon makes it a mark
2211 new
2212 setline(1, ['aaa', 'bbb', 'ccc'])
2213 normal! 3Gmt1G
2214 :'t
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002215 getcurpos()[1]->assert_equal(3)
Bram Moolenaar13e12b82020-07-24 18:47:22 +02002216 bwipe!
2217
Bram Moolenaare6b53242020-07-01 17:28:33 +02002218 MyFunc(
2219 'continued'
2220 )
2221 assert_equal('continued',
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002222 name
Bram Moolenaare6b53242020-07-01 17:28:33 +02002223 )
2224
2225 call MyFunc(
2226 'more'
2227 ..
2228 'lines'
2229 )
2230 assert_equal(
2231 'morelines',
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002232 name)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002233 END
2234 writefile(lines, 'Xcall.vim')
2235 source Xcall.vim
2236 delete('Xcall.vim')
2237enddef
2238
2239def Test_vim9script_call_fail_decl()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002240 var lines =<< trim END
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002241 vim9script
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002242 var name = ''
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002243 def MyFunc(arg: string)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002244 var name = 123
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002245 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +02002246 defcompile
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002247 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002248 v9.CheckScriptFailure(lines, 'E1054:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002249enddef
2250
Bram Moolenaar65b95452020-07-19 14:03:09 +02002251def Test_vim9script_call_fail_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002252 var lines =<< trim END
Bram Moolenaar65b95452020-07-19 14:03:09 +02002253 vim9script
2254 def MyFunc(arg: string)
2255 echo arg
2256 enddef
2257 MyFunc(1234)
2258 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002259 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected string but got number')
Bram Moolenaar65b95452020-07-19 14:03:09 +02002260enddef
2261
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002262def Test_vim9script_call_fail_const()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002263 var lines =<< trim END
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002264 vim9script
2265 const var = ''
2266 def MyFunc(arg: string)
2267 var = 'asdf'
2268 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +02002269 defcompile
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002270 END
2271 writefile(lines, 'Xcall_const.vim')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +02002272 assert_fails('source Xcall_const.vim', 'E46:', '', 1, 'MyFunc')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002273 delete('Xcall_const.vim')
Bram Moolenaar3bdc90b2020-12-22 20:35:40 +01002274
2275 lines =<< trim END
2276 const g:Aconst = 77
2277 def Change()
2278 # comment
2279 g:Aconst = 99
2280 enddef
2281 call Change()
2282 unlet g:Aconst
2283 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002284 v9.CheckScriptFailure(lines, 'E741: Value is locked: Aconst', 2)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002285enddef
2286
2287" Test that inside :function a Python function can be defined, :def is not
2288" recognized.
2289func Test_function_python()
2290 CheckFeature python3
Bram Moolenaar727345e2020-09-27 23:33:59 +02002291 let py = 'python3'
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002292 execute py "<< EOF"
2293def do_something():
2294 return 1
2295EOF
2296endfunc
2297
2298def Test_delfunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002299 var lines =<< trim END
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002300 vim9script
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02002301 def g:GoneSoon()
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002302 echo 'hello'
2303 enddef
2304
2305 def CallGoneSoon()
Bram Moolenaar62aec932022-01-29 21:45:34 +00002306 g:GoneSoon()
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002307 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +02002308 defcompile
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002309
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02002310 delfunc g:GoneSoon
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002311 CallGoneSoon()
2312 END
2313 writefile(lines, 'XToDelFunc')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +02002314 assert_fails('so XToDelFunc', 'E933:', '', 1, 'CallGoneSoon')
2315 assert_fails('so XToDelFunc', 'E933:', '', 1, 'CallGoneSoon')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002316
2317 delete('XToDelFunc')
2318enddef
2319
Bram Moolenaar7509ad82021-12-14 18:14:37 +00002320func Test_free_dict_while_in_funcstack()
2321 " relies on the sleep command
2322 CheckUnix
2323 call Run_Test_free_dict_while_in_funcstack()
2324endfunc
2325
2326def Run_Test_free_dict_while_in_funcstack()
Bram Moolenaar7509ad82021-12-14 18:14:37 +00002327 # this was freeing the TermRun() default argument dictionary while it was
2328 # still referenced in a funcstack_T
2329 var lines =<< trim END
2330 vim9script
2331
2332 &updatetime = 400
2333 def TermRun(_ = {})
2334 def Post()
2335 enddef
2336 def Exec()
2337 term_start('sleep 1', {
2338 term_finish: 'close',
2339 exit_cb: (_, _) => Post(),
2340 })
2341 enddef
2342 Exec()
2343 enddef
2344 nnoremap <F4> <Cmd>call <SID>TermRun()<CR>
2345 timer_start(100, (_) => feedkeys("\<F4>"))
2346 timer_start(1000, (_) => feedkeys("\<F4>"))
2347 sleep 1500m
2348 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002349 v9.CheckScriptSuccess(lines)
Bram Moolenaar7509ad82021-12-14 18:14:37 +00002350 nunmap <F4>
2351 set updatetime&
2352enddef
2353
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002354def Test_redef_failure()
Bram Moolenaard2c61702020-09-06 15:58:36 +02002355 writefile(['def Func0(): string', 'return "Func0"', 'enddef'], 'Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002356 so Xdef
Bram Moolenaard2c61702020-09-06 15:58:36 +02002357 writefile(['def Func1(): string', 'return "Func1"', 'enddef'], 'Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002358 so Xdef
Bram Moolenaard2c61702020-09-06 15:58:36 +02002359 writefile(['def! Func0(): string', 'enddef', 'defcompile'], 'Xdef')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +02002360 assert_fails('so Xdef', 'E1027:', '', 1, 'Func0')
Bram Moolenaard2c61702020-09-06 15:58:36 +02002361 writefile(['def Func2(): string', 'return "Func2"', 'enddef'], 'Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002362 so Xdef
Bram Moolenaard2c61702020-09-06 15:58:36 +02002363 delete('Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002364
Bram Moolenaar701cc6c2021-04-10 13:33:48 +02002365 assert_fails('g:Func0()', 'E1091:')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002366 g:Func1()->assert_equal('Func1')
2367 g:Func2()->assert_equal('Func2')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002368
2369 delfunc! Func0
2370 delfunc! Func1
2371 delfunc! Func2
2372enddef
2373
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02002374def Test_vim9script_func()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002375 var lines =<< trim END
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02002376 vim9script
2377 func Func(arg)
2378 echo a:arg
2379 endfunc
2380 Func('text')
2381 END
2382 writefile(lines, 'XVim9Func')
2383 so XVim9Func
2384
2385 delete('XVim9Func')
2386enddef
2387
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002388let s:funcResult = 0
2389
2390def FuncNoArgNoRet()
Bram Moolenaar53900992020-08-22 19:02:02 +02002391 s:funcResult = 11
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002392enddef
2393
2394def FuncNoArgRetNumber(): number
Bram Moolenaar53900992020-08-22 19:02:02 +02002395 s:funcResult = 22
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002396 return 1234
2397enddef
2398
Bram Moolenaarec5929d2020-04-07 20:53:39 +02002399def FuncNoArgRetString(): string
Bram Moolenaar53900992020-08-22 19:02:02 +02002400 s:funcResult = 45
Bram Moolenaarec5929d2020-04-07 20:53:39 +02002401 return 'text'
2402enddef
2403
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002404def FuncOneArgNoRet(arg: number)
Bram Moolenaar53900992020-08-22 19:02:02 +02002405 s:funcResult = arg
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002406enddef
2407
2408def FuncOneArgRetNumber(arg: number): number
Bram Moolenaar53900992020-08-22 19:02:02 +02002409 s:funcResult = arg
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002410 return arg
2411enddef
2412
Bram Moolenaar08938ee2020-04-11 23:17:17 +02002413def FuncTwoArgNoRet(one: bool, two: number)
Bram Moolenaar53900992020-08-22 19:02:02 +02002414 s:funcResult = two
Bram Moolenaar08938ee2020-04-11 23:17:17 +02002415enddef
2416
Bram Moolenaar62aec932022-01-29 21:45:34 +00002417def s:FuncOneArgRetString(arg: string): string
Bram Moolenaarec5929d2020-04-07 20:53:39 +02002418 return arg
2419enddef
2420
Bram Moolenaar62aec932022-01-29 21:45:34 +00002421def s:FuncOneArgRetAny(arg: any): any
Bram Moolenaar89228602020-04-05 22:14:54 +02002422 return arg
2423enddef
2424
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002425def Test_func_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002426 var Ref1: func()
Bram Moolenaar53900992020-08-22 19:02:02 +02002427 s:funcResult = 0
Bram Moolenaar62aec932022-01-29 21:45:34 +00002428 Ref1 = g:FuncNoArgNoRet
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002429 Ref1()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002430 s:funcResult->assert_equal(11)
Bram Moolenaar4c683752020-04-05 21:38:23 +02002431
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002432 var Ref2: func
Bram Moolenaar53900992020-08-22 19:02:02 +02002433 s:funcResult = 0
Bram Moolenaar62aec932022-01-29 21:45:34 +00002434 Ref2 = g:FuncNoArgNoRet
Bram Moolenaar4c683752020-04-05 21:38:23 +02002435 Ref2()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002436 s:funcResult->assert_equal(11)
Bram Moolenaar4c683752020-04-05 21:38:23 +02002437
Bram Moolenaar53900992020-08-22 19:02:02 +02002438 s:funcResult = 0
Bram Moolenaar62aec932022-01-29 21:45:34 +00002439 Ref2 = g:FuncOneArgNoRet
Bram Moolenaar4c683752020-04-05 21:38:23 +02002440 Ref2(12)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002441 s:funcResult->assert_equal(12)
Bram Moolenaar4c683752020-04-05 21:38:23 +02002442
Bram Moolenaar53900992020-08-22 19:02:02 +02002443 s:funcResult = 0
Bram Moolenaar62aec932022-01-29 21:45:34 +00002444 Ref2 = g:FuncNoArgRetNumber
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002445 Ref2()->assert_equal(1234)
2446 s:funcResult->assert_equal(22)
Bram Moolenaar4c683752020-04-05 21:38:23 +02002447
Bram Moolenaar53900992020-08-22 19:02:02 +02002448 s:funcResult = 0
Bram Moolenaar848fadd2022-01-30 15:28:30 +00002449 Ref2 = g:FuncOneArgRetNumber
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002450 Ref2(13)->assert_equal(13)
2451 s:funcResult->assert_equal(13)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002452enddef
2453
Bram Moolenaar9978d472020-07-05 16:01:56 +02002454def Test_repeat_return_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002455 var res = 0
Bram Moolenaar9978d472020-07-05 16:01:56 +02002456 for n in repeat([1], 3)
2457 res += n
2458 endfor
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002459 res->assert_equal(3)
Bram Moolenaarfce82b32020-07-05 16:07:21 +02002460
2461 res = 0
2462 for n in add([1, 2], 3)
2463 res += n
2464 endfor
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002465 res->assert_equal(6)
Bram Moolenaar9978d472020-07-05 16:01:56 +02002466enddef
2467
Bram Moolenaar846178a2020-07-05 17:04:13 +02002468def Test_argv_return_type()
2469 next fileone filetwo
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002470 var res = ''
Bram Moolenaar846178a2020-07-05 17:04:13 +02002471 for name in argv()
2472 res ..= name
2473 endfor
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002474 res->assert_equal('fileonefiletwo')
Bram Moolenaar846178a2020-07-05 17:04:13 +02002475enddef
2476
Bram Moolenaarec5929d2020-04-07 20:53:39 +02002477def Test_func_type_part()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002478 var RefVoid: func: void
Bram Moolenaar62aec932022-01-29 21:45:34 +00002479 RefVoid = g:FuncNoArgNoRet
2480 RefVoid = g:FuncOneArgNoRet
2481 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 +00002482 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 +02002483
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002484 var RefAny: func(): any
Bram Moolenaar62aec932022-01-29 21:45:34 +00002485 RefAny = g:FuncNoArgRetNumber
Bram Moolenaar848fadd2022-01-30 15:28:30 +00002486 RefAny = g:FuncNoArgRetString
Bram Moolenaar62aec932022-01-29 21:45:34 +00002487 v9.CheckDefFailure(['var RefAny: func(): any', 'RefAny = g:FuncNoArgNoRet'], 'E1012: Type mismatch; expected func(): any but got func()')
2488 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 +02002489
Bram Moolenaar6abd3dc2020-10-04 14:17:32 +02002490 var RefAnyNoArgs: func: any = RefAny
2491
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002492 var RefNr: func: number
Bram Moolenaar62aec932022-01-29 21:45:34 +00002493 RefNr = g:FuncNoArgRetNumber
Bram Moolenaar848fadd2022-01-30 15:28:30 +00002494 RefNr = g:FuncOneArgRetNumber
Bram Moolenaar62aec932022-01-29 21:45:34 +00002495 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 +00002496 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 +02002497
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002498 var RefStr: func: string
Bram Moolenaar848fadd2022-01-30 15:28:30 +00002499 RefStr = g:FuncNoArgRetString
Bram Moolenaarec5929d2020-04-07 20:53:39 +02002500 RefStr = FuncOneArgRetString
Bram Moolenaar62aec932022-01-29 21:45:34 +00002501 v9.CheckDefFailure(['var RefStr: func: string', 'RefStr = g:FuncNoArgNoRet'], 'E1012: Type mismatch; expected func(...): string but got func()')
2502 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 +02002503enddef
2504
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002505def Test_func_type_fails()
Bram Moolenaar62aec932022-01-29 21:45:34 +00002506 v9.CheckDefFailure(['var ref1: func()'], 'E704:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002507
Bram Moolenaar62aec932022-01-29 21:45:34 +00002508 v9.CheckDefFailure(['var Ref1: func()', 'Ref1 = g:FuncNoArgRetNumber'], 'E1012: Type mismatch; expected func() but got func(): number')
2509 v9.CheckDefFailure(['var Ref1: func()', 'Ref1 = g:FuncOneArgNoRet'], 'E1012: Type mismatch; expected func() but got func(number)')
Bram Moolenaar848fadd2022-01-30 15:28:30 +00002510 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 +00002511 v9.CheckDefFailure(['var Ref1: func(bool)', 'Ref1 = g:FuncTwoArgNoRet'], 'E1012: Type mismatch; expected func(bool) but got func(bool, number)')
2512 v9.CheckDefFailure(['var Ref1: func(?bool)', 'Ref1 = g:FuncTwoArgNoRet'], 'E1012: Type mismatch; expected func(?bool) but got func(bool, number)')
2513 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 +02002514
Bram Moolenaar62aec932022-01-29 21:45:34 +00002515 v9.CheckDefFailure(['var RefWrong: func(string ,number)'], 'E1068:')
2516 v9.CheckDefFailure(['var RefWrong: func(string,number)'], 'E1069:')
2517 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:')
2518 v9.CheckDefFailure(['var RefWrong: func(bool):string'], 'E1069:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002519enddef
2520
Bram Moolenaar89228602020-04-05 22:14:54 +02002521def Test_func_return_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002522 var nr: number
Bram Moolenaar62aec932022-01-29 21:45:34 +00002523 nr = g:FuncNoArgRetNumber()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002524 nr->assert_equal(1234)
Bram Moolenaar89228602020-04-05 22:14:54 +02002525
2526 nr = FuncOneArgRetAny(122)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002527 nr->assert_equal(122)
Bram Moolenaar89228602020-04-05 22:14:54 +02002528
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002529 var str: string
Bram Moolenaar89228602020-04-05 22:14:54 +02002530 str = FuncOneArgRetAny('yes')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002531 str->assert_equal('yes')
Bram Moolenaar89228602020-04-05 22:14:54 +02002532
Bram Moolenaar62aec932022-01-29 21:45:34 +00002533 v9.CheckDefFailure(['var str: string', 'str = g:FuncNoArgRetNumber()'], 'E1012: Type mismatch; expected string but got number')
Bram Moolenaar89228602020-04-05 22:14:54 +02002534enddef
2535
Bram Moolenaar6abd3dc2020-10-04 14:17:32 +02002536def Test_func_common_type()
2537 def FuncOne(n: number): number
2538 return n
2539 enddef
2540 def FuncTwo(s: string): number
2541 return len(s)
2542 enddef
2543 def FuncThree(n: number, s: string): number
2544 return n + len(s)
2545 enddef
2546 var list = [FuncOne, FuncTwo, FuncThree]
2547 assert_equal(8, list[0](8))
2548 assert_equal(4, list[1]('word'))
2549 assert_equal(7, list[2](3, 'word'))
2550enddef
2551
Bram Moolenaar62aec932022-01-29 21:45:34 +00002552def s:MultiLine(
Bram Moolenaar5e774c72020-04-12 21:53:00 +02002553 arg1: string,
2554 arg2 = 1234,
2555 ...rest: list<string>
2556 ): string
2557 return arg1 .. arg2 .. join(rest, '-')
2558enddef
2559
Bram Moolenaar2c330432020-04-13 14:41:35 +02002560def MultiLineComment(
2561 arg1: string, # comment
2562 arg2 = 1234, # comment
2563 ...rest: list<string> # comment
2564 ): string # comment
2565 return arg1 .. arg2 .. join(rest, '-')
2566enddef
2567
Bram Moolenaar5e774c72020-04-12 21:53:00 +02002568def Test_multiline()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002569 MultiLine('text')->assert_equal('text1234')
2570 MultiLine('text', 777)->assert_equal('text777')
2571 MultiLine('text', 777, 'one')->assert_equal('text777one')
2572 MultiLine('text', 777, 'one', 'two')->assert_equal('text777one-two')
Bram Moolenaar5e774c72020-04-12 21:53:00 +02002573enddef
2574
Bram Moolenaar23e03252020-04-12 22:22:31 +02002575func Test_multiline_not_vim9()
Bram Moolenaar62aec932022-01-29 21:45:34 +00002576 call s:MultiLine('text')->assert_equal('text1234')
2577 call s:MultiLine('text', 777)->assert_equal('text777')
2578 call s:MultiLine('text', 777, 'one')->assert_equal('text777one')
2579 call s:MultiLine('text', 777, 'one', 'two')->assert_equal('text777one-two')
Bram Moolenaar23e03252020-04-12 22:22:31 +02002580endfunc
2581
Bram Moolenaar5e774c72020-04-12 21:53:00 +02002582
Bram Moolenaaree4e0c12020-04-06 21:35:05 +02002583" When using CheckScriptFailure() for the below test, E1010 is generated instead
2584" of E1056.
2585func Test_E1056_1059()
2586 let caught_1056 = 0
2587 try
2588 def F():
2589 return 1
2590 enddef
2591 catch /E1056:/
2592 let caught_1056 = 1
2593 endtry
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002594 eval caught_1056->assert_equal(1)
Bram Moolenaaree4e0c12020-04-06 21:35:05 +02002595
2596 let caught_1059 = 0
2597 try
2598 def F5(items : list)
2599 echo 'a'
2600 enddef
2601 catch /E1059:/
2602 let caught_1059 = 1
2603 endtry
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002604 eval caught_1059->assert_equal(1)
Bram Moolenaaree4e0c12020-04-06 21:35:05 +02002605endfunc
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002606
Bram Moolenaar015f4262020-05-05 21:25:22 +02002607func DelMe()
2608 echo 'DelMe'
2609endfunc
2610
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002611def Test_error_reporting()
2612 # comment lines at the start of the function
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002613 var lines =<< trim END
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002614 " comment
2615 def Func()
2616 # comment
2617 # comment
2618 invalid
2619 enddef
2620 defcompile
2621 END
Bram Moolenaar08052222020-09-14 17:04:31 +02002622 writefile(lines, 'Xdef')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002623 try
2624 source Xdef
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02002625 assert_report('should have failed')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002626 catch /E476:/
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002627 v:exception->assert_match('Invalid command: invalid')
2628 v:throwpoint->assert_match(', line 3$')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002629 endtry
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002630 delfunc! g:Func
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002631
2632 # comment lines after the start of the function
2633 lines =<< trim END
2634 " comment
2635 def Func()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002636 var x = 1234
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002637 # comment
2638 # comment
2639 invalid
2640 enddef
2641 defcompile
2642 END
Bram Moolenaar08052222020-09-14 17:04:31 +02002643 writefile(lines, 'Xdef')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002644 try
2645 source Xdef
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02002646 assert_report('should have failed')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002647 catch /E476:/
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002648 v:exception->assert_match('Invalid command: invalid')
2649 v:throwpoint->assert_match(', line 4$')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002650 endtry
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002651 delfunc! g:Func
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002652
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02002653 lines =<< trim END
2654 vim9script
2655 def Func()
Bram Moolenaare0de1712020-12-02 17:36:54 +01002656 var db = {foo: 1, bar: 2}
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02002657 # comment
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002658 var x = db.asdf
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02002659 enddef
2660 defcompile
2661 Func()
2662 END
Bram Moolenaar08052222020-09-14 17:04:31 +02002663 writefile(lines, 'Xdef')
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02002664 try
2665 source Xdef
2666 assert_report('should have failed')
2667 catch /E716:/
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002668 v:throwpoint->assert_match('_Func, line 3$')
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02002669 endtry
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002670 delfunc! g:Func
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02002671
Bram Moolenaar08052222020-09-14 17:04:31 +02002672 delete('Xdef')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002673enddef
2674
Bram Moolenaar015f4262020-05-05 21:25:22 +02002675def Test_deleted_function()
Bram Moolenaar62aec932022-01-29 21:45:34 +00002676 v9.CheckDefExecFailure([
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002677 'var RefMe: func = function("g:DelMe")',
Bram Moolenaar015f4262020-05-05 21:25:22 +02002678 'delfunc g:DelMe',
2679 'echo RefMe()'], 'E117:')
2680enddef
2681
2682def Test_unknown_function()
Bram Moolenaar62aec932022-01-29 21:45:34 +00002683 v9.CheckDefExecFailure([
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002684 'var Ref: func = function("NotExist")',
Bram Moolenaar9b7bf9e2020-07-11 22:14:59 +02002685 'delfunc g:NotExist'], 'E700:')
Bram Moolenaar015f4262020-05-05 21:25:22 +02002686enddef
2687
Bram Moolenaar62aec932022-01-29 21:45:34 +00002688def s:RefFunc(Ref: func(any): any): string
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02002689 return Ref('more')
2690enddef
2691
2692def Test_closure_simple()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002693 var local = 'some '
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002694 RefFunc((s) => local .. s)->assert_equal('some more')
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02002695enddef
2696
Bram Moolenaar62aec932022-01-29 21:45:34 +00002697def s:MakeRef()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002698 var local = 'some '
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002699 g:Ref = (s) => local .. s
Bram Moolenaarbf67ea12020-05-02 17:52:42 +02002700enddef
2701
2702def Test_closure_ref_after_return()
2703 MakeRef()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002704 g:Ref('thing')->assert_equal('some thing')
Bram Moolenaarbf67ea12020-05-02 17:52:42 +02002705 unlet g:Ref
2706enddef
2707
Bram Moolenaar62aec932022-01-29 21:45:34 +00002708def s:MakeTwoRefs()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002709 var local = ['some']
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002710 g:Extend = (s) => local->add(s)
2711 g:Read = () => local
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002712enddef
2713
2714def Test_closure_two_refs()
2715 MakeTwoRefs()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002716 join(g:Read(), ' ')->assert_equal('some')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002717 g:Extend('more')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002718 join(g:Read(), ' ')->assert_equal('some more')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002719 g:Extend('even')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002720 join(g:Read(), ' ')->assert_equal('some more even')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002721
2722 unlet g:Extend
2723 unlet g:Read
2724enddef
2725
Bram Moolenaar62aec932022-01-29 21:45:34 +00002726def s:ReadRef(Ref: func(): list<string>): string
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002727 return join(Ref(), ' ')
2728enddef
2729
Bram Moolenaar62aec932022-01-29 21:45:34 +00002730def s:ExtendRef(Ref: func(string): list<string>, add: string)
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002731 Ref(add)
2732enddef
2733
2734def Test_closure_two_indirect_refs()
Bram Moolenaarf7779c62020-05-03 15:38:16 +02002735 MakeTwoRefs()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002736 ReadRef(g:Read)->assert_equal('some')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002737 ExtendRef(g:Extend, 'more')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002738 ReadRef(g:Read)->assert_equal('some more')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002739 ExtendRef(g:Extend, 'even')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002740 ReadRef(g:Read)->assert_equal('some more even')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002741
2742 unlet g:Extend
2743 unlet g:Read
2744enddef
Bram Moolenaarbf67ea12020-05-02 17:52:42 +02002745
Bram Moolenaar62aec932022-01-29 21:45:34 +00002746def s:MakeArgRefs(theArg: string)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002747 var local = 'loc_val'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002748 g:UseArg = (s) => theArg .. '/' .. local .. '/' .. s
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02002749enddef
2750
Bram Moolenaar62aec932022-01-29 21:45:34 +00002751def s:MakeArgRefsVarargs(theArg: string, ...rest: list<string>)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002752 var local = 'the_loc'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002753 g:UseVararg = (s) => theArg .. '/' .. local .. '/' .. s .. '/' .. join(rest)
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02002754enddef
2755
2756def Test_closure_using_argument()
2757 MakeArgRefs('arg_val')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002758 g:UseArg('call_val')->assert_equal('arg_val/loc_val/call_val')
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02002759
2760 MakeArgRefsVarargs('arg_val', 'one', 'two')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002761 g:UseVararg('call_val')->assert_equal('arg_val/the_loc/call_val/one two')
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02002762
2763 unlet g:UseArg
2764 unlet g:UseVararg
Bram Moolenaar44ec21c2021-02-12 21:50:57 +01002765
2766 var lines =<< trim END
2767 vim9script
2768 def Test(Fun: func(number): number): list<number>
2769 return map([1, 2, 3], (_, i) => Fun(i))
2770 enddef
2771 def Inc(nr: number): number
2772 return nr + 2
2773 enddef
2774 assert_equal([3, 4, 5], Test(Inc))
2775 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002776 v9.CheckScriptSuccess(lines)
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02002777enddef
2778
Bram Moolenaar62aec932022-01-29 21:45:34 +00002779def s:MakeGetAndAppendRefs()
Bram Moolenaar85d5e2b2020-10-10 14:13:01 +02002780 var local = 'a'
2781
2782 def Append(arg: string)
2783 local ..= arg
2784 enddef
2785 g:Append = Append
2786
2787 def Get(): string
2788 return local
2789 enddef
2790 g:Get = Get
2791enddef
2792
2793def Test_closure_append_get()
2794 MakeGetAndAppendRefs()
2795 g:Get()->assert_equal('a')
2796 g:Append('-b')
2797 g:Get()->assert_equal('a-b')
2798 g:Append('-c')
2799 g:Get()->assert_equal('a-b-c')
2800
2801 unlet g:Append
2802 unlet g:Get
2803enddef
Bram Moolenaarb68b3462020-05-06 21:06:30 +02002804
Bram Moolenaar04b12692020-05-04 23:24:44 +02002805def Test_nested_closure()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002806 var local = 'text'
Bram Moolenaar04b12692020-05-04 23:24:44 +02002807 def Closure(arg: string): string
2808 return local .. arg
2809 enddef
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002810 Closure('!!!')->assert_equal('text!!!')
Bram Moolenaar04b12692020-05-04 23:24:44 +02002811enddef
2812
Bram Moolenaar62aec932022-01-29 21:45:34 +00002813func s:GetResult(Ref)
Bram Moolenaar6f5b6df2020-05-16 21:20:12 +02002814 return a:Ref('some')
2815endfunc
2816
2817def Test_call_closure_not_compiled()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002818 var text = 'text'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002819 g:Ref = (s) => s .. text
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002820 GetResult(g:Ref)->assert_equal('sometext')
Bram Moolenaar6f5b6df2020-05-16 21:20:12 +02002821enddef
2822
Bram Moolenaar7cbfaa52020-09-18 21:25:32 +02002823def Test_double_closure_fails()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002824 var lines =<< trim END
Bram Moolenaar7cbfaa52020-09-18 21:25:32 +02002825 vim9script
2826 def Func()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002827 var name = 0
2828 for i in range(2)
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002829 timer_start(0, () => name)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002830 endfor
Bram Moolenaar7cbfaa52020-09-18 21:25:32 +02002831 enddef
2832 Func()
2833 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002834 v9.CheckScriptSuccess(lines)
Bram Moolenaar7cbfaa52020-09-18 21:25:32 +02002835enddef
2836
Bram Moolenaar85d5e2b2020-10-10 14:13:01 +02002837def Test_nested_closure_used()
2838 var lines =<< trim END
2839 vim9script
2840 def Func()
2841 var x = 'hello'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002842 var Closure = () => x
2843 g:Myclosure = () => Closure()
Bram Moolenaar85d5e2b2020-10-10 14:13:01 +02002844 enddef
2845 Func()
2846 assert_equal('hello', g:Myclosure())
2847 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002848 v9.CheckScriptSuccess(lines)
Bram Moolenaar85d5e2b2020-10-10 14:13:01 +02002849enddef
Bram Moolenaar0876c782020-10-07 19:08:04 +02002850
Bram Moolenaarc70bdab2020-09-26 19:59:38 +02002851def Test_nested_closure_fails()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002852 var lines =<< trim END
Bram Moolenaarc70bdab2020-09-26 19:59:38 +02002853 vim9script
2854 def FuncA()
2855 FuncB(0)
2856 enddef
2857 def FuncB(n: number): list<string>
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002858 return map([0], (_, v) => n)
Bram Moolenaarc70bdab2020-09-26 19:59:38 +02002859 enddef
2860 FuncA()
2861 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002862 v9.CheckScriptFailure(lines, 'E1012:')
Bram Moolenaarc70bdab2020-09-26 19:59:38 +02002863enddef
2864
Bram Moolenaarf112f302020-12-20 17:47:52 +01002865def Test_global_closure()
2866 var lines =<< trim END
2867 vim9script
2868 def ReverseEveryNLines(n: number, line1: number, line2: number)
2869 var mods = 'sil keepj keepp lockm '
2870 var range = ':' .. line1 .. ',' .. line2
2871 def g:Offset(): number
2872 var offset = (line('.') - line1 + 1) % n
2873 return offset != 0 ? offset : n
2874 enddef
2875 exe mods .. range .. 'g/^/exe "m .-" .. g:Offset()'
2876 enddef
2877
2878 new
2879 repeat(['aaa', 'bbb', 'ccc'], 3)->setline(1)
2880 ReverseEveryNLines(3, 1, 9)
2881 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002882 v9.CheckScriptSuccess(lines)
Bram Moolenaarf112f302020-12-20 17:47:52 +01002883 var expected = repeat(['ccc', 'bbb', 'aaa'], 3)
2884 assert_equal(expected, getline(1, 9))
2885 bwipe!
2886enddef
2887
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01002888def Test_global_closure_called_directly()
2889 var lines =<< trim END
2890 vim9script
2891 def Outer()
2892 var x = 1
2893 def g:Inner()
2894 var y = x
2895 x += 1
2896 assert_equal(1, y)
2897 enddef
2898 g:Inner()
2899 assert_equal(2, x)
2900 enddef
2901 Outer()
2902 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002903 v9.CheckScriptSuccess(lines)
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01002904 delfunc g:Inner
2905enddef
2906
Bram Moolenaar69c76172021-12-02 16:38:52 +00002907def Test_closure_called_from_legacy()
2908 var lines =<< trim END
2909 vim9script
2910 def Func()
2911 var outer = 'foo'
2912 var F = () => {
2913 outer = 'bar'
2914 }
2915 execute printf('call %s()', string(F))
2916 enddef
2917 Func()
2918 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002919 v9.CheckScriptFailure(lines, 'E1248')
Bram Moolenaar69c76172021-12-02 16:38:52 +00002920enddef
2921
Bram Moolenaar34c54eb2020-11-25 19:15:19 +01002922def Test_failure_in_called_function()
2923 # this was using the frame index as the return value
2924 var lines =<< trim END
2925 vim9script
2926 au TerminalWinOpen * eval [][0]
2927 def PopupTerm(a: any)
2928 # make sure typvals on stack are string
2929 ['a', 'b', 'c', 'd', 'e', 'f', 'g']->join()
2930 FireEvent()
2931 enddef
2932 def FireEvent()
2933 do TerminalWinOpen
2934 enddef
2935 # use try/catch to make eval fail
2936 try
2937 call PopupTerm(0)
2938 catch
2939 endtry
2940 au! TerminalWinOpen
2941 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002942 v9.CheckScriptSuccess(lines)
Bram Moolenaar34c54eb2020-11-25 19:15:19 +01002943enddef
2944
Bram Moolenaar5366e1a2020-10-01 13:01:34 +02002945def Test_nested_lambda()
2946 var lines =<< trim END
2947 vim9script
2948 def Func()
2949 var x = 4
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002950 var Lambda1 = () => 7
2951 var Lambda2 = () => [Lambda1(), x]
Bram Moolenaar5366e1a2020-10-01 13:01:34 +02002952 var res = Lambda2()
2953 assert_equal([7, 4], res)
2954 enddef
2955 Func()
2956 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002957 v9.CheckScriptSuccess(lines)
Bram Moolenaar5366e1a2020-10-01 13:01:34 +02002958enddef
2959
Bram Moolenaarc04f2a42021-06-09 19:30:03 +02002960def Test_double_nested_lambda()
2961 var lines =<< trim END
2962 vim9script
2963 def F(head: string): func(string): func(string): string
2964 return (sep: string): func(string): string => ((tail: string): string => {
2965 return head .. sep .. tail
2966 })
2967 enddef
2968 assert_equal('hello-there', F('hello')('-')('there'))
2969 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002970 v9.CheckScriptSuccess(lines)
Bram Moolenaarc04f2a42021-06-09 19:30:03 +02002971enddef
2972
Bram Moolenaar074f84c2021-05-18 11:47:44 +02002973def Test_nested_inline_lambda()
Bram Moolenaar074f84c2021-05-18 11:47:44 +02002974 var lines =<< trim END
2975 vim9script
2976 def F(text: string): func(string): func(string): string
2977 return (arg: string): func(string): string => ((sep: string): string => {
Bram Moolenaar23e2e112021-08-03 21:16:18 +02002978 return sep .. arg .. text
Bram Moolenaar074f84c2021-05-18 11:47:44 +02002979 })
2980 enddef
Bram Moolenaar23e2e112021-08-03 21:16:18 +02002981 assert_equal('--there++', F('++')('there')('--'))
Bram Moolenaar074f84c2021-05-18 11:47:44 +02002982 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002983 v9.CheckScriptSuccess(lines)
Bram Moolenaar5245beb2021-07-15 22:03:50 +02002984
2985 lines =<< trim END
2986 vim9script
2987 echo range(4)->mapnew((_, v) => {
2988 return range(v) ->mapnew((_, s) => {
2989 return string(s)
2990 })
2991 })
2992 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002993 v9.CheckScriptSuccess(lines)
Bram Moolenaarc6ba2f92021-07-18 13:42:29 +02002994
2995 lines =<< trim END
2996 vim9script
2997
Bram Moolenaara749a422022-02-12 19:52:25 +00002998 def Func()
Bram Moolenaarc6ba2f92021-07-18 13:42:29 +02002999 range(10)
3000 ->mapnew((_, _) => ({
3001 key: range(10)->mapnew((_, _) => {
3002 return ' '
3003 }),
3004 }))
3005 enddef
3006
3007 defcomp
3008 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003009 v9.CheckScriptSuccess(lines)
Bram Moolenaar074f84c2021-05-18 11:47:44 +02003010enddef
3011
Bram Moolenaar52bf81c2020-11-17 18:50:44 +01003012def Shadowed(): list<number>
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01003013 var FuncList: list<func: number> = [() => 42]
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01003014 return FuncList->mapnew((_, Shadowed) => Shadowed())
Bram Moolenaar52bf81c2020-11-17 18:50:44 +01003015enddef
3016
3017def Test_lambda_arg_shadows_func()
Bram Moolenaar62aec932022-01-29 21:45:34 +00003018 assert_equal([42], g:Shadowed())
Bram Moolenaar52bf81c2020-11-17 18:50:44 +01003019enddef
3020
Bram Moolenaar21dc8f12022-03-16 17:54:17 +00003021def Test_compiling_referenced_func_no_shadow()
3022 var lines =<< trim END
3023 vim9script
3024
3025 def InitializeReply(lspserver: dict<any>)
3026 enddef
3027
3028 def ProcessReply(lspserver: dict<any>)
3029 var lsp_reply_handlers: dict<func> =
3030 { 'initialize': InitializeReply }
3031 lsp_reply_handlers['initialize'](lspserver)
3032 enddef
3033
3034 call ProcessReply({})
3035 END
3036 v9.CheckScriptSuccess(lines)
3037enddef
3038
Bram Moolenaar62aec932022-01-29 21:45:34 +00003039def s:Line_continuation_in_def(dir: string = ''): string
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02003040 var path: string = empty(dir)
3041 \ ? 'empty'
3042 \ : 'full'
3043 return path
Bram Moolenaaracd4c5e2020-06-22 19:39:03 +02003044enddef
3045
3046def Test_line_continuation_in_def()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02003047 Line_continuation_in_def('.')->assert_equal('full')
Bram Moolenaaracd4c5e2020-06-22 19:39:03 +02003048enddef
3049
Bram Moolenaar2ea95b62020-11-19 21:47:56 +01003050def Test_script_var_in_lambda()
3051 var lines =<< trim END
3052 vim9script
3053 var script = 'test'
Bram Moolenaarbb8a7ce2021-04-10 20:10:26 +02003054 assert_equal(['test'], map(['one'], (_, _) => script))
Bram Moolenaar2ea95b62020-11-19 21:47:56 +01003055 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003056 v9.CheckScriptSuccess(lines)
Bram Moolenaar2ea95b62020-11-19 21:47:56 +01003057enddef
3058
Bram Moolenaar62aec932022-01-29 21:45:34 +00003059def s:Line_continuation_in_lambda(): list<string>
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02003060 var x = range(97, 100)
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01003061 ->mapnew((_, v) => nr2char(v)
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01003062 ->toupper())
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02003063 ->reverse()
3064 return x
3065enddef
3066
3067def Test_line_continuation_in_lambda()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02003068 Line_continuation_in_lambda()->assert_equal(['D', 'C', 'B', 'A'])
Bram Moolenaarf898f7c2021-01-16 18:09:52 +01003069
3070 var lines =<< trim END
3071 vim9script
3072 var res = [{n: 1, m: 2, s: 'xxx'}]
3073 ->mapnew((_, v: dict<any>): string => printf('%d:%d:%s',
3074 v.n,
3075 v.m,
3076 substitute(v.s, '.*', 'yyy', '')
3077 ))
3078 assert_equal(['1:2:yyy'], res)
3079 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003080 v9.CheckScriptSuccess(lines)
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02003081enddef
3082
Bram Moolenaarb6571982021-01-08 22:24:19 +01003083def Test_list_lambda()
3084 timer_start(1000, (_) => 0)
3085 var body = execute(timer_info()[0].callback
3086 ->string()
3087 ->substitute("('", ' ', '')
3088 ->substitute("')", '', '')
3089 ->substitute('function\zs', ' ', ''))
Bram Moolenaar767034c2021-04-09 17:24:52 +02003090 assert_match('def <lambda>\d\+(_: any): number\n1 return 0\n enddef', body)
Bram Moolenaarb6571982021-01-08 22:24:19 +01003091enddef
3092
Bram Moolenaar3c77b6a2021-07-25 18:07:00 +02003093def Test_lambda_block_variable()
Bram Moolenaar88421d62021-07-24 14:14:52 +02003094 var lines =<< trim END
3095 vim9script
3096 var flist: list<func>
3097 for i in range(10)
3098 var inloop = i
3099 flist[i] = () => inloop
3100 endfor
3101 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003102 v9.CheckScriptSuccess(lines)
Bram Moolenaar88421d62021-07-24 14:14:52 +02003103
3104 lines =<< trim END
3105 vim9script
3106 if true
3107 var outloop = 5
3108 var flist: list<func>
3109 for i in range(10)
3110 flist[i] = () => outloop
3111 endfor
3112 endif
3113 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003114 v9.CheckScriptSuccess(lines)
Bram Moolenaar88421d62021-07-24 14:14:52 +02003115
3116 lines =<< trim END
3117 vim9script
3118 if true
3119 var outloop = 5
3120 endif
3121 var flist: list<func>
3122 for i in range(10)
3123 flist[i] = () => outloop
3124 endfor
3125 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003126 v9.CheckScriptFailure(lines, 'E1001: Variable not found: outloop', 1)
Bram Moolenaar3c77b6a2021-07-25 18:07:00 +02003127
3128 lines =<< trim END
3129 vim9script
3130 for i in range(10)
3131 var Ref = () => 0
3132 endfor
3133 assert_equal(0, ((i) => 0)(0))
3134 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003135 v9.CheckScriptSuccess(lines)
Bram Moolenaar88421d62021-07-24 14:14:52 +02003136enddef
3137
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02003138def Test_legacy_lambda()
3139 legacy echo {x -> 'hello ' .. x}('foo')
Bram Moolenaardc4c2302021-04-25 13:54:42 +02003140
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02003141 var lines =<< trim END
3142 echo {x -> 'hello ' .. x}('foo')
3143 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003144 v9.CheckDefAndScriptFailure(lines, 'E720:')
Bram Moolenaardc4c2302021-04-25 13:54:42 +02003145
3146 lines =<< trim END
3147 vim9script
3148 def Func()
3149 echo (() => 'no error')()
3150 enddef
3151 legacy call s:Func()
3152 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003153 v9.CheckScriptSuccess(lines)
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02003154enddef
3155
Bram Moolenaarce024c32021-06-26 13:00:49 +02003156def Test_legacy()
3157 var lines =<< trim END
3158 vim9script
3159 func g:LegacyFunction()
3160 let g:legacyvar = 1
3161 endfunc
3162 def Testit()
3163 legacy call g:LegacyFunction()
3164 enddef
3165 Testit()
3166 assert_equal(1, g:legacyvar)
3167 unlet g:legacyvar
3168 delfunc g:LegacyFunction
3169 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003170 v9.CheckScriptSuccess(lines)
Bram Moolenaarce024c32021-06-26 13:00:49 +02003171enddef
3172
Bram Moolenaarc3cb1c92021-06-02 16:47:53 +02003173def Test_legacy_errors()
3174 for cmd in ['if', 'elseif', 'else', 'endif',
3175 'for', 'endfor', 'continue', 'break',
3176 'while', 'endwhile',
3177 'try', 'catch', 'finally', 'endtry']
Bram Moolenaar62aec932022-01-29 21:45:34 +00003178 v9.CheckDefFailure(['legacy ' .. cmd .. ' expr'], 'E1189:')
Bram Moolenaarc3cb1c92021-06-02 16:47:53 +02003179 endfor
3180enddef
3181
Bram Moolenaarb1b6f4d2021-09-13 18:25:54 +02003182def Test_call_legacy_with_dict()
3183 var lines =<< trim END
3184 vim9script
3185 func Legacy() dict
3186 let g:result = self.value
3187 endfunc
3188 def TestDirect()
3189 var d = {value: 'yes', func: Legacy}
3190 d.func()
3191 enddef
3192 TestDirect()
3193 assert_equal('yes', g:result)
3194 unlet g:result
3195
3196 def TestIndirect()
3197 var d = {value: 'foo', func: Legacy}
3198 var Fi = d.func
3199 Fi()
3200 enddef
3201 TestIndirect()
3202 assert_equal('foo', g:result)
3203 unlet g:result
3204
3205 var d = {value: 'bar', func: Legacy}
3206 d.func()
3207 assert_equal('bar', g:result)
3208 unlet g:result
3209 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003210 v9.CheckScriptSuccess(lines)
Bram Moolenaarb1b6f4d2021-09-13 18:25:54 +02003211enddef
3212
Bram Moolenaar62aec932022-01-29 21:45:34 +00003213def s:DoFilterThis(a: string): list<string>
Bram Moolenaarab360522021-01-10 14:02:28 +01003214 # closure nested inside another closure using argument
3215 var Filter = (l) => filter(l, (_, v) => stridx(v, a) == 0)
3216 return ['x', 'y', 'a', 'x2', 'c']->Filter()
3217enddef
3218
3219def Test_nested_closure_using_argument()
3220 assert_equal(['x', 'x2'], DoFilterThis('x'))
3221enddef
3222
Bram Moolenaar0186e582021-01-10 18:33:11 +01003223def Test_triple_nested_closure()
3224 var what = 'x'
3225 var Match = (val: string, cmp: string): bool => stridx(val, cmp) == 0
3226 var Filter = (l) => filter(l, (_, v) => Match(v, what))
3227 assert_equal(['x', 'x2'], ['x', 'y', 'a', 'x2', 'c']->Filter())
3228enddef
3229
Bram Moolenaar8f510af2020-07-05 18:48:23 +02003230func Test_silent_echo()
Bram Moolenaar47e7d702020-07-05 18:18:42 +02003231 CheckScreendump
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003232 call Run_Test_silent_echo()
3233endfunc
Bram Moolenaar47e7d702020-07-05 18:18:42 +02003234
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003235def Run_Test_silent_echo()
3236 var lines =<< trim END
Bram Moolenaar47e7d702020-07-05 18:18:42 +02003237 vim9script
3238 def EchoNothing()
3239 silent echo ''
3240 enddef
3241 defcompile
3242 END
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003243 writefile(lines, 'XTest_silent_echo')
Bram Moolenaar47e7d702020-07-05 18:18:42 +02003244
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003245 # Check that the balloon shows up after a mouse move
Bram Moolenaar62aec932022-01-29 21:45:34 +00003246 var buf = g:RunVimInTerminal('-S XTest_silent_echo', {'rows': 6})
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003247 term_sendkeys(buf, ":abc")
Bram Moolenaar62aec932022-01-29 21:45:34 +00003248 g:VerifyScreenDump(buf, 'Test_vim9_silent_echo', {})
Bram Moolenaar47e7d702020-07-05 18:18:42 +02003249
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003250 # clean up
Bram Moolenaar62aec932022-01-29 21:45:34 +00003251 g:StopVimInTerminal(buf)
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003252 delete('XTest_silent_echo')
3253enddef
Bram Moolenaar47e7d702020-07-05 18:18:42 +02003254
Bram Moolenaar171fb922020-10-28 16:54:47 +01003255def SilentlyError()
3256 execute('silent! invalid')
3257 g:did_it = 'yes'
3258enddef
3259
Bram Moolenaar62aec932022-01-29 21:45:34 +00003260func s:UserError()
Bram Moolenaar28ee8922020-10-28 20:20:00 +01003261 silent! invalid
3262endfunc
3263
3264def SilentlyUserError()
3265 UserError()
3266 g:did_it = 'yes'
3267enddef
Bram Moolenaar171fb922020-10-28 16:54:47 +01003268
3269" This can't be a :def function, because the assert would not be reached.
Bram Moolenaar171fb922020-10-28 16:54:47 +01003270func Test_ignore_silent_error()
3271 let g:did_it = 'no'
3272 call SilentlyError()
3273 call assert_equal('yes', g:did_it)
3274
Bram Moolenaar28ee8922020-10-28 20:20:00 +01003275 let g:did_it = 'no'
3276 call SilentlyUserError()
3277 call assert_equal('yes', g:did_it)
Bram Moolenaar171fb922020-10-28 16:54:47 +01003278
3279 unlet g:did_it
3280endfunc
3281
Bram Moolenaarcd030c42020-10-30 21:49:40 +01003282def Test_ignore_silent_error_in_filter()
3283 var lines =<< trim END
3284 vim9script
3285 def Filter(winid: number, key: string): bool
3286 if key == 'o'
3287 silent! eval [][0]
3288 return true
3289 endif
3290 return popup_filter_menu(winid, key)
3291 enddef
3292
Bram Moolenaare0de1712020-12-02 17:36:54 +01003293 popup_create('popup', {filter: Filter})
Bram Moolenaarcd030c42020-10-30 21:49:40 +01003294 feedkeys("o\r", 'xnt')
3295 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003296 v9.CheckScriptSuccess(lines)
Bram Moolenaarcd030c42020-10-30 21:49:40 +01003297enddef
3298
Bram Moolenaar62aec932022-01-29 21:45:34 +00003299def s:Fibonacci(n: number): number
Bram Moolenaar4b9bd692020-09-05 21:57:53 +02003300 if n < 2
3301 return n
3302 else
3303 return Fibonacci(n - 1) + Fibonacci(n - 2)
3304 endif
3305enddef
3306
Bram Moolenaar985116a2020-07-12 17:31:09 +02003307def Test_recursive_call()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02003308 Fibonacci(20)->assert_equal(6765)
Bram Moolenaar985116a2020-07-12 17:31:09 +02003309enddef
3310
Bram Moolenaar62aec932022-01-29 21:45:34 +00003311def s:TreeWalk(dir: string): list<any>
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01003312 return readdir(dir)->mapnew((_, val) =>
Bram Moolenaar08f7a412020-07-13 20:41:08 +02003313 fnamemodify(dir .. '/' .. val, ':p')->isdirectory()
Bram Moolenaar2bede172020-11-19 18:53:18 +01003314 ? {[val]: TreeWalk(dir .. '/' .. val)}
Bram Moolenaar08f7a412020-07-13 20:41:08 +02003315 : val
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01003316 )
Bram Moolenaar08f7a412020-07-13 20:41:08 +02003317enddef
3318
3319def Test_closure_in_map()
3320 mkdir('XclosureDir/tdir', 'p')
3321 writefile(['111'], 'XclosureDir/file1')
3322 writefile(['222'], 'XclosureDir/file2')
3323 writefile(['333'], 'XclosureDir/tdir/file3')
3324
Bram Moolenaare0de1712020-12-02 17:36:54 +01003325 TreeWalk('XclosureDir')->assert_equal(['file1', 'file2', {tdir: ['file3']}])
Bram Moolenaar08f7a412020-07-13 20:41:08 +02003326
3327 delete('XclosureDir', 'rf')
3328enddef
3329
Bram Moolenaar7b5d5442020-10-04 13:42:34 +02003330def Test_invalid_function_name()
3331 var lines =<< trim END
3332 vim9script
3333 def s: list<string>
3334 END
Bram Moolenaara749a422022-02-12 19:52:25 +00003335 v9.CheckScriptFailure(lines, 'E1268:')
Bram Moolenaar7b5d5442020-10-04 13:42:34 +02003336
3337 lines =<< trim END
3338 vim9script
3339 def g: list<string>
3340 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003341 v9.CheckScriptFailure(lines, 'E129:')
Bram Moolenaar7b5d5442020-10-04 13:42:34 +02003342
3343 lines =<< trim END
3344 vim9script
3345 def <SID>: list<string>
3346 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003347 v9.CheckScriptFailure(lines, 'E884:')
Bram Moolenaar7b5d5442020-10-04 13:42:34 +02003348
3349 lines =<< trim END
3350 vim9script
3351 def F list<string>
3352 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003353 v9.CheckScriptFailure(lines, 'E488:')
Bram Moolenaar7b5d5442020-10-04 13:42:34 +02003354enddef
3355
Bram Moolenaara90afb92020-07-15 22:38:56 +02003356def Test_partial_call()
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02003357 var lines =<< trim END
3358 var Xsetlist: func
3359 Xsetlist = function('setloclist', [0])
3360 Xsetlist([], ' ', {title: 'test'})
3361 getloclist(0, {title: 1})->assert_equal({title: 'test'})
Bram Moolenaara90afb92020-07-15 22:38:56 +02003362
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02003363 Xsetlist = function('setloclist', [0, [], ' '])
3364 Xsetlist({title: 'test'})
3365 getloclist(0, {title: 1})->assert_equal({title: 'test'})
Bram Moolenaara90afb92020-07-15 22:38:56 +02003366
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02003367 Xsetlist = function('setqflist')
3368 Xsetlist([], ' ', {title: 'test'})
3369 getqflist({title: 1})->assert_equal({title: 'test'})
Bram Moolenaara90afb92020-07-15 22:38:56 +02003370
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02003371 Xsetlist = function('setqflist', [[], ' '])
3372 Xsetlist({title: 'test'})
3373 getqflist({title: 1})->assert_equal({title: 'test'})
Bram Moolenaar6abd3dc2020-10-04 14:17:32 +02003374
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02003375 var Len: func: number = function('len', ['word'])
3376 assert_equal(4, Len())
3377
3378 var RepeatFunc = function('repeat', ['o'])
3379 assert_equal('ooooo', RepeatFunc(5))
3380 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003381 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarc66f6452021-08-19 21:08:30 +02003382
3383 lines =<< trim END
3384 vim9script
3385 def Foo(Parser: any)
3386 enddef
3387 var Expr: func(dict<any>): dict<any>
3388 const Call = Foo(Expr)
3389 END
Bram Moolenaar8acb9cc2022-03-08 13:18:55 +00003390 v9.CheckScriptFailure(lines, 'E1031:')
Bram Moolenaara90afb92020-07-15 22:38:56 +02003391enddef
3392
Bram Moolenaarcd1cda22022-02-16 21:48:25 +00003393def Test_partial_double_nested()
3394 var idx = 123
3395 var Get = () => idx
3396 var Ref = function(Get, [])
3397 var RefRef = function(Ref, [])
3398 assert_equal(123, RefRef())
3399enddef
3400
Bram Moolenaar673bcb12022-03-08 16:52:24 +00003401def Test_partial_null_function()
3402 var lines =<< trim END
3403 var d: dict<func> = {f: null_function}
3404 var Ref = d.f
Bram Moolenaared0c62e2022-03-08 19:43:55 +00003405 assert_equal('func(...): unknown', typename(Ref))
Bram Moolenaar673bcb12022-03-08 16:52:24 +00003406 END
3407 v9.CheckDefAndScriptSuccess(lines)
3408enddef
3409
Bram Moolenaarfe1bfc92022-02-06 13:55:03 +00003410" Using "idx" from a legacy global function does not work.
3411" This caused a crash when called from legacy context.
3412func Test_partial_call_fails()
3413 let lines =<< trim END
3414 vim9script
3415
3416 var l = ['a', 'b', 'c']
3417 def Iter(container: any): any
3418 var idx = -1
3419 var obj = {state: container}
Bram Moolenaarf681cfb2022-02-07 20:30:57 +00003420 def g:NextItem__(self: dict<any>): any
Bram Moolenaarfe1bfc92022-02-06 13:55:03 +00003421 ++idx
3422 return self.state[idx]
3423 enddef
Bram Moolenaarf681cfb2022-02-07 20:30:57 +00003424 obj.__next__ = function('g:NextItem__', [obj])
Bram Moolenaarfe1bfc92022-02-06 13:55:03 +00003425 return obj
3426 enddef
3427
3428 var it = Iter(l)
3429 echo it.__next__()
3430 END
3431 call writefile(lines, 'XpartialCall')
3432 try
3433 source XpartialCall
3434 catch /E1248:/
3435 endtry
3436 call delete('XpartialCall')
3437endfunc
3438
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02003439def Test_cmd_modifier()
3440 tab echo '0'
Bram Moolenaar62aec932022-01-29 21:45:34 +00003441 v9.CheckDefFailure(['5tab echo 3'], 'E16:')
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02003442enddef
3443
3444def Test_restore_modifiers()
3445 # check that when compiling a :def function command modifiers are not messed
3446 # up.
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02003447 var lines =<< trim END
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02003448 vim9script
3449 set eventignore=
3450 autocmd QuickFixCmdPost * copen
3451 def AutocmdsDisabled()
Bram Moolenaarc3235272021-07-10 19:42:03 +02003452 eval 1 + 2
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02003453 enddef
3454 func Func()
3455 noautocmd call s:AutocmdsDisabled()
3456 let g:ei_after = &eventignore
3457 endfunc
3458 Func()
3459 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003460 v9.CheckScriptSuccess(lines)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02003461 g:ei_after->assert_equal('')
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02003462enddef
3463
Bram Moolenaardfa3d552020-09-10 22:05:08 +02003464def StackTop()
Bram Moolenaarc3235272021-07-10 19:42:03 +02003465 eval 1 + 2
3466 eval 2 + 3
Bram Moolenaardfa3d552020-09-10 22:05:08 +02003467 # call not on fourth line
Bram Moolenaar62aec932022-01-29 21:45:34 +00003468 g:StackBot()
Bram Moolenaardfa3d552020-09-10 22:05:08 +02003469enddef
3470
3471def StackBot()
3472 # throw an error
3473 eval [][0]
3474enddef
3475
3476def Test_callstack_def()
3477 try
Bram Moolenaar62aec932022-01-29 21:45:34 +00003478 g:StackTop()
Bram Moolenaardfa3d552020-09-10 22:05:08 +02003479 catch
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02003480 v:throwpoint->assert_match('Test_callstack_def\[2\]..StackTop\[4\]..StackBot, line 2')
Bram Moolenaardfa3d552020-09-10 22:05:08 +02003481 endtry
3482enddef
3483
Bram Moolenaare8211a32020-10-09 22:04:29 +02003484" Re-using spot for variable used in block
3485def Test_block_scoped_var()
3486 var lines =<< trim END
3487 vim9script
3488 def Func()
3489 var x = ['a', 'b', 'c']
3490 if 1
3491 var y = 'x'
Bram Moolenaarbb8a7ce2021-04-10 20:10:26 +02003492 map(x, (_, _) => y)
Bram Moolenaare8211a32020-10-09 22:04:29 +02003493 endif
3494 var z = x
3495 assert_equal(['x', 'x', 'x'], z)
3496 enddef
3497 Func()
3498 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003499 v9.CheckScriptSuccess(lines)
Bram Moolenaare8211a32020-10-09 22:04:29 +02003500enddef
3501
Bram Moolenaareeece9e2020-11-20 19:26:48 +01003502def Test_reset_did_emsg()
3503 var lines =<< trim END
3504 @s = 'blah'
3505 au BufWinLeave * #
3506 def Func()
3507 var winid = popup_create('popup', {})
3508 exe '*s'
3509 popup_close(winid)
3510 enddef
3511 Func()
3512 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003513 v9.CheckScriptFailure(lines, 'E492:', 8)
Bram Moolenaar2d870f82020-12-05 13:41:01 +01003514 delfunc! g:Func
Bram Moolenaareeece9e2020-11-20 19:26:48 +01003515enddef
3516
Bram Moolenaar57f799e2020-12-12 20:42:19 +01003517def Test_did_emsg_reset()
3518 # executing an autocommand resets did_emsg, this should not result in a
3519 # builtin function considered failing
3520 var lines =<< trim END
3521 vim9script
3522 au BufWinLeave * #
3523 def Func()
Bram Moolenaar767034c2021-04-09 17:24:52 +02003524 popup_menu('', {callback: (a, b) => popup_create('', {})->popup_close()})
Bram Moolenaar57f799e2020-12-12 20:42:19 +01003525 eval [][0]
3526 enddef
3527 nno <F3> <cmd>call <sid>Func()<cr>
3528 feedkeys("\<F3>\e", 'xt')
3529 END
3530 writefile(lines, 'XemsgReset')
3531 assert_fails('so XemsgReset', ['E684:', 'E684:'], lines, 2)
3532 delete('XemsgReset')
3533 nunmap <F3>
3534 au! BufWinLeave
3535enddef
3536
Bram Moolenaar56602ba2020-12-05 21:22:08 +01003537def Test_abort_with_silent_call()
3538 var lines =<< trim END
3539 vim9script
3540 g:result = 'none'
3541 def Func()
3542 g:result += 3
3543 g:result = 'yes'
3544 enddef
3545 # error is silenced, but function aborts on error
3546 silent! Func()
3547 assert_equal('none', g:result)
3548 unlet g:result
3549 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003550 v9.CheckScriptSuccess(lines)
Bram Moolenaar56602ba2020-12-05 21:22:08 +01003551enddef
3552
Bram Moolenaarf665e972020-12-05 19:17:16 +01003553def Test_continues_with_silent_error()
3554 var lines =<< trim END
3555 vim9script
3556 g:result = 'none'
3557 def Func()
3558 silent! g:result += 3
3559 g:result = 'yes'
3560 enddef
3561 # error is silenced, function does not abort
3562 Func()
3563 assert_equal('yes', g:result)
3564 unlet g:result
3565 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003566 v9.CheckScriptSuccess(lines)
Bram Moolenaarf665e972020-12-05 19:17:16 +01003567enddef
3568
Bram Moolenaaraf0df472020-12-02 20:51:22 +01003569def Test_abort_even_with_silent()
3570 var lines =<< trim END
3571 vim9script
3572 g:result = 'none'
3573 def Func()
3574 eval {-> ''}() .. '' .. {}['X']
3575 g:result = 'yes'
3576 enddef
Bram Moolenaarf665e972020-12-05 19:17:16 +01003577 silent! Func()
Bram Moolenaaraf0df472020-12-02 20:51:22 +01003578 assert_equal('none', g:result)
Bram Moolenaar4029cab2020-12-05 18:13:27 +01003579 unlet g:result
3580 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003581 v9.CheckScriptSuccess(lines)
Bram Moolenaar4029cab2020-12-05 18:13:27 +01003582enddef
3583
Bram Moolenaarf665e972020-12-05 19:17:16 +01003584def Test_cmdmod_silent_restored()
3585 var lines =<< trim END
3586 vim9script
3587 def Func()
3588 g:result = 'none'
3589 silent! g:result += 3
3590 g:result = 'none'
3591 g:result += 3
3592 enddef
3593 Func()
3594 END
3595 # can't use CheckScriptFailure, it ignores the :silent!
3596 var fname = 'Xdefsilent'
3597 writefile(lines, fname)
3598 var caught = 'no'
3599 try
3600 exe 'source ' .. fname
3601 catch /E1030:/
3602 caught = 'yes'
3603 assert_match('Func, line 4', v:throwpoint)
3604 endtry
3605 assert_equal('yes', caught)
3606 delete(fname)
3607enddef
3608
Bram Moolenaar2fecb532021-03-24 22:00:56 +01003609def Test_cmdmod_silent_nested()
3610 var lines =<< trim END
3611 vim9script
3612 var result = ''
3613
3614 def Error()
3615 result ..= 'Eb'
3616 eval [][0]
3617 result ..= 'Ea'
3618 enddef
3619
3620 def Crash()
3621 result ..= 'Cb'
3622 sil! Error()
3623 result ..= 'Ca'
3624 enddef
3625
3626 Crash()
3627 assert_equal('CbEbEaCa', result)
3628 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003629 v9.CheckScriptSuccess(lines)
Bram Moolenaar2fecb532021-03-24 22:00:56 +01003630enddef
3631
Bram Moolenaar4029cab2020-12-05 18:13:27 +01003632def Test_dict_member_with_silent()
3633 var lines =<< trim END
3634 vim9script
3635 g:result = 'none'
3636 var d: dict<any>
3637 def Func()
3638 try
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01003639 g:result = map([], (_, v) => ({}[v]))->join() .. d['']
Bram Moolenaar4029cab2020-12-05 18:13:27 +01003640 catch
3641 endtry
3642 enddef
3643 silent! Func()
3644 assert_equal('0', g:result)
3645 unlet g:result
Bram Moolenaaraf0df472020-12-02 20:51:22 +01003646 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003647 v9.CheckScriptSuccess(lines)
Bram Moolenaaraf0df472020-12-02 20:51:22 +01003648enddef
3649
Bram Moolenaarf9041332021-01-21 19:41:16 +01003650def Test_skip_cmds_with_silent()
3651 var lines =<< trim END
3652 vim9script
3653
3654 def Func(b: bool)
3655 Crash()
3656 enddef
3657
3658 def Crash()
3659 sil! :/not found/d _
3660 sil! :/not found/put _
3661 enddef
3662
3663 Func(true)
3664 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003665 v9.CheckScriptSuccess(lines)
Bram Moolenaarf9041332021-01-21 19:41:16 +01003666enddef
3667
Bram Moolenaar5b3d1bb2020-12-22 12:20:08 +01003668def Test_opfunc()
Bram Moolenaar848fadd2022-01-30 15:28:30 +00003669 nnoremap <F3> <cmd>set opfunc=g:Opfunc<cr>g@
Bram Moolenaar5b3d1bb2020-12-22 12:20:08 +01003670 def g:Opfunc(_: any): string
3671 setline(1, 'ASDF')
3672 return ''
3673 enddef
3674 new
3675 setline(1, 'asdf')
3676 feedkeys("\<F3>$", 'x')
3677 assert_equal('ASDF', getline(1))
3678
3679 bwipe!
3680 nunmap <F3>
3681enddef
3682
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003683func Test_opfunc_error()
3684 CheckScreendump
3685 call Run_Test_opfunc_error()
3686endfunc
3687
3688def Run_Test_opfunc_error()
3689 # test that the error from Opfunc() is displayed right away
3690 var lines =<< trim END
3691 vim9script
3692
3693 def Opfunc(type: string)
3694 try
3695 eval [][0]
3696 catch /nothing/ # error not caught
3697 endtry
3698 enddef
3699 &operatorfunc = Opfunc
3700 nnoremap <expr> l <SID>L()
3701 def L(): string
3702 return 'l'
3703 enddef
3704 'x'->repeat(10)->setline(1)
3705 feedkeys('g@l', 'n')
3706 feedkeys('llll')
3707 END
3708 call writefile(lines, 'XTest_opfunc_error')
3709
Bram Moolenaar62aec932022-01-29 21:45:34 +00003710 var buf = g:RunVimInTerminal('-S XTest_opfunc_error', {rows: 6, wait_for_ruler: 0})
3711 g:WaitForAssert(() => assert_match('Press ENTER', term_getline(buf, 6)))
3712 g:WaitForAssert(() => assert_match('E684: list index out of range: 0', term_getline(buf, 5)))
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003713
3714 # clean up
Bram Moolenaar62aec932022-01-29 21:45:34 +00003715 g:StopVimInTerminal(buf)
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003716 delete('XTest_opfunc_error')
3717enddef
3718
Bram Moolenaar077a4232020-12-22 18:33:27 +01003719" this was crashing on exit
3720def Test_nested_lambda_in_closure()
3721 var lines =<< trim END
3722 vim9script
Bram Moolenaar227c58a2021-04-28 20:40:44 +02003723 command WriteDone writefile(['Done'], 'XnestedDone')
Bram Moolenaar077a4232020-12-22 18:33:27 +01003724 def Outer()
3725 def g:Inner()
3726 echo map([1, 2, 3], {_, v -> v + 1})
3727 enddef
3728 g:Inner()
3729 enddef
3730 defcompile
Bram Moolenaar227c58a2021-04-28 20:40:44 +02003731 # not reached
Bram Moolenaar077a4232020-12-22 18:33:27 +01003732 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003733 if !g:RunVim([], lines, '--clean -c WriteDone -c quit')
Bram Moolenaar077a4232020-12-22 18:33:27 +01003734 return
3735 endif
3736 assert_equal(['Done'], readfile('XnestedDone'))
3737 delete('XnestedDone')
3738enddef
3739
Bram Moolenaar92368aa2022-02-07 17:50:39 +00003740def Test_nested_closure_funcref()
3741 var lines =<< trim END
3742 vim9script
3743 def Func()
3744 var n: number
3745 def Nested()
3746 ++n
3747 enddef
3748 Nested()
3749 g:result_one = n
3750 var Ref = function(Nested)
3751 Ref()
3752 g:result_two = n
3753 enddef
3754 Func()
3755 END
3756 v9.CheckScriptSuccess(lines)
3757 assert_equal(1, g:result_one)
3758 assert_equal(2, g:result_two)
3759 unlet g:result_one g:result_two
3760enddef
3761
Bram Moolenaar7aca5ca2022-02-07 19:56:43 +00003762def Test_nested_closure_in_dict()
3763 var lines =<< trim END
3764 vim9script
3765 def Func(): dict<any>
3766 var n: number
3767 def Inc(): number
3768 ++n
3769 return n
3770 enddef
3771 return {inc: function(Inc)}
3772 enddef
3773 disas Func
3774 var d = Func()
3775 assert_equal(1, d.inc())
3776 assert_equal(2, d.inc())
3777 END
3778 v9.CheckScriptSuccess(lines)
3779enddef
3780
Bram Moolenaarfb43cfc2022-03-11 18:54:17 +00003781def Test_script_local_other_script()
3782 var lines =<< trim END
3783 function LegacyJob()
3784 let FuncRef = function('s:close_cb')
3785 endfunction
3786 function s:close_cb(...)
3787 endfunction
3788 END
3789 lines->writefile('Xlegacy.vim')
3790 source Xlegacy.vim
3791 g:LegacyJob()
3792 g:LegacyJob()
3793 g:LegacyJob()
3794
3795 delfunc g:LegacyJob
3796 delete('Xlegacy.vim')
3797enddef
3798
Bram Moolenaar04947cc2021-03-06 19:26:46 +01003799def Test_check_func_arg_types()
3800 var lines =<< trim END
3801 vim9script
3802 def F1(x: string): string
3803 return x
3804 enddef
3805
3806 def F2(x: number): number
3807 return x + 1
3808 enddef
3809
Bram Moolenaar1d9cef72022-03-17 16:30:03 +00003810 def G(Fg: func): dict<func>
3811 return {f: Fg}
Bram Moolenaar04947cc2021-03-06 19:26:46 +01003812 enddef
3813
3814 def H(d: dict<func>): string
3815 return d.f('a')
3816 enddef
3817 END
3818
Bram Moolenaar62aec932022-01-29 21:45:34 +00003819 v9.CheckScriptSuccess(lines + ['echo H(G(F1))'])
3820 v9.CheckScriptFailure(lines + ['echo H(G(F2))'], 'E1013:')
Bram Moolenaar1d9cef72022-03-17 16:30:03 +00003821
3822 v9.CheckScriptFailure(lines + ['def SomeFunc(ff: func)', 'enddef'], 'E704:')
Bram Moolenaar04947cc2021-03-06 19:26:46 +01003823enddef
3824
Bram Moolenaarbadf04f2022-03-12 21:28:22 +00003825def Test_call_func_with_null()
3826 var lines =<< trim END
3827 def Fstring(v: string)
3828 assert_equal(null_string, v)
3829 enddef
3830 Fstring(null_string)
3831 def Fblob(v: blob)
3832 assert_equal(null_blob, v)
3833 enddef
3834 Fblob(null_blob)
3835 def Flist(v: list<number>)
3836 assert_equal(null_list, v)
3837 enddef
3838 Flist(null_list)
3839 def Fdict(v: dict<number>)
3840 assert_equal(null_dict, v)
3841 enddef
3842 Fdict(null_dict)
3843 def Ffunc(Fv: func(number): number)
3844 assert_equal(null_function, Fv)
3845 enddef
3846 Ffunc(null_function)
3847 if has('channel')
3848 def Fchannel(v: channel)
3849 assert_equal(null_channel, v)
3850 enddef
3851 Fchannel(null_channel)
3852 def Fjob(v: job)
3853 assert_equal(null_job, v)
3854 enddef
3855 Fjob(null_job)
3856 endif
3857 END
3858 v9.CheckDefAndScriptSuccess(lines)
3859enddef
3860
3861def Test_null_default_argument()
3862 var lines =<< trim END
3863 def Fstring(v: string = null_string)
3864 assert_equal(null_string, v)
3865 enddef
3866 Fstring()
3867 def Fblob(v: blob = null_blob)
3868 assert_equal(null_blob, v)
3869 enddef
3870 Fblob()
3871 def Flist(v: list<number> = null_list)
3872 assert_equal(null_list, v)
3873 enddef
3874 Flist()
3875 def Fdict(v: dict<number> = null_dict)
3876 assert_equal(null_dict, v)
3877 enddef
3878 Fdict()
3879 def Ffunc(Fv: func(number): number = null_function)
3880 assert_equal(null_function, Fv)
3881 enddef
3882 Ffunc()
3883 if has('channel')
3884 def Fchannel(v: channel = null_channel)
3885 assert_equal(null_channel, v)
3886 enddef
3887 Fchannel()
3888 def Fjob(v: job = null_job)
3889 assert_equal(null_job, v)
3890 enddef
3891 Fjob()
3892 endif
3893 END
3894 v9.CheckDefAndScriptSuccess(lines)
3895enddef
3896
3897def Test_null_return()
3898 var lines =<< trim END
3899 def Fstring(): string
3900 return null_string
3901 enddef
3902 assert_equal(null_string, Fstring())
3903 def Fblob(): blob
3904 return null_blob
3905 enddef
3906 assert_equal(null_blob, Fblob())
3907 def Flist(): list<number>
3908 return null_list
3909 enddef
3910 assert_equal(null_list, Flist())
3911 def Fdict(): dict<number>
3912 return null_dict
3913 enddef
3914 assert_equal(null_dict, Fdict())
3915 def Ffunc(): func(number): number
3916 return null_function
3917 enddef
3918 assert_equal(null_function, Ffunc())
3919 if has('channel')
3920 def Fchannel(): channel
3921 return null_channel
3922 enddef
3923 assert_equal(null_channel, Fchannel())
3924 def Fjob(): job
3925 return null_job
3926 enddef
3927 assert_equal(null_job, Fjob())
3928 endif
3929 END
3930 v9.CheckDefAndScriptSuccess(lines)
3931enddef
3932
Bram Moolenaar6e48b842021-08-10 22:52:02 +02003933def Test_list_any_type_checked()
3934 var lines =<< trim END
3935 vim9script
3936 def Foo()
3937 --decl--
3938 Bar(l)
3939 enddef
3940 def Bar(ll: list<dict<any>>)
3941 enddef
3942 Foo()
3943 END
Bram Moolenaar2d3ac2e2022-02-03 12:34:05 +00003944 # "any" could be "dict<any>", thus OK
Bram Moolenaar6e48b842021-08-10 22:52:02 +02003945 lines[2] = 'var l: list<any>'
Bram Moolenaar2d3ac2e2022-02-03 12:34:05 +00003946 v9.CheckScriptSuccess(lines)
Bram Moolenaar6e48b842021-08-10 22:52:02 +02003947 lines[2] = 'var l: list<any> = []'
Bram Moolenaar2d3ac2e2022-02-03 12:34:05 +00003948 v9.CheckScriptSuccess(lines)
Bram Moolenaar6e48b842021-08-10 22:52:02 +02003949
3950 lines[2] = 'var l: list<any> = [11]'
Bram Moolenaar62aec932022-01-29 21:45:34 +00003951 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected list<dict<any>> but got list<number>', 2)
Bram Moolenaar6e48b842021-08-10 22:52:02 +02003952enddef
3953
Bram Moolenaar701cc6c2021-04-10 13:33:48 +02003954def Test_compile_error()
3955 var lines =<< trim END
3956 def g:Broken()
3957 echo 'a' + {}
3958 enddef
3959 call g:Broken()
3960 END
3961 # First call: compilation error
Bram Moolenaar62aec932022-01-29 21:45:34 +00003962 v9.CheckScriptFailure(lines, 'E1051: Wrong argument type for +')
Bram Moolenaar701cc6c2021-04-10 13:33:48 +02003963
3964 # Second call won't try compiling again
3965 assert_fails('call g:Broken()', 'E1091: Function is not compiled: Broken')
Bram Moolenaar599410c2021-04-10 14:03:43 +02003966 delfunc g:Broken
3967
3968 # No error when compiling with :silent!
3969 lines =<< trim END
3970 def g:Broken()
3971 echo 'a' + []
3972 enddef
3973 silent! defcompile
3974 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003975 v9.CheckScriptSuccess(lines)
Bram Moolenaar599410c2021-04-10 14:03:43 +02003976
3977 # Calling the function won't try compiling again
3978 assert_fails('call g:Broken()', 'E1091: Function is not compiled: Broken')
3979 delfunc g:Broken
Bram Moolenaar701cc6c2021-04-10 13:33:48 +02003980enddef
3981
Bram Moolenaar962c43b2021-04-10 17:18:09 +02003982def Test_ignored_argument()
3983 var lines =<< trim END
3984 vim9script
3985 def Ignore(_, _): string
3986 return 'yes'
3987 enddef
3988 assert_equal('yes', Ignore(1, 2))
3989
3990 func Ok(_)
3991 return a:_
3992 endfunc
3993 assert_equal('ok', Ok('ok'))
3994
3995 func Oktoo()
3996 let _ = 'too'
3997 return _
3998 endfunc
3999 assert_equal('too', Oktoo())
Bram Moolenaarda479c72021-04-10 21:01:38 +02004000
4001 assert_equal([[1], [2], [3]], range(3)->mapnew((_, v) => [v]->map((_, w) => w + 1)))
Bram Moolenaar962c43b2021-04-10 17:18:09 +02004002 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004003 v9.CheckScriptSuccess(lines)
Bram Moolenaar962c43b2021-04-10 17:18:09 +02004004
4005 lines =<< trim END
4006 def Ignore(_: string): string
4007 return _
4008 enddef
4009 defcompile
4010 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004011 v9.CheckScriptFailure(lines, 'E1181:', 1)
Bram Moolenaar962c43b2021-04-10 17:18:09 +02004012
4013 lines =<< trim END
4014 var _ = 1
4015 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004016 v9.CheckDefAndScriptFailure(lines, 'E1181:', 1)
Yegappan Lakshmanan34fcb692021-05-25 20:14:00 +02004017
4018 lines =<< trim END
4019 var x = _
4020 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004021 v9.CheckDefAndScriptFailure(lines, 'E1181:', 1)
Bram Moolenaar962c43b2021-04-10 17:18:09 +02004022enddef
4023
Bram Moolenaarbb8a7ce2021-04-10 20:10:26 +02004024def Test_too_many_arguments()
4025 var lines =<< trim END
4026 echo [0, 1, 2]->map(() => 123)
4027 END
Bram Moolenaareddd4fc2022-02-20 15:52:28 +00004028 v9.CheckDefAndScriptFailure(lines, ['E176:', 'E1106: 2 arguments too many'], 1)
Bram Moolenaarbb8a7ce2021-04-10 20:10:26 +02004029
4030 lines =<< trim END
4031 echo [0, 1, 2]->map((_) => 123)
4032 END
Bram Moolenaareddd4fc2022-02-20 15:52:28 +00004033 v9.CheckDefAndScriptFailure(lines, ['E176', 'E1106: One argument too many'], 1)
Bram Moolenaarbb8a7ce2021-04-10 20:10:26 +02004034enddef
Bram Moolenaar077a4232020-12-22 18:33:27 +01004035
Bram Moolenaara6aa1642021-04-23 19:32:23 +02004036def Test_closing_brace_at_start_of_line()
4037 var lines =<< trim END
4038 def Func()
4039 enddef
4040 Func(
4041 )
4042 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004043 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaara6aa1642021-04-23 19:32:23 +02004044enddef
4045
Bram Moolenaar62aec932022-01-29 21:45:34 +00004046func s:CreateMydict()
Bram Moolenaarb033ee22021-08-15 16:08:36 +02004047 let g:mydict = {}
4048 func g:mydict.afunc()
4049 let g:result = self.key
4050 endfunc
4051endfunc
4052
4053def Test_numbered_function_reference()
4054 CreateMydict()
4055 var output = execute('legacy func g:mydict.afunc')
4056 var funcName = 'g:' .. substitute(output, '.*function \(\d\+\).*', '\1', '')
4057 execute 'function(' .. funcName .. ', [], {key: 42})()'
4058 # check that the function still exists
4059 assert_equal(output, execute('legacy func g:mydict.afunc'))
4060 unlet g:mydict
4061enddef
4062
Bram Moolenaard3a11782022-01-05 16:50:40 +00004063def Test_go_beyond_end_of_cmd()
4064 # this was reading the byte after the end of the line
4065 var lines =<< trim END
4066 def F()
4067 cal
4068 enddef
4069 defcompile
4070 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004071 v9.CheckScriptFailure(lines, 'E476:')
Bram Moolenaard3a11782022-01-05 16:50:40 +00004072enddef
4073
Yegappan Lakshmanan7c7e19c2022-04-09 11:09:07 +01004074" Test for memory allocation failure when defining a new lambda
4075func Test_lambda_allocation_failure()
4076 new
4077 let lines =<< trim END
4078 vim9script
4079 g:Xlambda = (x): number => {
4080 return x + 1
4081 }
4082 END
4083 call setline(1, lines)
4084 call test_alloc_fail(GetAllocId('get_func'), 0, 0)
4085 call assert_fails('source', 'E342:')
4086 call assert_false(exists('g:Xlambda'))
4087 bw!
4088endfunc
4089
Bram Moolenaar8b716f52022-02-15 21:17:56 +00004090" The following messes up syntax highlight, keep near the end.
Bram Moolenaar20677332021-06-06 17:02:53 +02004091if has('python3')
Bram Moolenaar8b716f52022-02-15 21:17:56 +00004092 def Test_python3_command()
4093 py3 import vim
Bram Moolenaarf5288c52022-02-15 21:33:29 +00004094 py3 vim.command("g:done = 'yes'")
Bram Moolenaar8b716f52022-02-15 21:17:56 +00004095 assert_equal('yes', g:done)
4096 unlet g:done
4097 enddef
4098
Bram Moolenaar20677332021-06-06 17:02:53 +02004099 def Test_python3_heredoc()
4100 py3 << trim EOF
4101 import vim
4102 vim.vars['didit'] = 'yes'
4103 EOF
4104 assert_equal('yes', g:didit)
4105
4106 python3 << trim EOF
4107 import vim
4108 vim.vars['didit'] = 'again'
4109 EOF
4110 assert_equal('again', g:didit)
4111 enddef
4112endif
4113
Bram Moolenaar20677332021-06-06 17:02:53 +02004114if has('lua')
4115 def Test_lua_heredoc()
4116 g:d = {}
4117 lua << trim EOF
4118 x = vim.eval('g:d')
4119 x['key'] = 'val'
4120 EOF
4121 assert_equal('val', g:d.key)
4122 enddef
Bram Moolenaarefd73ae2022-03-20 18:51:00 +00004123
4124 def Test_lua_heredoc_fails()
4125 var lines = [
4126 'vim9script',
4127 'def ExeLua()',
4128 'lua << trim EOLUA',
4129 "x = vim.eval('g:nodict')",
4130 'EOLUA',
4131 'enddef',
4132 'ExeLua()',
4133 ]
4134 v9.CheckScriptFailure(lines, 'E121: Undefined variable: g:nodict')
4135 enddef
Bram Moolenaar20677332021-06-06 17:02:53 +02004136endif
4137
Bram Moolenaarf7779c62020-05-03 15:38:16 +02004138
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02004139" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker