blob: 2ac8609873dc453cc63387375cd965362dd6e7f2 [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 Moolenaar04b12692020-05-04 23:24:44 +02006source vim9.vim
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()
21endfunc
22
23def TestCompilingError()
Bram Moolenaarf4e8cdd2020-10-12 22:07:13 +020024 var lines =<< trim END
25 vim9script
26 def Fails()
27 echo nothing
28 enddef
29 defcompile
30 END
31 call writefile(lines, 'XTest_compile_error')
32 var buf = RunVimInTerminal('-S XTest_compile_error',
Bram Moolenaare0de1712020-12-02 17:36:54 +010033 {rows: 10, wait_for_ruler: 0})
Bram Moolenaar03dfde22021-02-14 13:17:22 +010034 call WaitForAssert(() => assert_match('Error detected while compiling command line.*Fails.*Variable not found: nothing',
35 Term_getlines(buf, range(1, 9))))
Bram Moolenaarf4e8cdd2020-10-12 22:07:13 +020036
37 # clean up
38 call StopVimInTerminal(buf)
39 call delete('XTest_compile_error')
40enddef
41
Bram Moolenaar0ba48e82020-11-17 18:23:19 +010042def CallRecursive(n: number): number
43 return CallRecursive(n + 1)
44enddef
45
46def CallMapRecursive(l: list<number>): number
Bram Moolenaar2949cfd2020-12-31 21:28:47 +010047 return map(l, (_, v) => CallMapRecursive([v]))[0]
Bram Moolenaar0ba48e82020-11-17 18:23:19 +010048enddef
49
50def Test_funcdepth_error()
51 set maxfuncdepth=10
52
53 var caught = false
54 try
55 CallRecursive(1)
56 catch /E132:/
57 caught = true
58 endtry
59 assert_true(caught)
60
61 caught = false
62 try
63 CallMapRecursive([1])
64 catch /E132:/
65 caught = true
66 endtry
67 assert_true(caught)
68
69 set maxfuncdepth&
70enddef
71
Bram Moolenaar5178b1b2021-01-01 18:43:51 +010072def Test_endfunc_enddef()
73 var lines =<< trim END
74 def Test()
75 echo 'test'
76 endfunc
77 enddef
78 END
79 CheckScriptFailure(lines, 'E1151:', 3)
80
81 lines =<< trim END
82 def Test()
83 func Nested()
84 echo 'test'
85 enddef
86 enddef
87 END
88 CheckScriptFailure(lines, 'E1152:', 4)
89enddef
90
Bram Moolenaarb8ba9b92021-01-01 18:54:34 +010091def Test_missing_endfunc_enddef()
92 var lines =<< trim END
93 vim9script
94 def Test()
95 echo 'test'
96 endef
97 END
98 CheckScriptFailure(lines, 'E1057:', 2)
99
100 lines =<< trim END
101 vim9script
102 func Some()
103 echo 'test'
104 enfffunc
105 END
106 CheckScriptFailure(lines, 'E126:', 2)
107enddef
108
Bram Moolenaar4efd9942021-01-24 21:14:20 +0100109def Test_white_space_before_paren()
110 var lines =<< trim END
111 vim9script
112 def Test ()
113 echo 'test'
114 enddef
115 END
116 CheckScriptFailure(lines, 'E1068:', 2)
117
118 lines =<< trim END
119 vim9script
120 func Test ()
121 echo 'test'
122 endfunc
123 END
124 CheckScriptFailure(lines, 'E1068:', 2)
125
126 lines =<< trim END
127 def Test ()
128 echo 'test'
129 enddef
130 END
131 CheckScriptFailure(lines, 'E1068:', 1)
132
133 lines =<< trim END
134 func Test ()
135 echo 'test'
136 endfunc
137 END
138 CheckScriptSuccess(lines)
139enddef
140
Bram Moolenaar832ea892021-01-08 21:55:26 +0100141def Test_enddef_dict_key()
142 var d = {
143 enddef: 'x',
144 endfunc: 'y',
145 }
146 assert_equal({enddef: 'x', endfunc: 'y'}, d)
147enddef
148
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200149def ReturnString(): string
150 return 'string'
151enddef
152
153def ReturnNumber(): number
154 return 123
155enddef
156
157let g:notNumber = 'string'
158
159def ReturnGlobal(): number
160 return g:notNumber
161enddef
162
163def Test_return_something()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200164 ReturnString()->assert_equal('string')
165 ReturnNumber()->assert_equal(123)
Bram Moolenaar5e654232020-09-16 15:22:00 +0200166 assert_fails('ReturnGlobal()', 'E1012: Type mismatch; expected number but got string', '', 1, 'ReturnGlobal')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200167enddef
168
Bram Moolenaare32e5162021-01-21 20:21:29 +0100169def Test_check_argument_type()
170 var lines =<< trim END
171 vim9script
172 def Val(a: number, b: number): number
173 return 0
174 enddef
175 def Func()
176 var x: any = true
177 Val(0, x)
178 enddef
179 disass Func
180 Func()
181 END
182 CheckScriptFailure(lines, 'E1013: Argument 2: type mismatch, expected number but got bool', 2)
183enddef
184
Bram Moolenaarefd88552020-06-18 20:50:10 +0200185def Test_missing_return()
186 CheckDefFailure(['def Missing(): number',
187 ' if g:cond',
188 ' echo "no return"',
189 ' else',
190 ' return 0',
191 ' endif'
192 'enddef'], 'E1027:')
193 CheckDefFailure(['def Missing(): number',
194 ' if g:cond',
195 ' return 1',
196 ' else',
197 ' echo "no return"',
198 ' endif'
199 'enddef'], 'E1027:')
200 CheckDefFailure(['def Missing(): number',
201 ' if g:cond',
202 ' return 1',
203 ' else',
204 ' return 2',
205 ' endif'
206 ' return 3'
207 'enddef'], 'E1095:')
208enddef
209
Bram Moolenaar403dc312020-10-17 19:29:51 +0200210def Test_return_bool()
211 var lines =<< trim END
212 vim9script
213 def MenuFilter(id: number, key: string): bool
214 return popup_filter_menu(id, key)
215 enddef
216 def YesnoFilter(id: number, key: string): bool
217 return popup_filter_yesno(id, key)
218 enddef
219 defcompile
220 END
221 CheckScriptSuccess(lines)
222enddef
223
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200224let s:nothing = 0
225def ReturnNothing()
226 s:nothing = 1
227 if true
228 return
229 endif
230 s:nothing = 2
231enddef
232
233def Test_return_nothing()
234 ReturnNothing()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200235 s:nothing->assert_equal(1)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200236enddef
237
Bram Moolenaar648ea762021-01-15 19:04:32 +0100238def Test_return_invalid()
239 var lines =<< trim END
240 vim9script
241 def Func(): invalid
242 return xxx
243 enddef
244 defcompile
245 END
246 CheckScriptFailure(lines, 'E1010:', 2)
Bram Moolenaar31842cd2021-02-12 22:10:21 +0100247
248 lines =<< trim END
249 vim9script
250 def Test(Fun: func(number): number): list<number>
251 return map([1, 2, 3], (_, i) => Fun(i))
252 enddef
253 defcompile
254 def Inc(nr: number): nr
255 return nr + 2
256 enddef
257 echo Test(Inc)
258 END
259 # doing this twice was leaking memory
260 CheckScriptFailure(lines, 'E1010:')
261 CheckScriptFailure(lines, 'E1010:')
Bram Moolenaar648ea762021-01-15 19:04:32 +0100262enddef
263
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200264func Increment()
265 let g:counter += 1
266endfunc
267
268def Test_call_ufunc_count()
269 g:counter = 1
270 Increment()
271 Increment()
272 Increment()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200273 # works with and without :call
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200274 g:counter->assert_equal(4)
275 eval g:counter->assert_equal(4)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200276 unlet g:counter
277enddef
278
279def MyVarargs(arg: string, ...rest: list<string>): string
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200280 var res = arg
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200281 for s in rest
282 res ..= ',' .. s
283 endfor
284 return res
285enddef
286
287def Test_call_varargs()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200288 MyVarargs('one')->assert_equal('one')
289 MyVarargs('one', 'two')->assert_equal('one,two')
290 MyVarargs('one', 'two', 'three')->assert_equal('one,two,three')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200291enddef
292
293def MyDefaultArgs(name = 'string'): string
294 return name
295enddef
296
Bram Moolenaare30f64b2020-07-15 19:48:20 +0200297def MyDefaultSecond(name: string, second: bool = true): string
298 return second ? name : 'none'
299enddef
300
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200301def Test_call_default_args()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200302 MyDefaultArgs()->assert_equal('string')
303 MyDefaultArgs('one')->assert_equal('one')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +0200304 assert_fails('MyDefaultArgs("one", "two")', 'E118:', '', 3, 'Test_call_default_args')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200305
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200306 MyDefaultSecond('test')->assert_equal('test')
307 MyDefaultSecond('test', true)->assert_equal('test')
308 MyDefaultSecond('test', false)->assert_equal('none')
Bram Moolenaare30f64b2020-07-15 19:48:20 +0200309
Bram Moolenaar822ba242020-05-24 23:00:18 +0200310 CheckScriptFailure(['def Func(arg: number = asdf)', 'enddef', 'defcompile'], 'E1001:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +0100311 delfunc g:Func
Bram Moolenaar77072282020-09-16 17:55:40 +0200312 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 +0100313 delfunc g:Func
Bram Moolenaar04b12692020-05-04 23:24:44 +0200314enddef
315
Bram Moolenaarcef12702021-01-04 14:09:43 +0100316def FuncWithComment( # comment
317 a: number, #comment
318 b: bool, # comment
319 c: string) #comment
320 assert_equal(4, a)
321 assert_equal(true, b)
322 assert_equal('yes', c)
323enddef
324
325def Test_func_with_comments()
326 FuncWithComment(4, true, 'yes')
327
328 var lines =<< trim END
329 def Func(# comment
330 arg: string)
331 enddef
332 END
333 CheckScriptFailure(lines, 'E125:', 1)
334
335 lines =<< trim END
336 def Func(
337 arg: string# comment
338 )
339 enddef
340 END
341 CheckScriptFailure(lines, 'E475:', 2)
342
343 lines =<< trim END
344 def Func(
345 arg: string
346 )# comment
347 enddef
348 END
349 CheckScriptFailure(lines, 'E488:', 3)
350enddef
351
Bram Moolenaar04b12692020-05-04 23:24:44 +0200352def Test_nested_function()
353 def Nested(arg: string): string
354 return 'nested ' .. arg
355 enddef
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200356 Nested('function')->assert_equal('nested function')
Bram Moolenaar04b12692020-05-04 23:24:44 +0200357
Bram Moolenaar0e65d3d2020-05-05 17:53:16 +0200358 CheckDefFailure(['def Nested()', 'enddef', 'Nested(66)'], 'E118:')
359 CheckDefFailure(['def Nested(arg: string)', 'enddef', 'Nested()'], 'E119:')
360
Bram Moolenaar04b12692020-05-04 23:24:44 +0200361 CheckDefFailure(['func Nested()', 'endfunc'], 'E1086:')
Bram Moolenaarbcbf4132020-08-01 22:35:13 +0200362 CheckDefFailure(['def s:Nested()', 'enddef'], 'E1075:')
363 CheckDefFailure(['def b:Nested()', 'enddef'], 'E1075:')
Bram Moolenaar8b848ca2020-09-10 22:28:01 +0200364
Bram Moolenaar54021752020-12-06 18:50:36 +0100365 var lines =<< trim END
366 def Outer()
367 def Inner()
368 # comment
369 enddef
370 def Inner()
371 enddef
372 enddef
373 END
374 CheckDefFailure(lines, 'E1073:')
375
376 lines =<< trim END
377 def Outer()
378 def Inner()
379 # comment
380 enddef
381 def! Inner()
382 enddef
383 enddef
384 END
385 CheckDefFailure(lines, 'E1117:')
386
387 # nested function inside conditional
388 # TODO: should it work when "thecount" is inside the "if"?
389 lines =<< trim END
390 vim9script
391 var thecount = 0
392 if true
393 def Test(): number
394 def TheFunc(): number
395 thecount += 1
396 return thecount
397 enddef
398 return TheFunc()
399 enddef
400 endif
401 defcompile
402 assert_equal(1, Test())
403 assert_equal(2, Test())
404 END
405 CheckScriptSuccess(lines)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200406enddef
407
Bram Moolenaaradc8e442020-12-31 18:28:18 +0100408def Test_not_nested_function()
409 echo printf('%d',
410 function('len')('xxx'))
411enddef
412
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200413func Test_call_default_args_from_func()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200414 call MyDefaultArgs()->assert_equal('string')
415 call MyDefaultArgs('one')->assert_equal('one')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +0200416 call assert_fails('call MyDefaultArgs("one", "two")', 'E118:', '', 3, 'Test_call_default_args_from_func')
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200417endfunc
418
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200419def Test_nested_global_function()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200420 var lines =<< trim END
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200421 vim9script
422 def Outer()
423 def g:Inner(): string
424 return 'inner'
425 enddef
426 enddef
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200427 defcompile
428 Outer()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200429 g:Inner()->assert_equal('inner')
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200430 delfunc g:Inner
431 Outer()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200432 g:Inner()->assert_equal('inner')
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200433 delfunc g:Inner
434 Outer()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200435 g:Inner()->assert_equal('inner')
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200436 delfunc g:Inner
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200437 END
438 CheckScriptSuccess(lines)
Bram Moolenaar2c79e9d2020-08-01 18:57:52 +0200439
440 lines =<< trim END
441 vim9script
442 def Outer()
443 def g:Inner(): string
444 return 'inner'
445 enddef
446 enddef
447 defcompile
448 Outer()
449 Outer()
450 END
451 CheckScriptFailure(lines, "E122:")
Bram Moolenaarcd45ed02020-12-22 17:35:54 +0100452 delfunc g:Inner
Bram Moolenaarad486a02020-08-01 23:22:18 +0200453
454 lines =<< trim END
455 vim9script
Bram Moolenaar58a52f22020-12-22 18:56:55 +0100456 def Outer()
457 def g:Inner()
Bram Moolenaar2949cfd2020-12-31 21:28:47 +0100458 echo map([1, 2, 3], (_, v) => v + 1)
Bram Moolenaar58a52f22020-12-22 18:56:55 +0100459 enddef
460 g:Inner()
461 enddef
462 Outer()
463 END
464 CheckScriptSuccess(lines)
465 delfunc g:Inner
466
467 lines =<< trim END
468 vim9script
Bram Moolenaarad486a02020-08-01 23:22:18 +0200469 def Func()
470 echo 'script'
471 enddef
472 def Outer()
473 def Func()
474 echo 'inner'
475 enddef
476 enddef
477 defcompile
478 END
479 CheckScriptFailure(lines, "E1073:")
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200480enddef
481
Bram Moolenaar6abdcf82020-11-22 18:15:44 +0100482def DefListAll()
483 def
484enddef
485
486def DefListOne()
487 def DefListOne
488enddef
489
490def DefListMatches()
491 def /DefList
492enddef
493
494def Test_nested_def_list()
495 var funcs = split(execute('call DefListAll()'), "\n")
496 assert_true(len(funcs) > 10)
497 assert_true(funcs->index('def DefListAll()') >= 0)
498
499 funcs = split(execute('call DefListOne()'), "\n")
500 assert_equal([' def DefListOne()', '1 def DefListOne', ' enddef'], funcs)
501
502 funcs = split(execute('call DefListMatches()'), "\n")
503 assert_true(len(funcs) >= 3)
504 assert_true(funcs->index('def DefListAll()') >= 0)
505 assert_true(funcs->index('def DefListOne()') >= 0)
506 assert_true(funcs->index('def DefListMatches()') >= 0)
Bram Moolenaar54021752020-12-06 18:50:36 +0100507
508 var lines =<< trim END
509 vim9script
510 def Func()
511 def +Func+
512 enddef
513 defcompile
514 END
515 CheckScriptFailure(lines, 'E476:', 1)
Bram Moolenaar6abdcf82020-11-22 18:15:44 +0100516enddef
517
Bram Moolenaar333894b2020-08-01 18:53:07 +0200518def Test_global_local_function()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200519 var lines =<< trim END
Bram Moolenaar333894b2020-08-01 18:53:07 +0200520 vim9script
521 def g:Func(): string
522 return 'global'
523 enddef
524 def Func(): string
525 return 'local'
526 enddef
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200527 g:Func()->assert_equal('global')
528 Func()->assert_equal('local')
Bram Moolenaar2d870f82020-12-05 13:41:01 +0100529 delfunc g:Func
Bram Moolenaar333894b2020-08-01 18:53:07 +0200530 END
531 CheckScriptSuccess(lines)
Bram Moolenaar035d6e92020-08-11 22:30:42 +0200532
533 lines =<< trim END
534 vim9script
535 def g:Funcy()
536 echo 'funcy'
537 enddef
538 s:Funcy()
539 END
540 CheckScriptFailure(lines, 'E117:')
Bram Moolenaar333894b2020-08-01 18:53:07 +0200541enddef
542
Bram Moolenaar0f769812020-09-12 18:32:34 +0200543def Test_local_function_shadows_global()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200544 var lines =<< trim END
Bram Moolenaar0f769812020-09-12 18:32:34 +0200545 vim9script
546 def g:Gfunc(): string
547 return 'global'
548 enddef
549 def AnotherFunc(): number
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200550 var Gfunc = function('len')
Bram Moolenaar0f769812020-09-12 18:32:34 +0200551 return Gfunc('testing')
552 enddef
553 g:Gfunc()->assert_equal('global')
554 AnotherFunc()->assert_equal(7)
555 delfunc g:Gfunc
556 END
557 CheckScriptSuccess(lines)
558
559 lines =<< trim END
560 vim9script
561 def g:Func(): string
562 return 'global'
563 enddef
564 def AnotherFunc()
565 g:Func = function('len')
566 enddef
567 AnotherFunc()
568 END
569 CheckScriptFailure(lines, 'E705:')
570 delfunc g:Func
571enddef
572
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200573func TakesOneArg(arg)
574 echo a:arg
575endfunc
576
577def Test_call_wrong_args()
Bram Moolenaard2c61702020-09-06 15:58:36 +0200578 CheckDefFailure(['TakesOneArg()'], 'E119:')
579 CheckDefFailure(['TakesOneArg(11, 22)'], 'E118:')
580 CheckDefFailure(['bufnr(xxx)'], 'E1001:')
581 CheckScriptFailure(['def Func(Ref: func(s: string))'], 'E475:')
Bram Moolenaaree8580e2020-08-28 17:19:07 +0200582
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200583 var lines =<< trim END
Bram Moolenaaree8580e2020-08-28 17:19:07 +0200584 vim9script
585 def Func(s: string)
586 echo s
587 enddef
588 Func([])
589 END
Bram Moolenaar77072282020-09-16 17:55:40 +0200590 CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected string but got list<unknown>', 5)
Bram Moolenaarb185a402020-09-18 22:42:00 +0200591
592 lines =<< trim END
593 vim9script
Bram Moolenaarb4893b82021-02-21 22:20:24 +0100594 var name = 'piet'
595 def FuncOne(name: string)
596 echo nr
597 enddef
598 END
Bram Moolenaar057e84a2021-02-28 16:55:11 +0100599 CheckScriptFailure(lines, 'E1168:')
Bram Moolenaarb4893b82021-02-21 22:20:24 +0100600
601 lines =<< trim END
602 vim9script
Bram Moolenaarb185a402020-09-18 22:42:00 +0200603 def FuncOne(nr: number)
604 echo nr
605 enddef
606 def FuncTwo()
607 FuncOne()
608 enddef
609 defcompile
610 END
611 writefile(lines, 'Xscript')
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200612 var didCatch = false
Bram Moolenaarb185a402020-09-18 22:42:00 +0200613 try
614 source Xscript
615 catch
616 assert_match('E119: Not enough arguments for function: <SNR>\d\+_FuncOne', v:exception)
617 assert_match('Xscript\[8\]..function <SNR>\d\+_FuncTwo, line 1', v:throwpoint)
618 didCatch = true
619 endtry
620 assert_true(didCatch)
621
622 lines =<< trim END
623 vim9script
624 def FuncOne(nr: number)
625 echo nr
626 enddef
627 def FuncTwo()
628 FuncOne(1, 2)
629 enddef
630 defcompile
631 END
632 writefile(lines, 'Xscript')
633 didCatch = false
634 try
635 source Xscript
636 catch
637 assert_match('E118: Too many arguments for function: <SNR>\d\+_FuncOne', v:exception)
638 assert_match('Xscript\[8\]..function <SNR>\d\+_FuncTwo, line 1', v:throwpoint)
639 didCatch = true
640 endtry
641 assert_true(didCatch)
642
643 delete('Xscript')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200644enddef
645
Bram Moolenaar50824712020-12-20 21:10:17 +0100646def Test_call_funcref_wrong_args()
647 var head =<< trim END
648 vim9script
649 def Func3(a1: string, a2: number, a3: list<number>)
650 echo a1 .. a2 .. a3[0]
651 enddef
652 def Testme()
653 var funcMap: dict<func> = {func: Func3}
654 END
655 var tail =<< trim END
656 enddef
657 Testme()
658 END
659 CheckScriptSuccess(head + ["funcMap['func']('str', 123, [1, 2, 3])"] + tail)
660
661 CheckScriptFailure(head + ["funcMap['func']('str', 123)"] + tail, 'E119:')
662 CheckScriptFailure(head + ["funcMap['func']('str', 123, [1], 4)"] + tail, 'E118:')
Bram Moolenaar32b3f822021-01-06 21:59:39 +0100663
664 var lines =<< trim END
665 vim9script
666 var Ref: func(number): any
667 Ref = (j) => !j
668 echo Ref(false)
669 END
670 CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected number but got bool', 4)
671
672 lines =<< trim END
673 vim9script
674 var Ref: func(number): any
675 Ref = (j) => !j
676 call Ref(false)
677 END
678 CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected number but got bool', 4)
Bram Moolenaar50824712020-12-20 21:10:17 +0100679enddef
680
Bram Moolenaarb4d16cb2020-11-05 18:45:46 +0100681def Test_call_lambda_args()
Bram Moolenaar2949cfd2020-12-31 21:28:47 +0100682 CheckDefFailure(['echo ((i) => 0)()'],
683 'E119: Not enough arguments for function: ((i) => 0)()')
Bram Moolenaarb4d16cb2020-11-05 18:45:46 +0100684
685 var lines =<< trim END
Bram Moolenaar2949cfd2020-12-31 21:28:47 +0100686 var Ref = (x: number, y: number) => x + y
Bram Moolenaarb4d16cb2020-11-05 18:45:46 +0100687 echo Ref(1, 'x')
688 END
689 CheckDefFailure(lines, 'E1013: Argument 2: type mismatch, expected number but got string')
Bram Moolenaare68b02a2021-01-03 13:09:51 +0100690
691 lines =<< trim END
692 var Ref: func(job, string, number)
693 Ref = (x, y) => 0
694 END
695 CheckDefAndScriptFailure(lines, 'E1012:')
696
697 lines =<< trim END
698 var Ref: func(job, string)
699 Ref = (x, y, z) => 0
700 END
701 CheckDefAndScriptFailure(lines, 'E1012:')
Bram Moolenaar057e84a2021-02-28 16:55:11 +0100702
703 lines =<< trim END
704 var one = 1
705 var l = [1, 2, 3]
706 echo map(l, (one) => one)
707 END
708 CheckDefFailure(lines, 'E1167:')
709 CheckScriptFailure(['vim9script'] + lines, 'E1168:')
710
711 lines =<< trim END
712 def ShadowLocal()
713 var one = 1
714 var l = [1, 2, 3]
715 echo map(l, (one) => one)
716 enddef
717 END
718 CheckDefFailure(lines, 'E1167:')
719
720 lines =<< trim END
721 def Shadowarg(one: number)
722 var l = [1, 2, 3]
723 echo map(l, (one) => one)
724 enddef
725 END
726 CheckDefFailure(lines, 'E1167:')
Bram Moolenaarb4d16cb2020-11-05 18:45:46 +0100727enddef
728
Bram Moolenaar0346b792021-01-31 22:18:29 +0100729def Test_lambda_return_type()
730 var lines =<< trim END
731 var Ref = (): => 123
732 END
733 CheckDefAndScriptFailure(lines, 'E1157:', 1)
734enddef
735
Bram Moolenaar709664c2020-12-12 14:33:41 +0100736def Test_lambda_uses_assigned_var()
737 CheckDefSuccess([
738 'var x: any = "aaa"'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +0100739 'x = filter(["bbb"], (_, v) => v =~ x)'])
Bram Moolenaar709664c2020-12-12 14:33:41 +0100740enddef
741
Bram Moolenaar18062fc2021-03-05 21:35:47 +0100742def Test_pass_legacy_lambda_to_def_func()
743 var lines =<< trim END
744 vim9script
745 func Foo()
746 eval s:Bar({x -> 0})
747 endfunc
748 def Bar(y: any)
749 enddef
750 Foo()
751 END
752 CheckScriptSuccess(lines)
753enddef
754
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200755" Default arg and varargs
756def MyDefVarargs(one: string, two = 'foo', ...rest: list<string>): string
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200757 var res = one .. ',' .. two
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200758 for s in rest
759 res ..= ',' .. s
760 endfor
761 return res
762enddef
763
764def Test_call_def_varargs()
Bram Moolenaar9bd5d872020-09-06 21:47:48 +0200765 assert_fails('MyDefVarargs()', 'E119:', '', 1, 'Test_call_def_varargs')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200766 MyDefVarargs('one')->assert_equal('one,foo')
767 MyDefVarargs('one', 'two')->assert_equal('one,two')
768 MyDefVarargs('one', 'two', 'three')->assert_equal('one,two,three')
Bram Moolenaar24aa48b2020-07-25 16:33:02 +0200769 CheckDefFailure(['MyDefVarargs("one", 22)'],
Bram Moolenaar77072282020-09-16 17:55:40 +0200770 'E1013: Argument 2: type mismatch, expected string but got number')
Bram Moolenaar24aa48b2020-07-25 16:33:02 +0200771 CheckDefFailure(['MyDefVarargs("one", "two", 123)'],
Bram Moolenaar77072282020-09-16 17:55:40 +0200772 'E1013: Argument 3: type mismatch, expected string but got number')
Bram Moolenaar24aa48b2020-07-25 16:33:02 +0200773
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200774 var lines =<< trim END
Bram Moolenaar24aa48b2020-07-25 16:33:02 +0200775 vim9script
776 def Func(...l: list<string>)
777 echo l
778 enddef
779 Func('a', 'b', 'c')
780 END
781 CheckScriptSuccess(lines)
782
783 lines =<< trim END
784 vim9script
785 def Func(...l: list<string>)
786 echo l
787 enddef
788 Func()
789 END
790 CheckScriptSuccess(lines)
791
792 lines =<< trim END
793 vim9script
Bram Moolenaar2f8cbc42020-09-16 17:22:59 +0200794 def Func(...l: any)
795 echo l
796 enddef
797 Func(0)
798 END
799 CheckScriptSuccess(lines)
800
801 lines =<< trim END
802 vim9script
Bram Moolenaar28022722020-09-21 22:02:49 +0200803 def Func(..._l: list<string>)
804 echo _l
805 enddef
806 Func('a', 'b', 'c')
807 END
808 CheckScriptSuccess(lines)
809
810 lines =<< trim END
811 vim9script
Bram Moolenaar24aa48b2020-07-25 16:33:02 +0200812 def Func(...l: list<string>)
813 echo l
814 enddef
815 Func(1, 2, 3)
816 END
Bram Moolenaar77072282020-09-16 17:55:40 +0200817 CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch')
Bram Moolenaar24aa48b2020-07-25 16:33:02 +0200818
819 lines =<< trim END
820 vim9script
821 def Func(...l: list<string>)
822 echo l
823 enddef
824 Func('a', 9)
825 END
Bram Moolenaar77072282020-09-16 17:55:40 +0200826 CheckScriptFailure(lines, 'E1013: Argument 2: type mismatch')
Bram Moolenaar24aa48b2020-07-25 16:33:02 +0200827
828 lines =<< trim END
829 vim9script
830 def Func(...l: list<string>)
831 echo l
832 enddef
833 Func(1, 'a')
834 END
Bram Moolenaar77072282020-09-16 17:55:40 +0200835 CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch')
Bram Moolenaar4f53b792021-02-07 15:59:49 +0100836
837 lines =<< trim END
838 vim9script
839 def Func( # some comment
840 ...l = []
841 )
842 echo l
843 enddef
844 END
845 CheckScriptFailure(lines, 'E1160:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200846enddef
847
Bram Moolenaar1378fbc2020-04-11 20:50:33 +0200848let s:value = ''
849
850def FuncOneDefArg(opt = 'text')
851 s:value = opt
852enddef
853
854def FuncTwoDefArg(nr = 123, opt = 'text'): string
855 return nr .. opt
856enddef
857
858def FuncVarargs(...arg: list<string>): string
859 return join(arg, ',')
860enddef
861
862def Test_func_type_varargs()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200863 var RefDefArg: func(?string)
Bram Moolenaar1378fbc2020-04-11 20:50:33 +0200864 RefDefArg = FuncOneDefArg
865 RefDefArg()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200866 s:value->assert_equal('text')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +0200867 RefDefArg('some')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200868 s:value->assert_equal('some')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +0200869
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200870 var RefDef2Arg: func(?number, ?string): string
Bram Moolenaar1378fbc2020-04-11 20:50:33 +0200871 RefDef2Arg = FuncTwoDefArg
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200872 RefDef2Arg()->assert_equal('123text')
873 RefDef2Arg(99)->assert_equal('99text')
874 RefDef2Arg(77, 'some')->assert_equal('77some')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +0200875
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200876 CheckDefFailure(['var RefWrong: func(string?)'], 'E1010:')
877 CheckDefFailure(['var RefWrong: func(?string, string)'], 'E1007:')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +0200878
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200879 var RefVarargs: func(...list<string>): string
Bram Moolenaar1378fbc2020-04-11 20:50:33 +0200880 RefVarargs = FuncVarargs
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200881 RefVarargs()->assert_equal('')
882 RefVarargs('one')->assert_equal('one')
883 RefVarargs('one', 'two')->assert_equal('one,two')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +0200884
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200885 CheckDefFailure(['var RefWrong: func(...list<string>, string)'], 'E110:')
886 CheckDefFailure(['var RefWrong: func(...list<string>, ?string)'], 'E110:')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +0200887enddef
888
Bram Moolenaar0b76b422020-04-07 22:05:08 +0200889" Only varargs
890def MyVarargsOnly(...args: list<string>): string
891 return join(args, ',')
892enddef
893
894def Test_call_varargs_only()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200895 MyVarargsOnly()->assert_equal('')
896 MyVarargsOnly('one')->assert_equal('one')
897 MyVarargsOnly('one', 'two')->assert_equal('one,two')
Bram Moolenaar77072282020-09-16 17:55:40 +0200898 CheckDefFailure(['MyVarargsOnly(1)'], 'E1013: Argument 1: type mismatch, expected string but got number')
899 CheckDefFailure(['MyVarargsOnly("one", 2)'], 'E1013: Argument 2: type mismatch, expected string but got number')
Bram Moolenaar0b76b422020-04-07 22:05:08 +0200900enddef
901
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200902def Test_using_var_as_arg()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200903 writefile(['def Func(x: number)', 'var x = 234', 'enddef', 'defcompile'], 'Xdef')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +0200904 assert_fails('so Xdef', 'E1006:', '', 1, 'Func')
Bram Moolenaard2c61702020-09-06 15:58:36 +0200905 delete('Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200906enddef
907
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +0200908def DictArg(arg: dict<string>)
909 arg['key'] = 'value'
910enddef
911
912def ListArg(arg: list<string>)
913 arg[0] = 'value'
914enddef
915
916def Test_assign_to_argument()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200917 # works for dict and list
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200918 var d: dict<string> = {}
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +0200919 DictArg(d)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200920 d['key']->assert_equal('value')
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200921 var l: list<string> = []
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +0200922 ListArg(l)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200923 l[0]->assert_equal('value')
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +0200924
Bram Moolenaard2c61702020-09-06 15:58:36 +0200925 CheckScriptFailure(['def Func(arg: number)', 'arg = 3', 'enddef', 'defcompile'], 'E1090:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +0100926 delfunc! g:Func
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +0200927enddef
928
Bram Moolenaarb816dae2020-09-20 22:04:00 +0200929" These argument names are reserved in legacy functions.
930def WithReservedNames(firstline: string, lastline: string): string
931 return firstline .. lastline
932enddef
933
934def Test_argument_names()
935 assert_equal('OK', WithReservedNames('O', 'K'))
936enddef
937
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200938def Test_call_func_defined_later()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200939 g:DefinedLater('one')->assert_equal('one')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +0200940 assert_fails('NotDefined("one")', 'E117:', '', 2, 'Test_call_func_defined_later')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200941enddef
942
Bram Moolenaar1df8b3f2020-04-23 18:13:23 +0200943func DefinedLater(arg)
944 return a:arg
945endfunc
946
947def Test_call_funcref()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200948 g:SomeFunc('abc')->assert_equal(3)
Bram Moolenaar9bd5d872020-09-06 21:47:48 +0200949 assert_fails('NotAFunc()', 'E117:', '', 2, 'Test_call_funcref') # comment after call
950 assert_fails('g:NotAFunc()', 'E117:', '', 3, 'Test_call_funcref')
Bram Moolenaar2f1980f2020-07-22 19:30:06 +0200951
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200952 var lines =<< trim END
Bram Moolenaar2f1980f2020-07-22 19:30:06 +0200953 vim9script
954 def RetNumber(): number
955 return 123
956 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200957 var Funcref: func: number = function('RetNumber')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200958 Funcref()->assert_equal(123)
Bram Moolenaar2f1980f2020-07-22 19:30:06 +0200959 END
960 CheckScriptSuccess(lines)
Bram Moolenaar0f60e802020-07-22 20:16:11 +0200961
962 lines =<< trim END
963 vim9script
964 def RetNumber(): number
965 return 123
966 enddef
967 def Bar(F: func: number): number
968 return F()
969 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200970 var Funcref = function('RetNumber')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200971 Bar(Funcref)->assert_equal(123)
Bram Moolenaar0f60e802020-07-22 20:16:11 +0200972 END
973 CheckScriptSuccess(lines)
Bram Moolenaarbfba8652020-07-23 20:09:10 +0200974
975 lines =<< trim END
976 vim9script
977 def UseNumber(nr: number)
978 echo nr
979 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200980 var Funcref: func(number) = function('UseNumber')
Bram Moolenaarbfba8652020-07-23 20:09:10 +0200981 Funcref(123)
982 END
983 CheckScriptSuccess(lines)
Bram Moolenaarb8070e32020-07-23 20:56:04 +0200984
985 lines =<< trim END
986 vim9script
987 def UseNumber(nr: number)
988 echo nr
989 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200990 var Funcref: func(string) = function('UseNumber')
Bram Moolenaarb8070e32020-07-23 20:56:04 +0200991 END
Bram Moolenaar5e654232020-09-16 15:22:00 +0200992 CheckScriptFailure(lines, 'E1012: Type mismatch; expected func(string) but got func(number)')
Bram Moolenaar4fc224c2020-07-26 17:56:25 +0200993
994 lines =<< trim END
995 vim9script
996 def EchoNr(nr = 34)
997 g:echo = nr
998 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200999 var Funcref: func(?number) = function('EchoNr')
Bram Moolenaar4fc224c2020-07-26 17:56:25 +02001000 Funcref()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001001 g:echo->assert_equal(34)
Bram Moolenaar4fc224c2020-07-26 17:56:25 +02001002 Funcref(123)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001003 g:echo->assert_equal(123)
Bram Moolenaar4fc224c2020-07-26 17:56:25 +02001004 END
1005 CheckScriptSuccess(lines)
Bram Moolenaarace61322020-07-26 18:16:58 +02001006
1007 lines =<< trim END
1008 vim9script
1009 def EchoList(...l: list<number>)
1010 g:echo = l
1011 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001012 var Funcref: func(...list<number>) = function('EchoList')
Bram Moolenaarace61322020-07-26 18:16:58 +02001013 Funcref()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001014 g:echo->assert_equal([])
Bram Moolenaarace61322020-07-26 18:16:58 +02001015 Funcref(1, 2, 3)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001016 g:echo->assert_equal([1, 2, 3])
Bram Moolenaarace61322020-07-26 18:16:58 +02001017 END
1018 CheckScriptSuccess(lines)
Bram Moolenaar01865ad2020-07-26 18:33:09 +02001019
1020 lines =<< trim END
1021 vim9script
1022 def OptAndVar(nr: number, opt = 12, ...l: list<number>): number
1023 g:optarg = opt
1024 g:listarg = l
1025 return nr
1026 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001027 var Funcref: func(number, ?number, ...list<number>): number = function('OptAndVar')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001028 Funcref(10)->assert_equal(10)
1029 g:optarg->assert_equal(12)
1030 g:listarg->assert_equal([])
Bram Moolenaar01865ad2020-07-26 18:33:09 +02001031
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001032 Funcref(11, 22)->assert_equal(11)
1033 g:optarg->assert_equal(22)
1034 g:listarg->assert_equal([])
Bram Moolenaar01865ad2020-07-26 18:33:09 +02001035
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001036 Funcref(17, 18, 1, 2, 3)->assert_equal(17)
1037 g:optarg->assert_equal(18)
1038 g:listarg->assert_equal([1, 2, 3])
Bram Moolenaar01865ad2020-07-26 18:33:09 +02001039 END
1040 CheckScriptSuccess(lines)
Bram Moolenaar1df8b3f2020-04-23 18:13:23 +02001041enddef
1042
1043let SomeFunc = function('len')
1044let NotAFunc = 'text'
1045
Bram Moolenaar99aaf0c2020-04-12 14:39:53 +02001046def CombineFuncrefTypes()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001047 # same arguments, different return type
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001048 var Ref1: func(bool): string
1049 var Ref2: func(bool): number
1050 var Ref3: func(bool): any
Bram Moolenaar99aaf0c2020-04-12 14:39:53 +02001051 Ref3 = g:cond ? Ref1 : Ref2
1052
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001053 # different number of arguments
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001054 var Refa1: func(bool): number
1055 var Refa2: func(bool, number): number
1056 var Refa3: func: number
Bram Moolenaar99aaf0c2020-04-12 14:39:53 +02001057 Refa3 = g:cond ? Refa1 : Refa2
1058
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001059 # different argument types
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001060 var Refb1: func(bool, string): number
1061 var Refb2: func(string, number): number
1062 var Refb3: func(any, any): number
Bram Moolenaar99aaf0c2020-04-12 14:39:53 +02001063 Refb3 = g:cond ? Refb1 : Refb2
1064enddef
1065
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001066def FuncWithForwardCall()
Bram Moolenaar1df8b3f2020-04-23 18:13:23 +02001067 return g:DefinedEvenLater("yes")
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001068enddef
1069
1070def DefinedEvenLater(arg: string): string
1071 return arg
1072enddef
1073
1074def Test_error_in_nested_function()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001075 # Error in called function requires unwinding the call stack.
Bram Moolenaar44d66522020-09-06 22:26:57 +02001076 assert_fails('FuncWithForwardCall()', 'E1096:', '', 1, 'FuncWithForwardCall')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001077enddef
1078
1079def Test_return_type_wrong()
Bram Moolenaar5a849da2020-08-08 16:47:30 +02001080 CheckScriptFailure([
1081 'def Func(): number',
1082 'return "a"',
1083 'enddef',
1084 'defcompile'], 'expected number but got string')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001085 delfunc! g:Func
Bram Moolenaar5a849da2020-08-08 16:47:30 +02001086 CheckScriptFailure([
1087 'def Func(): string',
1088 'return 1',
1089 'enddef',
1090 'defcompile'], 'expected string but got number')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001091 delfunc! g:Func
Bram Moolenaar5a849da2020-08-08 16:47:30 +02001092 CheckScriptFailure([
1093 'def Func(): void',
1094 'return "a"',
1095 'enddef',
1096 'defcompile'],
1097 'E1096: Returning a value in a function without a return type')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001098 delfunc! g:Func
Bram Moolenaar5a849da2020-08-08 16:47:30 +02001099 CheckScriptFailure([
1100 'def Func()',
1101 'return "a"',
1102 'enddef',
1103 'defcompile'],
1104 'E1096: Returning a value in a function without a return type')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001105 delfunc! g:Func
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001106
Bram Moolenaar5a849da2020-08-08 16:47:30 +02001107 CheckScriptFailure([
1108 'def Func(): number',
1109 'return',
1110 'enddef',
1111 'defcompile'], 'E1003:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001112 delfunc! g:Func
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001113
1114 CheckScriptFailure(['def Func(): list', 'return []', 'enddef'], 'E1008:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001115 delfunc! g:Func
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001116 CheckScriptFailure(['def Func(): dict', 'return {}', 'enddef'], 'E1008:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001117 delfunc! g:Func
Bram Moolenaaree4e0c12020-04-06 21:35:05 +02001118 CheckScriptFailure(['def Func()', 'return 1'], 'E1057:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001119 delfunc! g:Func
Bram Moolenaar5a849da2020-08-08 16:47:30 +02001120
1121 CheckScriptFailure([
1122 'vim9script',
1123 'def FuncB()',
1124 ' return 123',
1125 'enddef',
1126 'def FuncA()',
1127 ' FuncB()',
1128 'enddef',
1129 'defcompile'], 'E1096:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001130enddef
1131
1132def Test_arg_type_wrong()
1133 CheckScriptFailure(['def Func3(items: list)', 'echo "a"', 'enddef'], 'E1008: Missing <type>')
Bram Moolenaaree4e0c12020-04-06 21:35:05 +02001134 CheckScriptFailure(['def Func4(...)', 'echo "a"', 'enddef'], 'E1055: Missing name after ...')
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001135 CheckScriptFailure(['def Func5(items:string)', 'echo "a"'], 'E1069:')
Bram Moolenaar6e949782020-04-13 17:21:00 +02001136 CheckScriptFailure(['def Func5(items)', 'echo "a"'], 'E1077:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001137enddef
1138
1139def Test_vim9script_call()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001140 var lines =<< trim END
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001141 vim9script
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001142 var name = ''
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001143 def MyFunc(arg: string)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001144 name = arg
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001145 enddef
1146 MyFunc('foobar')
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001147 name->assert_equal('foobar')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001148
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001149 var str = 'barfoo'
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001150 str->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001151 name->assert_equal('barfoo')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001152
Bram Moolenaar67979662020-06-20 22:50:47 +02001153 g:value = 'value'
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001154 g:value->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001155 name->assert_equal('value')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001156
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001157 var listvar = []
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001158 def ListFunc(arg: list<number>)
1159 listvar = arg
1160 enddef
1161 [1, 2, 3]->ListFunc()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001162 listvar->assert_equal([1, 2, 3])
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001163
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001164 var dictvar = {}
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001165 def DictFunc(arg: dict<number>)
1166 dictvar = arg
1167 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +01001168 {a: 1, b: 2}->DictFunc()
1169 dictvar->assert_equal({a: 1, b: 2})
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001170 def CompiledDict()
Bram Moolenaare0de1712020-12-02 17:36:54 +01001171 {a: 3, b: 4}->DictFunc()
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001172 enddef
1173 CompiledDict()
Bram Moolenaare0de1712020-12-02 17:36:54 +01001174 dictvar->assert_equal({a: 3, b: 4})
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001175
Bram Moolenaare0de1712020-12-02 17:36:54 +01001176 {a: 3, b: 4}->DictFunc()
1177 dictvar->assert_equal({a: 3, b: 4})
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001178
1179 ('text')->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001180 name->assert_equal('text')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001181 ("some")->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001182 name->assert_equal('some')
Bram Moolenaare6b53242020-07-01 17:28:33 +02001183
Bram Moolenaar13e12b82020-07-24 18:47:22 +02001184 # line starting with single quote is not a mark
Bram Moolenaar10409562020-07-29 20:00:38 +02001185 # line starting with double quote can be a method call
Bram Moolenaar3d48e252020-07-15 14:15:52 +02001186 'asdfasdf'->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001187 name->assert_equal('asdfasdf')
Bram Moolenaar10409562020-07-29 20:00:38 +02001188 "xyz"->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001189 name->assert_equal('xyz')
Bram Moolenaar3d48e252020-07-15 14:15:52 +02001190
1191 def UseString()
1192 'xyork'->MyFunc()
1193 enddef
1194 UseString()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001195 name->assert_equal('xyork')
Bram Moolenaar3d48e252020-07-15 14:15:52 +02001196
Bram Moolenaar10409562020-07-29 20:00:38 +02001197 def UseString2()
1198 "knife"->MyFunc()
1199 enddef
1200 UseString2()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001201 name->assert_equal('knife')
Bram Moolenaar10409562020-07-29 20:00:38 +02001202
Bram Moolenaar13e12b82020-07-24 18:47:22 +02001203 # prepending a colon makes it a mark
1204 new
1205 setline(1, ['aaa', 'bbb', 'ccc'])
1206 normal! 3Gmt1G
1207 :'t
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001208 getcurpos()[1]->assert_equal(3)
Bram Moolenaar13e12b82020-07-24 18:47:22 +02001209 bwipe!
1210
Bram Moolenaare6b53242020-07-01 17:28:33 +02001211 MyFunc(
1212 'continued'
1213 )
1214 assert_equal('continued',
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001215 name
Bram Moolenaare6b53242020-07-01 17:28:33 +02001216 )
1217
1218 call MyFunc(
1219 'more'
1220 ..
1221 'lines'
1222 )
1223 assert_equal(
1224 'morelines',
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001225 name)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001226 END
1227 writefile(lines, 'Xcall.vim')
1228 source Xcall.vim
1229 delete('Xcall.vim')
1230enddef
1231
1232def Test_vim9script_call_fail_decl()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001233 var lines =<< trim END
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001234 vim9script
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001235 var name = ''
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001236 def MyFunc(arg: string)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001237 var name = 123
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001238 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +02001239 defcompile
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001240 END
Bram Moolenaar6c4bfe42020-07-23 18:26:30 +02001241 CheckScriptFailure(lines, 'E1054:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001242enddef
1243
Bram Moolenaar65b95452020-07-19 14:03:09 +02001244def Test_vim9script_call_fail_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001245 var lines =<< trim END
Bram Moolenaar65b95452020-07-19 14:03:09 +02001246 vim9script
1247 def MyFunc(arg: string)
1248 echo arg
1249 enddef
1250 MyFunc(1234)
1251 END
Bram Moolenaar77072282020-09-16 17:55:40 +02001252 CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected string but got number')
Bram Moolenaar65b95452020-07-19 14:03:09 +02001253enddef
1254
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001255def Test_vim9script_call_fail_const()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001256 var lines =<< trim END
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001257 vim9script
1258 const var = ''
1259 def MyFunc(arg: string)
1260 var = 'asdf'
1261 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +02001262 defcompile
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001263 END
1264 writefile(lines, 'Xcall_const.vim')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +02001265 assert_fails('source Xcall_const.vim', 'E46:', '', 1, 'MyFunc')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001266 delete('Xcall_const.vim')
Bram Moolenaar3bdc90b2020-12-22 20:35:40 +01001267
1268 lines =<< trim END
1269 const g:Aconst = 77
1270 def Change()
1271 # comment
1272 g:Aconst = 99
1273 enddef
1274 call Change()
1275 unlet g:Aconst
1276 END
Bram Moolenaar1dcf55d2020-12-22 22:07:30 +01001277 CheckScriptFailure(lines, 'E741: Value is locked: Aconst', 2)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001278enddef
1279
1280" Test that inside :function a Python function can be defined, :def is not
1281" recognized.
1282func Test_function_python()
1283 CheckFeature python3
Bram Moolenaar727345e2020-09-27 23:33:59 +02001284 let py = 'python3'
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001285 execute py "<< EOF"
1286def do_something():
1287 return 1
1288EOF
1289endfunc
1290
1291def Test_delfunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001292 var lines =<< trim END
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001293 vim9script
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001294 def g:GoneSoon()
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001295 echo 'hello'
1296 enddef
1297
1298 def CallGoneSoon()
1299 GoneSoon()
1300 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +02001301 defcompile
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001302
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001303 delfunc g:GoneSoon
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001304 CallGoneSoon()
1305 END
1306 writefile(lines, 'XToDelFunc')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +02001307 assert_fails('so XToDelFunc', 'E933:', '', 1, 'CallGoneSoon')
1308 assert_fails('so XToDelFunc', 'E933:', '', 1, 'CallGoneSoon')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001309
1310 delete('XToDelFunc')
1311enddef
1312
1313def Test_redef_failure()
Bram Moolenaard2c61702020-09-06 15:58:36 +02001314 writefile(['def Func0(): string', 'return "Func0"', 'enddef'], 'Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001315 so Xdef
Bram Moolenaard2c61702020-09-06 15:58:36 +02001316 writefile(['def Func1(): string', 'return "Func1"', 'enddef'], 'Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001317 so Xdef
Bram Moolenaard2c61702020-09-06 15:58:36 +02001318 writefile(['def! Func0(): string', 'enddef', 'defcompile'], 'Xdef')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +02001319 assert_fails('so Xdef', 'E1027:', '', 1, 'Func0')
Bram Moolenaard2c61702020-09-06 15:58:36 +02001320 writefile(['def Func2(): string', 'return "Func2"', 'enddef'], 'Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001321 so Xdef
Bram Moolenaard2c61702020-09-06 15:58:36 +02001322 delete('Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001323
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001324 g:Func0()->assert_equal(0)
1325 g:Func1()->assert_equal('Func1')
1326 g:Func2()->assert_equal('Func2')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001327
1328 delfunc! Func0
1329 delfunc! Func1
1330 delfunc! Func2
1331enddef
1332
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001333def Test_vim9script_func()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001334 var lines =<< trim END
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001335 vim9script
1336 func Func(arg)
1337 echo a:arg
1338 endfunc
1339 Func('text')
1340 END
1341 writefile(lines, 'XVim9Func')
1342 so XVim9Func
1343
1344 delete('XVim9Func')
1345enddef
1346
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001347let s:funcResult = 0
1348
1349def FuncNoArgNoRet()
Bram Moolenaar53900992020-08-22 19:02:02 +02001350 s:funcResult = 11
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001351enddef
1352
1353def FuncNoArgRetNumber(): number
Bram Moolenaar53900992020-08-22 19:02:02 +02001354 s:funcResult = 22
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001355 return 1234
1356enddef
1357
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001358def FuncNoArgRetString(): string
Bram Moolenaar53900992020-08-22 19:02:02 +02001359 s:funcResult = 45
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001360 return 'text'
1361enddef
1362
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001363def FuncOneArgNoRet(arg: number)
Bram Moolenaar53900992020-08-22 19:02:02 +02001364 s:funcResult = arg
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001365enddef
1366
1367def FuncOneArgRetNumber(arg: number): number
Bram Moolenaar53900992020-08-22 19:02:02 +02001368 s:funcResult = arg
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001369 return arg
1370enddef
1371
Bram Moolenaar08938ee2020-04-11 23:17:17 +02001372def FuncTwoArgNoRet(one: bool, two: number)
Bram Moolenaar53900992020-08-22 19:02:02 +02001373 s:funcResult = two
Bram Moolenaar08938ee2020-04-11 23:17:17 +02001374enddef
1375
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001376def FuncOneArgRetString(arg: string): string
1377 return arg
1378enddef
1379
Bram Moolenaar89228602020-04-05 22:14:54 +02001380def FuncOneArgRetAny(arg: any): any
1381 return arg
1382enddef
1383
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001384def Test_func_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001385 var Ref1: func()
Bram Moolenaar53900992020-08-22 19:02:02 +02001386 s:funcResult = 0
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001387 Ref1 = FuncNoArgNoRet
1388 Ref1()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001389 s:funcResult->assert_equal(11)
Bram Moolenaar4c683752020-04-05 21:38:23 +02001390
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001391 var Ref2: func
Bram Moolenaar53900992020-08-22 19:02:02 +02001392 s:funcResult = 0
Bram Moolenaar4c683752020-04-05 21:38:23 +02001393 Ref2 = FuncNoArgNoRet
1394 Ref2()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001395 s:funcResult->assert_equal(11)
Bram Moolenaar4c683752020-04-05 21:38:23 +02001396
Bram Moolenaar53900992020-08-22 19:02:02 +02001397 s:funcResult = 0
Bram Moolenaar4c683752020-04-05 21:38:23 +02001398 Ref2 = FuncOneArgNoRet
1399 Ref2(12)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001400 s:funcResult->assert_equal(12)
Bram Moolenaar4c683752020-04-05 21:38:23 +02001401
Bram Moolenaar53900992020-08-22 19:02:02 +02001402 s:funcResult = 0
Bram Moolenaar4c683752020-04-05 21:38:23 +02001403 Ref2 = FuncNoArgRetNumber
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001404 Ref2()->assert_equal(1234)
1405 s:funcResult->assert_equal(22)
Bram Moolenaar4c683752020-04-05 21:38:23 +02001406
Bram Moolenaar53900992020-08-22 19:02:02 +02001407 s:funcResult = 0
Bram Moolenaar4c683752020-04-05 21:38:23 +02001408 Ref2 = FuncOneArgRetNumber
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001409 Ref2(13)->assert_equal(13)
1410 s:funcResult->assert_equal(13)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001411enddef
1412
Bram Moolenaar9978d472020-07-05 16:01:56 +02001413def Test_repeat_return_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001414 var res = 0
Bram Moolenaar9978d472020-07-05 16:01:56 +02001415 for n in repeat([1], 3)
1416 res += n
1417 endfor
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001418 res->assert_equal(3)
Bram Moolenaarfce82b32020-07-05 16:07:21 +02001419
1420 res = 0
1421 for n in add([1, 2], 3)
1422 res += n
1423 endfor
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001424 res->assert_equal(6)
Bram Moolenaar9978d472020-07-05 16:01:56 +02001425enddef
1426
Bram Moolenaar846178a2020-07-05 17:04:13 +02001427def Test_argv_return_type()
1428 next fileone filetwo
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001429 var res = ''
Bram Moolenaar846178a2020-07-05 17:04:13 +02001430 for name in argv()
1431 res ..= name
1432 endfor
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001433 res->assert_equal('fileonefiletwo')
Bram Moolenaar846178a2020-07-05 17:04:13 +02001434enddef
1435
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001436def Test_func_type_part()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001437 var RefVoid: func: void
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001438 RefVoid = FuncNoArgNoRet
1439 RefVoid = FuncOneArgNoRet
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001440 CheckDefFailure(['var RefVoid: func: void', 'RefVoid = FuncNoArgRetNumber'], 'E1012: Type mismatch; expected func(...) but got func(): number')
1441 CheckDefFailure(['var RefVoid: func: void', 'RefVoid = FuncNoArgRetString'], 'E1012: Type mismatch; expected func(...) but got func(): string')
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001442
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001443 var RefAny: func(): any
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001444 RefAny = FuncNoArgRetNumber
1445 RefAny = FuncNoArgRetString
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001446 CheckDefFailure(['var RefAny: func(): any', 'RefAny = FuncNoArgNoRet'], 'E1012: Type mismatch; expected func(): any but got func()')
1447 CheckDefFailure(['var RefAny: func(): any', 'RefAny = FuncOneArgNoRet'], 'E1012: Type mismatch; expected func(): any but got func(number)')
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001448
Bram Moolenaar6abd3dc2020-10-04 14:17:32 +02001449 var RefAnyNoArgs: func: any = RefAny
1450
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001451 var RefNr: func: number
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001452 RefNr = FuncNoArgRetNumber
1453 RefNr = FuncOneArgRetNumber
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001454 CheckDefFailure(['var RefNr: func: number', 'RefNr = FuncNoArgNoRet'], 'E1012: Type mismatch; expected func(...): number but got func()')
1455 CheckDefFailure(['var RefNr: func: number', 'RefNr = FuncNoArgRetString'], 'E1012: Type mismatch; expected func(...): number but got func(): string')
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001456
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001457 var RefStr: func: string
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001458 RefStr = FuncNoArgRetString
1459 RefStr = FuncOneArgRetString
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001460 CheckDefFailure(['var RefStr: func: string', 'RefStr = FuncNoArgNoRet'], 'E1012: Type mismatch; expected func(...): string but got func()')
1461 CheckDefFailure(['var RefStr: func: string', 'RefStr = FuncNoArgRetNumber'], 'E1012: Type mismatch; expected func(...): string but got func(): number')
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001462enddef
1463
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001464def Test_func_type_fails()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001465 CheckDefFailure(['var ref1: func()'], 'E704:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001466
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001467 CheckDefFailure(['var Ref1: func()', 'Ref1 = FuncNoArgRetNumber'], 'E1012: Type mismatch; expected func() but got func(): number')
1468 CheckDefFailure(['var Ref1: func()', 'Ref1 = FuncOneArgNoRet'], 'E1012: Type mismatch; expected func() but got func(number)')
1469 CheckDefFailure(['var Ref1: func()', 'Ref1 = FuncOneArgRetNumber'], 'E1012: Type mismatch; expected func() but got func(number): number')
1470 CheckDefFailure(['var Ref1: func(bool)', 'Ref1 = FuncTwoArgNoRet'], 'E1012: Type mismatch; expected func(bool) but got func(bool, number)')
1471 CheckDefFailure(['var Ref1: func(?bool)', 'Ref1 = FuncTwoArgNoRet'], 'E1012: Type mismatch; expected func(?bool) but got func(bool, number)')
1472 CheckDefFailure(['var Ref1: func(...bool)', 'Ref1 = FuncTwoArgNoRet'], 'E1012: Type mismatch; expected func(...bool) but got func(bool, number)')
Bram Moolenaar08938ee2020-04-11 23:17:17 +02001473
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001474 CheckDefFailure(['var RefWrong: func(string ,number)'], 'E1068:')
1475 CheckDefFailure(['var RefWrong: func(string,number)'], 'E1069:')
1476 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:')
1477 CheckDefFailure(['var RefWrong: func(bool):string'], 'E1069:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001478enddef
1479
Bram Moolenaar89228602020-04-05 22:14:54 +02001480def Test_func_return_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001481 var nr: number
Bram Moolenaar89228602020-04-05 22:14:54 +02001482 nr = FuncNoArgRetNumber()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001483 nr->assert_equal(1234)
Bram Moolenaar89228602020-04-05 22:14:54 +02001484
1485 nr = FuncOneArgRetAny(122)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001486 nr->assert_equal(122)
Bram Moolenaar89228602020-04-05 22:14:54 +02001487
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001488 var str: string
Bram Moolenaar89228602020-04-05 22:14:54 +02001489 str = FuncOneArgRetAny('yes')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001490 str->assert_equal('yes')
Bram Moolenaar89228602020-04-05 22:14:54 +02001491
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001492 CheckDefFailure(['var str: string', 'str = FuncNoArgRetNumber()'], 'E1012: Type mismatch; expected string but got number')
Bram Moolenaar89228602020-04-05 22:14:54 +02001493enddef
1494
Bram Moolenaar6abd3dc2020-10-04 14:17:32 +02001495def Test_func_common_type()
1496 def FuncOne(n: number): number
1497 return n
1498 enddef
1499 def FuncTwo(s: string): number
1500 return len(s)
1501 enddef
1502 def FuncThree(n: number, s: string): number
1503 return n + len(s)
1504 enddef
1505 var list = [FuncOne, FuncTwo, FuncThree]
1506 assert_equal(8, list[0](8))
1507 assert_equal(4, list[1]('word'))
1508 assert_equal(7, list[2](3, 'word'))
1509enddef
1510
Bram Moolenaar5e774c72020-04-12 21:53:00 +02001511def MultiLine(
1512 arg1: string,
1513 arg2 = 1234,
1514 ...rest: list<string>
1515 ): string
1516 return arg1 .. arg2 .. join(rest, '-')
1517enddef
1518
Bram Moolenaar2c330432020-04-13 14:41:35 +02001519def MultiLineComment(
1520 arg1: string, # comment
1521 arg2 = 1234, # comment
1522 ...rest: list<string> # comment
1523 ): string # comment
1524 return arg1 .. arg2 .. join(rest, '-')
1525enddef
1526
Bram Moolenaar5e774c72020-04-12 21:53:00 +02001527def Test_multiline()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001528 MultiLine('text')->assert_equal('text1234')
1529 MultiLine('text', 777)->assert_equal('text777')
1530 MultiLine('text', 777, 'one')->assert_equal('text777one')
1531 MultiLine('text', 777, 'one', 'two')->assert_equal('text777one-two')
Bram Moolenaar5e774c72020-04-12 21:53:00 +02001532enddef
1533
Bram Moolenaar23e03252020-04-12 22:22:31 +02001534func Test_multiline_not_vim9()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001535 call MultiLine('text')->assert_equal('text1234')
1536 call MultiLine('text', 777)->assert_equal('text777')
1537 call MultiLine('text', 777, 'one')->assert_equal('text777one')
1538 call MultiLine('text', 777, 'one', 'two')->assert_equal('text777one-two')
Bram Moolenaar23e03252020-04-12 22:22:31 +02001539endfunc
1540
Bram Moolenaar5e774c72020-04-12 21:53:00 +02001541
Bram Moolenaaree4e0c12020-04-06 21:35:05 +02001542" When using CheckScriptFailure() for the below test, E1010 is generated instead
1543" of E1056.
1544func Test_E1056_1059()
1545 let caught_1056 = 0
1546 try
1547 def F():
1548 return 1
1549 enddef
1550 catch /E1056:/
1551 let caught_1056 = 1
1552 endtry
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001553 eval caught_1056->assert_equal(1)
Bram Moolenaaree4e0c12020-04-06 21:35:05 +02001554
1555 let caught_1059 = 0
1556 try
1557 def F5(items : list)
1558 echo 'a'
1559 enddef
1560 catch /E1059:/
1561 let caught_1059 = 1
1562 endtry
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001563 eval caught_1059->assert_equal(1)
Bram Moolenaaree4e0c12020-04-06 21:35:05 +02001564endfunc
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001565
Bram Moolenaar015f4262020-05-05 21:25:22 +02001566func DelMe()
1567 echo 'DelMe'
1568endfunc
1569
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001570def Test_error_reporting()
1571 # comment lines at the start of the function
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001572 var lines =<< trim END
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001573 " comment
1574 def Func()
1575 # comment
1576 # comment
1577 invalid
1578 enddef
1579 defcompile
1580 END
Bram Moolenaar08052222020-09-14 17:04:31 +02001581 writefile(lines, 'Xdef')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001582 try
1583 source Xdef
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02001584 assert_report('should have failed')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001585 catch /E476:/
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001586 v:exception->assert_match('Invalid command: invalid')
1587 v:throwpoint->assert_match(', line 3$')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001588 endtry
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001589 delfunc! g:Func
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001590
1591 # comment lines after the start of the function
1592 lines =<< trim END
1593 " comment
1594 def Func()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001595 var x = 1234
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001596 # comment
1597 # comment
1598 invalid
1599 enddef
1600 defcompile
1601 END
Bram Moolenaar08052222020-09-14 17:04:31 +02001602 writefile(lines, 'Xdef')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001603 try
1604 source Xdef
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02001605 assert_report('should have failed')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001606 catch /E476:/
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001607 v:exception->assert_match('Invalid command: invalid')
1608 v:throwpoint->assert_match(', line 4$')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001609 endtry
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001610 delfunc! g:Func
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001611
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02001612 lines =<< trim END
1613 vim9script
1614 def Func()
Bram Moolenaare0de1712020-12-02 17:36:54 +01001615 var db = {foo: 1, bar: 2}
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02001616 # comment
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001617 var x = db.asdf
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02001618 enddef
1619 defcompile
1620 Func()
1621 END
Bram Moolenaar08052222020-09-14 17:04:31 +02001622 writefile(lines, 'Xdef')
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02001623 try
1624 source Xdef
1625 assert_report('should have failed')
1626 catch /E716:/
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001627 v:throwpoint->assert_match('_Func, line 3$')
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02001628 endtry
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001629 delfunc! g:Func
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02001630
Bram Moolenaar08052222020-09-14 17:04:31 +02001631 delete('Xdef')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001632enddef
1633
Bram Moolenaar015f4262020-05-05 21:25:22 +02001634def Test_deleted_function()
1635 CheckDefExecFailure([
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001636 'var RefMe: func = function("g:DelMe")',
Bram Moolenaar015f4262020-05-05 21:25:22 +02001637 'delfunc g:DelMe',
1638 'echo RefMe()'], 'E117:')
1639enddef
1640
1641def Test_unknown_function()
1642 CheckDefExecFailure([
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001643 'var Ref: func = function("NotExist")',
Bram Moolenaar9b7bf9e2020-07-11 22:14:59 +02001644 'delfunc g:NotExist'], 'E700:')
Bram Moolenaar015f4262020-05-05 21:25:22 +02001645enddef
1646
Bram Moolenaar328eac22021-01-07 19:23:08 +01001647def RefFunc(Ref: func(any): any): string
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02001648 return Ref('more')
1649enddef
1650
1651def Test_closure_simple()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001652 var local = 'some '
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001653 RefFunc((s) => local .. s)->assert_equal('some more')
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02001654enddef
1655
Bram Moolenaarbf67ea12020-05-02 17:52:42 +02001656def MakeRef()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001657 var local = 'some '
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001658 g:Ref = (s) => local .. s
Bram Moolenaarbf67ea12020-05-02 17:52:42 +02001659enddef
1660
1661def Test_closure_ref_after_return()
1662 MakeRef()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001663 g:Ref('thing')->assert_equal('some thing')
Bram Moolenaarbf67ea12020-05-02 17:52:42 +02001664 unlet g:Ref
1665enddef
1666
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02001667def MakeTwoRefs()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001668 var local = ['some']
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001669 g:Extend = (s) => local->add(s)
1670 g:Read = () => local
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02001671enddef
1672
1673def Test_closure_two_refs()
1674 MakeTwoRefs()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001675 join(g:Read(), ' ')->assert_equal('some')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02001676 g:Extend('more')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001677 join(g:Read(), ' ')->assert_equal('some more')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02001678 g:Extend('even')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001679 join(g:Read(), ' ')->assert_equal('some more even')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02001680
1681 unlet g:Extend
1682 unlet g:Read
1683enddef
1684
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02001685def ReadRef(Ref: func(): list<string>): string
1686 return join(Ref(), ' ')
1687enddef
1688
Bram Moolenaar5e654232020-09-16 15:22:00 +02001689def ExtendRef(Ref: func(string): list<string>, add: string)
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02001690 Ref(add)
1691enddef
1692
1693def Test_closure_two_indirect_refs()
Bram Moolenaarf7779c62020-05-03 15:38:16 +02001694 MakeTwoRefs()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001695 ReadRef(g:Read)->assert_equal('some')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02001696 ExtendRef(g:Extend, 'more')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001697 ReadRef(g:Read)->assert_equal('some more')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02001698 ExtendRef(g:Extend, 'even')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001699 ReadRef(g:Read)->assert_equal('some more even')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02001700
1701 unlet g:Extend
1702 unlet g:Read
1703enddef
Bram Moolenaarbf67ea12020-05-02 17:52:42 +02001704
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02001705def MakeArgRefs(theArg: string)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001706 var local = 'loc_val'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001707 g:UseArg = (s) => theArg .. '/' .. local .. '/' .. s
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02001708enddef
1709
1710def MakeArgRefsVarargs(theArg: string, ...rest: list<string>)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001711 var local = 'the_loc'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001712 g:UseVararg = (s) => theArg .. '/' .. local .. '/' .. s .. '/' .. join(rest)
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02001713enddef
1714
1715def Test_closure_using_argument()
1716 MakeArgRefs('arg_val')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001717 g:UseArg('call_val')->assert_equal('arg_val/loc_val/call_val')
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02001718
1719 MakeArgRefsVarargs('arg_val', 'one', 'two')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001720 g:UseVararg('call_val')->assert_equal('arg_val/the_loc/call_val/one two')
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02001721
1722 unlet g:UseArg
1723 unlet g:UseVararg
Bram Moolenaar44ec21c2021-02-12 21:50:57 +01001724
1725 var lines =<< trim END
1726 vim9script
1727 def Test(Fun: func(number): number): list<number>
1728 return map([1, 2, 3], (_, i) => Fun(i))
1729 enddef
1730 def Inc(nr: number): number
1731 return nr + 2
1732 enddef
1733 assert_equal([3, 4, 5], Test(Inc))
1734 END
1735 CheckScriptSuccess(lines)
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02001736enddef
1737
Bram Moolenaar85d5e2b2020-10-10 14:13:01 +02001738def MakeGetAndAppendRefs()
1739 var local = 'a'
1740
1741 def Append(arg: string)
1742 local ..= arg
1743 enddef
1744 g:Append = Append
1745
1746 def Get(): string
1747 return local
1748 enddef
1749 g:Get = Get
1750enddef
1751
1752def Test_closure_append_get()
1753 MakeGetAndAppendRefs()
1754 g:Get()->assert_equal('a')
1755 g:Append('-b')
1756 g:Get()->assert_equal('a-b')
1757 g:Append('-c')
1758 g:Get()->assert_equal('a-b-c')
1759
1760 unlet g:Append
1761 unlet g:Get
1762enddef
Bram Moolenaarb68b3462020-05-06 21:06:30 +02001763
Bram Moolenaar04b12692020-05-04 23:24:44 +02001764def Test_nested_closure()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001765 var local = 'text'
Bram Moolenaar04b12692020-05-04 23:24:44 +02001766 def Closure(arg: string): string
1767 return local .. arg
1768 enddef
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001769 Closure('!!!')->assert_equal('text!!!')
Bram Moolenaar04b12692020-05-04 23:24:44 +02001770enddef
1771
Bram Moolenaar6f5b6df2020-05-16 21:20:12 +02001772func GetResult(Ref)
1773 return a:Ref('some')
1774endfunc
1775
1776def Test_call_closure_not_compiled()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001777 var text = 'text'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001778 g:Ref = (s) => s .. text
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001779 GetResult(g:Ref)->assert_equal('sometext')
Bram Moolenaar6f5b6df2020-05-16 21:20:12 +02001780enddef
1781
Bram Moolenaar7cbfaa52020-09-18 21:25:32 +02001782def Test_double_closure_fails()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001783 var lines =<< trim END
Bram Moolenaar7cbfaa52020-09-18 21:25:32 +02001784 vim9script
1785 def Func()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001786 var name = 0
1787 for i in range(2)
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001788 timer_start(0, () => name)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001789 endfor
Bram Moolenaar7cbfaa52020-09-18 21:25:32 +02001790 enddef
1791 Func()
1792 END
Bram Moolenaar148ce7a2020-09-23 21:57:23 +02001793 CheckScriptSuccess(lines)
Bram Moolenaar7cbfaa52020-09-18 21:25:32 +02001794enddef
1795
Bram Moolenaar85d5e2b2020-10-10 14:13:01 +02001796def Test_nested_closure_used()
1797 var lines =<< trim END
1798 vim9script
1799 def Func()
1800 var x = 'hello'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001801 var Closure = () => x
1802 g:Myclosure = () => Closure()
Bram Moolenaar85d5e2b2020-10-10 14:13:01 +02001803 enddef
1804 Func()
1805 assert_equal('hello', g:Myclosure())
1806 END
1807 CheckScriptSuccess(lines)
1808enddef
Bram Moolenaar0876c782020-10-07 19:08:04 +02001809
Bram Moolenaarc70bdab2020-09-26 19:59:38 +02001810def Test_nested_closure_fails()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001811 var lines =<< trim END
Bram Moolenaarc70bdab2020-09-26 19:59:38 +02001812 vim9script
1813 def FuncA()
1814 FuncB(0)
1815 enddef
1816 def FuncB(n: number): list<string>
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001817 return map([0], (_, v) => n)
Bram Moolenaarc70bdab2020-09-26 19:59:38 +02001818 enddef
1819 FuncA()
1820 END
1821 CheckScriptFailure(lines, 'E1012:')
1822enddef
1823
Bram Moolenaarf112f302020-12-20 17:47:52 +01001824def Test_global_closure()
1825 var lines =<< trim END
1826 vim9script
1827 def ReverseEveryNLines(n: number, line1: number, line2: number)
1828 var mods = 'sil keepj keepp lockm '
1829 var range = ':' .. line1 .. ',' .. line2
1830 def g:Offset(): number
1831 var offset = (line('.') - line1 + 1) % n
1832 return offset != 0 ? offset : n
1833 enddef
1834 exe mods .. range .. 'g/^/exe "m .-" .. g:Offset()'
1835 enddef
1836
1837 new
1838 repeat(['aaa', 'bbb', 'ccc'], 3)->setline(1)
1839 ReverseEveryNLines(3, 1, 9)
1840 END
1841 CheckScriptSuccess(lines)
1842 var expected = repeat(['ccc', 'bbb', 'aaa'], 3)
1843 assert_equal(expected, getline(1, 9))
1844 bwipe!
1845enddef
1846
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01001847def Test_global_closure_called_directly()
1848 var lines =<< trim END
1849 vim9script
1850 def Outer()
1851 var x = 1
1852 def g:Inner()
1853 var y = x
1854 x += 1
1855 assert_equal(1, y)
1856 enddef
1857 g:Inner()
1858 assert_equal(2, x)
1859 enddef
1860 Outer()
1861 END
1862 CheckScriptSuccess(lines)
1863 delfunc g:Inner
1864enddef
1865
Bram Moolenaar34c54eb2020-11-25 19:15:19 +01001866def Test_failure_in_called_function()
1867 # this was using the frame index as the return value
1868 var lines =<< trim END
1869 vim9script
1870 au TerminalWinOpen * eval [][0]
1871 def PopupTerm(a: any)
1872 # make sure typvals on stack are string
1873 ['a', 'b', 'c', 'd', 'e', 'f', 'g']->join()
1874 FireEvent()
1875 enddef
1876 def FireEvent()
1877 do TerminalWinOpen
1878 enddef
1879 # use try/catch to make eval fail
1880 try
1881 call PopupTerm(0)
1882 catch
1883 endtry
1884 au! TerminalWinOpen
1885 END
1886 CheckScriptSuccess(lines)
1887enddef
1888
Bram Moolenaar5366e1a2020-10-01 13:01:34 +02001889def Test_nested_lambda()
1890 var lines =<< trim END
1891 vim9script
1892 def Func()
1893 var x = 4
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001894 var Lambda1 = () => 7
1895 var Lambda2 = () => [Lambda1(), x]
Bram Moolenaar5366e1a2020-10-01 13:01:34 +02001896 var res = Lambda2()
1897 assert_equal([7, 4], res)
1898 enddef
1899 Func()
1900 END
1901 CheckScriptSuccess(lines)
1902enddef
1903
Bram Moolenaar52bf81c2020-11-17 18:50:44 +01001904def Shadowed(): list<number>
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001905 var FuncList: list<func: number> = [() => 42]
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01001906 return FuncList->mapnew((_, Shadowed) => Shadowed())
Bram Moolenaar52bf81c2020-11-17 18:50:44 +01001907enddef
1908
1909def Test_lambda_arg_shadows_func()
1910 assert_equal([42], Shadowed())
1911enddef
1912
Bram Moolenaaracd4c5e2020-06-22 19:39:03 +02001913def Line_continuation_in_def(dir: string = ''): string
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001914 var path: string = empty(dir)
1915 \ ? 'empty'
1916 \ : 'full'
1917 return path
Bram Moolenaaracd4c5e2020-06-22 19:39:03 +02001918enddef
1919
1920def Test_line_continuation_in_def()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001921 Line_continuation_in_def('.')->assert_equal('full')
Bram Moolenaaracd4c5e2020-06-22 19:39:03 +02001922enddef
1923
Bram Moolenaar2ea95b62020-11-19 21:47:56 +01001924def Test_script_var_in_lambda()
1925 var lines =<< trim END
1926 vim9script
1927 var script = 'test'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001928 assert_equal(['test'], map(['one'], () => script))
Bram Moolenaar2ea95b62020-11-19 21:47:56 +01001929 END
1930 CheckScriptSuccess(lines)
1931enddef
1932
Bram Moolenaar5e654232020-09-16 15:22:00 +02001933def Line_continuation_in_lambda(): list<string>
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001934 var x = range(97, 100)
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01001935 ->mapnew((_, v) => nr2char(v)
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001936 ->toupper())
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02001937 ->reverse()
1938 return x
1939enddef
1940
1941def Test_line_continuation_in_lambda()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001942 Line_continuation_in_lambda()->assert_equal(['D', 'C', 'B', 'A'])
Bram Moolenaarf898f7c2021-01-16 18:09:52 +01001943
1944 var lines =<< trim END
1945 vim9script
1946 var res = [{n: 1, m: 2, s: 'xxx'}]
1947 ->mapnew((_, v: dict<any>): string => printf('%d:%d:%s',
1948 v.n,
1949 v.m,
1950 substitute(v.s, '.*', 'yyy', '')
1951 ))
1952 assert_equal(['1:2:yyy'], res)
1953 END
1954 CheckScriptSuccess(lines)
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02001955enddef
1956
Bram Moolenaarb6571982021-01-08 22:24:19 +01001957def Test_list_lambda()
1958 timer_start(1000, (_) => 0)
1959 var body = execute(timer_info()[0].callback
1960 ->string()
1961 ->substitute("('", ' ', '')
1962 ->substitute("')", '', '')
1963 ->substitute('function\zs', ' ', ''))
1964 assert_match('def <lambda>\d\+(_: any, ...): number\n1 return 0\n enddef', body)
1965enddef
1966
Bram Moolenaarab360522021-01-10 14:02:28 +01001967def DoFilterThis(a: string): list<string>
1968 # closure nested inside another closure using argument
1969 var Filter = (l) => filter(l, (_, v) => stridx(v, a) == 0)
1970 return ['x', 'y', 'a', 'x2', 'c']->Filter()
1971enddef
1972
1973def Test_nested_closure_using_argument()
1974 assert_equal(['x', 'x2'], DoFilterThis('x'))
1975enddef
1976
Bram Moolenaar0186e582021-01-10 18:33:11 +01001977def Test_triple_nested_closure()
1978 var what = 'x'
1979 var Match = (val: string, cmp: string): bool => stridx(val, cmp) == 0
1980 var Filter = (l) => filter(l, (_, v) => Match(v, what))
1981 assert_equal(['x', 'x2'], ['x', 'y', 'a', 'x2', 'c']->Filter())
1982enddef
1983
Bram Moolenaar8f510af2020-07-05 18:48:23 +02001984func Test_silent_echo()
Bram Moolenaar47e7d702020-07-05 18:18:42 +02001985 CheckScreendump
1986
1987 let lines =<< trim END
1988 vim9script
1989 def EchoNothing()
1990 silent echo ''
1991 enddef
1992 defcompile
1993 END
Bram Moolenaar8f510af2020-07-05 18:48:23 +02001994 call writefile(lines, 'XTest_silent_echo')
Bram Moolenaar47e7d702020-07-05 18:18:42 +02001995
1996 " Check that the balloon shows up after a mouse move
1997 let buf = RunVimInTerminal('-S XTest_silent_echo', {'rows': 6})
Bram Moolenaar8f510af2020-07-05 18:48:23 +02001998 call term_sendkeys(buf, ":abc")
Bram Moolenaar47e7d702020-07-05 18:18:42 +02001999 call VerifyScreenDump(buf, 'Test_vim9_silent_echo', {})
2000
2001 " clean up
2002 call StopVimInTerminal(buf)
2003 call delete('XTest_silent_echo')
Bram Moolenaar8f510af2020-07-05 18:48:23 +02002004endfunc
Bram Moolenaar47e7d702020-07-05 18:18:42 +02002005
Bram Moolenaar171fb922020-10-28 16:54:47 +01002006def SilentlyError()
2007 execute('silent! invalid')
2008 g:did_it = 'yes'
2009enddef
2010
Bram Moolenaar28ee8922020-10-28 20:20:00 +01002011func UserError()
2012 silent! invalid
2013endfunc
2014
2015def SilentlyUserError()
2016 UserError()
2017 g:did_it = 'yes'
2018enddef
Bram Moolenaar171fb922020-10-28 16:54:47 +01002019
2020" This can't be a :def function, because the assert would not be reached.
Bram Moolenaar171fb922020-10-28 16:54:47 +01002021func Test_ignore_silent_error()
2022 let g:did_it = 'no'
2023 call SilentlyError()
2024 call assert_equal('yes', g:did_it)
2025
Bram Moolenaar28ee8922020-10-28 20:20:00 +01002026 let g:did_it = 'no'
2027 call SilentlyUserError()
2028 call assert_equal('yes', g:did_it)
Bram Moolenaar171fb922020-10-28 16:54:47 +01002029
2030 unlet g:did_it
2031endfunc
2032
Bram Moolenaarcd030c42020-10-30 21:49:40 +01002033def Test_ignore_silent_error_in_filter()
2034 var lines =<< trim END
2035 vim9script
2036 def Filter(winid: number, key: string): bool
2037 if key == 'o'
2038 silent! eval [][0]
2039 return true
2040 endif
2041 return popup_filter_menu(winid, key)
2042 enddef
2043
Bram Moolenaare0de1712020-12-02 17:36:54 +01002044 popup_create('popup', {filter: Filter})
Bram Moolenaarcd030c42020-10-30 21:49:40 +01002045 feedkeys("o\r", 'xnt')
2046 END
2047 CheckScriptSuccess(lines)
2048enddef
2049
Bram Moolenaar4b9bd692020-09-05 21:57:53 +02002050def Fibonacci(n: number): number
2051 if n < 2
2052 return n
2053 else
2054 return Fibonacci(n - 1) + Fibonacci(n - 2)
2055 endif
2056enddef
2057
Bram Moolenaar985116a2020-07-12 17:31:09 +02002058def Test_recursive_call()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002059 Fibonacci(20)->assert_equal(6765)
Bram Moolenaar985116a2020-07-12 17:31:09 +02002060enddef
2061
Bram Moolenaar08f7a412020-07-13 20:41:08 +02002062def TreeWalk(dir: string): list<any>
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01002063 return readdir(dir)->mapnew((_, val) =>
Bram Moolenaar08f7a412020-07-13 20:41:08 +02002064 fnamemodify(dir .. '/' .. val, ':p')->isdirectory()
Bram Moolenaar2bede172020-11-19 18:53:18 +01002065 ? {[val]: TreeWalk(dir .. '/' .. val)}
Bram Moolenaar08f7a412020-07-13 20:41:08 +02002066 : val
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002067 )
Bram Moolenaar08f7a412020-07-13 20:41:08 +02002068enddef
2069
2070def Test_closure_in_map()
2071 mkdir('XclosureDir/tdir', 'p')
2072 writefile(['111'], 'XclosureDir/file1')
2073 writefile(['222'], 'XclosureDir/file2')
2074 writefile(['333'], 'XclosureDir/tdir/file3')
2075
Bram Moolenaare0de1712020-12-02 17:36:54 +01002076 TreeWalk('XclosureDir')->assert_equal(['file1', 'file2', {tdir: ['file3']}])
Bram Moolenaar08f7a412020-07-13 20:41:08 +02002077
2078 delete('XclosureDir', 'rf')
2079enddef
2080
Bram Moolenaar7b5d5442020-10-04 13:42:34 +02002081def Test_invalid_function_name()
2082 var lines =<< trim END
2083 vim9script
2084 def s: list<string>
2085 END
2086 CheckScriptFailure(lines, 'E129:')
2087
2088 lines =<< trim END
2089 vim9script
2090 def g: list<string>
2091 END
2092 CheckScriptFailure(lines, 'E129:')
2093
2094 lines =<< trim END
2095 vim9script
2096 def <SID>: list<string>
2097 END
2098 CheckScriptFailure(lines, 'E884:')
2099
2100 lines =<< trim END
2101 vim9script
2102 def F list<string>
2103 END
2104 CheckScriptFailure(lines, 'E488:')
2105enddef
2106
Bram Moolenaara90afb92020-07-15 22:38:56 +02002107def Test_partial_call()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002108 var Xsetlist = function('setloclist', [0])
Bram Moolenaare0de1712020-12-02 17:36:54 +01002109 Xsetlist([], ' ', {title: 'test'})
2110 getloclist(0, {title: 1})->assert_equal({title: 'test'})
Bram Moolenaara90afb92020-07-15 22:38:56 +02002111
2112 Xsetlist = function('setloclist', [0, [], ' '])
Bram Moolenaare0de1712020-12-02 17:36:54 +01002113 Xsetlist({title: 'test'})
2114 getloclist(0, {title: 1})->assert_equal({title: 'test'})
Bram Moolenaara90afb92020-07-15 22:38:56 +02002115
2116 Xsetlist = function('setqflist')
Bram Moolenaare0de1712020-12-02 17:36:54 +01002117 Xsetlist([], ' ', {title: 'test'})
2118 getqflist({title: 1})->assert_equal({title: 'test'})
Bram Moolenaara90afb92020-07-15 22:38:56 +02002119
2120 Xsetlist = function('setqflist', [[], ' '])
Bram Moolenaare0de1712020-12-02 17:36:54 +01002121 Xsetlist({title: 'test'})
2122 getqflist({title: 1})->assert_equal({title: 'test'})
Bram Moolenaar6abd3dc2020-10-04 14:17:32 +02002123
2124 var Len: func: number = function('len', ['word'])
2125 assert_equal(4, Len())
Bram Moolenaara90afb92020-07-15 22:38:56 +02002126enddef
2127
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02002128def Test_cmd_modifier()
2129 tab echo '0'
Bram Moolenaard2c61702020-09-06 15:58:36 +02002130 CheckDefFailure(['5tab echo 3'], 'E16:')
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02002131enddef
2132
2133def Test_restore_modifiers()
2134 # check that when compiling a :def function command modifiers are not messed
2135 # up.
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002136 var lines =<< trim END
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02002137 vim9script
2138 set eventignore=
2139 autocmd QuickFixCmdPost * copen
2140 def AutocmdsDisabled()
Bram Moolenaar6cf7e3b2020-10-28 14:31:16 +01002141 eval 0
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02002142 enddef
2143 func Func()
2144 noautocmd call s:AutocmdsDisabled()
2145 let g:ei_after = &eventignore
2146 endfunc
2147 Func()
2148 END
2149 CheckScriptSuccess(lines)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002150 g:ei_after->assert_equal('')
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02002151enddef
2152
Bram Moolenaardfa3d552020-09-10 22:05:08 +02002153def StackTop()
2154 eval 1
2155 eval 2
2156 # call not on fourth line
2157 StackBot()
2158enddef
2159
2160def StackBot()
2161 # throw an error
2162 eval [][0]
2163enddef
2164
2165def Test_callstack_def()
2166 try
2167 StackTop()
2168 catch
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002169 v:throwpoint->assert_match('Test_callstack_def\[2\]..StackTop\[4\]..StackBot, line 2')
Bram Moolenaardfa3d552020-09-10 22:05:08 +02002170 endtry
2171enddef
2172
Bram Moolenaare8211a32020-10-09 22:04:29 +02002173" Re-using spot for variable used in block
2174def Test_block_scoped_var()
2175 var lines =<< trim END
2176 vim9script
2177 def Func()
2178 var x = ['a', 'b', 'c']
2179 if 1
2180 var y = 'x'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002181 map(x, () => y)
Bram Moolenaare8211a32020-10-09 22:04:29 +02002182 endif
2183 var z = x
2184 assert_equal(['x', 'x', 'x'], z)
2185 enddef
2186 Func()
2187 END
2188 CheckScriptSuccess(lines)
2189enddef
2190
Bram Moolenaareeece9e2020-11-20 19:26:48 +01002191def Test_reset_did_emsg()
2192 var lines =<< trim END
2193 @s = 'blah'
2194 au BufWinLeave * #
2195 def Func()
2196 var winid = popup_create('popup', {})
2197 exe '*s'
2198 popup_close(winid)
2199 enddef
2200 Func()
2201 END
2202 CheckScriptFailure(lines, 'E492:', 8)
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002203 delfunc! g:Func
Bram Moolenaareeece9e2020-11-20 19:26:48 +01002204enddef
2205
Bram Moolenaar57f799e2020-12-12 20:42:19 +01002206def Test_did_emsg_reset()
2207 # executing an autocommand resets did_emsg, this should not result in a
2208 # builtin function considered failing
2209 var lines =<< trim END
2210 vim9script
2211 au BufWinLeave * #
2212 def Func()
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002213 popup_menu('', {callback: () => popup_create('', {})->popup_close()})
Bram Moolenaar57f799e2020-12-12 20:42:19 +01002214 eval [][0]
2215 enddef
2216 nno <F3> <cmd>call <sid>Func()<cr>
2217 feedkeys("\<F3>\e", 'xt')
2218 END
2219 writefile(lines, 'XemsgReset')
2220 assert_fails('so XemsgReset', ['E684:', 'E684:'], lines, 2)
2221 delete('XemsgReset')
2222 nunmap <F3>
2223 au! BufWinLeave
2224enddef
2225
Bram Moolenaar56602ba2020-12-05 21:22:08 +01002226def Test_abort_with_silent_call()
2227 var lines =<< trim END
2228 vim9script
2229 g:result = 'none'
2230 def Func()
2231 g:result += 3
2232 g:result = 'yes'
2233 enddef
2234 # error is silenced, but function aborts on error
2235 silent! Func()
2236 assert_equal('none', g:result)
2237 unlet g:result
2238 END
2239 CheckScriptSuccess(lines)
2240enddef
2241
Bram Moolenaarf665e972020-12-05 19:17:16 +01002242def Test_continues_with_silent_error()
2243 var lines =<< trim END
2244 vim9script
2245 g:result = 'none'
2246 def Func()
2247 silent! g:result += 3
2248 g:result = 'yes'
2249 enddef
2250 # error is silenced, function does not abort
2251 Func()
2252 assert_equal('yes', g:result)
2253 unlet g:result
2254 END
2255 CheckScriptSuccess(lines)
2256enddef
2257
Bram Moolenaaraf0df472020-12-02 20:51:22 +01002258def Test_abort_even_with_silent()
2259 var lines =<< trim END
2260 vim9script
2261 g:result = 'none'
2262 def Func()
2263 eval {-> ''}() .. '' .. {}['X']
2264 g:result = 'yes'
2265 enddef
Bram Moolenaarf665e972020-12-05 19:17:16 +01002266 silent! Func()
Bram Moolenaaraf0df472020-12-02 20:51:22 +01002267 assert_equal('none', g:result)
Bram Moolenaar4029cab2020-12-05 18:13:27 +01002268 unlet g:result
2269 END
2270 CheckScriptSuccess(lines)
2271enddef
2272
Bram Moolenaarf665e972020-12-05 19:17:16 +01002273def Test_cmdmod_silent_restored()
2274 var lines =<< trim END
2275 vim9script
2276 def Func()
2277 g:result = 'none'
2278 silent! g:result += 3
2279 g:result = 'none'
2280 g:result += 3
2281 enddef
2282 Func()
2283 END
2284 # can't use CheckScriptFailure, it ignores the :silent!
2285 var fname = 'Xdefsilent'
2286 writefile(lines, fname)
2287 var caught = 'no'
2288 try
2289 exe 'source ' .. fname
2290 catch /E1030:/
2291 caught = 'yes'
2292 assert_match('Func, line 4', v:throwpoint)
2293 endtry
2294 assert_equal('yes', caught)
2295 delete(fname)
2296enddef
2297
Bram Moolenaar4029cab2020-12-05 18:13:27 +01002298def Test_dict_member_with_silent()
2299 var lines =<< trim END
2300 vim9script
2301 g:result = 'none'
2302 var d: dict<any>
2303 def Func()
2304 try
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002305 g:result = map([], (_, v) => ({}[v]))->join() .. d['']
Bram Moolenaar4029cab2020-12-05 18:13:27 +01002306 catch
2307 endtry
2308 enddef
2309 silent! Func()
2310 assert_equal('0', g:result)
2311 unlet g:result
Bram Moolenaaraf0df472020-12-02 20:51:22 +01002312 END
2313 CheckScriptSuccess(lines)
2314enddef
2315
Bram Moolenaarf9041332021-01-21 19:41:16 +01002316def Test_skip_cmds_with_silent()
2317 var lines =<< trim END
2318 vim9script
2319
2320 def Func(b: bool)
2321 Crash()
2322 enddef
2323
2324 def Crash()
2325 sil! :/not found/d _
2326 sil! :/not found/put _
2327 enddef
2328
2329 Func(true)
2330 END
2331 CheckScriptSuccess(lines)
2332enddef
2333
Bram Moolenaar5b3d1bb2020-12-22 12:20:08 +01002334def Test_opfunc()
2335 nnoremap <F3> <cmd>set opfunc=Opfunc<cr>g@
2336 def g:Opfunc(_: any): string
2337 setline(1, 'ASDF')
2338 return ''
2339 enddef
2340 new
2341 setline(1, 'asdf')
2342 feedkeys("\<F3>$", 'x')
2343 assert_equal('ASDF', getline(1))
2344
2345 bwipe!
2346 nunmap <F3>
2347enddef
2348
Bram Moolenaar077a4232020-12-22 18:33:27 +01002349" this was crashing on exit
2350def Test_nested_lambda_in_closure()
2351 var lines =<< trim END
2352 vim9script
2353 def Outer()
2354 def g:Inner()
2355 echo map([1, 2, 3], {_, v -> v + 1})
2356 enddef
2357 g:Inner()
2358 enddef
2359 defcompile
2360 writefile(['Done'], 'XnestedDone')
2361 quit
2362 END
2363 if !RunVim([], lines, '--clean')
2364 return
2365 endif
2366 assert_equal(['Done'], readfile('XnestedDone'))
2367 delete('XnestedDone')
2368enddef
2369
Bram Moolenaar04947cc2021-03-06 19:26:46 +01002370def Test_check_func_arg_types()
2371 var lines =<< trim END
2372 vim9script
2373 def F1(x: string): string
2374 return x
2375 enddef
2376
2377 def F2(x: number): number
2378 return x + 1
2379 enddef
2380
2381 def G(g: func): dict<func>
2382 return {f: g}
2383 enddef
2384
2385 def H(d: dict<func>): string
2386 return d.f('a')
2387 enddef
2388 END
2389
2390 CheckScriptSuccess(lines + ['echo H(G(F1))'])
2391 CheckScriptFailure(lines + ['echo H(G(F2))'], 'E1013:')
2392enddef
2393
Bram Moolenaar077a4232020-12-22 18:33:27 +01002394
Bram Moolenaarf7779c62020-05-03 15:38:16 +02002395
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002396" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker