blob: 4816cb6674afbc653f1840c343d78f5f9848430e [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()
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 Moolenaarf4e8cdd2020-10-12 22:07:13 +020033 var buf = RunVimInTerminal('-S XTest_compile_error',
Bram Moolenaare0de1712020-12-02 17:36:54 +010034 {rows: 10, wait_for_ruler: 0})
Bram Moolenaare8c46602021-04-05 22:27:37 +020035 WaitForAssert(() => assert_match('Error detected while compiling command line.*Fails.*Variable not found: nothing',
Bram Moolenaar03dfde22021-02-14 13:17:22 +010036 Term_getlines(buf, range(1, 9))))
Bram Moolenaarf4e8cdd2020-10-12 22:07:13 +020037
38 # clean up
Bram Moolenaare8c46602021-04-05 22:27:37 +020039 StopVimInTerminal(buf)
40 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
49 def script#OnlyCompiled()
50 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
67 var buf = RunVimInTerminal('-S XTest_compile_error', {rows: 10, wait_for_ruler: 0})
68 WaitForAssert(() => assert_match('Error detected while compiling command line.*function script#OnlyCompiled.*Invalid command: invalid',
69 Term_getlines(buf, range(1, 9))))
70
71 # clean up
72 StopVimInTerminal(buf)
73 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
90 CheckScriptFailureList(lines, ['E1012:', 'E1191:'])
91enddef
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
100 CheckScriptFailure(lines, 'E128:')
101
102 lines =<< trim END
103 vim9script
104 def _Foo()
105 echo 'foo'
106 enddef
107 END
108 CheckScriptFailure(lines, 'E128:')
109enddef
110
Bram Moolenaarf48b2fa2021-04-12 22:02:36 +0200111def Test_autoload_name_mismatch()
112 var dir = 'Xdir/autoload'
113 mkdir(dir, 'p')
114
115 var lines =<< trim END
116 vim9script
117 def scriptX#Function()
118 # comment
119 g:runtime = 'yes'
120 enddef
121 END
122 writefile(lines, dir .. '/script.vim')
123
124 var save_rtp = &rtp
125 exe 'set rtp=' .. getcwd() .. '/Xdir'
126 lines =<< trim END
127 call script#Function()
128 END
129 CheckScriptFailure(lines, 'E746:', 2)
130
131 &rtp = save_rtp
132 delete(dir, 'rf')
133enddef
134
Bram Moolenaarf0a40692021-06-11 22:05:47 +0200135def Test_autoload_names()
136 var dir = 'Xdir/autoload'
137 mkdir(dir, 'p')
138
139 var lines =<< trim END
140 func foobar#function()
141 return 'yes'
142 endfunc
143 let foobar#var = 'no'
144 END
145 writefile(lines, dir .. '/foobar.vim')
146
147 var save_rtp = &rtp
148 exe 'set rtp=' .. getcwd() .. '/Xdir'
149
150 lines =<< trim END
151 assert_equal('yes', foobar#function())
152 var Function = foobar#function
153 assert_equal('yes', Function())
154
155 assert_equal('no', foobar#var)
156 END
157 CheckDefAndScriptSuccess(lines)
158
159 &rtp = save_rtp
160 delete(dir, 'rf')
161enddef
162
Bram Moolenaar0ba48e82020-11-17 18:23:19 +0100163def CallRecursive(n: number): number
164 return CallRecursive(n + 1)
165enddef
166
167def CallMapRecursive(l: list<number>): number
Bram Moolenaar2949cfd2020-12-31 21:28:47 +0100168 return map(l, (_, v) => CallMapRecursive([v]))[0]
Bram Moolenaar0ba48e82020-11-17 18:23:19 +0100169enddef
170
171def Test_funcdepth_error()
172 set maxfuncdepth=10
173
174 var caught = false
175 try
176 CallRecursive(1)
177 catch /E132:/
178 caught = true
179 endtry
180 assert_true(caught)
181
182 caught = false
183 try
184 CallMapRecursive([1])
185 catch /E132:/
186 caught = true
187 endtry
188 assert_true(caught)
189
190 set maxfuncdepth&
191enddef
192
Bram Moolenaar5178b1b2021-01-01 18:43:51 +0100193def Test_endfunc_enddef()
194 var lines =<< trim END
195 def Test()
196 echo 'test'
197 endfunc
198 enddef
199 END
200 CheckScriptFailure(lines, 'E1151:', 3)
201
202 lines =<< trim END
203 def Test()
204 func Nested()
205 echo 'test'
206 enddef
207 enddef
208 END
209 CheckScriptFailure(lines, 'E1152:', 4)
Bram Moolenaar49f1e9e2021-03-22 20:49:02 +0100210
211 lines =<< trim END
212 def Ok()
213 echo 'hello'
214 enddef | echo 'there'
215 def Bad()
216 echo 'hello'
217 enddef there
218 END
219 CheckScriptFailure(lines, 'E1173: Text found after enddef: there', 6)
Bram Moolenaar5178b1b2021-01-01 18:43:51 +0100220enddef
221
Bram Moolenaarb8ba9b92021-01-01 18:54:34 +0100222def Test_missing_endfunc_enddef()
223 var lines =<< trim END
224 vim9script
225 def Test()
226 echo 'test'
227 endef
228 END
229 CheckScriptFailure(lines, 'E1057:', 2)
230
231 lines =<< trim END
232 vim9script
233 func Some()
234 echo 'test'
235 enfffunc
236 END
237 CheckScriptFailure(lines, 'E126:', 2)
238enddef
239
Bram Moolenaar4efd9942021-01-24 21:14:20 +0100240def Test_white_space_before_paren()
241 var lines =<< trim END
242 vim9script
243 def Test ()
244 echo 'test'
245 enddef
246 END
247 CheckScriptFailure(lines, 'E1068:', 2)
248
249 lines =<< trim END
250 vim9script
251 func Test ()
252 echo 'test'
253 endfunc
254 END
255 CheckScriptFailure(lines, 'E1068:', 2)
256
257 lines =<< trim END
258 def Test ()
259 echo 'test'
260 enddef
261 END
262 CheckScriptFailure(lines, 'E1068:', 1)
263
264 lines =<< trim END
265 func Test ()
266 echo 'test'
267 endfunc
268 END
269 CheckScriptSuccess(lines)
270enddef
271
Bram Moolenaar832ea892021-01-08 21:55:26 +0100272def Test_enddef_dict_key()
273 var d = {
274 enddef: 'x',
275 endfunc: 'y',
276 }
277 assert_equal({enddef: 'x', endfunc: 'y'}, d)
278enddef
279
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200280def ReturnString(): string
281 return 'string'
282enddef
283
284def ReturnNumber(): number
285 return 123
286enddef
287
288let g:notNumber = 'string'
289
290def ReturnGlobal(): number
291 return g:notNumber
292enddef
293
294def Test_return_something()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200295 ReturnString()->assert_equal('string')
296 ReturnNumber()->assert_equal(123)
Bram Moolenaar5e654232020-09-16 15:22:00 +0200297 assert_fails('ReturnGlobal()', 'E1012: Type mismatch; expected number but got string', '', 1, 'ReturnGlobal')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200298enddef
299
Bram Moolenaare32e5162021-01-21 20:21:29 +0100300def Test_check_argument_type()
301 var lines =<< trim END
302 vim9script
303 def Val(a: number, b: number): number
304 return 0
305 enddef
306 def Func()
307 var x: any = true
308 Val(0, x)
309 enddef
310 disass Func
311 Func()
312 END
313 CheckScriptFailure(lines, 'E1013: Argument 2: type mismatch, expected number but got bool', 2)
314enddef
315
Bram Moolenaarefd88552020-06-18 20:50:10 +0200316def Test_missing_return()
317 CheckDefFailure(['def Missing(): number',
318 ' if g:cond',
319 ' echo "no return"',
320 ' else',
321 ' return 0',
322 ' endif'
323 'enddef'], 'E1027:')
324 CheckDefFailure(['def Missing(): number',
325 ' if g:cond',
326 ' return 1',
327 ' else',
328 ' echo "no return"',
329 ' endif'
330 'enddef'], 'E1027:')
331 CheckDefFailure(['def Missing(): number',
332 ' if g:cond',
333 ' return 1',
334 ' else',
335 ' return 2',
336 ' endif'
337 ' return 3'
338 'enddef'], 'E1095:')
339enddef
340
Bram Moolenaar403dc312020-10-17 19:29:51 +0200341def Test_return_bool()
342 var lines =<< trim END
343 vim9script
344 def MenuFilter(id: number, key: string): bool
345 return popup_filter_menu(id, key)
346 enddef
347 def YesnoFilter(id: number, key: string): bool
348 return popup_filter_yesno(id, key)
349 enddef
350 defcompile
351 END
352 CheckScriptSuccess(lines)
353enddef
354
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200355let s:nothing = 0
356def ReturnNothing()
357 s:nothing = 1
358 if true
359 return
360 endif
361 s:nothing = 2
362enddef
363
364def Test_return_nothing()
365 ReturnNothing()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200366 s:nothing->assert_equal(1)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200367enddef
368
Bram Moolenaar648ea762021-01-15 19:04:32 +0100369def Test_return_invalid()
370 var lines =<< trim END
371 vim9script
372 def Func(): invalid
373 return xxx
374 enddef
375 defcompile
376 END
377 CheckScriptFailure(lines, 'E1010:', 2)
Bram Moolenaar31842cd2021-02-12 22:10:21 +0100378
379 lines =<< trim END
380 vim9script
381 def Test(Fun: func(number): number): list<number>
382 return map([1, 2, 3], (_, i) => Fun(i))
383 enddef
384 defcompile
385 def Inc(nr: number): nr
386 return nr + 2
387 enddef
388 echo Test(Inc)
389 END
390 # doing this twice was leaking memory
391 CheckScriptFailure(lines, 'E1010:')
392 CheckScriptFailure(lines, 'E1010:')
Bram Moolenaar648ea762021-01-15 19:04:32 +0100393enddef
394
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200395func Increment()
396 let g:counter += 1
397endfunc
398
399def Test_call_ufunc_count()
400 g:counter = 1
401 Increment()
402 Increment()
403 Increment()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200404 # works with and without :call
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200405 g:counter->assert_equal(4)
406 eval g:counter->assert_equal(4)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200407 unlet g:counter
408enddef
409
410def MyVarargs(arg: string, ...rest: list<string>): string
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200411 var res = arg
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200412 for s in rest
413 res ..= ',' .. s
414 endfor
415 return res
416enddef
417
418def Test_call_varargs()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200419 MyVarargs('one')->assert_equal('one')
420 MyVarargs('one', 'two')->assert_equal('one,two')
421 MyVarargs('one', 'two', 'three')->assert_equal('one,two,three')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200422enddef
423
424def MyDefaultArgs(name = 'string'): string
425 return name
426enddef
427
Bram Moolenaare30f64b2020-07-15 19:48:20 +0200428def MyDefaultSecond(name: string, second: bool = true): string
429 return second ? name : 'none'
430enddef
431
Bram Moolenaar38a3bfa2021-03-29 22:14:55 +0200432
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200433def Test_call_default_args()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200434 MyDefaultArgs()->assert_equal('string')
Bram Moolenaar38a3bfa2021-03-29 22:14:55 +0200435 MyDefaultArgs(v:none)->assert_equal('string')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200436 MyDefaultArgs('one')->assert_equal('one')
Bram Moolenaar38a3bfa2021-03-29 22:14:55 +0200437 assert_fails('MyDefaultArgs("one", "two")', 'E118:', '', 4, 'Test_call_default_args')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200438
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200439 MyDefaultSecond('test')->assert_equal('test')
440 MyDefaultSecond('test', true)->assert_equal('test')
441 MyDefaultSecond('test', false)->assert_equal('none')
Bram Moolenaare30f64b2020-07-15 19:48:20 +0200442
Bram Moolenaar38a3bfa2021-03-29 22:14:55 +0200443 var lines =<< trim END
444 def MyDefaultThird(name: string, aa = 'aa', bb = 'bb'): string
445 return name .. aa .. bb
446 enddef
447
448 MyDefaultThird('->')->assert_equal('->aabb')
449 MyDefaultThird('->', v:none)->assert_equal('->aabb')
450 MyDefaultThird('->', 'xx')->assert_equal('->xxbb')
451 MyDefaultThird('->', v:none, v:none)->assert_equal('->aabb')
452 MyDefaultThird('->', 'xx', v:none)->assert_equal('->xxbb')
453 MyDefaultThird('->', v:none, 'yy')->assert_equal('->aayy')
454 MyDefaultThird('->', 'xx', 'yy')->assert_equal('->xxyy')
455 END
456 CheckDefAndScriptSuccess(lines)
457
Bram Moolenaar822ba242020-05-24 23:00:18 +0200458 CheckScriptFailure(['def Func(arg: number = asdf)', 'enddef', 'defcompile'], 'E1001:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +0100459 delfunc g:Func
Bram Moolenaar77072282020-09-16 17:55:40 +0200460 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 +0100461 delfunc g:Func
Yegappan Lakshmanan34fcb692021-05-25 20:14:00 +0200462 CheckDefFailure(['def Func(x: number = )', 'enddef'], 'E15:')
Bram Moolenaar12bce952021-03-11 20:04:04 +0100463
Bram Moolenaar38a3bfa2021-03-29 22:14:55 +0200464 lines =<< trim END
Bram Moolenaar12bce952021-03-11 20:04:04 +0100465 vim9script
466 def Func(a = b == 0 ? 1 : 2, b = 0)
467 enddef
468 defcompile
469 END
470 CheckScriptFailure(lines, 'E1001: Variable not found: b')
Bram Moolenaar04b12692020-05-04 23:24:44 +0200471enddef
472
Bram Moolenaarcef12702021-01-04 14:09:43 +0100473def FuncWithComment( # comment
474 a: number, #comment
475 b: bool, # comment
476 c: string) #comment
477 assert_equal(4, a)
478 assert_equal(true, b)
479 assert_equal('yes', c)
480enddef
481
482def Test_func_with_comments()
483 FuncWithComment(4, true, 'yes')
484
485 var lines =<< trim END
486 def Func(# comment
487 arg: string)
488 enddef
489 END
490 CheckScriptFailure(lines, 'E125:', 1)
491
492 lines =<< trim END
493 def Func(
494 arg: string# comment
495 )
496 enddef
497 END
498 CheckScriptFailure(lines, 'E475:', 2)
499
500 lines =<< trim END
501 def Func(
502 arg: string
503 )# comment
504 enddef
505 END
506 CheckScriptFailure(lines, 'E488:', 3)
507enddef
508
Bram Moolenaar04b12692020-05-04 23:24:44 +0200509def Test_nested_function()
510 def Nested(arg: string): string
511 return 'nested ' .. arg
512 enddef
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200513 Nested('function')->assert_equal('nested function')
Bram Moolenaar04b12692020-05-04 23:24:44 +0200514
Bram Moolenaar0e65d3d2020-05-05 17:53:16 +0200515 CheckDefFailure(['def Nested()', 'enddef', 'Nested(66)'], 'E118:')
516 CheckDefFailure(['def Nested(arg: string)', 'enddef', 'Nested()'], 'E119:')
517
Bram Moolenaar04b12692020-05-04 23:24:44 +0200518 CheckDefFailure(['func Nested()', 'endfunc'], 'E1086:')
Bram Moolenaarbcbf4132020-08-01 22:35:13 +0200519 CheckDefFailure(['def s:Nested()', 'enddef'], 'E1075:')
520 CheckDefFailure(['def b:Nested()', 'enddef'], 'E1075:')
Bram Moolenaar8b848ca2020-09-10 22:28:01 +0200521
Bram Moolenaar54021752020-12-06 18:50:36 +0100522 var lines =<< trim END
523 def Outer()
524 def Inner()
525 # comment
526 enddef
527 def Inner()
528 enddef
529 enddef
530 END
531 CheckDefFailure(lines, 'E1073:')
532
533 lines =<< trim END
534 def Outer()
535 def Inner()
536 # comment
537 enddef
538 def! Inner()
539 enddef
540 enddef
541 END
542 CheckDefFailure(lines, 'E1117:')
543
544 # nested function inside conditional
Bram Moolenaar54021752020-12-06 18:50:36 +0100545 lines =<< trim END
546 vim9script
547 var thecount = 0
548 if true
549 def Test(): number
550 def TheFunc(): number
551 thecount += 1
552 return thecount
553 enddef
554 return TheFunc()
555 enddef
556 endif
557 defcompile
558 assert_equal(1, Test())
559 assert_equal(2, Test())
560 END
561 CheckScriptSuccess(lines)
Bram Moolenaar8863bda2021-03-17 18:42:08 +0100562
563 # also works when "thecount" is inside the "if" block
564 lines =<< trim END
565 vim9script
566 if true
567 var thecount = 0
568 def Test(): number
569 def TheFunc(): number
570 thecount += 1
571 return thecount
572 enddef
573 return TheFunc()
574 enddef
575 endif
576 defcompile
577 assert_equal(1, Test())
578 assert_equal(2, Test())
579 END
580 CheckScriptSuccess(lines)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200581enddef
582
Bram Moolenaaradc8e442020-12-31 18:28:18 +0100583def Test_not_nested_function()
584 echo printf('%d',
585 function('len')('xxx'))
586enddef
587
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200588func Test_call_default_args_from_func()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200589 call MyDefaultArgs()->assert_equal('string')
590 call MyDefaultArgs('one')->assert_equal('one')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +0200591 call assert_fails('call MyDefaultArgs("one", "two")', 'E118:', '', 3, 'Test_call_default_args_from_func')
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200592endfunc
593
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200594def Test_nested_global_function()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200595 var lines =<< trim END
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200596 vim9script
597 def Outer()
598 def g:Inner(): string
599 return 'inner'
600 enddef
601 enddef
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200602 defcompile
603 Outer()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200604 g:Inner()->assert_equal('inner')
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200605 delfunc g:Inner
606 Outer()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200607 g:Inner()->assert_equal('inner')
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200608 delfunc g:Inner
609 Outer()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200610 g:Inner()->assert_equal('inner')
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200611 delfunc g:Inner
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200612 END
613 CheckScriptSuccess(lines)
Bram Moolenaar2c79e9d2020-08-01 18:57:52 +0200614
615 lines =<< trim END
616 vim9script
617 def Outer()
618 def g:Inner(): string
619 return 'inner'
620 enddef
621 enddef
622 defcompile
623 Outer()
624 Outer()
625 END
626 CheckScriptFailure(lines, "E122:")
Bram Moolenaarcd45ed02020-12-22 17:35:54 +0100627 delfunc g:Inner
Bram Moolenaarad486a02020-08-01 23:22:18 +0200628
629 lines =<< trim END
630 vim9script
Bram Moolenaar58a52f22020-12-22 18:56:55 +0100631 def Outer()
632 def g:Inner()
Bram Moolenaar2949cfd2020-12-31 21:28:47 +0100633 echo map([1, 2, 3], (_, v) => v + 1)
Bram Moolenaar58a52f22020-12-22 18:56:55 +0100634 enddef
635 g:Inner()
636 enddef
637 Outer()
638 END
639 CheckScriptSuccess(lines)
640 delfunc g:Inner
641
642 lines =<< trim END
643 vim9script
Bram Moolenaarad486a02020-08-01 23:22:18 +0200644 def Func()
645 echo 'script'
646 enddef
647 def Outer()
648 def Func()
649 echo 'inner'
650 enddef
651 enddef
652 defcompile
653 END
654 CheckScriptFailure(lines, "E1073:")
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200655enddef
656
Bram Moolenaar6abdcf82020-11-22 18:15:44 +0100657def DefListAll()
658 def
659enddef
660
661def DefListOne()
662 def DefListOne
663enddef
664
665def DefListMatches()
666 def /DefList
667enddef
668
669def Test_nested_def_list()
670 var funcs = split(execute('call DefListAll()'), "\n")
671 assert_true(len(funcs) > 10)
672 assert_true(funcs->index('def DefListAll()') >= 0)
673
674 funcs = split(execute('call DefListOne()'), "\n")
675 assert_equal([' def DefListOne()', '1 def DefListOne', ' enddef'], funcs)
676
677 funcs = split(execute('call DefListMatches()'), "\n")
678 assert_true(len(funcs) >= 3)
679 assert_true(funcs->index('def DefListAll()') >= 0)
680 assert_true(funcs->index('def DefListOne()') >= 0)
681 assert_true(funcs->index('def DefListMatches()') >= 0)
Bram Moolenaar54021752020-12-06 18:50:36 +0100682
683 var lines =<< trim END
684 vim9script
685 def Func()
686 def +Func+
687 enddef
688 defcompile
689 END
690 CheckScriptFailure(lines, 'E476:', 1)
Bram Moolenaar6abdcf82020-11-22 18:15:44 +0100691enddef
692
Bram Moolenaar333894b2020-08-01 18:53:07 +0200693def Test_global_local_function()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200694 var lines =<< trim END
Bram Moolenaar333894b2020-08-01 18:53:07 +0200695 vim9script
696 def g:Func(): string
697 return 'global'
698 enddef
699 def Func(): string
700 return 'local'
701 enddef
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200702 g:Func()->assert_equal('global')
703 Func()->assert_equal('local')
Bram Moolenaar2d870f82020-12-05 13:41:01 +0100704 delfunc g:Func
Bram Moolenaar333894b2020-08-01 18:53:07 +0200705 END
706 CheckScriptSuccess(lines)
Bram Moolenaar035d6e92020-08-11 22:30:42 +0200707
708 lines =<< trim END
709 vim9script
710 def g:Funcy()
711 echo 'funcy'
712 enddef
713 s:Funcy()
714 END
715 CheckScriptFailure(lines, 'E117:')
Bram Moolenaar333894b2020-08-01 18:53:07 +0200716enddef
717
Bram Moolenaar0f769812020-09-12 18:32:34 +0200718def Test_local_function_shadows_global()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200719 var lines =<< trim END
Bram Moolenaar0f769812020-09-12 18:32:34 +0200720 vim9script
721 def g:Gfunc(): string
722 return 'global'
723 enddef
724 def AnotherFunc(): number
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200725 var Gfunc = function('len')
Bram Moolenaar0f769812020-09-12 18:32:34 +0200726 return Gfunc('testing')
727 enddef
728 g:Gfunc()->assert_equal('global')
729 AnotherFunc()->assert_equal(7)
730 delfunc g:Gfunc
731 END
732 CheckScriptSuccess(lines)
733
734 lines =<< trim END
735 vim9script
736 def g:Func(): string
737 return 'global'
738 enddef
739 def AnotherFunc()
740 g:Func = function('len')
741 enddef
742 AnotherFunc()
743 END
744 CheckScriptFailure(lines, 'E705:')
745 delfunc g:Func
Bram Moolenaar0865b152021-04-05 15:38:51 +0200746
747 # global function is found without g: prefix
748 lines =<< trim END
749 vim9script
750 def g:Func(): string
751 return 'global'
752 enddef
753 def AnotherFunc(): string
754 return Func()
755 enddef
756 assert_equal('global', AnotherFunc())
757 delfunc g:Func
758 END
759 CheckScriptSuccess(lines)
760
761 lines =<< trim END
762 vim9script
763 def g:Func(): string
764 return 'global'
765 enddef
766 assert_equal('global', Func())
767 delfunc g:Func
768 END
769 CheckScriptSuccess(lines)
Bram Moolenaar0f769812020-09-12 18:32:34 +0200770enddef
771
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200772func TakesOneArg(arg)
773 echo a:arg
774endfunc
775
776def Test_call_wrong_args()
Bram Moolenaard2c61702020-09-06 15:58:36 +0200777 CheckDefFailure(['TakesOneArg()'], 'E119:')
778 CheckDefFailure(['TakesOneArg(11, 22)'], 'E118:')
779 CheckDefFailure(['bufnr(xxx)'], 'E1001:')
780 CheckScriptFailure(['def Func(Ref: func(s: string))'], 'E475:')
Bram Moolenaaree8580e2020-08-28 17:19:07 +0200781
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200782 var lines =<< trim END
Bram Moolenaaree8580e2020-08-28 17:19:07 +0200783 vim9script
784 def Func(s: string)
785 echo s
786 enddef
787 Func([])
788 END
Bram Moolenaar77072282020-09-16 17:55:40 +0200789 CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected string but got list<unknown>', 5)
Bram Moolenaarb185a402020-09-18 22:42:00 +0200790
791 lines =<< trim END
792 vim9script
Bram Moolenaarb4893b82021-02-21 22:20:24 +0100793 var name = 'piet'
794 def FuncOne(name: string)
795 echo nr
796 enddef
797 END
Bram Moolenaar057e84a2021-02-28 16:55:11 +0100798 CheckScriptFailure(lines, 'E1168:')
Bram Moolenaarb4893b82021-02-21 22:20:24 +0100799
800 lines =<< trim END
801 vim9script
Bram Moolenaarb185a402020-09-18 22:42:00 +0200802 def FuncOne(nr: number)
803 echo nr
804 enddef
805 def FuncTwo()
806 FuncOne()
807 enddef
808 defcompile
809 END
810 writefile(lines, 'Xscript')
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200811 var didCatch = false
Bram Moolenaarb185a402020-09-18 22:42:00 +0200812 try
813 source Xscript
814 catch
815 assert_match('E119: Not enough arguments for function: <SNR>\d\+_FuncOne', v:exception)
816 assert_match('Xscript\[8\]..function <SNR>\d\+_FuncTwo, line 1', v:throwpoint)
817 didCatch = true
818 endtry
819 assert_true(didCatch)
820
821 lines =<< trim END
822 vim9script
823 def FuncOne(nr: number)
824 echo nr
825 enddef
826 def FuncTwo()
827 FuncOne(1, 2)
828 enddef
829 defcompile
830 END
831 writefile(lines, 'Xscript')
832 didCatch = false
833 try
834 source Xscript
835 catch
836 assert_match('E118: Too many arguments for function: <SNR>\d\+_FuncOne', v:exception)
837 assert_match('Xscript\[8\]..function <SNR>\d\+_FuncTwo, line 1', v:throwpoint)
838 didCatch = true
839 endtry
840 assert_true(didCatch)
841
842 delete('Xscript')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200843enddef
844
Bram Moolenaar50824712020-12-20 21:10:17 +0100845def Test_call_funcref_wrong_args()
846 var head =<< trim END
847 vim9script
848 def Func3(a1: string, a2: number, a3: list<number>)
849 echo a1 .. a2 .. a3[0]
850 enddef
851 def Testme()
852 var funcMap: dict<func> = {func: Func3}
853 END
854 var tail =<< trim END
855 enddef
856 Testme()
857 END
858 CheckScriptSuccess(head + ["funcMap['func']('str', 123, [1, 2, 3])"] + tail)
859
860 CheckScriptFailure(head + ["funcMap['func']('str', 123)"] + tail, 'E119:')
861 CheckScriptFailure(head + ["funcMap['func']('str', 123, [1], 4)"] + tail, 'E118:')
Bram Moolenaar32b3f822021-01-06 21:59:39 +0100862
863 var lines =<< trim END
864 vim9script
865 var Ref: func(number): any
866 Ref = (j) => !j
867 echo Ref(false)
868 END
869 CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected number but got bool', 4)
870
871 lines =<< trim END
872 vim9script
873 var Ref: func(number): any
874 Ref = (j) => !j
875 call Ref(false)
876 END
877 CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected number but got bool', 4)
Bram Moolenaar50824712020-12-20 21:10:17 +0100878enddef
879
Bram Moolenaarb4d16cb2020-11-05 18:45:46 +0100880def Test_call_lambda_args()
Bram Moolenaar2a389082021-04-09 20:24:31 +0200881 var lines =<< trim END
882 var Callback = (..._) => 'anything'
883 assert_equal('anything', Callback())
884 assert_equal('anything', Callback(1))
885 assert_equal('anything', Callback('a', 2))
Bram Moolenaar1088b692021-04-09 22:12:44 +0200886
887 assert_equal('xyz', ((a: string): string => a)('xyz'))
Bram Moolenaar2a389082021-04-09 20:24:31 +0200888 END
889 CheckDefAndScriptSuccess(lines)
890
Bram Moolenaar2949cfd2020-12-31 21:28:47 +0100891 CheckDefFailure(['echo ((i) => 0)()'],
892 'E119: Not enough arguments for function: ((i) => 0)()')
Bram Moolenaarb4d16cb2020-11-05 18:45:46 +0100893
Bram Moolenaar2a389082021-04-09 20:24:31 +0200894 lines =<< trim END
Bram Moolenaar2949cfd2020-12-31 21:28:47 +0100895 var Ref = (x: number, y: number) => x + y
Bram Moolenaarb4d16cb2020-11-05 18:45:46 +0100896 echo Ref(1, 'x')
897 END
898 CheckDefFailure(lines, 'E1013: Argument 2: type mismatch, expected number but got string')
Bram Moolenaare68b02a2021-01-03 13:09:51 +0100899
900 lines =<< trim END
901 var Ref: func(job, string, number)
902 Ref = (x, y) => 0
903 END
904 CheckDefAndScriptFailure(lines, 'E1012:')
905
906 lines =<< trim END
907 var Ref: func(job, string)
908 Ref = (x, y, z) => 0
909 END
910 CheckDefAndScriptFailure(lines, 'E1012:')
Bram Moolenaar057e84a2021-02-28 16:55:11 +0100911
912 lines =<< trim END
913 var one = 1
914 var l = [1, 2, 3]
915 echo map(l, (one) => one)
916 END
917 CheckDefFailure(lines, 'E1167:')
918 CheckScriptFailure(['vim9script'] + lines, 'E1168:')
919
920 lines =<< trim END
Bram Moolenaar14ded112021-06-26 19:25:49 +0200921 var Ref: func(any, ?any): bool
922 Ref = (_, y = 1) => false
923 END
924 CheckDefAndScriptFailure(lines, 'E1172:')
925
926 lines =<< trim END
Bram Moolenaar015cf102021-06-26 21:52:02 +0200927 var a = 0
928 var b = (a == 0 ? 1 : 2)
929 assert_equal(1, b)
Bram Moolenaar98f9a5f2021-06-26 22:22:38 +0200930 var txt = 'a'
931 b = (txt =~ 'x' ? 1 : 2)
932 assert_equal(2, b)
Bram Moolenaar015cf102021-06-26 21:52:02 +0200933 END
934 CheckDefAndScriptSuccess(lines)
935
936 lines =<< trim END
Bram Moolenaar057e84a2021-02-28 16:55:11 +0100937 def ShadowLocal()
938 var one = 1
939 var l = [1, 2, 3]
940 echo map(l, (one) => one)
941 enddef
942 END
943 CheckDefFailure(lines, 'E1167:')
944
945 lines =<< trim END
946 def Shadowarg(one: number)
947 var l = [1, 2, 3]
948 echo map(l, (one) => one)
949 enddef
950 END
951 CheckDefFailure(lines, 'E1167:')
Bram Moolenaar767034c2021-04-09 17:24:52 +0200952
953 lines =<< trim END
954 echo ((a) => a)('aa', 'bb')
955 END
956 CheckDefAndScriptFailure(lines, 'E118:', 1)
Bram Moolenaarb4d16cb2020-11-05 18:45:46 +0100957enddef
958
Bram Moolenaar5f91e742021-03-17 21:29:29 +0100959def FilterWithCond(x: string, Cond: func(string): bool): bool
960 return Cond(x)
961enddef
962
Bram Moolenaar0346b792021-01-31 22:18:29 +0100963def Test_lambda_return_type()
964 var lines =<< trim END
965 var Ref = (): => 123
966 END
967 CheckDefAndScriptFailure(lines, 'E1157:', 1)
Bram Moolenaar5f91e742021-03-17 21:29:29 +0100968
Yegappan Lakshmanan611728f2021-05-24 15:15:47 +0200969 # no space before the return type
970 lines =<< trim END
971 var Ref = (x):number => x + 1
972 END
973 CheckDefAndScriptFailure(lines, 'E1069:', 1)
974
Bram Moolenaar5f91e742021-03-17 21:29:29 +0100975 # this works
976 for x in ['foo', 'boo']
977 echo FilterWithCond(x, (v) => v =~ '^b')
978 endfor
979
980 # this fails
981 lines =<< trim END
982 echo FilterWithCond('foo', (v) => v .. '^b')
983 END
984 CheckDefAndScriptFailure(lines, 'E1013: Argument 2: type mismatch, expected func(string): bool but got func(any): string', 1)
Bram Moolenaara9931532021-06-12 15:58:16 +0200985
986 lines =<< trim END
987 var Lambda1 = (x) => {
988 return x
989 }
990 assert_equal('asdf', Lambda1('asdf'))
991 var Lambda2 = (x): string => {
992 return x
993 }
994 assert_equal('foo', Lambda2('foo'))
995 END
996 CheckDefAndScriptSuccess(lines)
997
998 lines =<< trim END
999 var Lambda = (x): string => {
1000 return x
1001 }
1002 echo Lambda(['foo'])
1003 END
1004 CheckDefExecAndScriptFailure(lines, 'E1012:')
Bram Moolenaar0346b792021-01-31 22:18:29 +01001005enddef
1006
Bram Moolenaar709664c2020-12-12 14:33:41 +01001007def Test_lambda_uses_assigned_var()
1008 CheckDefSuccess([
1009 'var x: any = "aaa"'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001010 'x = filter(["bbb"], (_, v) => v =~ x)'])
Bram Moolenaar709664c2020-12-12 14:33:41 +01001011enddef
1012
Bram Moolenaar18062fc2021-03-05 21:35:47 +01001013def Test_pass_legacy_lambda_to_def_func()
1014 var lines =<< trim END
1015 vim9script
1016 func Foo()
1017 eval s:Bar({x -> 0})
1018 endfunc
1019 def Bar(y: any)
1020 enddef
1021 Foo()
1022 END
1023 CheckScriptSuccess(lines)
Bram Moolenaar831bdf82021-06-22 19:32:17 +02001024
1025 lines =<< trim END
1026 vim9script
1027 def g:TestFunc(f: func())
1028 enddef
1029 legacy call g:TestFunc({-> 0})
1030 delfunc g:TestFunc
1031
1032 def g:TestFunc(f: func(number))
1033 enddef
1034 legacy call g:TestFunc({nr -> 0})
1035 delfunc g:TestFunc
1036 END
1037 CheckScriptSuccess(lines)
Bram Moolenaar18062fc2021-03-05 21:35:47 +01001038enddef
1039
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001040" Default arg and varargs
1041def MyDefVarargs(one: string, two = 'foo', ...rest: list<string>): string
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001042 var res = one .. ',' .. two
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001043 for s in rest
1044 res ..= ',' .. s
1045 endfor
1046 return res
1047enddef
1048
1049def Test_call_def_varargs()
Bram Moolenaar9bd5d872020-09-06 21:47:48 +02001050 assert_fails('MyDefVarargs()', 'E119:', '', 1, 'Test_call_def_varargs')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001051 MyDefVarargs('one')->assert_equal('one,foo')
1052 MyDefVarargs('one', 'two')->assert_equal('one,two')
1053 MyDefVarargs('one', 'two', 'three')->assert_equal('one,two,three')
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001054 CheckDefFailure(['MyDefVarargs("one", 22)'],
Bram Moolenaar77072282020-09-16 17:55:40 +02001055 'E1013: Argument 2: type mismatch, expected string but got number')
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001056 CheckDefFailure(['MyDefVarargs("one", "two", 123)'],
Bram Moolenaar77072282020-09-16 17:55:40 +02001057 'E1013: Argument 3: type mismatch, expected string but got number')
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001058
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001059 var lines =<< trim END
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001060 vim9script
1061 def Func(...l: list<string>)
1062 echo l
1063 enddef
1064 Func('a', 'b', 'c')
1065 END
1066 CheckScriptSuccess(lines)
1067
1068 lines =<< trim END
1069 vim9script
1070 def Func(...l: list<string>)
1071 echo l
1072 enddef
1073 Func()
1074 END
1075 CheckScriptSuccess(lines)
1076
1077 lines =<< trim END
1078 vim9script
Bram Moolenaar2a389082021-04-09 20:24:31 +02001079 def Func(...l: list<any>)
Bram Moolenaar2f8cbc42020-09-16 17:22:59 +02001080 echo l
1081 enddef
1082 Func(0)
1083 END
1084 CheckScriptSuccess(lines)
1085
1086 lines =<< trim END
1087 vim9script
Bram Moolenaar2a389082021-04-09 20:24:31 +02001088 def Func(...l: any)
1089 echo l
1090 enddef
1091 Func(0)
1092 END
1093 CheckScriptFailure(lines, 'E1180:', 2)
1094
1095 lines =<< trim END
1096 vim9script
Bram Moolenaar28022722020-09-21 22:02:49 +02001097 def Func(..._l: list<string>)
1098 echo _l
1099 enddef
1100 Func('a', 'b', 'c')
1101 END
1102 CheckScriptSuccess(lines)
1103
1104 lines =<< trim END
1105 vim9script
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001106 def Func(...l: list<string>)
1107 echo l
1108 enddef
1109 Func(1, 2, 3)
1110 END
Bram Moolenaar77072282020-09-16 17:55:40 +02001111 CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch')
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001112
1113 lines =<< trim END
1114 vim9script
1115 def Func(...l: list<string>)
1116 echo l
1117 enddef
1118 Func('a', 9)
1119 END
Bram Moolenaar77072282020-09-16 17:55:40 +02001120 CheckScriptFailure(lines, 'E1013: Argument 2: type mismatch')
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001121
1122 lines =<< trim END
1123 vim9script
1124 def Func(...l: list<string>)
1125 echo l
1126 enddef
1127 Func(1, 'a')
1128 END
Bram Moolenaar77072282020-09-16 17:55:40 +02001129 CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch')
Bram Moolenaar4f53b792021-02-07 15:59:49 +01001130
1131 lines =<< trim END
1132 vim9script
1133 def Func( # some comment
1134 ...l = []
1135 )
1136 echo l
1137 enddef
1138 END
1139 CheckScriptFailure(lines, 'E1160:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001140enddef
1141
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001142let s:value = ''
1143
1144def FuncOneDefArg(opt = 'text')
1145 s:value = opt
1146enddef
1147
1148def FuncTwoDefArg(nr = 123, opt = 'text'): string
1149 return nr .. opt
1150enddef
1151
1152def FuncVarargs(...arg: list<string>): string
1153 return join(arg, ',')
1154enddef
1155
1156def Test_func_type_varargs()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001157 var RefDefArg: func(?string)
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001158 RefDefArg = FuncOneDefArg
1159 RefDefArg()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001160 s:value->assert_equal('text')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001161 RefDefArg('some')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001162 s:value->assert_equal('some')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001163
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001164 var RefDef2Arg: func(?number, ?string): string
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001165 RefDef2Arg = FuncTwoDefArg
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001166 RefDef2Arg()->assert_equal('123text')
1167 RefDef2Arg(99)->assert_equal('99text')
1168 RefDef2Arg(77, 'some')->assert_equal('77some')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001169
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001170 CheckDefFailure(['var RefWrong: func(string?)'], 'E1010:')
1171 CheckDefFailure(['var RefWrong: func(?string, string)'], 'E1007:')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001172
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001173 var RefVarargs: func(...list<string>): string
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001174 RefVarargs = FuncVarargs
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001175 RefVarargs()->assert_equal('')
1176 RefVarargs('one')->assert_equal('one')
1177 RefVarargs('one', 'two')->assert_equal('one,two')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001178
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001179 CheckDefFailure(['var RefWrong: func(...list<string>, string)'], 'E110:')
1180 CheckDefFailure(['var RefWrong: func(...list<string>, ?string)'], 'E110:')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001181enddef
1182
Bram Moolenaar0b76b422020-04-07 22:05:08 +02001183" Only varargs
1184def MyVarargsOnly(...args: list<string>): string
1185 return join(args, ',')
1186enddef
1187
1188def Test_call_varargs_only()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001189 MyVarargsOnly()->assert_equal('')
1190 MyVarargsOnly('one')->assert_equal('one')
1191 MyVarargsOnly('one', 'two')->assert_equal('one,two')
Bram Moolenaar77072282020-09-16 17:55:40 +02001192 CheckDefFailure(['MyVarargsOnly(1)'], 'E1013: Argument 1: type mismatch, expected string but got number')
1193 CheckDefFailure(['MyVarargsOnly("one", 2)'], 'E1013: Argument 2: type mismatch, expected string but got number')
Bram Moolenaar0b76b422020-04-07 22:05:08 +02001194enddef
1195
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001196def Test_using_var_as_arg()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001197 writefile(['def Func(x: number)', 'var x = 234', 'enddef', 'defcompile'], 'Xdef')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +02001198 assert_fails('so Xdef', 'E1006:', '', 1, 'Func')
Bram Moolenaard2c61702020-09-06 15:58:36 +02001199 delete('Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001200enddef
1201
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +02001202def DictArg(arg: dict<string>)
1203 arg['key'] = 'value'
1204enddef
1205
1206def ListArg(arg: list<string>)
1207 arg[0] = 'value'
1208enddef
1209
1210def Test_assign_to_argument()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001211 # works for dict and list
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001212 var d: dict<string> = {}
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +02001213 DictArg(d)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001214 d['key']->assert_equal('value')
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001215 var l: list<string> = []
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +02001216 ListArg(l)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001217 l[0]->assert_equal('value')
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +02001218
Bram Moolenaard2c61702020-09-06 15:58:36 +02001219 CheckScriptFailure(['def Func(arg: number)', 'arg = 3', 'enddef', 'defcompile'], 'E1090:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001220 delfunc! g:Func
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +02001221enddef
1222
Bram Moolenaarb816dae2020-09-20 22:04:00 +02001223" These argument names are reserved in legacy functions.
1224def WithReservedNames(firstline: string, lastline: string): string
1225 return firstline .. lastline
1226enddef
1227
1228def Test_argument_names()
1229 assert_equal('OK', WithReservedNames('O', 'K'))
1230enddef
1231
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001232def Test_call_func_defined_later()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001233 g:DefinedLater('one')->assert_equal('one')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +02001234 assert_fails('NotDefined("one")', 'E117:', '', 2, 'Test_call_func_defined_later')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001235enddef
1236
Bram Moolenaar1df8b3f2020-04-23 18:13:23 +02001237func DefinedLater(arg)
1238 return a:arg
1239endfunc
1240
1241def Test_call_funcref()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001242 g:SomeFunc('abc')->assert_equal(3)
Bram Moolenaar9bd5d872020-09-06 21:47:48 +02001243 assert_fails('NotAFunc()', 'E117:', '', 2, 'Test_call_funcref') # comment after call
1244 assert_fails('g:NotAFunc()', 'E117:', '', 3, 'Test_call_funcref')
Bram Moolenaar2f1980f2020-07-22 19:30:06 +02001245
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001246 var lines =<< trim END
Bram Moolenaar2f1980f2020-07-22 19:30:06 +02001247 vim9script
1248 def RetNumber(): number
1249 return 123
1250 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001251 var Funcref: func: number = function('RetNumber')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001252 Funcref()->assert_equal(123)
Bram Moolenaar2f1980f2020-07-22 19:30:06 +02001253 END
1254 CheckScriptSuccess(lines)
Bram Moolenaar0f60e802020-07-22 20:16:11 +02001255
1256 lines =<< trim END
1257 vim9script
1258 def RetNumber(): number
1259 return 123
1260 enddef
1261 def Bar(F: func: number): number
1262 return F()
1263 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001264 var Funcref = function('RetNumber')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001265 Bar(Funcref)->assert_equal(123)
Bram Moolenaar0f60e802020-07-22 20:16:11 +02001266 END
1267 CheckScriptSuccess(lines)
Bram Moolenaarbfba8652020-07-23 20:09:10 +02001268
1269 lines =<< trim END
1270 vim9script
1271 def UseNumber(nr: number)
1272 echo nr
1273 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001274 var Funcref: func(number) = function('UseNumber')
Bram Moolenaarbfba8652020-07-23 20:09:10 +02001275 Funcref(123)
1276 END
1277 CheckScriptSuccess(lines)
Bram Moolenaarb8070e32020-07-23 20:56:04 +02001278
1279 lines =<< trim END
1280 vim9script
1281 def UseNumber(nr: number)
1282 echo nr
1283 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001284 var Funcref: func(string) = function('UseNumber')
Bram Moolenaarb8070e32020-07-23 20:56:04 +02001285 END
Bram Moolenaar5e654232020-09-16 15:22:00 +02001286 CheckScriptFailure(lines, 'E1012: Type mismatch; expected func(string) but got func(number)')
Bram Moolenaar4fc224c2020-07-26 17:56:25 +02001287
1288 lines =<< trim END
1289 vim9script
1290 def EchoNr(nr = 34)
1291 g:echo = nr
1292 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001293 var Funcref: func(?number) = function('EchoNr')
Bram Moolenaar4fc224c2020-07-26 17:56:25 +02001294 Funcref()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001295 g:echo->assert_equal(34)
Bram Moolenaar4fc224c2020-07-26 17:56:25 +02001296 Funcref(123)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001297 g:echo->assert_equal(123)
Bram Moolenaar4fc224c2020-07-26 17:56:25 +02001298 END
1299 CheckScriptSuccess(lines)
Bram Moolenaarace61322020-07-26 18:16:58 +02001300
1301 lines =<< trim END
1302 vim9script
1303 def EchoList(...l: list<number>)
1304 g:echo = l
1305 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001306 var Funcref: func(...list<number>) = function('EchoList')
Bram Moolenaarace61322020-07-26 18:16:58 +02001307 Funcref()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001308 g:echo->assert_equal([])
Bram Moolenaarace61322020-07-26 18:16:58 +02001309 Funcref(1, 2, 3)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001310 g:echo->assert_equal([1, 2, 3])
Bram Moolenaarace61322020-07-26 18:16:58 +02001311 END
1312 CheckScriptSuccess(lines)
Bram Moolenaar01865ad2020-07-26 18:33:09 +02001313
1314 lines =<< trim END
1315 vim9script
1316 def OptAndVar(nr: number, opt = 12, ...l: list<number>): number
1317 g:optarg = opt
1318 g:listarg = l
1319 return nr
1320 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001321 var Funcref: func(number, ?number, ...list<number>): number = function('OptAndVar')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001322 Funcref(10)->assert_equal(10)
1323 g:optarg->assert_equal(12)
1324 g:listarg->assert_equal([])
Bram Moolenaar01865ad2020-07-26 18:33:09 +02001325
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001326 Funcref(11, 22)->assert_equal(11)
1327 g:optarg->assert_equal(22)
1328 g:listarg->assert_equal([])
Bram Moolenaar01865ad2020-07-26 18:33:09 +02001329
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001330 Funcref(17, 18, 1, 2, 3)->assert_equal(17)
1331 g:optarg->assert_equal(18)
1332 g:listarg->assert_equal([1, 2, 3])
Bram Moolenaar01865ad2020-07-26 18:33:09 +02001333 END
1334 CheckScriptSuccess(lines)
Bram Moolenaar1df8b3f2020-04-23 18:13:23 +02001335enddef
1336
1337let SomeFunc = function('len')
1338let NotAFunc = 'text'
1339
Bram Moolenaar99aaf0c2020-04-12 14:39:53 +02001340def CombineFuncrefTypes()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001341 # same arguments, different return type
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001342 var Ref1: func(bool): string
1343 var Ref2: func(bool): number
1344 var Ref3: func(bool): any
Bram Moolenaar99aaf0c2020-04-12 14:39:53 +02001345 Ref3 = g:cond ? Ref1 : Ref2
1346
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001347 # different number of arguments
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001348 var Refa1: func(bool): number
1349 var Refa2: func(bool, number): number
1350 var Refa3: func: number
Bram Moolenaar99aaf0c2020-04-12 14:39:53 +02001351 Refa3 = g:cond ? Refa1 : Refa2
1352
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001353 # different argument types
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001354 var Refb1: func(bool, string): number
1355 var Refb2: func(string, number): number
1356 var Refb3: func(any, any): number
Bram Moolenaar99aaf0c2020-04-12 14:39:53 +02001357 Refb3 = g:cond ? Refb1 : Refb2
1358enddef
1359
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001360def FuncWithForwardCall()
Bram Moolenaar1df8b3f2020-04-23 18:13:23 +02001361 return g:DefinedEvenLater("yes")
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001362enddef
1363
1364def DefinedEvenLater(arg: string): string
1365 return arg
1366enddef
1367
1368def Test_error_in_nested_function()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001369 # Error in called function requires unwinding the call stack.
Bram Moolenaar44d66522020-09-06 22:26:57 +02001370 assert_fails('FuncWithForwardCall()', 'E1096:', '', 1, 'FuncWithForwardCall')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001371enddef
1372
1373def Test_return_type_wrong()
Bram Moolenaar5a849da2020-08-08 16:47:30 +02001374 CheckScriptFailure([
1375 'def Func(): number',
1376 'return "a"',
1377 'enddef',
1378 'defcompile'], 'expected number but got string')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001379 delfunc! g:Func
Bram Moolenaar5a849da2020-08-08 16:47:30 +02001380 CheckScriptFailure([
1381 'def Func(): string',
1382 'return 1',
1383 'enddef',
1384 'defcompile'], 'expected string but got number')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001385 delfunc! g:Func
Bram Moolenaar5a849da2020-08-08 16:47:30 +02001386 CheckScriptFailure([
1387 'def Func(): void',
1388 'return "a"',
1389 'enddef',
1390 'defcompile'],
1391 'E1096: Returning a value in a function without a return type')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001392 delfunc! g:Func
Bram Moolenaar5a849da2020-08-08 16:47:30 +02001393 CheckScriptFailure([
1394 'def Func()',
1395 'return "a"',
1396 'enddef',
1397 'defcompile'],
1398 'E1096: Returning a value in a function without a return type')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001399 delfunc! g:Func
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001400
Bram Moolenaar5a849da2020-08-08 16:47:30 +02001401 CheckScriptFailure([
1402 'def Func(): number',
1403 'return',
1404 'enddef',
1405 'defcompile'], 'E1003:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001406 delfunc! g:Func
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001407
1408 CheckScriptFailure(['def Func(): list', 'return []', 'enddef'], 'E1008:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001409 delfunc! g:Func
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001410 CheckScriptFailure(['def Func(): dict', 'return {}', 'enddef'], 'E1008:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001411 delfunc! g:Func
Bram Moolenaaree4e0c12020-04-06 21:35:05 +02001412 CheckScriptFailure(['def Func()', 'return 1'], 'E1057:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001413 delfunc! g:Func
Bram Moolenaar5a849da2020-08-08 16:47:30 +02001414
1415 CheckScriptFailure([
1416 'vim9script',
1417 'def FuncB()',
1418 ' return 123',
1419 'enddef',
1420 'def FuncA()',
1421 ' FuncB()',
1422 'enddef',
1423 'defcompile'], 'E1096:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001424enddef
1425
1426def Test_arg_type_wrong()
1427 CheckScriptFailure(['def Func3(items: list)', 'echo "a"', 'enddef'], 'E1008: Missing <type>')
Bram Moolenaaree4e0c12020-04-06 21:35:05 +02001428 CheckScriptFailure(['def Func4(...)', 'echo "a"', 'enddef'], 'E1055: Missing name after ...')
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001429 CheckScriptFailure(['def Func5(items:string)', 'echo "a"'], 'E1069:')
Bram Moolenaar6e949782020-04-13 17:21:00 +02001430 CheckScriptFailure(['def Func5(items)', 'echo "a"'], 'E1077:')
Yegappan Lakshmanan34fcb692021-05-25 20:14:00 +02001431 CheckScriptFailure(['def Func6(...x:list<number>)', 'echo "a"', 'enddef'], 'E1069:')
1432 CheckScriptFailure(['def Func7(...x: int)', 'echo "a"', 'enddef'], 'E1010:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001433enddef
1434
Bram Moolenaar86cdb8a2021-04-06 19:01:03 +02001435def Test_white_space_before_comma()
1436 var lines =<< trim END
1437 vim9script
1438 def Func(a: number , b: number)
1439 enddef
1440 END
1441 CheckScriptFailure(lines, 'E1068:')
Yegappan Lakshmanan611728f2021-05-24 15:15:47 +02001442 call assert_fails('vim9cmd echo stridx("a" .. "b" , "a")', 'E1068:')
Bram Moolenaar86cdb8a2021-04-06 19:01:03 +02001443enddef
1444
Bram Moolenaar608d78f2021-03-06 22:33:12 +01001445def Test_white_space_after_comma()
1446 var lines =<< trim END
1447 vim9script
1448 def Func(a: number,b: number)
1449 enddef
1450 END
1451 CheckScriptFailure(lines, 'E1069:')
1452
1453 # OK in legacy function
1454 lines =<< trim END
1455 vim9script
1456 func Func(a,b)
1457 endfunc
1458 END
1459 CheckScriptSuccess(lines)
1460enddef
1461
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001462def Test_vim9script_call()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001463 var lines =<< trim END
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001464 vim9script
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001465 var name = ''
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001466 def MyFunc(arg: string)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001467 name = arg
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001468 enddef
1469 MyFunc('foobar')
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001470 name->assert_equal('foobar')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001471
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001472 var str = 'barfoo'
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001473 str->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001474 name->assert_equal('barfoo')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001475
Bram Moolenaar67979662020-06-20 22:50:47 +02001476 g:value = 'value'
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001477 g:value->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001478 name->assert_equal('value')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001479
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001480 var listvar = []
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001481 def ListFunc(arg: list<number>)
1482 listvar = arg
1483 enddef
1484 [1, 2, 3]->ListFunc()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001485 listvar->assert_equal([1, 2, 3])
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001486
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001487 var dictvar = {}
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001488 def DictFunc(arg: dict<number>)
1489 dictvar = arg
1490 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +01001491 {a: 1, b: 2}->DictFunc()
1492 dictvar->assert_equal({a: 1, b: 2})
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001493 def CompiledDict()
Bram Moolenaare0de1712020-12-02 17:36:54 +01001494 {a: 3, b: 4}->DictFunc()
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001495 enddef
1496 CompiledDict()
Bram Moolenaare0de1712020-12-02 17:36:54 +01001497 dictvar->assert_equal({a: 3, b: 4})
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001498
Bram Moolenaare0de1712020-12-02 17:36:54 +01001499 {a: 3, b: 4}->DictFunc()
1500 dictvar->assert_equal({a: 3, b: 4})
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001501
1502 ('text')->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001503 name->assert_equal('text')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001504 ("some")->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001505 name->assert_equal('some')
Bram Moolenaare6b53242020-07-01 17:28:33 +02001506
Bram Moolenaar13e12b82020-07-24 18:47:22 +02001507 # line starting with single quote is not a mark
Bram Moolenaar10409562020-07-29 20:00:38 +02001508 # line starting with double quote can be a method call
Bram Moolenaar3d48e252020-07-15 14:15:52 +02001509 'asdfasdf'->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001510 name->assert_equal('asdfasdf')
Bram Moolenaar10409562020-07-29 20:00:38 +02001511 "xyz"->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001512 name->assert_equal('xyz')
Bram Moolenaar3d48e252020-07-15 14:15:52 +02001513
1514 def UseString()
1515 'xyork'->MyFunc()
1516 enddef
1517 UseString()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001518 name->assert_equal('xyork')
Bram Moolenaar3d48e252020-07-15 14:15:52 +02001519
Bram Moolenaar10409562020-07-29 20:00:38 +02001520 def UseString2()
1521 "knife"->MyFunc()
1522 enddef
1523 UseString2()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001524 name->assert_equal('knife')
Bram Moolenaar10409562020-07-29 20:00:38 +02001525
Bram Moolenaar13e12b82020-07-24 18:47:22 +02001526 # prepending a colon makes it a mark
1527 new
1528 setline(1, ['aaa', 'bbb', 'ccc'])
1529 normal! 3Gmt1G
1530 :'t
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001531 getcurpos()[1]->assert_equal(3)
Bram Moolenaar13e12b82020-07-24 18:47:22 +02001532 bwipe!
1533
Bram Moolenaare6b53242020-07-01 17:28:33 +02001534 MyFunc(
1535 'continued'
1536 )
1537 assert_equal('continued',
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001538 name
Bram Moolenaare6b53242020-07-01 17:28:33 +02001539 )
1540
1541 call MyFunc(
1542 'more'
1543 ..
1544 'lines'
1545 )
1546 assert_equal(
1547 'morelines',
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001548 name)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001549 END
1550 writefile(lines, 'Xcall.vim')
1551 source Xcall.vim
1552 delete('Xcall.vim')
1553enddef
1554
1555def Test_vim9script_call_fail_decl()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001556 var lines =<< trim END
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001557 vim9script
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001558 var name = ''
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001559 def MyFunc(arg: string)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001560 var name = 123
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001561 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +02001562 defcompile
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001563 END
Bram Moolenaar6c4bfe42020-07-23 18:26:30 +02001564 CheckScriptFailure(lines, 'E1054:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001565enddef
1566
Bram Moolenaar65b95452020-07-19 14:03:09 +02001567def Test_vim9script_call_fail_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001568 var lines =<< trim END
Bram Moolenaar65b95452020-07-19 14:03:09 +02001569 vim9script
1570 def MyFunc(arg: string)
1571 echo arg
1572 enddef
1573 MyFunc(1234)
1574 END
Bram Moolenaar77072282020-09-16 17:55:40 +02001575 CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected string but got number')
Bram Moolenaar65b95452020-07-19 14:03:09 +02001576enddef
1577
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001578def Test_vim9script_call_fail_const()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001579 var lines =<< trim END
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001580 vim9script
1581 const var = ''
1582 def MyFunc(arg: string)
1583 var = 'asdf'
1584 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +02001585 defcompile
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001586 END
1587 writefile(lines, 'Xcall_const.vim')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +02001588 assert_fails('source Xcall_const.vim', 'E46:', '', 1, 'MyFunc')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001589 delete('Xcall_const.vim')
Bram Moolenaar3bdc90b2020-12-22 20:35:40 +01001590
1591 lines =<< trim END
1592 const g:Aconst = 77
1593 def Change()
1594 # comment
1595 g:Aconst = 99
1596 enddef
1597 call Change()
1598 unlet g:Aconst
1599 END
Bram Moolenaar1dcf55d2020-12-22 22:07:30 +01001600 CheckScriptFailure(lines, 'E741: Value is locked: Aconst', 2)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001601enddef
1602
1603" Test that inside :function a Python function can be defined, :def is not
1604" recognized.
1605func Test_function_python()
1606 CheckFeature python3
Bram Moolenaar727345e2020-09-27 23:33:59 +02001607 let py = 'python3'
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001608 execute py "<< EOF"
1609def do_something():
1610 return 1
1611EOF
1612endfunc
1613
1614def Test_delfunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001615 var lines =<< trim END
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001616 vim9script
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001617 def g:GoneSoon()
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001618 echo 'hello'
1619 enddef
1620
1621 def CallGoneSoon()
1622 GoneSoon()
1623 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +02001624 defcompile
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001625
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001626 delfunc g:GoneSoon
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001627 CallGoneSoon()
1628 END
1629 writefile(lines, 'XToDelFunc')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +02001630 assert_fails('so XToDelFunc', 'E933:', '', 1, 'CallGoneSoon')
1631 assert_fails('so XToDelFunc', 'E933:', '', 1, 'CallGoneSoon')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001632
1633 delete('XToDelFunc')
1634enddef
1635
1636def Test_redef_failure()
Bram Moolenaard2c61702020-09-06 15:58:36 +02001637 writefile(['def Func0(): string', 'return "Func0"', 'enddef'], 'Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001638 so Xdef
Bram Moolenaard2c61702020-09-06 15:58:36 +02001639 writefile(['def Func1(): string', 'return "Func1"', 'enddef'], 'Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001640 so Xdef
Bram Moolenaard2c61702020-09-06 15:58:36 +02001641 writefile(['def! Func0(): string', 'enddef', 'defcompile'], 'Xdef')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +02001642 assert_fails('so Xdef', 'E1027:', '', 1, 'Func0')
Bram Moolenaard2c61702020-09-06 15:58:36 +02001643 writefile(['def Func2(): string', 'return "Func2"', 'enddef'], 'Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001644 so Xdef
Bram Moolenaard2c61702020-09-06 15:58:36 +02001645 delete('Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001646
Bram Moolenaar701cc6c2021-04-10 13:33:48 +02001647 assert_fails('g:Func0()', 'E1091:')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001648 g:Func1()->assert_equal('Func1')
1649 g:Func2()->assert_equal('Func2')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001650
1651 delfunc! Func0
1652 delfunc! Func1
1653 delfunc! Func2
1654enddef
1655
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001656def Test_vim9script_func()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001657 var lines =<< trim END
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001658 vim9script
1659 func Func(arg)
1660 echo a:arg
1661 endfunc
1662 Func('text')
1663 END
1664 writefile(lines, 'XVim9Func')
1665 so XVim9Func
1666
1667 delete('XVim9Func')
1668enddef
1669
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001670let s:funcResult = 0
1671
1672def FuncNoArgNoRet()
Bram Moolenaar53900992020-08-22 19:02:02 +02001673 s:funcResult = 11
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001674enddef
1675
1676def FuncNoArgRetNumber(): number
Bram Moolenaar53900992020-08-22 19:02:02 +02001677 s:funcResult = 22
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001678 return 1234
1679enddef
1680
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001681def FuncNoArgRetString(): string
Bram Moolenaar53900992020-08-22 19:02:02 +02001682 s:funcResult = 45
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001683 return 'text'
1684enddef
1685
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001686def FuncOneArgNoRet(arg: number)
Bram Moolenaar53900992020-08-22 19:02:02 +02001687 s:funcResult = arg
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001688enddef
1689
1690def FuncOneArgRetNumber(arg: number): number
Bram Moolenaar53900992020-08-22 19:02:02 +02001691 s:funcResult = arg
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001692 return arg
1693enddef
1694
Bram Moolenaar08938ee2020-04-11 23:17:17 +02001695def FuncTwoArgNoRet(one: bool, two: number)
Bram Moolenaar53900992020-08-22 19:02:02 +02001696 s:funcResult = two
Bram Moolenaar08938ee2020-04-11 23:17:17 +02001697enddef
1698
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001699def FuncOneArgRetString(arg: string): string
1700 return arg
1701enddef
1702
Bram Moolenaar89228602020-04-05 22:14:54 +02001703def FuncOneArgRetAny(arg: any): any
1704 return arg
1705enddef
1706
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001707def Test_func_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001708 var Ref1: func()
Bram Moolenaar53900992020-08-22 19:02:02 +02001709 s:funcResult = 0
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001710 Ref1 = FuncNoArgNoRet
1711 Ref1()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001712 s:funcResult->assert_equal(11)
Bram Moolenaar4c683752020-04-05 21:38:23 +02001713
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001714 var Ref2: func
Bram Moolenaar53900992020-08-22 19:02:02 +02001715 s:funcResult = 0
Bram Moolenaar4c683752020-04-05 21:38:23 +02001716 Ref2 = FuncNoArgNoRet
1717 Ref2()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001718 s:funcResult->assert_equal(11)
Bram Moolenaar4c683752020-04-05 21:38:23 +02001719
Bram Moolenaar53900992020-08-22 19:02:02 +02001720 s:funcResult = 0
Bram Moolenaar4c683752020-04-05 21:38:23 +02001721 Ref2 = FuncOneArgNoRet
1722 Ref2(12)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001723 s:funcResult->assert_equal(12)
Bram Moolenaar4c683752020-04-05 21:38:23 +02001724
Bram Moolenaar53900992020-08-22 19:02:02 +02001725 s:funcResult = 0
Bram Moolenaar4c683752020-04-05 21:38:23 +02001726 Ref2 = FuncNoArgRetNumber
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001727 Ref2()->assert_equal(1234)
1728 s:funcResult->assert_equal(22)
Bram Moolenaar4c683752020-04-05 21:38:23 +02001729
Bram Moolenaar53900992020-08-22 19:02:02 +02001730 s:funcResult = 0
Bram Moolenaar4c683752020-04-05 21:38:23 +02001731 Ref2 = FuncOneArgRetNumber
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001732 Ref2(13)->assert_equal(13)
1733 s:funcResult->assert_equal(13)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001734enddef
1735
Bram Moolenaar9978d472020-07-05 16:01:56 +02001736def Test_repeat_return_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001737 var res = 0
Bram Moolenaar9978d472020-07-05 16:01:56 +02001738 for n in repeat([1], 3)
1739 res += n
1740 endfor
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001741 res->assert_equal(3)
Bram Moolenaarfce82b32020-07-05 16:07:21 +02001742
1743 res = 0
1744 for n in add([1, 2], 3)
1745 res += n
1746 endfor
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001747 res->assert_equal(6)
Bram Moolenaar9978d472020-07-05 16:01:56 +02001748enddef
1749
Bram Moolenaar846178a2020-07-05 17:04:13 +02001750def Test_argv_return_type()
1751 next fileone filetwo
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001752 var res = ''
Bram Moolenaar846178a2020-07-05 17:04:13 +02001753 for name in argv()
1754 res ..= name
1755 endfor
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001756 res->assert_equal('fileonefiletwo')
Bram Moolenaar846178a2020-07-05 17:04:13 +02001757enddef
1758
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001759def Test_func_type_part()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001760 var RefVoid: func: void
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001761 RefVoid = FuncNoArgNoRet
1762 RefVoid = FuncOneArgNoRet
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001763 CheckDefFailure(['var RefVoid: func: void', 'RefVoid = FuncNoArgRetNumber'], 'E1012: Type mismatch; expected func(...) but got func(): number')
1764 CheckDefFailure(['var RefVoid: func: void', 'RefVoid = FuncNoArgRetString'], 'E1012: Type mismatch; expected func(...) but got func(): string')
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001765
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001766 var RefAny: func(): any
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001767 RefAny = FuncNoArgRetNumber
1768 RefAny = FuncNoArgRetString
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001769 CheckDefFailure(['var RefAny: func(): any', 'RefAny = FuncNoArgNoRet'], 'E1012: Type mismatch; expected func(): any but got func()')
1770 CheckDefFailure(['var RefAny: func(): any', 'RefAny = FuncOneArgNoRet'], 'E1012: Type mismatch; expected func(): any but got func(number)')
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001771
Bram Moolenaar6abd3dc2020-10-04 14:17:32 +02001772 var RefAnyNoArgs: func: any = RefAny
1773
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001774 var RefNr: func: number
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001775 RefNr = FuncNoArgRetNumber
1776 RefNr = FuncOneArgRetNumber
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001777 CheckDefFailure(['var RefNr: func: number', 'RefNr = FuncNoArgNoRet'], 'E1012: Type mismatch; expected func(...): number but got func()')
1778 CheckDefFailure(['var RefNr: func: number', 'RefNr = FuncNoArgRetString'], 'E1012: Type mismatch; expected func(...): number but got func(): string')
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001779
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001780 var RefStr: func: string
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001781 RefStr = FuncNoArgRetString
1782 RefStr = FuncOneArgRetString
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001783 CheckDefFailure(['var RefStr: func: string', 'RefStr = FuncNoArgNoRet'], 'E1012: Type mismatch; expected func(...): string but got func()')
1784 CheckDefFailure(['var RefStr: func: string', 'RefStr = FuncNoArgRetNumber'], 'E1012: Type mismatch; expected func(...): string but got func(): number')
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001785enddef
1786
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001787def Test_func_type_fails()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001788 CheckDefFailure(['var ref1: func()'], 'E704:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001789
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001790 CheckDefFailure(['var Ref1: func()', 'Ref1 = FuncNoArgRetNumber'], 'E1012: Type mismatch; expected func() but got func(): number')
1791 CheckDefFailure(['var Ref1: func()', 'Ref1 = FuncOneArgNoRet'], 'E1012: Type mismatch; expected func() but got func(number)')
1792 CheckDefFailure(['var Ref1: func()', 'Ref1 = FuncOneArgRetNumber'], 'E1012: Type mismatch; expected func() but got func(number): number')
1793 CheckDefFailure(['var Ref1: func(bool)', 'Ref1 = FuncTwoArgNoRet'], 'E1012: Type mismatch; expected func(bool) but got func(bool, number)')
1794 CheckDefFailure(['var Ref1: func(?bool)', 'Ref1 = FuncTwoArgNoRet'], 'E1012: Type mismatch; expected func(?bool) but got func(bool, number)')
1795 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 +02001796
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001797 CheckDefFailure(['var RefWrong: func(string ,number)'], 'E1068:')
1798 CheckDefFailure(['var RefWrong: func(string,number)'], 'E1069:')
1799 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:')
1800 CheckDefFailure(['var RefWrong: func(bool):string'], 'E1069:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001801enddef
1802
Bram Moolenaar89228602020-04-05 22:14:54 +02001803def Test_func_return_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001804 var nr: number
Bram Moolenaar89228602020-04-05 22:14:54 +02001805 nr = FuncNoArgRetNumber()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001806 nr->assert_equal(1234)
Bram Moolenaar89228602020-04-05 22:14:54 +02001807
1808 nr = FuncOneArgRetAny(122)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001809 nr->assert_equal(122)
Bram Moolenaar89228602020-04-05 22:14:54 +02001810
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001811 var str: string
Bram Moolenaar89228602020-04-05 22:14:54 +02001812 str = FuncOneArgRetAny('yes')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001813 str->assert_equal('yes')
Bram Moolenaar89228602020-04-05 22:14:54 +02001814
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001815 CheckDefFailure(['var str: string', 'str = FuncNoArgRetNumber()'], 'E1012: Type mismatch; expected string but got number')
Bram Moolenaar89228602020-04-05 22:14:54 +02001816enddef
1817
Bram Moolenaar6abd3dc2020-10-04 14:17:32 +02001818def Test_func_common_type()
1819 def FuncOne(n: number): number
1820 return n
1821 enddef
1822 def FuncTwo(s: string): number
1823 return len(s)
1824 enddef
1825 def FuncThree(n: number, s: string): number
1826 return n + len(s)
1827 enddef
1828 var list = [FuncOne, FuncTwo, FuncThree]
1829 assert_equal(8, list[0](8))
1830 assert_equal(4, list[1]('word'))
1831 assert_equal(7, list[2](3, 'word'))
1832enddef
1833
Bram Moolenaar5e774c72020-04-12 21:53:00 +02001834def MultiLine(
1835 arg1: string,
1836 arg2 = 1234,
1837 ...rest: list<string>
1838 ): string
1839 return arg1 .. arg2 .. join(rest, '-')
1840enddef
1841
Bram Moolenaar2c330432020-04-13 14:41:35 +02001842def MultiLineComment(
1843 arg1: string, # comment
1844 arg2 = 1234, # comment
1845 ...rest: list<string> # comment
1846 ): string # comment
1847 return arg1 .. arg2 .. join(rest, '-')
1848enddef
1849
Bram Moolenaar5e774c72020-04-12 21:53:00 +02001850def Test_multiline()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001851 MultiLine('text')->assert_equal('text1234')
1852 MultiLine('text', 777)->assert_equal('text777')
1853 MultiLine('text', 777, 'one')->assert_equal('text777one')
1854 MultiLine('text', 777, 'one', 'two')->assert_equal('text777one-two')
Bram Moolenaar5e774c72020-04-12 21:53:00 +02001855enddef
1856
Bram Moolenaar23e03252020-04-12 22:22:31 +02001857func Test_multiline_not_vim9()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001858 call MultiLine('text')->assert_equal('text1234')
1859 call MultiLine('text', 777)->assert_equal('text777')
1860 call MultiLine('text', 777, 'one')->assert_equal('text777one')
1861 call MultiLine('text', 777, 'one', 'two')->assert_equal('text777one-two')
Bram Moolenaar23e03252020-04-12 22:22:31 +02001862endfunc
1863
Bram Moolenaar5e774c72020-04-12 21:53:00 +02001864
Bram Moolenaaree4e0c12020-04-06 21:35:05 +02001865" When using CheckScriptFailure() for the below test, E1010 is generated instead
1866" of E1056.
1867func Test_E1056_1059()
1868 let caught_1056 = 0
1869 try
1870 def F():
1871 return 1
1872 enddef
1873 catch /E1056:/
1874 let caught_1056 = 1
1875 endtry
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001876 eval caught_1056->assert_equal(1)
Bram Moolenaaree4e0c12020-04-06 21:35:05 +02001877
1878 let caught_1059 = 0
1879 try
1880 def F5(items : list)
1881 echo 'a'
1882 enddef
1883 catch /E1059:/
1884 let caught_1059 = 1
1885 endtry
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001886 eval caught_1059->assert_equal(1)
Bram Moolenaaree4e0c12020-04-06 21:35:05 +02001887endfunc
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001888
Bram Moolenaar015f4262020-05-05 21:25:22 +02001889func DelMe()
1890 echo 'DelMe'
1891endfunc
1892
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001893def Test_error_reporting()
1894 # comment lines at the start of the function
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001895 var lines =<< trim END
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001896 " comment
1897 def Func()
1898 # comment
1899 # comment
1900 invalid
1901 enddef
1902 defcompile
1903 END
Bram Moolenaar08052222020-09-14 17:04:31 +02001904 writefile(lines, 'Xdef')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001905 try
1906 source Xdef
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02001907 assert_report('should have failed')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001908 catch /E476:/
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001909 v:exception->assert_match('Invalid command: invalid')
1910 v:throwpoint->assert_match(', line 3$')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001911 endtry
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001912 delfunc! g:Func
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001913
1914 # comment lines after the start of the function
1915 lines =<< trim END
1916 " comment
1917 def Func()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001918 var x = 1234
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001919 # comment
1920 # comment
1921 invalid
1922 enddef
1923 defcompile
1924 END
Bram Moolenaar08052222020-09-14 17:04:31 +02001925 writefile(lines, 'Xdef')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001926 try
1927 source Xdef
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02001928 assert_report('should have failed')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001929 catch /E476:/
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001930 v:exception->assert_match('Invalid command: invalid')
1931 v:throwpoint->assert_match(', line 4$')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001932 endtry
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001933 delfunc! g:Func
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001934
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02001935 lines =<< trim END
1936 vim9script
1937 def Func()
Bram Moolenaare0de1712020-12-02 17:36:54 +01001938 var db = {foo: 1, bar: 2}
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02001939 # comment
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001940 var x = db.asdf
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02001941 enddef
1942 defcompile
1943 Func()
1944 END
Bram Moolenaar08052222020-09-14 17:04:31 +02001945 writefile(lines, 'Xdef')
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02001946 try
1947 source Xdef
1948 assert_report('should have failed')
1949 catch /E716:/
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001950 v:throwpoint->assert_match('_Func, line 3$')
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02001951 endtry
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001952 delfunc! g:Func
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02001953
Bram Moolenaar08052222020-09-14 17:04:31 +02001954 delete('Xdef')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001955enddef
1956
Bram Moolenaar015f4262020-05-05 21:25:22 +02001957def Test_deleted_function()
1958 CheckDefExecFailure([
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001959 'var RefMe: func = function("g:DelMe")',
Bram Moolenaar015f4262020-05-05 21:25:22 +02001960 'delfunc g:DelMe',
1961 'echo RefMe()'], 'E117:')
1962enddef
1963
1964def Test_unknown_function()
1965 CheckDefExecFailure([
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001966 'var Ref: func = function("NotExist")',
Bram Moolenaar9b7bf9e2020-07-11 22:14:59 +02001967 'delfunc g:NotExist'], 'E700:')
Bram Moolenaar015f4262020-05-05 21:25:22 +02001968enddef
1969
Bram Moolenaar328eac22021-01-07 19:23:08 +01001970def RefFunc(Ref: func(any): any): string
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02001971 return Ref('more')
1972enddef
1973
1974def Test_closure_simple()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001975 var local = 'some '
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001976 RefFunc((s) => local .. s)->assert_equal('some more')
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02001977enddef
1978
Bram Moolenaarbf67ea12020-05-02 17:52:42 +02001979def MakeRef()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001980 var local = 'some '
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001981 g:Ref = (s) => local .. s
Bram Moolenaarbf67ea12020-05-02 17:52:42 +02001982enddef
1983
1984def Test_closure_ref_after_return()
1985 MakeRef()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001986 g:Ref('thing')->assert_equal('some thing')
Bram Moolenaarbf67ea12020-05-02 17:52:42 +02001987 unlet g:Ref
1988enddef
1989
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02001990def MakeTwoRefs()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001991 var local = ['some']
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001992 g:Extend = (s) => local->add(s)
1993 g:Read = () => local
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02001994enddef
1995
1996def Test_closure_two_refs()
1997 MakeTwoRefs()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001998 join(g:Read(), ' ')->assert_equal('some')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02001999 g:Extend('more')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002000 join(g:Read(), ' ')->assert_equal('some more')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002001 g:Extend('even')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002002 join(g:Read(), ' ')->assert_equal('some more even')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002003
2004 unlet g:Extend
2005 unlet g:Read
2006enddef
2007
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002008def ReadRef(Ref: func(): list<string>): string
2009 return join(Ref(), ' ')
2010enddef
2011
Bram Moolenaar5e654232020-09-16 15:22:00 +02002012def ExtendRef(Ref: func(string): list<string>, add: string)
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002013 Ref(add)
2014enddef
2015
2016def Test_closure_two_indirect_refs()
Bram Moolenaarf7779c62020-05-03 15:38:16 +02002017 MakeTwoRefs()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002018 ReadRef(g:Read)->assert_equal('some')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002019 ExtendRef(g:Extend, 'more')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002020 ReadRef(g:Read)->assert_equal('some more')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002021 ExtendRef(g:Extend, 'even')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002022 ReadRef(g:Read)->assert_equal('some more even')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002023
2024 unlet g:Extend
2025 unlet g:Read
2026enddef
Bram Moolenaarbf67ea12020-05-02 17:52:42 +02002027
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02002028def MakeArgRefs(theArg: string)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002029 var local = 'loc_val'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002030 g:UseArg = (s) => theArg .. '/' .. local .. '/' .. s
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02002031enddef
2032
2033def MakeArgRefsVarargs(theArg: string, ...rest: list<string>)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002034 var local = 'the_loc'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002035 g:UseVararg = (s) => theArg .. '/' .. local .. '/' .. s .. '/' .. join(rest)
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02002036enddef
2037
2038def Test_closure_using_argument()
2039 MakeArgRefs('arg_val')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002040 g:UseArg('call_val')->assert_equal('arg_val/loc_val/call_val')
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02002041
2042 MakeArgRefsVarargs('arg_val', 'one', 'two')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002043 g:UseVararg('call_val')->assert_equal('arg_val/the_loc/call_val/one two')
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02002044
2045 unlet g:UseArg
2046 unlet g:UseVararg
Bram Moolenaar44ec21c2021-02-12 21:50:57 +01002047
2048 var lines =<< trim END
2049 vim9script
2050 def Test(Fun: func(number): number): list<number>
2051 return map([1, 2, 3], (_, i) => Fun(i))
2052 enddef
2053 def Inc(nr: number): number
2054 return nr + 2
2055 enddef
2056 assert_equal([3, 4, 5], Test(Inc))
2057 END
2058 CheckScriptSuccess(lines)
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02002059enddef
2060
Bram Moolenaar85d5e2b2020-10-10 14:13:01 +02002061def MakeGetAndAppendRefs()
2062 var local = 'a'
2063
2064 def Append(arg: string)
2065 local ..= arg
2066 enddef
2067 g:Append = Append
2068
2069 def Get(): string
2070 return local
2071 enddef
2072 g:Get = Get
2073enddef
2074
2075def Test_closure_append_get()
2076 MakeGetAndAppendRefs()
2077 g:Get()->assert_equal('a')
2078 g:Append('-b')
2079 g:Get()->assert_equal('a-b')
2080 g:Append('-c')
2081 g:Get()->assert_equal('a-b-c')
2082
2083 unlet g:Append
2084 unlet g:Get
2085enddef
Bram Moolenaarb68b3462020-05-06 21:06:30 +02002086
Bram Moolenaar04b12692020-05-04 23:24:44 +02002087def Test_nested_closure()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002088 var local = 'text'
Bram Moolenaar04b12692020-05-04 23:24:44 +02002089 def Closure(arg: string): string
2090 return local .. arg
2091 enddef
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002092 Closure('!!!')->assert_equal('text!!!')
Bram Moolenaar04b12692020-05-04 23:24:44 +02002093enddef
2094
Bram Moolenaar6f5b6df2020-05-16 21:20:12 +02002095func GetResult(Ref)
2096 return a:Ref('some')
2097endfunc
2098
2099def Test_call_closure_not_compiled()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002100 var text = 'text'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002101 g:Ref = (s) => s .. text
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002102 GetResult(g:Ref)->assert_equal('sometext')
Bram Moolenaar6f5b6df2020-05-16 21:20:12 +02002103enddef
2104
Bram Moolenaar7cbfaa52020-09-18 21:25:32 +02002105def Test_double_closure_fails()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002106 var lines =<< trim END
Bram Moolenaar7cbfaa52020-09-18 21:25:32 +02002107 vim9script
2108 def Func()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002109 var name = 0
2110 for i in range(2)
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002111 timer_start(0, () => name)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002112 endfor
Bram Moolenaar7cbfaa52020-09-18 21:25:32 +02002113 enddef
2114 Func()
2115 END
Bram Moolenaar148ce7a2020-09-23 21:57:23 +02002116 CheckScriptSuccess(lines)
Bram Moolenaar7cbfaa52020-09-18 21:25:32 +02002117enddef
2118
Bram Moolenaar85d5e2b2020-10-10 14:13:01 +02002119def Test_nested_closure_used()
2120 var lines =<< trim END
2121 vim9script
2122 def Func()
2123 var x = 'hello'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002124 var Closure = () => x
2125 g:Myclosure = () => Closure()
Bram Moolenaar85d5e2b2020-10-10 14:13:01 +02002126 enddef
2127 Func()
2128 assert_equal('hello', g:Myclosure())
2129 END
2130 CheckScriptSuccess(lines)
2131enddef
Bram Moolenaar0876c782020-10-07 19:08:04 +02002132
Bram Moolenaarc70bdab2020-09-26 19:59:38 +02002133def Test_nested_closure_fails()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002134 var lines =<< trim END
Bram Moolenaarc70bdab2020-09-26 19:59:38 +02002135 vim9script
2136 def FuncA()
2137 FuncB(0)
2138 enddef
2139 def FuncB(n: number): list<string>
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002140 return map([0], (_, v) => n)
Bram Moolenaarc70bdab2020-09-26 19:59:38 +02002141 enddef
2142 FuncA()
2143 END
2144 CheckScriptFailure(lines, 'E1012:')
2145enddef
2146
Bram Moolenaarf112f302020-12-20 17:47:52 +01002147def Test_global_closure()
2148 var lines =<< trim END
2149 vim9script
2150 def ReverseEveryNLines(n: number, line1: number, line2: number)
2151 var mods = 'sil keepj keepp lockm '
2152 var range = ':' .. line1 .. ',' .. line2
2153 def g:Offset(): number
2154 var offset = (line('.') - line1 + 1) % n
2155 return offset != 0 ? offset : n
2156 enddef
2157 exe mods .. range .. 'g/^/exe "m .-" .. g:Offset()'
2158 enddef
2159
2160 new
2161 repeat(['aaa', 'bbb', 'ccc'], 3)->setline(1)
2162 ReverseEveryNLines(3, 1, 9)
2163 END
2164 CheckScriptSuccess(lines)
2165 var expected = repeat(['ccc', 'bbb', 'aaa'], 3)
2166 assert_equal(expected, getline(1, 9))
2167 bwipe!
2168enddef
2169
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01002170def Test_global_closure_called_directly()
2171 var lines =<< trim END
2172 vim9script
2173 def Outer()
2174 var x = 1
2175 def g:Inner()
2176 var y = x
2177 x += 1
2178 assert_equal(1, y)
2179 enddef
2180 g:Inner()
2181 assert_equal(2, x)
2182 enddef
2183 Outer()
2184 END
2185 CheckScriptSuccess(lines)
2186 delfunc g:Inner
2187enddef
2188
Bram Moolenaar34c54eb2020-11-25 19:15:19 +01002189def Test_failure_in_called_function()
2190 # this was using the frame index as the return value
2191 var lines =<< trim END
2192 vim9script
2193 au TerminalWinOpen * eval [][0]
2194 def PopupTerm(a: any)
2195 # make sure typvals on stack are string
2196 ['a', 'b', 'c', 'd', 'e', 'f', 'g']->join()
2197 FireEvent()
2198 enddef
2199 def FireEvent()
2200 do TerminalWinOpen
2201 enddef
2202 # use try/catch to make eval fail
2203 try
2204 call PopupTerm(0)
2205 catch
2206 endtry
2207 au! TerminalWinOpen
2208 END
2209 CheckScriptSuccess(lines)
2210enddef
2211
Bram Moolenaar5366e1a2020-10-01 13:01:34 +02002212def Test_nested_lambda()
2213 var lines =<< trim END
2214 vim9script
2215 def Func()
2216 var x = 4
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002217 var Lambda1 = () => 7
2218 var Lambda2 = () => [Lambda1(), x]
Bram Moolenaar5366e1a2020-10-01 13:01:34 +02002219 var res = Lambda2()
2220 assert_equal([7, 4], res)
2221 enddef
2222 Func()
2223 END
2224 CheckScriptSuccess(lines)
2225enddef
2226
Bram Moolenaarc04f2a42021-06-09 19:30:03 +02002227def Test_double_nested_lambda()
2228 var lines =<< trim END
2229 vim9script
2230 def F(head: string): func(string): func(string): string
2231 return (sep: string): func(string): string => ((tail: string): string => {
2232 return head .. sep .. tail
2233 })
2234 enddef
2235 assert_equal('hello-there', F('hello')('-')('there'))
2236 END
2237 CheckScriptSuccess(lines)
2238enddef
2239
Bram Moolenaar074f84c2021-05-18 11:47:44 +02002240def Test_nested_inline_lambda()
2241 # TODO: use the "text" argument
2242 var lines =<< trim END
2243 vim9script
2244 def F(text: string): func(string): func(string): string
2245 return (arg: string): func(string): string => ((sep: string): string => {
2246 return sep .. arg
2247 })
2248 enddef
2249 assert_equal('--there', F('unused')('there')('--'))
2250 END
2251 CheckScriptSuccess(lines)
2252enddef
2253
Bram Moolenaar52bf81c2020-11-17 18:50:44 +01002254def Shadowed(): list<number>
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002255 var FuncList: list<func: number> = [() => 42]
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01002256 return FuncList->mapnew((_, Shadowed) => Shadowed())
Bram Moolenaar52bf81c2020-11-17 18:50:44 +01002257enddef
2258
2259def Test_lambda_arg_shadows_func()
2260 assert_equal([42], Shadowed())
2261enddef
2262
Bram Moolenaaracd4c5e2020-06-22 19:39:03 +02002263def Line_continuation_in_def(dir: string = ''): string
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002264 var path: string = empty(dir)
2265 \ ? 'empty'
2266 \ : 'full'
2267 return path
Bram Moolenaaracd4c5e2020-06-22 19:39:03 +02002268enddef
2269
2270def Test_line_continuation_in_def()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002271 Line_continuation_in_def('.')->assert_equal('full')
Bram Moolenaaracd4c5e2020-06-22 19:39:03 +02002272enddef
2273
Bram Moolenaar2ea95b62020-11-19 21:47:56 +01002274def Test_script_var_in_lambda()
2275 var lines =<< trim END
2276 vim9script
2277 var script = 'test'
Bram Moolenaarbb8a7ce2021-04-10 20:10:26 +02002278 assert_equal(['test'], map(['one'], (_, _) => script))
Bram Moolenaar2ea95b62020-11-19 21:47:56 +01002279 END
2280 CheckScriptSuccess(lines)
2281enddef
2282
Bram Moolenaar5e654232020-09-16 15:22:00 +02002283def Line_continuation_in_lambda(): list<string>
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002284 var x = range(97, 100)
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01002285 ->mapnew((_, v) => nr2char(v)
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002286 ->toupper())
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02002287 ->reverse()
2288 return x
2289enddef
2290
2291def Test_line_continuation_in_lambda()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002292 Line_continuation_in_lambda()->assert_equal(['D', 'C', 'B', 'A'])
Bram Moolenaarf898f7c2021-01-16 18:09:52 +01002293
2294 var lines =<< trim END
2295 vim9script
2296 var res = [{n: 1, m: 2, s: 'xxx'}]
2297 ->mapnew((_, v: dict<any>): string => printf('%d:%d:%s',
2298 v.n,
2299 v.m,
2300 substitute(v.s, '.*', 'yyy', '')
2301 ))
2302 assert_equal(['1:2:yyy'], res)
2303 END
2304 CheckScriptSuccess(lines)
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02002305enddef
2306
Bram Moolenaarb6571982021-01-08 22:24:19 +01002307def Test_list_lambda()
2308 timer_start(1000, (_) => 0)
2309 var body = execute(timer_info()[0].callback
2310 ->string()
2311 ->substitute("('", ' ', '')
2312 ->substitute("')", '', '')
2313 ->substitute('function\zs', ' ', ''))
Bram Moolenaar767034c2021-04-09 17:24:52 +02002314 assert_match('def <lambda>\d\+(_: any): number\n1 return 0\n enddef', body)
Bram Moolenaarb6571982021-01-08 22:24:19 +01002315enddef
2316
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02002317def Test_legacy_lambda()
2318 legacy echo {x -> 'hello ' .. x}('foo')
Bram Moolenaardc4c2302021-04-25 13:54:42 +02002319
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02002320 var lines =<< trim END
2321 echo {x -> 'hello ' .. x}('foo')
2322 END
2323 CheckDefAndScriptFailure(lines, 'E720:')
Bram Moolenaardc4c2302021-04-25 13:54:42 +02002324
2325 lines =<< trim END
2326 vim9script
2327 def Func()
2328 echo (() => 'no error')()
2329 enddef
2330 legacy call s:Func()
2331 END
2332 CheckScriptSuccess(lines)
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02002333enddef
2334
Bram Moolenaarce024c32021-06-26 13:00:49 +02002335def Test_legacy()
2336 var lines =<< trim END
2337 vim9script
2338 func g:LegacyFunction()
2339 let g:legacyvar = 1
2340 endfunc
2341 def Testit()
2342 legacy call g:LegacyFunction()
2343 enddef
2344 Testit()
2345 assert_equal(1, g:legacyvar)
2346 unlet g:legacyvar
2347 delfunc g:LegacyFunction
2348 END
2349 CheckScriptSuccess(lines)
2350enddef
2351
Bram Moolenaarc3cb1c92021-06-02 16:47:53 +02002352def Test_legacy_errors()
2353 for cmd in ['if', 'elseif', 'else', 'endif',
2354 'for', 'endfor', 'continue', 'break',
2355 'while', 'endwhile',
2356 'try', 'catch', 'finally', 'endtry']
2357 CheckDefFailure(['legacy ' .. cmd .. ' expr'], 'E1189:')
2358 endfor
2359enddef
2360
Bram Moolenaarab360522021-01-10 14:02:28 +01002361def DoFilterThis(a: string): list<string>
2362 # closure nested inside another closure using argument
2363 var Filter = (l) => filter(l, (_, v) => stridx(v, a) == 0)
2364 return ['x', 'y', 'a', 'x2', 'c']->Filter()
2365enddef
2366
2367def Test_nested_closure_using_argument()
2368 assert_equal(['x', 'x2'], DoFilterThis('x'))
2369enddef
2370
Bram Moolenaar0186e582021-01-10 18:33:11 +01002371def Test_triple_nested_closure()
2372 var what = 'x'
2373 var Match = (val: string, cmp: string): bool => stridx(val, cmp) == 0
2374 var Filter = (l) => filter(l, (_, v) => Match(v, what))
2375 assert_equal(['x', 'x2'], ['x', 'y', 'a', 'x2', 'c']->Filter())
2376enddef
2377
Bram Moolenaar8f510af2020-07-05 18:48:23 +02002378func Test_silent_echo()
Bram Moolenaar47e7d702020-07-05 18:18:42 +02002379 CheckScreendump
2380
2381 let lines =<< trim END
2382 vim9script
2383 def EchoNothing()
2384 silent echo ''
2385 enddef
2386 defcompile
2387 END
Bram Moolenaar8f510af2020-07-05 18:48:23 +02002388 call writefile(lines, 'XTest_silent_echo')
Bram Moolenaar47e7d702020-07-05 18:18:42 +02002389
2390 " Check that the balloon shows up after a mouse move
2391 let buf = RunVimInTerminal('-S XTest_silent_echo', {'rows': 6})
Bram Moolenaar8f510af2020-07-05 18:48:23 +02002392 call term_sendkeys(buf, ":abc")
Bram Moolenaar47e7d702020-07-05 18:18:42 +02002393 call VerifyScreenDump(buf, 'Test_vim9_silent_echo', {})
2394
2395 " clean up
2396 call StopVimInTerminal(buf)
2397 call delete('XTest_silent_echo')
Bram Moolenaar8f510af2020-07-05 18:48:23 +02002398endfunc
Bram Moolenaar47e7d702020-07-05 18:18:42 +02002399
Bram Moolenaar171fb922020-10-28 16:54:47 +01002400def SilentlyError()
2401 execute('silent! invalid')
2402 g:did_it = 'yes'
2403enddef
2404
Bram Moolenaar28ee8922020-10-28 20:20:00 +01002405func UserError()
2406 silent! invalid
2407endfunc
2408
2409def SilentlyUserError()
2410 UserError()
2411 g:did_it = 'yes'
2412enddef
Bram Moolenaar171fb922020-10-28 16:54:47 +01002413
2414" This can't be a :def function, because the assert would not be reached.
Bram Moolenaar171fb922020-10-28 16:54:47 +01002415func Test_ignore_silent_error()
2416 let g:did_it = 'no'
2417 call SilentlyError()
2418 call assert_equal('yes', g:did_it)
2419
Bram Moolenaar28ee8922020-10-28 20:20:00 +01002420 let g:did_it = 'no'
2421 call SilentlyUserError()
2422 call assert_equal('yes', g:did_it)
Bram Moolenaar171fb922020-10-28 16:54:47 +01002423
2424 unlet g:did_it
2425endfunc
2426
Bram Moolenaarcd030c42020-10-30 21:49:40 +01002427def Test_ignore_silent_error_in_filter()
2428 var lines =<< trim END
2429 vim9script
2430 def Filter(winid: number, key: string): bool
2431 if key == 'o'
2432 silent! eval [][0]
2433 return true
2434 endif
2435 return popup_filter_menu(winid, key)
2436 enddef
2437
Bram Moolenaare0de1712020-12-02 17:36:54 +01002438 popup_create('popup', {filter: Filter})
Bram Moolenaarcd030c42020-10-30 21:49:40 +01002439 feedkeys("o\r", 'xnt')
2440 END
2441 CheckScriptSuccess(lines)
2442enddef
2443
Bram Moolenaar4b9bd692020-09-05 21:57:53 +02002444def Fibonacci(n: number): number
2445 if n < 2
2446 return n
2447 else
2448 return Fibonacci(n - 1) + Fibonacci(n - 2)
2449 endif
2450enddef
2451
Bram Moolenaar985116a2020-07-12 17:31:09 +02002452def Test_recursive_call()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002453 Fibonacci(20)->assert_equal(6765)
Bram Moolenaar985116a2020-07-12 17:31:09 +02002454enddef
2455
Bram Moolenaar08f7a412020-07-13 20:41:08 +02002456def TreeWalk(dir: string): list<any>
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01002457 return readdir(dir)->mapnew((_, val) =>
Bram Moolenaar08f7a412020-07-13 20:41:08 +02002458 fnamemodify(dir .. '/' .. val, ':p')->isdirectory()
Bram Moolenaar2bede172020-11-19 18:53:18 +01002459 ? {[val]: TreeWalk(dir .. '/' .. val)}
Bram Moolenaar08f7a412020-07-13 20:41:08 +02002460 : val
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002461 )
Bram Moolenaar08f7a412020-07-13 20:41:08 +02002462enddef
2463
2464def Test_closure_in_map()
2465 mkdir('XclosureDir/tdir', 'p')
2466 writefile(['111'], 'XclosureDir/file1')
2467 writefile(['222'], 'XclosureDir/file2')
2468 writefile(['333'], 'XclosureDir/tdir/file3')
2469
Bram Moolenaare0de1712020-12-02 17:36:54 +01002470 TreeWalk('XclosureDir')->assert_equal(['file1', 'file2', {tdir: ['file3']}])
Bram Moolenaar08f7a412020-07-13 20:41:08 +02002471
2472 delete('XclosureDir', 'rf')
2473enddef
2474
Bram Moolenaar7b5d5442020-10-04 13:42:34 +02002475def Test_invalid_function_name()
2476 var lines =<< trim END
2477 vim9script
2478 def s: list<string>
2479 END
2480 CheckScriptFailure(lines, 'E129:')
2481
2482 lines =<< trim END
2483 vim9script
2484 def g: list<string>
2485 END
2486 CheckScriptFailure(lines, 'E129:')
2487
2488 lines =<< trim END
2489 vim9script
2490 def <SID>: list<string>
2491 END
2492 CheckScriptFailure(lines, 'E884:')
2493
2494 lines =<< trim END
2495 vim9script
2496 def F list<string>
2497 END
2498 CheckScriptFailure(lines, 'E488:')
2499enddef
2500
Bram Moolenaara90afb92020-07-15 22:38:56 +02002501def Test_partial_call()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002502 var Xsetlist = function('setloclist', [0])
Bram Moolenaare0de1712020-12-02 17:36:54 +01002503 Xsetlist([], ' ', {title: 'test'})
2504 getloclist(0, {title: 1})->assert_equal({title: 'test'})
Bram Moolenaara90afb92020-07-15 22:38:56 +02002505
2506 Xsetlist = function('setloclist', [0, [], ' '])
Bram Moolenaare0de1712020-12-02 17:36:54 +01002507 Xsetlist({title: 'test'})
2508 getloclist(0, {title: 1})->assert_equal({title: 'test'})
Bram Moolenaara90afb92020-07-15 22:38:56 +02002509
2510 Xsetlist = function('setqflist')
Bram Moolenaare0de1712020-12-02 17:36:54 +01002511 Xsetlist([], ' ', {title: 'test'})
2512 getqflist({title: 1})->assert_equal({title: 'test'})
Bram Moolenaara90afb92020-07-15 22:38:56 +02002513
2514 Xsetlist = function('setqflist', [[], ' '])
Bram Moolenaare0de1712020-12-02 17:36:54 +01002515 Xsetlist({title: 'test'})
2516 getqflist({title: 1})->assert_equal({title: 'test'})
Bram Moolenaar6abd3dc2020-10-04 14:17:32 +02002517
2518 var Len: func: number = function('len', ['word'])
2519 assert_equal(4, Len())
Bram Moolenaara90afb92020-07-15 22:38:56 +02002520enddef
2521
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02002522def Test_cmd_modifier()
2523 tab echo '0'
Bram Moolenaard2c61702020-09-06 15:58:36 +02002524 CheckDefFailure(['5tab echo 3'], 'E16:')
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02002525enddef
2526
2527def Test_restore_modifiers()
2528 # check that when compiling a :def function command modifiers are not messed
2529 # up.
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002530 var lines =<< trim END
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02002531 vim9script
2532 set eventignore=
2533 autocmd QuickFixCmdPost * copen
2534 def AutocmdsDisabled()
Bram Moolenaar6cf7e3b2020-10-28 14:31:16 +01002535 eval 0
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02002536 enddef
2537 func Func()
2538 noautocmd call s:AutocmdsDisabled()
2539 let g:ei_after = &eventignore
2540 endfunc
2541 Func()
2542 END
2543 CheckScriptSuccess(lines)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002544 g:ei_after->assert_equal('')
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02002545enddef
2546
Bram Moolenaardfa3d552020-09-10 22:05:08 +02002547def StackTop()
2548 eval 1
2549 eval 2
2550 # call not on fourth line
2551 StackBot()
2552enddef
2553
2554def StackBot()
2555 # throw an error
2556 eval [][0]
2557enddef
2558
2559def Test_callstack_def()
2560 try
2561 StackTop()
2562 catch
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002563 v:throwpoint->assert_match('Test_callstack_def\[2\]..StackTop\[4\]..StackBot, line 2')
Bram Moolenaardfa3d552020-09-10 22:05:08 +02002564 endtry
2565enddef
2566
Bram Moolenaare8211a32020-10-09 22:04:29 +02002567" Re-using spot for variable used in block
2568def Test_block_scoped_var()
2569 var lines =<< trim END
2570 vim9script
2571 def Func()
2572 var x = ['a', 'b', 'c']
2573 if 1
2574 var y = 'x'
Bram Moolenaarbb8a7ce2021-04-10 20:10:26 +02002575 map(x, (_, _) => y)
Bram Moolenaare8211a32020-10-09 22:04:29 +02002576 endif
2577 var z = x
2578 assert_equal(['x', 'x', 'x'], z)
2579 enddef
2580 Func()
2581 END
2582 CheckScriptSuccess(lines)
2583enddef
2584
Bram Moolenaareeece9e2020-11-20 19:26:48 +01002585def Test_reset_did_emsg()
2586 var lines =<< trim END
2587 @s = 'blah'
2588 au BufWinLeave * #
2589 def Func()
2590 var winid = popup_create('popup', {})
2591 exe '*s'
2592 popup_close(winid)
2593 enddef
2594 Func()
2595 END
2596 CheckScriptFailure(lines, 'E492:', 8)
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002597 delfunc! g:Func
Bram Moolenaareeece9e2020-11-20 19:26:48 +01002598enddef
2599
Bram Moolenaar57f799e2020-12-12 20:42:19 +01002600def Test_did_emsg_reset()
2601 # executing an autocommand resets did_emsg, this should not result in a
2602 # builtin function considered failing
2603 var lines =<< trim END
2604 vim9script
2605 au BufWinLeave * #
2606 def Func()
Bram Moolenaar767034c2021-04-09 17:24:52 +02002607 popup_menu('', {callback: (a, b) => popup_create('', {})->popup_close()})
Bram Moolenaar57f799e2020-12-12 20:42:19 +01002608 eval [][0]
2609 enddef
2610 nno <F3> <cmd>call <sid>Func()<cr>
2611 feedkeys("\<F3>\e", 'xt')
2612 END
2613 writefile(lines, 'XemsgReset')
2614 assert_fails('so XemsgReset', ['E684:', 'E684:'], lines, 2)
2615 delete('XemsgReset')
2616 nunmap <F3>
2617 au! BufWinLeave
2618enddef
2619
Bram Moolenaar56602ba2020-12-05 21:22:08 +01002620def Test_abort_with_silent_call()
2621 var lines =<< trim END
2622 vim9script
2623 g:result = 'none'
2624 def Func()
2625 g:result += 3
2626 g:result = 'yes'
2627 enddef
2628 # error is silenced, but function aborts on error
2629 silent! Func()
2630 assert_equal('none', g:result)
2631 unlet g:result
2632 END
2633 CheckScriptSuccess(lines)
2634enddef
2635
Bram Moolenaarf665e972020-12-05 19:17:16 +01002636def Test_continues_with_silent_error()
2637 var lines =<< trim END
2638 vim9script
2639 g:result = 'none'
2640 def Func()
2641 silent! g:result += 3
2642 g:result = 'yes'
2643 enddef
2644 # error is silenced, function does not abort
2645 Func()
2646 assert_equal('yes', g:result)
2647 unlet g:result
2648 END
2649 CheckScriptSuccess(lines)
2650enddef
2651
Bram Moolenaaraf0df472020-12-02 20:51:22 +01002652def Test_abort_even_with_silent()
2653 var lines =<< trim END
2654 vim9script
2655 g:result = 'none'
2656 def Func()
2657 eval {-> ''}() .. '' .. {}['X']
2658 g:result = 'yes'
2659 enddef
Bram Moolenaarf665e972020-12-05 19:17:16 +01002660 silent! Func()
Bram Moolenaaraf0df472020-12-02 20:51:22 +01002661 assert_equal('none', g:result)
Bram Moolenaar4029cab2020-12-05 18:13:27 +01002662 unlet g:result
2663 END
2664 CheckScriptSuccess(lines)
2665enddef
2666
Bram Moolenaarf665e972020-12-05 19:17:16 +01002667def Test_cmdmod_silent_restored()
2668 var lines =<< trim END
2669 vim9script
2670 def Func()
2671 g:result = 'none'
2672 silent! g:result += 3
2673 g:result = 'none'
2674 g:result += 3
2675 enddef
2676 Func()
2677 END
2678 # can't use CheckScriptFailure, it ignores the :silent!
2679 var fname = 'Xdefsilent'
2680 writefile(lines, fname)
2681 var caught = 'no'
2682 try
2683 exe 'source ' .. fname
2684 catch /E1030:/
2685 caught = 'yes'
2686 assert_match('Func, line 4', v:throwpoint)
2687 endtry
2688 assert_equal('yes', caught)
2689 delete(fname)
2690enddef
2691
Bram Moolenaar2fecb532021-03-24 22:00:56 +01002692def Test_cmdmod_silent_nested()
2693 var lines =<< trim END
2694 vim9script
2695 var result = ''
2696
2697 def Error()
2698 result ..= 'Eb'
2699 eval [][0]
2700 result ..= 'Ea'
2701 enddef
2702
2703 def Crash()
2704 result ..= 'Cb'
2705 sil! Error()
2706 result ..= 'Ca'
2707 enddef
2708
2709 Crash()
2710 assert_equal('CbEbEaCa', result)
2711 END
2712 CheckScriptSuccess(lines)
2713enddef
2714
Bram Moolenaar4029cab2020-12-05 18:13:27 +01002715def Test_dict_member_with_silent()
2716 var lines =<< trim END
2717 vim9script
2718 g:result = 'none'
2719 var d: dict<any>
2720 def Func()
2721 try
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002722 g:result = map([], (_, v) => ({}[v]))->join() .. d['']
Bram Moolenaar4029cab2020-12-05 18:13:27 +01002723 catch
2724 endtry
2725 enddef
2726 silent! Func()
2727 assert_equal('0', g:result)
2728 unlet g:result
Bram Moolenaaraf0df472020-12-02 20:51:22 +01002729 END
2730 CheckScriptSuccess(lines)
2731enddef
2732
Bram Moolenaarf9041332021-01-21 19:41:16 +01002733def Test_skip_cmds_with_silent()
2734 var lines =<< trim END
2735 vim9script
2736
2737 def Func(b: bool)
2738 Crash()
2739 enddef
2740
2741 def Crash()
2742 sil! :/not found/d _
2743 sil! :/not found/put _
2744 enddef
2745
2746 Func(true)
2747 END
2748 CheckScriptSuccess(lines)
2749enddef
2750
Bram Moolenaar5b3d1bb2020-12-22 12:20:08 +01002751def Test_opfunc()
2752 nnoremap <F3> <cmd>set opfunc=Opfunc<cr>g@
2753 def g:Opfunc(_: any): string
2754 setline(1, 'ASDF')
2755 return ''
2756 enddef
2757 new
2758 setline(1, 'asdf')
2759 feedkeys("\<F3>$", 'x')
2760 assert_equal('ASDF', getline(1))
2761
2762 bwipe!
2763 nunmap <F3>
2764enddef
2765
Bram Moolenaar077a4232020-12-22 18:33:27 +01002766" this was crashing on exit
2767def Test_nested_lambda_in_closure()
2768 var lines =<< trim END
2769 vim9script
Bram Moolenaar227c58a2021-04-28 20:40:44 +02002770 command WriteDone writefile(['Done'], 'XnestedDone')
Bram Moolenaar077a4232020-12-22 18:33:27 +01002771 def Outer()
2772 def g:Inner()
2773 echo map([1, 2, 3], {_, v -> v + 1})
2774 enddef
2775 g:Inner()
2776 enddef
2777 defcompile
Bram Moolenaar227c58a2021-04-28 20:40:44 +02002778 # not reached
Bram Moolenaar077a4232020-12-22 18:33:27 +01002779 END
Bram Moolenaar227c58a2021-04-28 20:40:44 +02002780 if !RunVim([], lines, '--clean -c WriteDone -c quit')
Bram Moolenaar077a4232020-12-22 18:33:27 +01002781 return
2782 endif
2783 assert_equal(['Done'], readfile('XnestedDone'))
2784 delete('XnestedDone')
2785enddef
2786
Bram Moolenaar04947cc2021-03-06 19:26:46 +01002787def Test_check_func_arg_types()
2788 var lines =<< trim END
2789 vim9script
2790 def F1(x: string): string
2791 return x
2792 enddef
2793
2794 def F2(x: number): number
2795 return x + 1
2796 enddef
2797
2798 def G(g: func): dict<func>
2799 return {f: g}
2800 enddef
2801
2802 def H(d: dict<func>): string
2803 return d.f('a')
2804 enddef
2805 END
2806
2807 CheckScriptSuccess(lines + ['echo H(G(F1))'])
2808 CheckScriptFailure(lines + ['echo H(G(F2))'], 'E1013:')
2809enddef
2810
Bram Moolenaar701cc6c2021-04-10 13:33:48 +02002811def Test_compile_error()
2812 var lines =<< trim END
2813 def g:Broken()
2814 echo 'a' + {}
2815 enddef
2816 call g:Broken()
2817 END
2818 # First call: compilation error
2819 CheckScriptFailure(lines, 'E1051: Wrong argument type for +')
2820
2821 # Second call won't try compiling again
2822 assert_fails('call g:Broken()', 'E1091: Function is not compiled: Broken')
Bram Moolenaar599410c2021-04-10 14:03:43 +02002823 delfunc g:Broken
2824
2825 # No error when compiling with :silent!
2826 lines =<< trim END
2827 def g:Broken()
2828 echo 'a' + []
2829 enddef
2830 silent! defcompile
2831 END
2832 CheckScriptSuccess(lines)
2833
2834 # Calling the function won't try compiling again
2835 assert_fails('call g:Broken()', 'E1091: Function is not compiled: Broken')
2836 delfunc g:Broken
Bram Moolenaar701cc6c2021-04-10 13:33:48 +02002837enddef
2838
Bram Moolenaar962c43b2021-04-10 17:18:09 +02002839def Test_ignored_argument()
2840 var lines =<< trim END
2841 vim9script
2842 def Ignore(_, _): string
2843 return 'yes'
2844 enddef
2845 assert_equal('yes', Ignore(1, 2))
2846
2847 func Ok(_)
2848 return a:_
2849 endfunc
2850 assert_equal('ok', Ok('ok'))
2851
2852 func Oktoo()
2853 let _ = 'too'
2854 return _
2855 endfunc
2856 assert_equal('too', Oktoo())
Bram Moolenaarda479c72021-04-10 21:01:38 +02002857
2858 assert_equal([[1], [2], [3]], range(3)->mapnew((_, v) => [v]->map((_, w) => w + 1)))
Bram Moolenaar962c43b2021-04-10 17:18:09 +02002859 END
2860 CheckScriptSuccess(lines)
2861
2862 lines =<< trim END
2863 def Ignore(_: string): string
2864 return _
2865 enddef
2866 defcompile
2867 END
2868 CheckScriptFailure(lines, 'E1181:', 1)
2869
2870 lines =<< trim END
2871 var _ = 1
2872 END
2873 CheckDefAndScriptFailure(lines, 'E1181:', 1)
Yegappan Lakshmanan34fcb692021-05-25 20:14:00 +02002874
2875 lines =<< trim END
2876 var x = _
2877 END
2878 CheckDefAndScriptFailure(lines, 'E1181:', 1)
Bram Moolenaar962c43b2021-04-10 17:18:09 +02002879enddef
2880
Bram Moolenaarbb8a7ce2021-04-10 20:10:26 +02002881def Test_too_many_arguments()
2882 var lines =<< trim END
2883 echo [0, 1, 2]->map(() => 123)
2884 END
2885 CheckDefExecAndScriptFailure(lines, 'E1106: 2 arguments too many', 1)
2886
2887 lines =<< trim END
2888 echo [0, 1, 2]->map((_) => 123)
2889 END
2890 CheckDefExecAndScriptFailure(lines, 'E1106: One argument too many', 1)
2891enddef
Bram Moolenaar077a4232020-12-22 18:33:27 +01002892
Bram Moolenaara6aa1642021-04-23 19:32:23 +02002893def Test_closing_brace_at_start_of_line()
2894 var lines =<< trim END
2895 def Func()
2896 enddef
2897 Func(
2898 )
2899 END
2900 call CheckDefAndScriptSuccess(lines)
2901enddef
2902
Bram Moolenaar20677332021-06-06 17:02:53 +02002903if has('python3')
2904 def Test_python3_heredoc()
2905 py3 << trim EOF
2906 import vim
2907 vim.vars['didit'] = 'yes'
2908 EOF
2909 assert_equal('yes', g:didit)
2910
2911 python3 << trim EOF
2912 import vim
2913 vim.vars['didit'] = 'again'
2914 EOF
2915 assert_equal('again', g:didit)
2916 enddef
2917endif
2918
2919" This messes up syntax highlight, keep near the end.
2920if has('lua')
2921 def Test_lua_heredoc()
2922 g:d = {}
2923 lua << trim EOF
2924 x = vim.eval('g:d')
2925 x['key'] = 'val'
2926 EOF
2927 assert_equal('val', g:d.key)
2928 enddef
2929endif
2930
Bram Moolenaarf7779c62020-05-03 15:38:16 +02002931
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002932" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker