blob: 7ab15f72f3174b941d38cd29e8f5fe70b9b63d14 [file] [log] [blame]
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001" Test various aspects of the Vim9 script language.
2
3source check.vim
Bram Moolenaarad304702020-09-06 18:22:53 +02004source term_util.vim
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02005source view_util.vim
Bram Moolenaar62aec932022-01-29 21:45:34 +00006import './vim9.vim' as v9
Bram Moolenaar47e7d702020-07-05 18:18:42 +02007source screendump.vim
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02008
9func Test_def_basic()
10 def SomeFunc(): string
11 return 'yes'
12 enddef
Bram Moolenaarc0c71e92020-09-11 19:09:48 +020013 call SomeFunc()->assert_equal('yes')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +020014endfunc
15
Bram Moolenaar2b9b17e2020-10-13 18:38:11 +020016func Test_compiling_error()
17 " use a terminal to see the whole error message
Bram Moolenaarf4e8cdd2020-10-12 22:07:13 +020018 CheckRunVimInTerminal
19
Bram Moolenaar2b9b17e2020-10-13 18:38:11 +020020 call TestCompilingError()
Bram Moolenaare8c46602021-04-05 22:27:37 +020021 call TestCompilingErrorInTry()
Bram Moolenaar2b9b17e2020-10-13 18:38:11 +020022endfunc
23
24def TestCompilingError()
Bram Moolenaarf4e8cdd2020-10-12 22:07:13 +020025 var lines =<< trim END
26 vim9script
27 def Fails()
28 echo nothing
29 enddef
30 defcompile
31 END
Bram Moolenaare8c46602021-04-05 22:27:37 +020032 writefile(lines, 'XTest_compile_error')
Bram Moolenaar62aec932022-01-29 21:45:34 +000033 var buf = g:RunVimInTerminal('-S XTest_compile_error',
Bram Moolenaare0de1712020-12-02 17:36:54 +010034 {rows: 10, wait_for_ruler: 0})
Bram Moolenaar62aec932022-01-29 21:45:34 +000035 g:WaitForAssert(() => assert_match('Error detected while compiling command line.*Fails.*Variable not found: nothing',
36 g:Term_getlines(buf, range(1, 9))))
Bram Moolenaarf4e8cdd2020-10-12 22:07:13 +020037
38 # clean up
Bram Moolenaar62aec932022-01-29 21:45:34 +000039 g:StopVimInTerminal(buf)
Bram Moolenaare8c46602021-04-05 22:27:37 +020040 delete('XTest_compile_error')
41enddef
42
43def TestCompilingErrorInTry()
44 var dir = 'Xdir/autoload'
45 mkdir(dir, 'p')
46
47 var lines =<< trim END
48 vim9script
Bram Moolenaard8fe6d32022-01-30 18:40:44 +000049 export def OnlyCompiled()
Bram Moolenaare8c46602021-04-05 22:27:37 +020050 g:runtime = 'yes'
51 invalid
52 enddef
53 END
54 writefile(lines, dir .. '/script.vim')
55
56 lines =<< trim END
57 vim9script
58 todo
59 try
60 script#OnlyCompiled()
61 catch /nothing/
62 endtry
63 END
64 lines[1] = 'set rtp=' .. getcwd() .. '/Xdir'
65 writefile(lines, 'XTest_compile_error')
66
Bram Moolenaar62aec932022-01-29 21:45:34 +000067 var buf = g:RunVimInTerminal('-S XTest_compile_error', {rows: 10, wait_for_ruler: 0})
68 g:WaitForAssert(() => assert_match('Error detected while compiling command line.*function script#OnlyCompiled.*Invalid command: invalid',
69 g:Term_getlines(buf, range(1, 9))))
Bram Moolenaare8c46602021-04-05 22:27:37 +020070
71 # clean up
Bram Moolenaar62aec932022-01-29 21:45:34 +000072 g:StopVimInTerminal(buf)
Bram Moolenaare8c46602021-04-05 22:27:37 +020073 delete('XTest_compile_error')
74 delete('Xdir', 'rf')
Bram Moolenaarf4e8cdd2020-10-12 22:07:13 +020075enddef
76
Bram Moolenaarb55d6182021-06-08 22:01:53 +020077def Test_compile_error_in_called_function()
78 var lines =<< trim END
79 vim9script
80 var n: number
81 def Foo()
82 &hls = n
83 enddef
84 def Bar()
85 Foo()
86 enddef
87 silent! Foo()
88 Bar()
89 END
Bram Moolenaar62aec932022-01-29 21:45:34 +000090 v9.CheckScriptFailureList(lines, ['E1012:', 'E1191:'])
Bram Moolenaarb55d6182021-06-08 22:01:53 +020091enddef
92
Bram Moolenaar22f17a22021-06-21 20:48:58 +020093def Test_wrong_function_name()
94 var lines =<< trim END
95 vim9script
96 func _Foo()
97 echo 'foo'
98 endfunc
99 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000100 v9.CheckScriptFailure(lines, 'E128:')
Bram Moolenaar22f17a22021-06-21 20:48:58 +0200101
102 lines =<< trim END
103 vim9script
104 def _Foo()
105 echo 'foo'
106 enddef
107 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000108 v9.CheckScriptFailure(lines, 'E128:')
Bram Moolenaar22f17a22021-06-21 20:48:58 +0200109enddef
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
Bram Moolenaard8fe6d32022-01-30 18:40:44 +0000117 export def NoFunction()
Bram Moolenaarf48b2fa2021-04-12 22:02:36 +0200118 # 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
Bram Moolenaard8fe6d32022-01-30 18:40:44 +0000129 v9.CheckScriptFailure(lines, 'E117:', 1)
Bram Moolenaarf48b2fa2021-04-12 22:02:36 +0200130
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
Bram Moolenaar62aec932022-01-29 21:45:34 +0000157 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarf0a40692021-06-11 22:05:47 +0200158
159 &rtp = save_rtp
160 delete(dir, 'rf')
161enddef
162
Bram Moolenaar88c89c72021-08-14 14:01:05 +0200163def Test_autoload_error_in_script()
164 var dir = 'Xdir/autoload'
165 mkdir(dir, 'p')
166
167 var lines =<< trim END
168 func scripterror#function()
169 let g:called_function = 'yes'
170 endfunc
171 let 0 = 1
172 END
173 writefile(lines, dir .. '/scripterror.vim')
174
175 var save_rtp = &rtp
176 exe 'set rtp=' .. getcwd() .. '/Xdir'
177
178 g:called_function = 'no'
179 # The error in the autoload script cannot be checked with assert_fails(), use
180 # CheckDefSuccess() instead of CheckDefFailure()
181 try
Bram Moolenaar62aec932022-01-29 21:45:34 +0000182 v9.CheckDefSuccess(['scripterror#function()'])
Bram Moolenaar88c89c72021-08-14 14:01:05 +0200183 catch
184 assert_match('E121: Undefined variable: 0', v:exception)
185 endtry
186 assert_equal('no', g:called_function)
187
188 lines =<< trim END
189 func scriptcaught#function()
190 let g:called_function = 'yes'
191 endfunc
192 try
193 let 0 = 1
194 catch
195 let g:caught = v:exception
196 endtry
197 END
198 writefile(lines, dir .. '/scriptcaught.vim')
199
200 g:called_function = 'no'
Bram Moolenaar62aec932022-01-29 21:45:34 +0000201 v9.CheckDefSuccess(['scriptcaught#function()'])
Bram Moolenaar88c89c72021-08-14 14:01:05 +0200202 assert_match('E121: Undefined variable: 0', g:caught)
203 assert_equal('yes', g:called_function)
204
205 &rtp = save_rtp
206 delete(dir, 'rf')
207enddef
208
Bram Moolenaar62aec932022-01-29 21:45:34 +0000209def s:CallRecursive(n: number): number
Bram Moolenaar0ba48e82020-11-17 18:23:19 +0100210 return CallRecursive(n + 1)
211enddef
212
Bram Moolenaar62aec932022-01-29 21:45:34 +0000213def s:CallMapRecursive(l: list<number>): number
Bram Moolenaar2949cfd2020-12-31 21:28:47 +0100214 return map(l, (_, v) => CallMapRecursive([v]))[0]
Bram Moolenaar0ba48e82020-11-17 18:23:19 +0100215enddef
216
217def Test_funcdepth_error()
218 set maxfuncdepth=10
219
220 var caught = false
221 try
222 CallRecursive(1)
223 catch /E132:/
224 caught = true
225 endtry
226 assert_true(caught)
227
228 caught = false
229 try
230 CallMapRecursive([1])
231 catch /E132:/
232 caught = true
233 endtry
234 assert_true(caught)
235
236 set maxfuncdepth&
237enddef
238
Bram Moolenaar5178b1b2021-01-01 18:43:51 +0100239def Test_endfunc_enddef()
240 var lines =<< trim END
241 def Test()
242 echo 'test'
243 endfunc
244 enddef
245 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000246 v9.CheckScriptFailure(lines, 'E1151:', 3)
Bram Moolenaar5178b1b2021-01-01 18:43:51 +0100247
248 lines =<< trim END
249 def Test()
250 func Nested()
251 echo 'test'
252 enddef
253 enddef
254 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000255 v9.CheckScriptFailure(lines, 'E1152:', 4)
Bram Moolenaar49f1e9e2021-03-22 20:49:02 +0100256
257 lines =<< trim END
258 def Ok()
259 echo 'hello'
260 enddef | echo 'there'
261 def Bad()
262 echo 'hello'
263 enddef there
264 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000265 v9.CheckScriptFailure(lines, 'E1173: Text found after enddef: there', 6)
Bram Moolenaar5178b1b2021-01-01 18:43:51 +0100266enddef
267
Bram Moolenaarb8ba9b92021-01-01 18:54:34 +0100268def Test_missing_endfunc_enddef()
269 var lines =<< trim END
270 vim9script
271 def Test()
272 echo 'test'
273 endef
274 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000275 v9.CheckScriptFailure(lines, 'E1057:', 2)
Bram Moolenaarb8ba9b92021-01-01 18:54:34 +0100276
277 lines =<< trim END
278 vim9script
279 func Some()
280 echo 'test'
281 enfffunc
282 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000283 v9.CheckScriptFailure(lines, 'E126:', 2)
Bram Moolenaarb8ba9b92021-01-01 18:54:34 +0100284enddef
285
Bram Moolenaar4efd9942021-01-24 21:14:20 +0100286def Test_white_space_before_paren()
287 var lines =<< trim END
288 vim9script
289 def Test ()
290 echo 'test'
291 enddef
292 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000293 v9.CheckScriptFailure(lines, 'E1068:', 2)
Bram Moolenaar4efd9942021-01-24 21:14:20 +0100294
295 lines =<< trim END
296 vim9script
297 func Test ()
298 echo 'test'
299 endfunc
300 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000301 v9.CheckScriptFailure(lines, 'E1068:', 2)
Bram Moolenaar4efd9942021-01-24 21:14:20 +0100302
303 lines =<< trim END
304 def Test ()
305 echo 'test'
306 enddef
307 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000308 v9.CheckScriptFailure(lines, 'E1068:', 1)
Bram Moolenaar4efd9942021-01-24 21:14:20 +0100309
310 lines =<< trim END
311 func Test ()
312 echo 'test'
313 endfunc
314 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000315 v9.CheckScriptSuccess(lines)
Bram Moolenaar4efd9942021-01-24 21:14:20 +0100316enddef
317
Bram Moolenaar832ea892021-01-08 21:55:26 +0100318def Test_enddef_dict_key()
319 var d = {
320 enddef: 'x',
321 endfunc: 'y',
322 }
323 assert_equal({enddef: 'x', endfunc: 'y'}, d)
324enddef
325
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200326def ReturnString(): string
327 return 'string'
328enddef
329
330def ReturnNumber(): number
331 return 123
332enddef
333
334let g:notNumber = 'string'
335
336def ReturnGlobal(): number
337 return g:notNumber
338enddef
339
340def Test_return_something()
Bram Moolenaar62aec932022-01-29 21:45:34 +0000341 g:ReturnString()->assert_equal('string')
342 g:ReturnNumber()->assert_equal(123)
Bram Moolenaar848fadd2022-01-30 15:28:30 +0000343 assert_fails('g:ReturnGlobal()', 'E1012: Type mismatch; expected number but got string', '', 1, 'ReturnGlobal')
Bram Moolenaaref7aadb2022-01-18 18:46:07 +0000344
345 var lines =<< trim END
346 vim9script
347
348 def Msg()
349 echomsg 'in Msg()...'
350 enddef
351
352 def Func()
353 return Msg()
354 enddef
355 defcompile
356 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000357 v9.CheckScriptFailure(lines, 'E1096:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200358enddef
359
Bram Moolenaare32e5162021-01-21 20:21:29 +0100360def Test_check_argument_type()
361 var lines =<< trim END
362 vim9script
363 def Val(a: number, b: number): number
364 return 0
365 enddef
366 def Func()
367 var x: any = true
368 Val(0, x)
369 enddef
370 disass Func
371 Func()
372 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000373 v9.CheckScriptFailure(lines, 'E1013: Argument 2: type mismatch, expected number but got bool', 2)
Bram Moolenaare32e5162021-01-21 20:21:29 +0100374enddef
375
Bram Moolenaarefd88552020-06-18 20:50:10 +0200376def Test_missing_return()
Bram Moolenaar62aec932022-01-29 21:45:34 +0000377 v9.CheckDefFailure(['def Missing(): number',
Bram Moolenaarefd88552020-06-18 20:50:10 +0200378 ' if g:cond',
379 ' echo "no return"',
380 ' else',
381 ' return 0',
382 ' endif'
383 'enddef'], 'E1027:')
Bram Moolenaar62aec932022-01-29 21:45:34 +0000384 v9.CheckDefFailure(['def Missing(): number',
Bram Moolenaarefd88552020-06-18 20:50:10 +0200385 ' if g:cond',
386 ' return 1',
387 ' else',
388 ' echo "no return"',
389 ' endif'
390 'enddef'], 'E1027:')
Bram Moolenaar62aec932022-01-29 21:45:34 +0000391 v9.CheckDefFailure(['def Missing(): number',
Bram Moolenaarefd88552020-06-18 20:50:10 +0200392 ' if g:cond',
393 ' return 1',
394 ' else',
395 ' return 2',
396 ' endif'
397 ' return 3'
398 'enddef'], 'E1095:')
399enddef
400
Bram Moolenaar403dc312020-10-17 19:29:51 +0200401def Test_return_bool()
402 var lines =<< trim END
403 vim9script
404 def MenuFilter(id: number, key: string): bool
405 return popup_filter_menu(id, key)
406 enddef
407 def YesnoFilter(id: number, key: string): bool
408 return popup_filter_yesno(id, key)
409 enddef
410 defcompile
411 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000412 v9.CheckScriptSuccess(lines)
Bram Moolenaar403dc312020-10-17 19:29:51 +0200413enddef
414
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200415let s:nothing = 0
416def ReturnNothing()
417 s:nothing = 1
418 if true
419 return
420 endif
421 s:nothing = 2
422enddef
423
424def Test_return_nothing()
Bram Moolenaar62aec932022-01-29 21:45:34 +0000425 g:ReturnNothing()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200426 s:nothing->assert_equal(1)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200427enddef
428
Bram Moolenaar648ea762021-01-15 19:04:32 +0100429def Test_return_invalid()
430 var lines =<< trim END
431 vim9script
432 def Func(): invalid
433 return xxx
434 enddef
435 defcompile
436 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000437 v9.CheckScriptFailure(lines, 'E1010:', 2)
Bram Moolenaar31842cd2021-02-12 22:10:21 +0100438
439 lines =<< trim END
440 vim9script
441 def Test(Fun: func(number): number): list<number>
442 return map([1, 2, 3], (_, i) => Fun(i))
443 enddef
444 defcompile
445 def Inc(nr: number): nr
446 return nr + 2
447 enddef
448 echo Test(Inc)
449 END
450 # doing this twice was leaking memory
Bram Moolenaar62aec932022-01-29 21:45:34 +0000451 v9.CheckScriptFailure(lines, 'E1010:')
452 v9.CheckScriptFailure(lines, 'E1010:')
Bram Moolenaar648ea762021-01-15 19:04:32 +0100453enddef
454
Bram Moolenaarefc084e2021-09-09 22:30:52 +0200455def Test_return_list_any()
Bram Moolenaar114dbda2022-01-03 12:28:03 +0000456 # This used to fail but now the actual list type is checked, and since it has
457 # an item of type string it can be used as list<string>.
Bram Moolenaarefc084e2021-09-09 22:30:52 +0200458 var lines =<< trim END
459 vim9script
460 def Func(): list<string>
461 var l: list<any>
462 l->add('string')
463 return l
464 enddef
465 echo Func()
466 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000467 v9.CheckScriptSuccess(lines)
Bram Moolenaar114dbda2022-01-03 12:28:03 +0000468
Bram Moolenaarefc084e2021-09-09 22:30:52 +0200469 lines =<< trim END
470 vim9script
471 def Func(): list<string>
472 var l: list<any>
473 l += ['string']
474 return l
475 enddef
476 echo Func()
477 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000478 v9.CheckScriptSuccess(lines)
Bram Moolenaarefc084e2021-09-09 22:30:52 +0200479enddef
480
Bram Moolenaar62aec932022-01-29 21:45:34 +0000481func s:Increment()
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200482 let g:counter += 1
483endfunc
484
485def Test_call_ufunc_count()
486 g:counter = 1
487 Increment()
488 Increment()
489 Increment()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200490 # works with and without :call
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200491 g:counter->assert_equal(4)
492 eval g:counter->assert_equal(4)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200493 unlet g:counter
494enddef
495
Bram Moolenaar62aec932022-01-29 21:45:34 +0000496def s:MyVarargs(arg: string, ...rest: list<string>): string
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200497 var res = arg
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200498 for s in rest
499 res ..= ',' .. s
500 endfor
501 return res
502enddef
503
504def Test_call_varargs()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200505 MyVarargs('one')->assert_equal('one')
506 MyVarargs('one', 'two')->assert_equal('one,two')
507 MyVarargs('one', 'two', 'three')->assert_equal('one,two,three')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200508enddef
509
Bram Moolenaar01dd6c32021-09-05 16:36:23 +0200510def Test_call_white_space()
Bram Moolenaar62aec932022-01-29 21:45:34 +0000511 v9.CheckDefAndScriptFailure(["call Test ('text')"], ['E476:', 'E1068:'])
Bram Moolenaar01dd6c32021-09-05 16:36:23 +0200512enddef
513
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200514def MyDefaultArgs(name = 'string'): string
515 return name
516enddef
517
Bram Moolenaar62aec932022-01-29 21:45:34 +0000518def s:MyDefaultSecond(name: string, second: bool = true): string
Bram Moolenaare30f64b2020-07-15 19:48:20 +0200519 return second ? name : 'none'
520enddef
521
Bram Moolenaar38a3bfa2021-03-29 22:14:55 +0200522
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200523def Test_call_default_args()
Bram Moolenaar62aec932022-01-29 21:45:34 +0000524 g:MyDefaultArgs()->assert_equal('string')
525 g:MyDefaultArgs(v:none)->assert_equal('string')
526 g:MyDefaultArgs('one')->assert_equal('one')
527 assert_fails('g:MyDefaultArgs("one", "two")', 'E118:', '', 4, 'Test_call_default_args')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200528
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200529 MyDefaultSecond('test')->assert_equal('test')
530 MyDefaultSecond('test', true)->assert_equal('test')
531 MyDefaultSecond('test', false)->assert_equal('none')
Bram Moolenaare30f64b2020-07-15 19:48:20 +0200532
Bram Moolenaar38a3bfa2021-03-29 22:14:55 +0200533 var lines =<< trim END
534 def MyDefaultThird(name: string, aa = 'aa', bb = 'bb'): string
535 return name .. aa .. bb
536 enddef
537
538 MyDefaultThird('->')->assert_equal('->aabb')
539 MyDefaultThird('->', v:none)->assert_equal('->aabb')
540 MyDefaultThird('->', 'xx')->assert_equal('->xxbb')
541 MyDefaultThird('->', v:none, v:none)->assert_equal('->aabb')
542 MyDefaultThird('->', 'xx', v:none)->assert_equal('->xxbb')
543 MyDefaultThird('->', v:none, 'yy')->assert_equal('->aayy')
544 MyDefaultThird('->', 'xx', 'yy')->assert_equal('->xxyy')
Bram Moolenaare28d9b32021-07-03 18:56:53 +0200545
546 def DefArg(mandatory: any, optional = mandatory): string
547 return mandatory .. optional
548 enddef
549 DefArg(1234)->assert_equal('12341234')
550 DefArg("ok")->assert_equal('okok')
Bram Moolenaar38a3bfa2021-03-29 22:14:55 +0200551 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000552 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar38a3bfa2021-03-29 22:14:55 +0200553
Bram Moolenaar62aec932022-01-29 21:45:34 +0000554 v9.CheckScriptFailure(['def Func(arg: number = asdf)', 'enddef', 'defcompile'], 'E1001:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +0100555 delfunc g:Func
Bram Moolenaar62aec932022-01-29 21:45:34 +0000556 v9.CheckScriptFailure(['def Func(arg: number = "text")', 'enddef', 'defcompile'], 'E1013: Argument 1: type mismatch, expected number but got string')
Bram Moolenaar2d870f82020-12-05 13:41:01 +0100557 delfunc g:Func
Bram Moolenaar62aec932022-01-29 21:45:34 +0000558 v9.CheckDefFailure(['def Func(x: number = )', 'enddef'], 'E15:')
Bram Moolenaar12bce952021-03-11 20:04:04 +0100559
Bram Moolenaar38a3bfa2021-03-29 22:14:55 +0200560 lines =<< trim END
Bram Moolenaar12bce952021-03-11 20:04:04 +0100561 vim9script
562 def Func(a = b == 0 ? 1 : 2, b = 0)
563 enddef
564 defcompile
565 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000566 v9.CheckScriptFailure(lines, 'E1001: Variable not found: b')
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000567
Bram Moolenaarfa46ead2021-12-22 13:18:39 +0000568 # using script variable requires matching type or type cast when executed
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000569 lines =<< trim END
570 vim9script
571 var a: any
572 def Func(arg: string = a)
573 echo arg
574 enddef
575 defcompile
576 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000577 v9.CheckScriptSuccess(lines + ['a = "text"', 'Func()'])
578 v9.CheckScriptFailure(lines + ['a = 123', 'Func()'], 'E1013: Argument 1: type mismatch, expected string but got number')
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000579
580 # using global variable does not require type cast
581 lines =<< trim END
582 vim9script
583 def Func(arg: string = g:str)
584 echo arg
585 enddef
586 g:str = 'works'
587 Func()
588 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000589 v9.CheckScriptSuccess(lines)
Bram Moolenaar04b12692020-05-04 23:24:44 +0200590enddef
591
Bram Moolenaar62aec932022-01-29 21:45:34 +0000592def s:FuncWithComment( # comment
Bram Moolenaarcef12702021-01-04 14:09:43 +0100593 a: number, #comment
594 b: bool, # comment
595 c: string) #comment
596 assert_equal(4, a)
597 assert_equal(true, b)
598 assert_equal('yes', c)
599enddef
600
601def Test_func_with_comments()
602 FuncWithComment(4, true, 'yes')
603
604 var lines =<< trim END
605 def Func(# comment
606 arg: string)
607 enddef
608 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000609 v9.CheckScriptFailure(lines, 'E125:', 1)
Bram Moolenaarcef12702021-01-04 14:09:43 +0100610
611 lines =<< trim END
612 def Func(
613 arg: string# comment
614 )
615 enddef
616 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000617 v9.CheckScriptFailure(lines, 'E475:', 2)
Bram Moolenaarcef12702021-01-04 14:09:43 +0100618
619 lines =<< trim END
620 def Func(
621 arg: string
622 )# comment
623 enddef
624 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000625 v9.CheckScriptFailure(lines, 'E488:', 3)
Bram Moolenaarcef12702021-01-04 14:09:43 +0100626enddef
627
Bram Moolenaar04b12692020-05-04 23:24:44 +0200628def Test_nested_function()
Bram Moolenaar38453522021-11-28 22:00:12 +0000629 def NestedDef(arg: string): string
Bram Moolenaar04b12692020-05-04 23:24:44 +0200630 return 'nested ' .. arg
631 enddef
Bram Moolenaar38453522021-11-28 22:00:12 +0000632 NestedDef(':def')->assert_equal('nested :def')
633
634 func NestedFunc(arg)
635 return 'nested ' .. a:arg
636 endfunc
637 NestedFunc(':func')->assert_equal('nested :func')
Bram Moolenaar04b12692020-05-04 23:24:44 +0200638
Bram Moolenaar62aec932022-01-29 21:45:34 +0000639 v9.CheckDefFailure(['def Nested()', 'enddef', 'Nested(66)'], 'E118:')
640 v9.CheckDefFailure(['def Nested(arg: string)', 'enddef', 'Nested()'], 'E119:')
Bram Moolenaar0e65d3d2020-05-05 17:53:16 +0200641
Bram Moolenaar62aec932022-01-29 21:45:34 +0000642 v9.CheckDefFailure(['def s:Nested()', 'enddef'], 'E1075:')
643 v9.CheckDefFailure(['def b:Nested()', 'enddef'], 'E1075:')
Bram Moolenaar8b848ca2020-09-10 22:28:01 +0200644
Bram Moolenaar54021752020-12-06 18:50:36 +0100645 var lines =<< trim END
646 def Outer()
647 def Inner()
648 # comment
649 enddef
650 def Inner()
651 enddef
652 enddef
653 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000654 v9.CheckDefFailure(lines, 'E1073:')
Bram Moolenaar54021752020-12-06 18:50:36 +0100655
656 lines =<< trim END
657 def Outer()
658 def Inner()
659 # comment
660 enddef
661 def! Inner()
662 enddef
663 enddef
664 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000665 v9.CheckDefFailure(lines, 'E1117:')
Bram Moolenaar54021752020-12-06 18:50:36 +0100666
Bram Moolenaardb8e5c22021-12-25 19:58:22 +0000667 lines =<< trim END
668 vim9script
669 def Outer()
670 def Inner()
671 g:result = 'ok'
672 enddef
673 Inner()
674 enddef
675 Outer()
676 Inner()
677 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000678 v9.CheckScriptFailure(lines, 'E117: Unknown function: Inner')
Bram Moolenaardb8e5c22021-12-25 19:58:22 +0000679 assert_equal('ok', g:result)
680 unlet g:result
681
Bram Moolenaar54021752020-12-06 18:50:36 +0100682 # nested function inside conditional
Bram Moolenaar54021752020-12-06 18:50:36 +0100683 lines =<< trim END
684 vim9script
685 var thecount = 0
686 if true
687 def Test(): number
688 def TheFunc(): number
689 thecount += 1
690 return thecount
691 enddef
692 return TheFunc()
693 enddef
694 endif
695 defcompile
696 assert_equal(1, Test())
697 assert_equal(2, Test())
698 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000699 v9.CheckScriptSuccess(lines)
Bram Moolenaar8863bda2021-03-17 18:42:08 +0100700
701 # also works when "thecount" is inside the "if" block
702 lines =<< trim END
703 vim9script
704 if true
705 var thecount = 0
706 def Test(): number
707 def TheFunc(): number
708 thecount += 1
709 return thecount
710 enddef
711 return TheFunc()
712 enddef
713 endif
714 defcompile
715 assert_equal(1, Test())
716 assert_equal(2, Test())
717 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000718 v9.CheckScriptSuccess(lines)
Bram Moolenaar4bba16d2021-08-15 19:28:05 +0200719
720 lines =<< trim END
721 vim9script
722 def Outer()
723 def Inner()
724 echo 'hello'
725 enddef burp
726 enddef
727 defcompile
728 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000729 v9.CheckScriptFailure(lines, 'E1173: Text found after enddef: burp', 3)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200730enddef
731
Bram Moolenaaradc8e442020-12-31 18:28:18 +0100732def Test_not_nested_function()
733 echo printf('%d',
734 function('len')('xxx'))
735enddef
736
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200737func Test_call_default_args_from_func()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200738 call MyDefaultArgs()->assert_equal('string')
739 call MyDefaultArgs('one')->assert_equal('one')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +0200740 call assert_fails('call MyDefaultArgs("one", "two")', 'E118:', '', 3, 'Test_call_default_args_from_func')
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200741endfunc
742
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200743def Test_nested_global_function()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200744 var lines =<< trim END
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200745 vim9script
746 def Outer()
747 def g:Inner(): string
748 return 'inner'
749 enddef
750 enddef
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200751 defcompile
752 Outer()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200753 g:Inner()->assert_equal('inner')
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200754 delfunc g:Inner
755 Outer()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200756 g:Inner()->assert_equal('inner')
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200757 delfunc g:Inner
758 Outer()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200759 g:Inner()->assert_equal('inner')
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200760 delfunc g:Inner
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200761 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000762 v9.CheckScriptSuccess(lines)
Bram Moolenaar2c79e9d2020-08-01 18:57:52 +0200763
764 lines =<< trim END
765 vim9script
766 def Outer()
Bram Moolenaar38453522021-11-28 22:00:12 +0000767 func g:Inner()
768 return 'inner'
769 endfunc
770 enddef
771 defcompile
772 Outer()
773 g:Inner()->assert_equal('inner')
774 delfunc g:Inner
775 Outer()
776 g:Inner()->assert_equal('inner')
777 delfunc g:Inner
778 Outer()
779 g:Inner()->assert_equal('inner')
780 delfunc g:Inner
781 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000782 v9.CheckScriptSuccess(lines)
Bram Moolenaar38453522021-11-28 22:00:12 +0000783
784 lines =<< trim END
785 vim9script
786 def Outer()
Bram Moolenaar2c79e9d2020-08-01 18:57:52 +0200787 def g:Inner(): string
788 return 'inner'
789 enddef
790 enddef
791 defcompile
792 Outer()
793 Outer()
794 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000795 v9.CheckScriptFailure(lines, "E122:")
Bram Moolenaarcd45ed02020-12-22 17:35:54 +0100796 delfunc g:Inner
Bram Moolenaarad486a02020-08-01 23:22:18 +0200797
798 lines =<< trim END
799 vim9script
Bram Moolenaar58a52f22020-12-22 18:56:55 +0100800 def Outer()
801 def g:Inner()
Bram Moolenaar2949cfd2020-12-31 21:28:47 +0100802 echo map([1, 2, 3], (_, v) => v + 1)
Bram Moolenaar58a52f22020-12-22 18:56:55 +0100803 enddef
804 g:Inner()
805 enddef
806 Outer()
807 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000808 v9.CheckScriptSuccess(lines)
Bram Moolenaar58a52f22020-12-22 18:56:55 +0100809 delfunc g:Inner
810
811 lines =<< trim END
812 vim9script
Bram Moolenaarad486a02020-08-01 23:22:18 +0200813 def Func()
814 echo 'script'
815 enddef
816 def Outer()
817 def Func()
818 echo 'inner'
819 enddef
820 enddef
821 defcompile
822 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000823 v9.CheckScriptFailure(lines, "E1073:", 1)
Bram Moolenaard604d782021-11-20 21:46:20 +0000824
825 lines =<< trim END
826 vim9script
827 def Func()
828 echo 'script'
829 enddef
830 def Func()
831 echo 'script'
832 enddef
833 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000834 v9.CheckScriptFailure(lines, "E1073:", 5)
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200835enddef
836
Bram Moolenaar6abdcf82020-11-22 18:15:44 +0100837def DefListAll()
838 def
839enddef
840
841def DefListOne()
842 def DefListOne
843enddef
844
845def DefListMatches()
846 def /DefList
847enddef
848
849def Test_nested_def_list()
850 var funcs = split(execute('call DefListAll()'), "\n")
851 assert_true(len(funcs) > 10)
852 assert_true(funcs->index('def DefListAll()') >= 0)
853
854 funcs = split(execute('call DefListOne()'), "\n")
855 assert_equal([' def DefListOne()', '1 def DefListOne', ' enddef'], funcs)
856
857 funcs = split(execute('call DefListMatches()'), "\n")
858 assert_true(len(funcs) >= 3)
859 assert_true(funcs->index('def DefListAll()') >= 0)
860 assert_true(funcs->index('def DefListOne()') >= 0)
861 assert_true(funcs->index('def DefListMatches()') >= 0)
Bram Moolenaar54021752020-12-06 18:50:36 +0100862
863 var lines =<< trim END
864 vim9script
865 def Func()
866 def +Func+
867 enddef
868 defcompile
869 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000870 v9.CheckScriptFailure(lines, 'E476:', 1)
Bram Moolenaar6abdcf82020-11-22 18:15:44 +0100871enddef
872
Bram Moolenaar333894b2020-08-01 18:53:07 +0200873def Test_global_local_function()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200874 var lines =<< trim END
Bram Moolenaar333894b2020-08-01 18:53:07 +0200875 vim9script
876 def g:Func(): string
877 return 'global'
878 enddef
879 def Func(): string
880 return 'local'
881 enddef
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200882 g:Func()->assert_equal('global')
883 Func()->assert_equal('local')
Bram Moolenaar2d870f82020-12-05 13:41:01 +0100884 delfunc g:Func
Bram Moolenaar333894b2020-08-01 18:53:07 +0200885 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000886 v9.CheckScriptSuccess(lines)
Bram Moolenaar035d6e92020-08-11 22:30:42 +0200887
888 lines =<< trim END
889 vim9script
890 def g:Funcy()
891 echo 'funcy'
892 enddef
893 s:Funcy()
894 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000895 v9.CheckScriptFailure(lines, 'E117:')
Bram Moolenaar333894b2020-08-01 18:53:07 +0200896enddef
897
Bram Moolenaar0f769812020-09-12 18:32:34 +0200898def Test_local_function_shadows_global()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200899 var lines =<< trim END
Bram Moolenaar0f769812020-09-12 18:32:34 +0200900 vim9script
901 def g:Gfunc(): string
902 return 'global'
903 enddef
904 def AnotherFunc(): number
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200905 var Gfunc = function('len')
Bram Moolenaar0f769812020-09-12 18:32:34 +0200906 return Gfunc('testing')
907 enddef
908 g:Gfunc()->assert_equal('global')
909 AnotherFunc()->assert_equal(7)
910 delfunc g:Gfunc
911 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000912 v9.CheckScriptSuccess(lines)
Bram Moolenaar0f769812020-09-12 18:32:34 +0200913
914 lines =<< trim END
915 vim9script
916 def g:Func(): string
917 return 'global'
918 enddef
919 def AnotherFunc()
920 g:Func = function('len')
921 enddef
922 AnotherFunc()
923 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000924 v9.CheckScriptFailure(lines, 'E705:')
Bram Moolenaar0f769812020-09-12 18:32:34 +0200925 delfunc g:Func
Bram Moolenaar0865b152021-04-05 15:38:51 +0200926
Bram Moolenaar62aec932022-01-29 21:45:34 +0000927 # global function is not found with g: prefix
Bram Moolenaar0865b152021-04-05 15:38:51 +0200928 lines =<< trim END
929 vim9script
930 def g:Func(): string
931 return 'global'
932 enddef
933 def AnotherFunc(): string
934 return Func()
935 enddef
936 assert_equal('global', AnotherFunc())
Bram Moolenaar0865b152021-04-05 15:38:51 +0200937 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000938 v9.CheckScriptFailure(lines, 'E117:')
939 delfunc g:Func
Bram Moolenaar0865b152021-04-05 15:38:51 +0200940
941 lines =<< trim END
942 vim9script
943 def g:Func(): string
944 return 'global'
945 enddef
Bram Moolenaar848fadd2022-01-30 15:28:30 +0000946 assert_equal('global', g:Func())
Bram Moolenaar0865b152021-04-05 15:38:51 +0200947 delfunc g:Func
948 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000949 v9.CheckScriptSuccess(lines)
Bram Moolenaar58493cf2022-01-06 12:23:30 +0000950
951 # This does not shadow "i" which is visible only inside the for loop
952 lines =<< trim END
953 vim9script
954
955 def Foo(i: number)
956 echo i
957 enddef
958
959 for i in range(3)
960 # Foo() is compiled here
961 Foo(i)
962 endfor
963 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000964 v9.CheckScriptSuccess(lines)
Bram Moolenaar0f769812020-09-12 18:32:34 +0200965enddef
966
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200967func TakesOneArg(arg)
968 echo a:arg
969endfunc
970
971def Test_call_wrong_args()
Bram Moolenaar62aec932022-01-29 21:45:34 +0000972 v9.CheckDefFailure(['g:TakesOneArg()'], 'E119:')
973 v9.CheckDefFailure(['g:TakesOneArg(11, 22)'], 'E118:')
974 v9.CheckDefFailure(['bufnr(xxx)'], 'E1001:')
975 v9.CheckScriptFailure(['def Func(Ref: func(s: string))'], 'E475:')
Bram Moolenaaree8580e2020-08-28 17:19:07 +0200976
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200977 var lines =<< trim END
Bram Moolenaaree8580e2020-08-28 17:19:07 +0200978 vim9script
979 def Func(s: string)
980 echo s
981 enddef
982 Func([])
983 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000984 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected string but got list<unknown>', 5)
Bram Moolenaarb185a402020-09-18 22:42:00 +0200985
Bram Moolenaar9a015112021-12-31 14:06:45 +0000986 # argument name declared earlier is found when declaring a function
Bram Moolenaarb185a402020-09-18 22:42:00 +0200987 lines =<< trim END
988 vim9script
Bram Moolenaarb4893b82021-02-21 22:20:24 +0100989 var name = 'piet'
990 def FuncOne(name: string)
991 echo nr
992 enddef
993 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000994 v9.CheckScriptFailure(lines, 'E1168:')
Bram Moolenaarb4893b82021-02-21 22:20:24 +0100995
Bram Moolenaar9a015112021-12-31 14:06:45 +0000996 # argument name declared later is only found when compiling
997 lines =<< trim END
998 vim9script
999 def FuncOne(name: string)
1000 echo nr
1001 enddef
1002 var name = 'piet'
1003 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001004 v9.CheckScriptSuccess(lines)
1005 v9.CheckScriptFailure(lines + ['defcompile'], 'E1168:')
Bram Moolenaar9a015112021-12-31 14:06:45 +00001006
Bram Moolenaarb4893b82021-02-21 22:20:24 +01001007 lines =<< trim END
1008 vim9script
Bram Moolenaarb185a402020-09-18 22:42:00 +02001009 def FuncOne(nr: number)
1010 echo nr
1011 enddef
1012 def FuncTwo()
1013 FuncOne()
1014 enddef
1015 defcompile
1016 END
1017 writefile(lines, 'Xscript')
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001018 var didCatch = false
Bram Moolenaarb185a402020-09-18 22:42:00 +02001019 try
1020 source Xscript
1021 catch
1022 assert_match('E119: Not enough arguments for function: <SNR>\d\+_FuncOne', v:exception)
1023 assert_match('Xscript\[8\]..function <SNR>\d\+_FuncTwo, line 1', v:throwpoint)
1024 didCatch = true
1025 endtry
1026 assert_true(didCatch)
1027
1028 lines =<< trim END
1029 vim9script
1030 def FuncOne(nr: number)
1031 echo nr
1032 enddef
1033 def FuncTwo()
1034 FuncOne(1, 2)
1035 enddef
1036 defcompile
1037 END
1038 writefile(lines, 'Xscript')
1039 didCatch = false
1040 try
1041 source Xscript
1042 catch
1043 assert_match('E118: Too many arguments for function: <SNR>\d\+_FuncOne', v:exception)
1044 assert_match('Xscript\[8\]..function <SNR>\d\+_FuncTwo, line 1', v:throwpoint)
1045 didCatch = true
1046 endtry
1047 assert_true(didCatch)
1048
1049 delete('Xscript')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001050enddef
1051
Bram Moolenaar50824712020-12-20 21:10:17 +01001052def Test_call_funcref_wrong_args()
1053 var head =<< trim END
1054 vim9script
1055 def Func3(a1: string, a2: number, a3: list<number>)
1056 echo a1 .. a2 .. a3[0]
1057 enddef
1058 def Testme()
1059 var funcMap: dict<func> = {func: Func3}
1060 END
1061 var tail =<< trim END
1062 enddef
1063 Testme()
1064 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001065 v9.CheckScriptSuccess(head + ["funcMap['func']('str', 123, [1, 2, 3])"] + tail)
Bram Moolenaar50824712020-12-20 21:10:17 +01001066
Bram Moolenaar62aec932022-01-29 21:45:34 +00001067 v9.CheckScriptFailure(head + ["funcMap['func']('str', 123)"] + tail, 'E119:')
1068 v9.CheckScriptFailure(head + ["funcMap['func']('str', 123, [1], 4)"] + tail, 'E118:')
Bram Moolenaar32b3f822021-01-06 21:59:39 +01001069
1070 var lines =<< trim END
1071 vim9script
1072 var Ref: func(number): any
1073 Ref = (j) => !j
1074 echo Ref(false)
1075 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001076 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected number but got bool', 4)
Bram Moolenaar32b3f822021-01-06 21:59:39 +01001077
1078 lines =<< trim END
1079 vim9script
1080 var Ref: func(number): any
1081 Ref = (j) => !j
1082 call Ref(false)
1083 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001084 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected number but got bool', 4)
Bram Moolenaar50824712020-12-20 21:10:17 +01001085enddef
1086
Bram Moolenaarb4d16cb2020-11-05 18:45:46 +01001087def Test_call_lambda_args()
Bram Moolenaar2a389082021-04-09 20:24:31 +02001088 var lines =<< trim END
1089 var Callback = (..._) => 'anything'
1090 assert_equal('anything', Callback())
1091 assert_equal('anything', Callback(1))
1092 assert_equal('anything', Callback('a', 2))
Bram Moolenaar1088b692021-04-09 22:12:44 +02001093
1094 assert_equal('xyz', ((a: string): string => a)('xyz'))
Bram Moolenaar2a389082021-04-09 20:24:31 +02001095 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001096 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar2a389082021-04-09 20:24:31 +02001097
Bram Moolenaar62aec932022-01-29 21:45:34 +00001098 v9.CheckDefFailure(['echo ((i) => 0)()'],
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001099 'E119: Not enough arguments for function: ((i) => 0)()')
Bram Moolenaarb4d16cb2020-11-05 18:45:46 +01001100
Bram Moolenaar2a389082021-04-09 20:24:31 +02001101 lines =<< trim END
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001102 var Ref = (x: number, y: number) => x + y
Bram Moolenaarb4d16cb2020-11-05 18:45:46 +01001103 echo Ref(1, 'x')
1104 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001105 v9.CheckDefFailure(lines, 'E1013: Argument 2: type mismatch, expected number but got string')
Bram Moolenaare68b02a2021-01-03 13:09:51 +01001106
1107 lines =<< trim END
1108 var Ref: func(job, string, number)
1109 Ref = (x, y) => 0
1110 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001111 v9.CheckDefAndScriptFailure(lines, 'E1012:')
Bram Moolenaare68b02a2021-01-03 13:09:51 +01001112
1113 lines =<< trim END
1114 var Ref: func(job, string)
1115 Ref = (x, y, z) => 0
1116 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001117 v9.CheckDefAndScriptFailure(lines, 'E1012:')
Bram Moolenaar057e84a2021-02-28 16:55:11 +01001118
1119 lines =<< trim END
1120 var one = 1
1121 var l = [1, 2, 3]
1122 echo map(l, (one) => one)
1123 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001124 v9.CheckDefFailure(lines, 'E1167:')
1125 v9.CheckScriptFailure(['vim9script'] + lines, 'E1168:')
Bram Moolenaar057e84a2021-02-28 16:55:11 +01001126
1127 lines =<< trim END
Bram Moolenaar14ded112021-06-26 19:25:49 +02001128 var Ref: func(any, ?any): bool
1129 Ref = (_, y = 1) => false
1130 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001131 v9.CheckDefAndScriptFailure(lines, 'E1172:')
Bram Moolenaar14ded112021-06-26 19:25:49 +02001132
1133 lines =<< trim END
Bram Moolenaar015cf102021-06-26 21:52:02 +02001134 var a = 0
1135 var b = (a == 0 ? 1 : 2)
1136 assert_equal(1, b)
Bram Moolenaar98f9a5f2021-06-26 22:22:38 +02001137 var txt = 'a'
1138 b = (txt =~ 'x' ? 1 : 2)
1139 assert_equal(2, b)
Bram Moolenaar015cf102021-06-26 21:52:02 +02001140 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001141 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar015cf102021-06-26 21:52:02 +02001142
1143 lines =<< trim END
Bram Moolenaar057e84a2021-02-28 16:55:11 +01001144 def ShadowLocal()
1145 var one = 1
1146 var l = [1, 2, 3]
1147 echo map(l, (one) => one)
1148 enddef
1149 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001150 v9.CheckDefFailure(lines, 'E1167:')
Bram Moolenaar057e84a2021-02-28 16:55:11 +01001151
1152 lines =<< trim END
1153 def Shadowarg(one: number)
1154 var l = [1, 2, 3]
1155 echo map(l, (one) => one)
1156 enddef
1157 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001158 v9.CheckDefFailure(lines, 'E1167:')
Bram Moolenaar767034c2021-04-09 17:24:52 +02001159
1160 lines =<< trim END
1161 echo ((a) => a)('aa', 'bb')
1162 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001163 v9.CheckDefAndScriptFailure(lines, 'E118:', 1)
Bram Moolenaarc4c56422021-07-21 20:38:46 +02001164
1165 lines =<< trim END
1166 echo 'aa'->((a) => a)('bb')
1167 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001168 v9.CheckDefFailure(lines, 'E118: Too many arguments for function: ->((a) => a)(''bb'')', 1)
1169 v9.CheckScriptFailure(['vim9script'] + lines, 'E118: Too many arguments for function: <lambda>', 2)
Bram Moolenaarb4d16cb2020-11-05 18:45:46 +01001170enddef
1171
Bram Moolenaara755fdb2021-11-20 21:35:41 +00001172def Test_lambda_line_nr()
1173 var lines =<< trim END
1174 vim9script
1175 # comment
1176 # comment
1177 var id = timer_start(1'000, (_) => 0)
1178 var out = execute('verbose ' .. timer_info(id)[0].callback
1179 ->string()
1180 ->substitute("('\\|')", ' ', 'g'))
1181 assert_match('Last set from .* line 4', out)
1182 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001183 v9.CheckScriptSuccess(lines)
Bram Moolenaara755fdb2021-11-20 21:35:41 +00001184enddef
1185
Bram Moolenaar5f91e742021-03-17 21:29:29 +01001186def FilterWithCond(x: string, Cond: func(string): bool): bool
1187 return Cond(x)
1188enddef
1189
Bram Moolenaar0346b792021-01-31 22:18:29 +01001190def Test_lambda_return_type()
1191 var lines =<< trim END
1192 var Ref = (): => 123
1193 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001194 v9.CheckDefAndScriptFailure(lines, 'E1157:', 1)
Bram Moolenaar5f91e742021-03-17 21:29:29 +01001195
Yegappan Lakshmanan611728f2021-05-24 15:15:47 +02001196 # no space before the return type
1197 lines =<< trim END
1198 var Ref = (x):number => x + 1
1199 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001200 v9.CheckDefAndScriptFailure(lines, 'E1069:', 1)
Yegappan Lakshmanan611728f2021-05-24 15:15:47 +02001201
Bram Moolenaar5f91e742021-03-17 21:29:29 +01001202 # this works
1203 for x in ['foo', 'boo']
Bram Moolenaar62aec932022-01-29 21:45:34 +00001204 echo g:FilterWithCond(x, (v) => v =~ '^b')
Bram Moolenaar5f91e742021-03-17 21:29:29 +01001205 endfor
1206
1207 # this fails
1208 lines =<< trim END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001209 echo g:FilterWithCond('foo', (v) => v .. '^b')
Bram Moolenaar5f91e742021-03-17 21:29:29 +01001210 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001211 v9.CheckDefAndScriptFailure(lines, 'E1013: Argument 2: type mismatch, expected func(string): bool but got func(any): string', 1)
Bram Moolenaara9931532021-06-12 15:58:16 +02001212
1213 lines =<< trim END
1214 var Lambda1 = (x) => {
1215 return x
1216 }
1217 assert_equal('asdf', Lambda1('asdf'))
1218 var Lambda2 = (x): string => {
1219 return x
1220 }
1221 assert_equal('foo', Lambda2('foo'))
1222 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001223 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaara9931532021-06-12 15:58:16 +02001224
1225 lines =<< trim END
1226 var Lambda = (x): string => {
1227 return x
1228 }
1229 echo Lambda(['foo'])
1230 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001231 v9.CheckDefExecAndScriptFailure(lines, 'E1012:')
Bram Moolenaar0346b792021-01-31 22:18:29 +01001232enddef
1233
Bram Moolenaar709664c2020-12-12 14:33:41 +01001234def Test_lambda_uses_assigned_var()
Bram Moolenaar62aec932022-01-29 21:45:34 +00001235 v9.CheckDefSuccess([
Bram Moolenaar709664c2020-12-12 14:33:41 +01001236 'var x: any = "aaa"'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001237 'x = filter(["bbb"], (_, v) => v =~ x)'])
Bram Moolenaar709664c2020-12-12 14:33:41 +01001238enddef
1239
Bram Moolenaar18062fc2021-03-05 21:35:47 +01001240def Test_pass_legacy_lambda_to_def_func()
1241 var lines =<< trim END
1242 vim9script
1243 func Foo()
1244 eval s:Bar({x -> 0})
1245 endfunc
1246 def Bar(y: any)
1247 enddef
1248 Foo()
1249 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001250 v9.CheckScriptSuccess(lines)
Bram Moolenaar831bdf82021-06-22 19:32:17 +02001251
1252 lines =<< trim END
1253 vim9script
Bram Moolenaar7a40ff02021-07-04 15:54:08 +02001254 def g:TestFunc(f: func)
Bram Moolenaar831bdf82021-06-22 19:32:17 +02001255 enddef
1256 legacy call g:TestFunc({-> 0})
1257 delfunc g:TestFunc
1258
1259 def g:TestFunc(f: func(number))
1260 enddef
1261 legacy call g:TestFunc({nr -> 0})
1262 delfunc g:TestFunc
1263 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001264 v9.CheckScriptSuccess(lines)
Bram Moolenaar18062fc2021-03-05 21:35:47 +01001265enddef
1266
Bram Moolenaar844fb642021-10-23 13:32:30 +01001267def Test_lambda_in_reduce_line_break()
1268 # this was using freed memory
1269 var lines =<< trim END
1270 vim9script
1271 const result: dict<number> =
1272 ['Bob', 'Sam', 'Cat', 'Bob', 'Cat', 'Cat']
1273 ->reduce((acc, val) => {
1274 if has_key(acc, val)
1275 acc[val] += 1
1276 return acc
1277 else
1278 acc[val] = 1
1279 return acc
1280 endif
1281 }, {})
1282 assert_equal({Bob: 2, Sam: 1, Cat: 3}, result)
1283 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001284 v9.CheckScriptSuccess(lines)
Bram Moolenaar844fb642021-10-23 13:32:30 +01001285enddef
1286
Bram Moolenaardcb53be2021-12-09 14:23:43 +00001287def Test_set_opfunc_to_lambda()
1288 var lines =<< trim END
1289 vim9script
1290 nnoremap <expr> <F4> <SID>CountSpaces() .. '_'
1291 def CountSpaces(type = ''): string
1292 if type == ''
1293 &operatorfunc = (t) => CountSpaces(t)
1294 return 'g@'
1295 endif
1296 normal! '[V']y
1297 g:result = getreg('"')->count(' ')
1298 return ''
1299 enddef
1300 new
1301 'a b c d e'->setline(1)
1302 feedkeys("\<F4>", 'x')
1303 assert_equal(4, g:result)
1304 bwipe!
1305 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001306 v9.CheckScriptSuccess(lines)
Bram Moolenaardcb53be2021-12-09 14:23:43 +00001307enddef
1308
Bram Moolenaaref082e12021-12-12 21:02:03 +00001309def Test_set_opfunc_to_global_function()
1310 var lines =<< trim END
1311 vim9script
1312 def g:CountSpaces(type = ''): string
1313 normal! '[V']y
1314 g:result = getreg('"')->count(' ')
1315 return ''
1316 enddef
Bram Moolenaarb15cf442021-12-16 15:49:43 +00001317 # global function works at script level
Bram Moolenaaref082e12021-12-12 21:02:03 +00001318 &operatorfunc = g:CountSpaces
1319 new
1320 'a b c d e'->setline(1)
1321 feedkeys("g@_", 'x')
1322 assert_equal(4, g:result)
Bram Moolenaarb15cf442021-12-16 15:49:43 +00001323
1324 &operatorfunc = ''
1325 g:result = 0
1326 # global function works in :def function
1327 def Func()
1328 &operatorfunc = g:CountSpaces
1329 enddef
1330 Func()
1331 feedkeys("g@_", 'x')
1332 assert_equal(4, g:result)
1333
Bram Moolenaaref082e12021-12-12 21:02:03 +00001334 bwipe!
1335 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001336 v9.CheckScriptSuccess(lines)
Bram Moolenaaref082e12021-12-12 21:02:03 +00001337 &operatorfunc = ''
1338enddef
1339
Bram Moolenaar33b968d2021-12-13 11:31:04 +00001340def Test_use_script_func_name_with_prefix()
1341 var lines =<< trim END
1342 vim9script
1343 func s:Getit()
1344 return 'it'
1345 endfunc
1346 var Fn = s:Getit
1347 assert_equal('it', Fn())
1348 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001349 v9.CheckScriptSuccess(lines)
Bram Moolenaar33b968d2021-12-13 11:31:04 +00001350enddef
1351
Bram Moolenaardd297bc2021-12-10 10:37:38 +00001352def Test_lambda_type_allocated()
1353 # Check that unreferencing a partial using a lambda can use the variable type
1354 # after the lambda has been freed and does not leak memory.
1355 var lines =<< trim END
1356 vim9script
1357
1358 func MyomniFunc1(val, findstart, base)
1359 return a:findstart ? 0 : []
1360 endfunc
1361
1362 var Lambda = (a, b) => MyomniFunc1(19, a, b)
1363 &omnifunc = Lambda
1364 Lambda = (a, b) => MyomniFunc1(20, a, b)
1365 &omnifunc = string(Lambda)
1366 Lambda = (a, b) => strlen(a)
1367 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001368 v9.CheckScriptSuccess(lines)
Bram Moolenaardd297bc2021-12-10 10:37:38 +00001369enddef
1370
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001371" Default arg and varargs
1372def MyDefVarargs(one: string, two = 'foo', ...rest: list<string>): string
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001373 var res = one .. ',' .. two
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001374 for s in rest
1375 res ..= ',' .. s
1376 endfor
1377 return res
1378enddef
1379
1380def Test_call_def_varargs()
Bram Moolenaar62aec932022-01-29 21:45:34 +00001381 assert_fails('g:MyDefVarargs()', 'E119:', '', 1, 'Test_call_def_varargs')
1382 g:MyDefVarargs('one')->assert_equal('one,foo')
1383 g:MyDefVarargs('one', 'two')->assert_equal('one,two')
1384 g:MyDefVarargs('one', 'two', 'three')->assert_equal('one,two,three')
1385 v9.CheckDefFailure(['g:MyDefVarargs("one", 22)'],
Bram Moolenaar77072282020-09-16 17:55:40 +02001386 'E1013: Argument 2: type mismatch, expected string but got number')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001387 v9.CheckDefFailure(['g:MyDefVarargs("one", "two", 123)'],
Bram Moolenaar77072282020-09-16 17:55:40 +02001388 'E1013: Argument 3: type mismatch, expected string but got number')
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001389
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001390 var lines =<< trim END
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001391 vim9script
1392 def Func(...l: list<string>)
1393 echo l
1394 enddef
1395 Func('a', 'b', 'c')
1396 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001397 v9.CheckScriptSuccess(lines)
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001398
1399 lines =<< trim END
1400 vim9script
1401 def Func(...l: list<string>)
1402 echo l
1403 enddef
1404 Func()
1405 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001406 v9.CheckScriptSuccess(lines)
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001407
1408 lines =<< trim END
1409 vim9script
Bram Moolenaar2a389082021-04-09 20:24:31 +02001410 def Func(...l: list<any>)
Bram Moolenaar2f8cbc42020-09-16 17:22:59 +02001411 echo l
1412 enddef
1413 Func(0)
1414 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001415 v9.CheckScriptSuccess(lines)
Bram Moolenaar2f8cbc42020-09-16 17:22:59 +02001416
1417 lines =<< trim END
1418 vim9script
Bram Moolenaar2a389082021-04-09 20:24:31 +02001419 def Func(...l: any)
1420 echo l
1421 enddef
1422 Func(0)
1423 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001424 v9.CheckScriptFailure(lines, 'E1180:', 2)
Bram Moolenaar2a389082021-04-09 20:24:31 +02001425
1426 lines =<< trim END
1427 vim9script
Bram Moolenaar28022722020-09-21 22:02:49 +02001428 def Func(..._l: list<string>)
1429 echo _l
1430 enddef
1431 Func('a', 'b', 'c')
1432 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001433 v9.CheckScriptSuccess(lines)
Bram Moolenaar28022722020-09-21 22:02:49 +02001434
1435 lines =<< trim END
1436 vim9script
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001437 def Func(...l: list<string>)
1438 echo l
1439 enddef
1440 Func(1, 2, 3)
1441 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001442 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch')
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001443
1444 lines =<< trim END
1445 vim9script
1446 def Func(...l: list<string>)
1447 echo l
1448 enddef
1449 Func('a', 9)
1450 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001451 v9.CheckScriptFailure(lines, 'E1013: Argument 2: type mismatch')
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001452
1453 lines =<< trim END
1454 vim9script
1455 def Func(...l: list<string>)
1456 echo l
1457 enddef
1458 Func(1, 'a')
1459 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001460 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch')
Bram Moolenaar4f53b792021-02-07 15:59:49 +01001461
1462 lines =<< trim END
1463 vim9script
1464 def Func( # some comment
1465 ...l = []
1466 )
1467 echo l
1468 enddef
1469 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001470 v9.CheckScriptFailure(lines, 'E1160:')
Bram Moolenaar6ce46b92021-08-07 15:35:36 +02001471
1472 lines =<< trim END
1473 vim9script
1474 def DoIt()
1475 g:Later('')
1476 enddef
1477 defcompile
1478 def g:Later(...l: list<number>)
1479 enddef
1480 DoIt()
1481 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001482 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected number but got string')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001483enddef
1484
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001485let s:value = ''
1486
1487def FuncOneDefArg(opt = 'text')
1488 s:value = opt
1489enddef
1490
1491def FuncTwoDefArg(nr = 123, opt = 'text'): string
1492 return nr .. opt
1493enddef
1494
1495def FuncVarargs(...arg: list<string>): string
1496 return join(arg, ',')
1497enddef
1498
1499def Test_func_type_varargs()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001500 var RefDefArg: func(?string)
Bram Moolenaar848fadd2022-01-30 15:28:30 +00001501 RefDefArg = g:FuncOneDefArg
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001502 RefDefArg()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001503 s:value->assert_equal('text')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001504 RefDefArg('some')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001505 s:value->assert_equal('some')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001506
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001507 var RefDef2Arg: func(?number, ?string): string
Bram Moolenaar848fadd2022-01-30 15:28:30 +00001508 RefDef2Arg = g:FuncTwoDefArg
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001509 RefDef2Arg()->assert_equal('123text')
1510 RefDef2Arg(99)->assert_equal('99text')
1511 RefDef2Arg(77, 'some')->assert_equal('77some')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001512
Bram Moolenaar62aec932022-01-29 21:45:34 +00001513 v9.CheckDefFailure(['var RefWrong: func(string?)'], 'E1010:')
1514 v9.CheckDefFailure(['var RefWrong: func(?string, string)'], 'E1007:')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001515
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001516 var RefVarargs: func(...list<string>): string
Bram Moolenaar848fadd2022-01-30 15:28:30 +00001517 RefVarargs = g:FuncVarargs
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001518 RefVarargs()->assert_equal('')
1519 RefVarargs('one')->assert_equal('one')
1520 RefVarargs('one', 'two')->assert_equal('one,two')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001521
Bram Moolenaar62aec932022-01-29 21:45:34 +00001522 v9.CheckDefFailure(['var RefWrong: func(...list<string>, string)'], 'E110:')
1523 v9.CheckDefFailure(['var RefWrong: func(...list<string>, ?string)'], 'E110:')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001524enddef
1525
Bram Moolenaar0b76b422020-04-07 22:05:08 +02001526" Only varargs
1527def MyVarargsOnly(...args: list<string>): string
1528 return join(args, ',')
1529enddef
1530
1531def Test_call_varargs_only()
Bram Moolenaar62aec932022-01-29 21:45:34 +00001532 g:MyVarargsOnly()->assert_equal('')
1533 g:MyVarargsOnly('one')->assert_equal('one')
1534 g:MyVarargsOnly('one', 'two')->assert_equal('one,two')
1535 v9.CheckDefFailure(['g:MyVarargsOnly(1)'], 'E1013: Argument 1: type mismatch, expected string but got number')
1536 v9.CheckDefFailure(['g:MyVarargsOnly("one", 2)'], 'E1013: Argument 2: type mismatch, expected string but got number')
Bram Moolenaar0b76b422020-04-07 22:05:08 +02001537enddef
1538
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001539def Test_using_var_as_arg()
Bram Moolenaard2939812021-12-30 17:09:05 +00001540 var lines =<< trim END
1541 def Func(x: number)
1542 var x = 234
1543 enddef
1544 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001545 v9.CheckDefFailure(lines, 'E1006:')
Bram Moolenaard2939812021-12-30 17:09:05 +00001546
1547 lines =<< trim END
1548 def Func(Ref: number)
1549 def Ref()
1550 enddef
1551 enddef
1552 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001553 v9.CheckDefFailure(lines, 'E1073:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001554enddef
1555
Bram Moolenaar62aec932022-01-29 21:45:34 +00001556def s:DictArg(arg: dict<string>)
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +02001557 arg['key'] = 'value'
1558enddef
1559
Bram Moolenaar62aec932022-01-29 21:45:34 +00001560def s:ListArg(arg: list<string>)
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +02001561 arg[0] = 'value'
1562enddef
1563
1564def Test_assign_to_argument()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001565 # works for dict and list
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001566 var d: dict<string> = {}
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +02001567 DictArg(d)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001568 d['key']->assert_equal('value')
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001569 var l: list<string> = []
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +02001570 ListArg(l)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001571 l[0]->assert_equal('value')
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +02001572
Bram Moolenaar62aec932022-01-29 21:45:34 +00001573 v9.CheckScriptFailure(['def Func(arg: number)', 'arg = 3', 'enddef', 'defcompile'], 'E1090:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001574 delfunc! g:Func
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +02001575enddef
1576
Bram Moolenaarb816dae2020-09-20 22:04:00 +02001577" These argument names are reserved in legacy functions.
Bram Moolenaar62aec932022-01-29 21:45:34 +00001578def s:WithReservedNames(firstline: string, lastline: string): string
Bram Moolenaarb816dae2020-09-20 22:04:00 +02001579 return firstline .. lastline
1580enddef
1581
1582def Test_argument_names()
1583 assert_equal('OK', WithReservedNames('O', 'K'))
1584enddef
1585
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001586def Test_call_func_defined_later()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001587 g:DefinedLater('one')->assert_equal('one')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +02001588 assert_fails('NotDefined("one")', 'E117:', '', 2, 'Test_call_func_defined_later')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001589enddef
1590
Bram Moolenaar1df8b3f2020-04-23 18:13:23 +02001591func DefinedLater(arg)
1592 return a:arg
1593endfunc
1594
1595def Test_call_funcref()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001596 g:SomeFunc('abc')->assert_equal(3)
Bram Moolenaar9bd5d872020-09-06 21:47:48 +02001597 assert_fails('NotAFunc()', 'E117:', '', 2, 'Test_call_funcref') # comment after call
Bram Moolenaar2ef91562021-12-11 16:14:07 +00001598 assert_fails('g:NotAFunc()', 'E1085:', '', 3, 'Test_call_funcref')
Bram Moolenaar2f1980f2020-07-22 19:30:06 +02001599
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001600 var lines =<< trim END
Bram Moolenaar2f1980f2020-07-22 19:30:06 +02001601 vim9script
1602 def RetNumber(): number
1603 return 123
1604 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001605 var Funcref: func: number = function('RetNumber')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001606 Funcref()->assert_equal(123)
Bram Moolenaar2f1980f2020-07-22 19:30:06 +02001607 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001608 v9.CheckScriptSuccess(lines)
Bram Moolenaar0f60e802020-07-22 20:16:11 +02001609
1610 lines =<< trim END
1611 vim9script
1612 def RetNumber(): number
1613 return 123
1614 enddef
1615 def Bar(F: func: number): number
1616 return F()
1617 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001618 var Funcref = function('RetNumber')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001619 Bar(Funcref)->assert_equal(123)
Bram Moolenaar0f60e802020-07-22 20:16:11 +02001620 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001621 v9.CheckScriptSuccess(lines)
Bram Moolenaarbfba8652020-07-23 20:09:10 +02001622
1623 lines =<< trim END
1624 vim9script
1625 def UseNumber(nr: number)
1626 echo nr
1627 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001628 var Funcref: func(number) = function('UseNumber')
Bram Moolenaarbfba8652020-07-23 20:09:10 +02001629 Funcref(123)
1630 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001631 v9.CheckScriptSuccess(lines)
Bram Moolenaarb8070e32020-07-23 20:56:04 +02001632
1633 lines =<< trim END
1634 vim9script
1635 def UseNumber(nr: number)
1636 echo nr
1637 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001638 var Funcref: func(string) = function('UseNumber')
Bram Moolenaarb8070e32020-07-23 20:56:04 +02001639 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001640 v9.CheckScriptFailure(lines, 'E1012: Type mismatch; expected func(string) but got func(number)')
Bram Moolenaar4fc224c2020-07-26 17:56:25 +02001641
1642 lines =<< trim END
1643 vim9script
1644 def EchoNr(nr = 34)
1645 g:echo = nr
1646 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001647 var Funcref: func(?number) = function('EchoNr')
Bram Moolenaar4fc224c2020-07-26 17:56:25 +02001648 Funcref()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001649 g:echo->assert_equal(34)
Bram Moolenaar4fc224c2020-07-26 17:56:25 +02001650 Funcref(123)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001651 g:echo->assert_equal(123)
Bram Moolenaar4fc224c2020-07-26 17:56:25 +02001652 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001653 v9.CheckScriptSuccess(lines)
Bram Moolenaarace61322020-07-26 18:16:58 +02001654
1655 lines =<< trim END
1656 vim9script
1657 def EchoList(...l: list<number>)
1658 g:echo = l
1659 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001660 var Funcref: func(...list<number>) = function('EchoList')
Bram Moolenaarace61322020-07-26 18:16:58 +02001661 Funcref()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001662 g:echo->assert_equal([])
Bram Moolenaarace61322020-07-26 18:16:58 +02001663 Funcref(1, 2, 3)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001664 g:echo->assert_equal([1, 2, 3])
Bram Moolenaarace61322020-07-26 18:16:58 +02001665 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001666 v9.CheckScriptSuccess(lines)
Bram Moolenaar01865ad2020-07-26 18:33:09 +02001667
1668 lines =<< trim END
1669 vim9script
1670 def OptAndVar(nr: number, opt = 12, ...l: list<number>): number
1671 g:optarg = opt
1672 g:listarg = l
1673 return nr
1674 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001675 var Funcref: func(number, ?number, ...list<number>): number = function('OptAndVar')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001676 Funcref(10)->assert_equal(10)
1677 g:optarg->assert_equal(12)
1678 g:listarg->assert_equal([])
Bram Moolenaar01865ad2020-07-26 18:33:09 +02001679
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001680 Funcref(11, 22)->assert_equal(11)
1681 g:optarg->assert_equal(22)
1682 g:listarg->assert_equal([])
Bram Moolenaar01865ad2020-07-26 18:33:09 +02001683
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001684 Funcref(17, 18, 1, 2, 3)->assert_equal(17)
1685 g:optarg->assert_equal(18)
1686 g:listarg->assert_equal([1, 2, 3])
Bram Moolenaar01865ad2020-07-26 18:33:09 +02001687 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001688 v9.CheckScriptSuccess(lines)
Bram Moolenaar1df8b3f2020-04-23 18:13:23 +02001689enddef
1690
1691let SomeFunc = function('len')
1692let NotAFunc = 'text'
1693
Bram Moolenaar99aaf0c2020-04-12 14:39:53 +02001694def CombineFuncrefTypes()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001695 # same arguments, different return type
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001696 var Ref1: func(bool): string
1697 var Ref2: func(bool): number
1698 var Ref3: func(bool): any
Bram Moolenaar99aaf0c2020-04-12 14:39:53 +02001699 Ref3 = g:cond ? Ref1 : Ref2
1700
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001701 # different number of arguments
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001702 var Refa1: func(bool): number
1703 var Refa2: func(bool, number): number
1704 var Refa3: func: number
Bram Moolenaar99aaf0c2020-04-12 14:39:53 +02001705 Refa3 = g:cond ? Refa1 : Refa2
1706
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001707 # different argument types
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001708 var Refb1: func(bool, string): number
1709 var Refb2: func(string, number): number
1710 var Refb3: func(any, any): number
Bram Moolenaar99aaf0c2020-04-12 14:39:53 +02001711 Refb3 = g:cond ? Refb1 : Refb2
1712enddef
1713
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001714def FuncWithForwardCall()
Bram Moolenaar1df8b3f2020-04-23 18:13:23 +02001715 return g:DefinedEvenLater("yes")
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001716enddef
1717
1718def DefinedEvenLater(arg: string): string
1719 return arg
1720enddef
1721
1722def Test_error_in_nested_function()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001723 # Error in called function requires unwinding the call stack.
Bram Moolenaar848fadd2022-01-30 15:28:30 +00001724 assert_fails('g:FuncWithForwardCall()', 'E1096:', '', 1, 'FuncWithForwardCall')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001725enddef
1726
Bram Moolenaar4bf10062021-12-28 17:23:12 +00001727def Test_nested_function_with_nextcmd()
Bram Moolenaar9c23f9b2021-12-26 14:23:22 +00001728 var lines =<< trim END
1729 vim9script
1730 # Define an outer function
1731 def FirstFunction()
1732 # Define an inner function
1733 def SecondFunction()
1734 # the function has a body, a double free is detected.
1735 AAAAA
1736
1737 # enddef followed by | or } followed by # one or more characters
1738 enddef|BBBB
1739 enddef
1740
1741 # Compile all functions
1742 defcompile
1743 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001744 v9.CheckScriptFailure(lines, 'E1173: Text found after enddef: BBBB')
Bram Moolenaar9c23f9b2021-12-26 14:23:22 +00001745enddef
1746
Bram Moolenaar4bf10062021-12-28 17:23:12 +00001747def Test_nested_function_with_args_split()
1748 var lines =<< trim END
1749 vim9script
1750 def FirstFunction()
1751 def SecondFunction(
1752 )
1753 # had a double free if the right parenthesis of the nested function is
1754 # on the next line
1755
1756 enddef|BBBB
1757 enddef
1758 # Compile all functions
1759 defcompile
1760 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001761 v9.CheckScriptFailure(lines, 'E1173: Text found after enddef: BBBB')
Bram Moolenaar7473a842021-12-28 17:55:26 +00001762
1763 lines =<< trim END
1764 vim9script
1765 def FirstFunction()
1766 func SecondFunction()
1767 endfunc|BBBB
1768 enddef
1769 defcompile
1770 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001771 v9.CheckScriptFailure(lines, 'E1173: Text found after endfunction: BBBB')
Bram Moolenaar4bf10062021-12-28 17:23:12 +00001772enddef
1773
Bram Moolenaar9f1a39a2022-01-08 15:39:39 +00001774def Test_error_in_function_args()
1775 var lines =<< trim END
1776 def FirstFunction()
1777 def SecondFunction(J =
1778 # Nois
1779 # one
1780
1781 enddef|BBBB
1782 enddef
1783 # Compile all functions
1784 defcompile
1785 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001786 v9.CheckScriptFailure(lines, 'E488:')
Bram Moolenaar9f1a39a2022-01-08 15:39:39 +00001787enddef
1788
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001789def Test_return_type_wrong()
Bram Moolenaar62aec932022-01-29 21:45:34 +00001790 v9.CheckScriptFailure([
Bram Moolenaar5a849da2020-08-08 16:47:30 +02001791 'def Func(): number',
1792 'return "a"',
1793 'enddef',
1794 'defcompile'], 'expected number but got string')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001795 delfunc! g:Func
Bram Moolenaar62aec932022-01-29 21:45:34 +00001796 v9.CheckScriptFailure([
Bram Moolenaar5a849da2020-08-08 16:47:30 +02001797 'def Func(): string',
1798 'return 1',
1799 'enddef',
1800 'defcompile'], 'expected string but got number')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001801 delfunc! g:Func
Bram Moolenaar62aec932022-01-29 21:45:34 +00001802 v9.CheckScriptFailure([
Bram Moolenaar5a849da2020-08-08 16:47:30 +02001803 'def Func(): void',
1804 'return "a"',
1805 'enddef',
1806 'defcompile'],
1807 'E1096: Returning a value in a function without a return type')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001808 delfunc! g:Func
Bram Moolenaar62aec932022-01-29 21:45:34 +00001809 v9.CheckScriptFailure([
Bram Moolenaar5a849da2020-08-08 16:47:30 +02001810 'def Func()',
1811 'return "a"',
1812 'enddef',
1813 'defcompile'],
1814 'E1096: Returning a value in a function without a return type')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001815 delfunc! g:Func
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001816
Bram Moolenaar62aec932022-01-29 21:45:34 +00001817 v9.CheckScriptFailure([
Bram Moolenaar5a849da2020-08-08 16:47:30 +02001818 'def Func(): number',
1819 'return',
1820 'enddef',
1821 'defcompile'], 'E1003:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001822 delfunc! g:Func
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001823
Bram Moolenaar62aec932022-01-29 21:45:34 +00001824 v9.CheckScriptFailure([
Bram Moolenaar33ea9fd2021-08-08 19:07:37 +02001825 'def Func():number',
1826 'return 123',
1827 'enddef',
1828 'defcompile'], 'E1069:')
1829 delfunc! g:Func
1830
Bram Moolenaar62aec932022-01-29 21:45:34 +00001831 v9.CheckScriptFailure([
Bram Moolenaar33ea9fd2021-08-08 19:07:37 +02001832 'def Func() :number',
1833 'return 123',
1834 'enddef',
1835 'defcompile'], 'E1059:')
1836 delfunc! g:Func
1837
Bram Moolenaar62aec932022-01-29 21:45:34 +00001838 v9.CheckScriptFailure([
Bram Moolenaar33ea9fd2021-08-08 19:07:37 +02001839 'def Func() : number',
1840 'return 123',
1841 'enddef',
1842 'defcompile'], 'E1059:')
1843 delfunc! g:Func
1844
Bram Moolenaar62aec932022-01-29 21:45:34 +00001845 v9.CheckScriptFailure(['def Func(): list', 'return []', 'enddef'], 'E1008:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001846 delfunc! g:Func
Bram Moolenaar62aec932022-01-29 21:45:34 +00001847 v9.CheckScriptFailure(['def Func(): dict', 'return {}', 'enddef'], 'E1008:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001848 delfunc! g:Func
Bram Moolenaar62aec932022-01-29 21:45:34 +00001849 v9.CheckScriptFailure(['def Func()', 'return 1'], 'E1057:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001850 delfunc! g:Func
Bram Moolenaar5a849da2020-08-08 16:47:30 +02001851
Bram Moolenaar62aec932022-01-29 21:45:34 +00001852 v9.CheckScriptFailure([
Bram Moolenaar5a849da2020-08-08 16:47:30 +02001853 'vim9script',
1854 'def FuncB()',
1855 ' return 123',
1856 'enddef',
1857 'def FuncA()',
1858 ' FuncB()',
1859 'enddef',
1860 'defcompile'], 'E1096:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001861enddef
1862
1863def Test_arg_type_wrong()
Bram Moolenaar62aec932022-01-29 21:45:34 +00001864 v9.CheckScriptFailure(['def Func3(items: list)', 'echo "a"', 'enddef'], 'E1008: Missing <type>')
1865 v9.CheckScriptFailure(['def Func4(...)', 'echo "a"', 'enddef'], 'E1055: Missing name after ...')
1866 v9.CheckScriptFailure(['def Func5(items:string)', 'echo "a"'], 'E1069:')
1867 v9.CheckScriptFailure(['def Func5(items)', 'echo "a"'], 'E1077:')
1868 v9.CheckScriptFailure(['def Func6(...x:list<number>)', 'echo "a"', 'enddef'], 'E1069:')
1869 v9.CheckScriptFailure(['def Func7(...x: int)', 'echo "a"', 'enddef'], 'E1010:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001870enddef
1871
Bram Moolenaar86cdb8a2021-04-06 19:01:03 +02001872def Test_white_space_before_comma()
1873 var lines =<< trim END
1874 vim9script
1875 def Func(a: number , b: number)
1876 enddef
1877 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001878 v9.CheckScriptFailure(lines, 'E1068:')
Yegappan Lakshmanan611728f2021-05-24 15:15:47 +02001879 call assert_fails('vim9cmd echo stridx("a" .. "b" , "a")', 'E1068:')
Bram Moolenaar86cdb8a2021-04-06 19:01:03 +02001880enddef
1881
Bram Moolenaar608d78f2021-03-06 22:33:12 +01001882def Test_white_space_after_comma()
1883 var lines =<< trim END
1884 vim9script
1885 def Func(a: number,b: number)
1886 enddef
1887 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001888 v9.CheckScriptFailure(lines, 'E1069:')
Bram Moolenaar608d78f2021-03-06 22:33:12 +01001889
1890 # OK in legacy function
1891 lines =<< trim END
1892 vim9script
1893 func Func(a,b)
1894 endfunc
1895 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001896 v9.CheckScriptSuccess(lines)
Bram Moolenaar608d78f2021-03-06 22:33:12 +01001897enddef
1898
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001899def Test_vim9script_call()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001900 var lines =<< trim END
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001901 vim9script
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001902 var name = ''
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001903 def MyFunc(arg: string)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001904 name = arg
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001905 enddef
1906 MyFunc('foobar')
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001907 name->assert_equal('foobar')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001908
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001909 var str = 'barfoo'
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001910 str->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001911 name->assert_equal('barfoo')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001912
Bram Moolenaar67979662020-06-20 22:50:47 +02001913 g:value = 'value'
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001914 g:value->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001915 name->assert_equal('value')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001916
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001917 var listvar = []
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001918 def ListFunc(arg: list<number>)
1919 listvar = arg
1920 enddef
1921 [1, 2, 3]->ListFunc()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001922 listvar->assert_equal([1, 2, 3])
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001923
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001924 var dictvar = {}
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001925 def DictFunc(arg: dict<number>)
1926 dictvar = arg
1927 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +01001928 {a: 1, b: 2}->DictFunc()
1929 dictvar->assert_equal({a: 1, b: 2})
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001930 def CompiledDict()
Bram Moolenaare0de1712020-12-02 17:36:54 +01001931 {a: 3, b: 4}->DictFunc()
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001932 enddef
1933 CompiledDict()
Bram Moolenaare0de1712020-12-02 17:36:54 +01001934 dictvar->assert_equal({a: 3, b: 4})
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001935
Bram Moolenaare0de1712020-12-02 17:36:54 +01001936 {a: 3, b: 4}->DictFunc()
1937 dictvar->assert_equal({a: 3, b: 4})
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001938
1939 ('text')->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001940 name->assert_equal('text')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001941 ("some")->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001942 name->assert_equal('some')
Bram Moolenaare6b53242020-07-01 17:28:33 +02001943
Bram Moolenaar13e12b82020-07-24 18:47:22 +02001944 # line starting with single quote is not a mark
Bram Moolenaar10409562020-07-29 20:00:38 +02001945 # line starting with double quote can be a method call
Bram Moolenaar3d48e252020-07-15 14:15:52 +02001946 'asdfasdf'->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001947 name->assert_equal('asdfasdf')
Bram Moolenaar10409562020-07-29 20:00:38 +02001948 "xyz"->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001949 name->assert_equal('xyz')
Bram Moolenaar3d48e252020-07-15 14:15:52 +02001950
1951 def UseString()
1952 'xyork'->MyFunc()
1953 enddef
1954 UseString()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001955 name->assert_equal('xyork')
Bram Moolenaar3d48e252020-07-15 14:15:52 +02001956
Bram Moolenaar10409562020-07-29 20:00:38 +02001957 def UseString2()
1958 "knife"->MyFunc()
1959 enddef
1960 UseString2()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001961 name->assert_equal('knife')
Bram Moolenaar10409562020-07-29 20:00:38 +02001962
Bram Moolenaar13e12b82020-07-24 18:47:22 +02001963 # prepending a colon makes it a mark
1964 new
1965 setline(1, ['aaa', 'bbb', 'ccc'])
1966 normal! 3Gmt1G
1967 :'t
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001968 getcurpos()[1]->assert_equal(3)
Bram Moolenaar13e12b82020-07-24 18:47:22 +02001969 bwipe!
1970
Bram Moolenaare6b53242020-07-01 17:28:33 +02001971 MyFunc(
1972 'continued'
1973 )
1974 assert_equal('continued',
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001975 name
Bram Moolenaare6b53242020-07-01 17:28:33 +02001976 )
1977
1978 call MyFunc(
1979 'more'
1980 ..
1981 'lines'
1982 )
1983 assert_equal(
1984 'morelines',
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001985 name)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001986 END
1987 writefile(lines, 'Xcall.vim')
1988 source Xcall.vim
1989 delete('Xcall.vim')
1990enddef
1991
1992def Test_vim9script_call_fail_decl()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001993 var lines =<< trim END
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001994 vim9script
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001995 var name = ''
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001996 def MyFunc(arg: string)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001997 var name = 123
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001998 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +02001999 defcompile
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002000 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002001 v9.CheckScriptFailure(lines, 'E1054:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002002enddef
2003
Bram Moolenaar65b95452020-07-19 14:03:09 +02002004def Test_vim9script_call_fail_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002005 var lines =<< trim END
Bram Moolenaar65b95452020-07-19 14:03:09 +02002006 vim9script
2007 def MyFunc(arg: string)
2008 echo arg
2009 enddef
2010 MyFunc(1234)
2011 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002012 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected string but got number')
Bram Moolenaar65b95452020-07-19 14:03:09 +02002013enddef
2014
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002015def Test_vim9script_call_fail_const()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002016 var lines =<< trim END
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002017 vim9script
2018 const var = ''
2019 def MyFunc(arg: string)
2020 var = 'asdf'
2021 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +02002022 defcompile
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002023 END
2024 writefile(lines, 'Xcall_const.vim')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +02002025 assert_fails('source Xcall_const.vim', 'E46:', '', 1, 'MyFunc')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002026 delete('Xcall_const.vim')
Bram Moolenaar3bdc90b2020-12-22 20:35:40 +01002027
2028 lines =<< trim END
2029 const g:Aconst = 77
2030 def Change()
2031 # comment
2032 g:Aconst = 99
2033 enddef
2034 call Change()
2035 unlet g:Aconst
2036 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002037 v9.CheckScriptFailure(lines, 'E741: Value is locked: Aconst', 2)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002038enddef
2039
2040" Test that inside :function a Python function can be defined, :def is not
2041" recognized.
2042func Test_function_python()
2043 CheckFeature python3
Bram Moolenaar727345e2020-09-27 23:33:59 +02002044 let py = 'python3'
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002045 execute py "<< EOF"
2046def do_something():
2047 return 1
2048EOF
2049endfunc
2050
2051def Test_delfunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002052 var lines =<< trim END
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002053 vim9script
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02002054 def g:GoneSoon()
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002055 echo 'hello'
2056 enddef
2057
2058 def CallGoneSoon()
Bram Moolenaar62aec932022-01-29 21:45:34 +00002059 g:GoneSoon()
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002060 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +02002061 defcompile
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002062
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02002063 delfunc g:GoneSoon
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002064 CallGoneSoon()
2065 END
2066 writefile(lines, 'XToDelFunc')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +02002067 assert_fails('so XToDelFunc', 'E933:', '', 1, 'CallGoneSoon')
2068 assert_fails('so XToDelFunc', 'E933:', '', 1, 'CallGoneSoon')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002069
2070 delete('XToDelFunc')
2071enddef
2072
Bram Moolenaar7509ad82021-12-14 18:14:37 +00002073func Test_free_dict_while_in_funcstack()
2074 " relies on the sleep command
2075 CheckUnix
2076 call Run_Test_free_dict_while_in_funcstack()
2077endfunc
2078
2079def Run_Test_free_dict_while_in_funcstack()
Bram Moolenaar7509ad82021-12-14 18:14:37 +00002080 # this was freeing the TermRun() default argument dictionary while it was
2081 # still referenced in a funcstack_T
2082 var lines =<< trim END
2083 vim9script
2084
2085 &updatetime = 400
2086 def TermRun(_ = {})
2087 def Post()
2088 enddef
2089 def Exec()
2090 term_start('sleep 1', {
2091 term_finish: 'close',
2092 exit_cb: (_, _) => Post(),
2093 })
2094 enddef
2095 Exec()
2096 enddef
2097 nnoremap <F4> <Cmd>call <SID>TermRun()<CR>
2098 timer_start(100, (_) => feedkeys("\<F4>"))
2099 timer_start(1000, (_) => feedkeys("\<F4>"))
2100 sleep 1500m
2101 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002102 v9.CheckScriptSuccess(lines)
Bram Moolenaar7509ad82021-12-14 18:14:37 +00002103 nunmap <F4>
2104 set updatetime&
2105enddef
2106
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002107def Test_redef_failure()
Bram Moolenaard2c61702020-09-06 15:58:36 +02002108 writefile(['def Func0(): string', 'return "Func0"', 'enddef'], 'Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002109 so Xdef
Bram Moolenaard2c61702020-09-06 15:58:36 +02002110 writefile(['def Func1(): string', 'return "Func1"', 'enddef'], 'Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002111 so Xdef
Bram Moolenaard2c61702020-09-06 15:58:36 +02002112 writefile(['def! Func0(): string', 'enddef', 'defcompile'], 'Xdef')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +02002113 assert_fails('so Xdef', 'E1027:', '', 1, 'Func0')
Bram Moolenaard2c61702020-09-06 15:58:36 +02002114 writefile(['def Func2(): string', 'return "Func2"', 'enddef'], 'Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002115 so Xdef
Bram Moolenaard2c61702020-09-06 15:58:36 +02002116 delete('Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002117
Bram Moolenaar701cc6c2021-04-10 13:33:48 +02002118 assert_fails('g:Func0()', 'E1091:')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002119 g:Func1()->assert_equal('Func1')
2120 g:Func2()->assert_equal('Func2')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002121
2122 delfunc! Func0
2123 delfunc! Func1
2124 delfunc! Func2
2125enddef
2126
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02002127def Test_vim9script_func()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002128 var lines =<< trim END
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02002129 vim9script
2130 func Func(arg)
2131 echo a:arg
2132 endfunc
2133 Func('text')
2134 END
2135 writefile(lines, 'XVim9Func')
2136 so XVim9Func
2137
2138 delete('XVim9Func')
2139enddef
2140
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002141let s:funcResult = 0
2142
2143def FuncNoArgNoRet()
Bram Moolenaar53900992020-08-22 19:02:02 +02002144 s:funcResult = 11
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002145enddef
2146
2147def FuncNoArgRetNumber(): number
Bram Moolenaar53900992020-08-22 19:02:02 +02002148 s:funcResult = 22
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002149 return 1234
2150enddef
2151
Bram Moolenaarec5929d2020-04-07 20:53:39 +02002152def FuncNoArgRetString(): string
Bram Moolenaar53900992020-08-22 19:02:02 +02002153 s:funcResult = 45
Bram Moolenaarec5929d2020-04-07 20:53:39 +02002154 return 'text'
2155enddef
2156
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002157def FuncOneArgNoRet(arg: number)
Bram Moolenaar53900992020-08-22 19:02:02 +02002158 s:funcResult = arg
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002159enddef
2160
2161def FuncOneArgRetNumber(arg: number): number
Bram Moolenaar53900992020-08-22 19:02:02 +02002162 s:funcResult = arg
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002163 return arg
2164enddef
2165
Bram Moolenaar08938ee2020-04-11 23:17:17 +02002166def FuncTwoArgNoRet(one: bool, two: number)
Bram Moolenaar53900992020-08-22 19:02:02 +02002167 s:funcResult = two
Bram Moolenaar08938ee2020-04-11 23:17:17 +02002168enddef
2169
Bram Moolenaar62aec932022-01-29 21:45:34 +00002170def s:FuncOneArgRetString(arg: string): string
Bram Moolenaarec5929d2020-04-07 20:53:39 +02002171 return arg
2172enddef
2173
Bram Moolenaar62aec932022-01-29 21:45:34 +00002174def s:FuncOneArgRetAny(arg: any): any
Bram Moolenaar89228602020-04-05 22:14:54 +02002175 return arg
2176enddef
2177
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002178def Test_func_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002179 var Ref1: func()
Bram Moolenaar53900992020-08-22 19:02:02 +02002180 s:funcResult = 0
Bram Moolenaar62aec932022-01-29 21:45:34 +00002181 Ref1 = g:FuncNoArgNoRet
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002182 Ref1()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002183 s:funcResult->assert_equal(11)
Bram Moolenaar4c683752020-04-05 21:38:23 +02002184
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002185 var Ref2: func
Bram Moolenaar53900992020-08-22 19:02:02 +02002186 s:funcResult = 0
Bram Moolenaar62aec932022-01-29 21:45:34 +00002187 Ref2 = g:FuncNoArgNoRet
Bram Moolenaar4c683752020-04-05 21:38:23 +02002188 Ref2()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002189 s:funcResult->assert_equal(11)
Bram Moolenaar4c683752020-04-05 21:38:23 +02002190
Bram Moolenaar53900992020-08-22 19:02:02 +02002191 s:funcResult = 0
Bram Moolenaar62aec932022-01-29 21:45:34 +00002192 Ref2 = g:FuncOneArgNoRet
Bram Moolenaar4c683752020-04-05 21:38:23 +02002193 Ref2(12)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002194 s:funcResult->assert_equal(12)
Bram Moolenaar4c683752020-04-05 21:38:23 +02002195
Bram Moolenaar53900992020-08-22 19:02:02 +02002196 s:funcResult = 0
Bram Moolenaar62aec932022-01-29 21:45:34 +00002197 Ref2 = g:FuncNoArgRetNumber
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002198 Ref2()->assert_equal(1234)
2199 s:funcResult->assert_equal(22)
Bram Moolenaar4c683752020-04-05 21:38:23 +02002200
Bram Moolenaar53900992020-08-22 19:02:02 +02002201 s:funcResult = 0
Bram Moolenaar848fadd2022-01-30 15:28:30 +00002202 Ref2 = g:FuncOneArgRetNumber
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002203 Ref2(13)->assert_equal(13)
2204 s:funcResult->assert_equal(13)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002205enddef
2206
Bram Moolenaar9978d472020-07-05 16:01:56 +02002207def Test_repeat_return_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002208 var res = 0
Bram Moolenaar9978d472020-07-05 16:01:56 +02002209 for n in repeat([1], 3)
2210 res += n
2211 endfor
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002212 res->assert_equal(3)
Bram Moolenaarfce82b32020-07-05 16:07:21 +02002213
2214 res = 0
2215 for n in add([1, 2], 3)
2216 res += n
2217 endfor
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002218 res->assert_equal(6)
Bram Moolenaar9978d472020-07-05 16:01:56 +02002219enddef
2220
Bram Moolenaar846178a2020-07-05 17:04:13 +02002221def Test_argv_return_type()
2222 next fileone filetwo
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002223 var res = ''
Bram Moolenaar846178a2020-07-05 17:04:13 +02002224 for name in argv()
2225 res ..= name
2226 endfor
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002227 res->assert_equal('fileonefiletwo')
Bram Moolenaar846178a2020-07-05 17:04:13 +02002228enddef
2229
Bram Moolenaarec5929d2020-04-07 20:53:39 +02002230def Test_func_type_part()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002231 var RefVoid: func: void
Bram Moolenaar62aec932022-01-29 21:45:34 +00002232 RefVoid = g:FuncNoArgNoRet
2233 RefVoid = g:FuncOneArgNoRet
2234 v9.CheckDefFailure(['var RefVoid: func: void', 'RefVoid = g:FuncNoArgRetNumber'], 'E1012: Type mismatch; expected func(...) but got func(): number')
Bram Moolenaar848fadd2022-01-30 15:28:30 +00002235 v9.CheckDefFailure(['var RefVoid: func: void', 'RefVoid = g:FuncNoArgRetString'], 'E1012: Type mismatch; expected func(...) but got func(): string')
Bram Moolenaarec5929d2020-04-07 20:53:39 +02002236
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002237 var RefAny: func(): any
Bram Moolenaar62aec932022-01-29 21:45:34 +00002238 RefAny = g:FuncNoArgRetNumber
Bram Moolenaar848fadd2022-01-30 15:28:30 +00002239 RefAny = g:FuncNoArgRetString
Bram Moolenaar62aec932022-01-29 21:45:34 +00002240 v9.CheckDefFailure(['var RefAny: func(): any', 'RefAny = g:FuncNoArgNoRet'], 'E1012: Type mismatch; expected func(): any but got func()')
2241 v9.CheckDefFailure(['var RefAny: func(): any', 'RefAny = g:FuncOneArgNoRet'], 'E1012: Type mismatch; expected func(): any but got func(number)')
Bram Moolenaarec5929d2020-04-07 20:53:39 +02002242
Bram Moolenaar6abd3dc2020-10-04 14:17:32 +02002243 var RefAnyNoArgs: func: any = RefAny
2244
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002245 var RefNr: func: number
Bram Moolenaar62aec932022-01-29 21:45:34 +00002246 RefNr = g:FuncNoArgRetNumber
Bram Moolenaar848fadd2022-01-30 15:28:30 +00002247 RefNr = g:FuncOneArgRetNumber
Bram Moolenaar62aec932022-01-29 21:45:34 +00002248 v9.CheckDefFailure(['var RefNr: func: number', 'RefNr = g:FuncNoArgNoRet'], 'E1012: Type mismatch; expected func(...): number but got func()')
Bram Moolenaar848fadd2022-01-30 15:28:30 +00002249 v9.CheckDefFailure(['var RefNr: func: number', 'RefNr = g:FuncNoArgRetString'], 'E1012: Type mismatch; expected func(...): number but got func(): string')
Bram Moolenaarec5929d2020-04-07 20:53:39 +02002250
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002251 var RefStr: func: string
Bram Moolenaar848fadd2022-01-30 15:28:30 +00002252 RefStr = g:FuncNoArgRetString
Bram Moolenaarec5929d2020-04-07 20:53:39 +02002253 RefStr = FuncOneArgRetString
Bram Moolenaar62aec932022-01-29 21:45:34 +00002254 v9.CheckDefFailure(['var RefStr: func: string', 'RefStr = g:FuncNoArgNoRet'], 'E1012: Type mismatch; expected func(...): string but got func()')
2255 v9.CheckDefFailure(['var RefStr: func: string', 'RefStr = g:FuncNoArgRetNumber'], 'E1012: Type mismatch; expected func(...): string but got func(): number')
Bram Moolenaarec5929d2020-04-07 20:53:39 +02002256enddef
2257
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002258def Test_func_type_fails()
Bram Moolenaar62aec932022-01-29 21:45:34 +00002259 v9.CheckDefFailure(['var ref1: func()'], 'E704:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002260
Bram Moolenaar62aec932022-01-29 21:45:34 +00002261 v9.CheckDefFailure(['var Ref1: func()', 'Ref1 = g:FuncNoArgRetNumber'], 'E1012: Type mismatch; expected func() but got func(): number')
2262 v9.CheckDefFailure(['var Ref1: func()', 'Ref1 = g:FuncOneArgNoRet'], 'E1012: Type mismatch; expected func() but got func(number)')
Bram Moolenaar848fadd2022-01-30 15:28:30 +00002263 v9.CheckDefFailure(['var Ref1: func()', 'Ref1 = g:FuncOneArgRetNumber'], 'E1012: Type mismatch; expected func() but got func(number): number')
Bram Moolenaar62aec932022-01-29 21:45:34 +00002264 v9.CheckDefFailure(['var Ref1: func(bool)', 'Ref1 = g:FuncTwoArgNoRet'], 'E1012: Type mismatch; expected func(bool) but got func(bool, number)')
2265 v9.CheckDefFailure(['var Ref1: func(?bool)', 'Ref1 = g:FuncTwoArgNoRet'], 'E1012: Type mismatch; expected func(?bool) but got func(bool, number)')
2266 v9.CheckDefFailure(['var Ref1: func(...bool)', 'Ref1 = g:FuncTwoArgNoRet'], 'E1012: Type mismatch; expected func(...bool) but got func(bool, number)')
Bram Moolenaar08938ee2020-04-11 23:17:17 +02002267
Bram Moolenaar62aec932022-01-29 21:45:34 +00002268 v9.CheckDefFailure(['var RefWrong: func(string ,number)'], 'E1068:')
2269 v9.CheckDefFailure(['var RefWrong: func(string,number)'], 'E1069:')
2270 v9.CheckDefFailure(['var RefWrong: func(bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool)'], 'E1005:')
2271 v9.CheckDefFailure(['var RefWrong: func(bool):string'], 'E1069:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002272enddef
2273
Bram Moolenaar89228602020-04-05 22:14:54 +02002274def Test_func_return_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002275 var nr: number
Bram Moolenaar62aec932022-01-29 21:45:34 +00002276 nr = g:FuncNoArgRetNumber()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002277 nr->assert_equal(1234)
Bram Moolenaar89228602020-04-05 22:14:54 +02002278
2279 nr = FuncOneArgRetAny(122)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002280 nr->assert_equal(122)
Bram Moolenaar89228602020-04-05 22:14:54 +02002281
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002282 var str: string
Bram Moolenaar89228602020-04-05 22:14:54 +02002283 str = FuncOneArgRetAny('yes')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002284 str->assert_equal('yes')
Bram Moolenaar89228602020-04-05 22:14:54 +02002285
Bram Moolenaar62aec932022-01-29 21:45:34 +00002286 v9.CheckDefFailure(['var str: string', 'str = g:FuncNoArgRetNumber()'], 'E1012: Type mismatch; expected string but got number')
Bram Moolenaar89228602020-04-05 22:14:54 +02002287enddef
2288
Bram Moolenaar6abd3dc2020-10-04 14:17:32 +02002289def Test_func_common_type()
2290 def FuncOne(n: number): number
2291 return n
2292 enddef
2293 def FuncTwo(s: string): number
2294 return len(s)
2295 enddef
2296 def FuncThree(n: number, s: string): number
2297 return n + len(s)
2298 enddef
2299 var list = [FuncOne, FuncTwo, FuncThree]
2300 assert_equal(8, list[0](8))
2301 assert_equal(4, list[1]('word'))
2302 assert_equal(7, list[2](3, 'word'))
2303enddef
2304
Bram Moolenaar62aec932022-01-29 21:45:34 +00002305def s:MultiLine(
Bram Moolenaar5e774c72020-04-12 21:53:00 +02002306 arg1: string,
2307 arg2 = 1234,
2308 ...rest: list<string>
2309 ): string
2310 return arg1 .. arg2 .. join(rest, '-')
2311enddef
2312
Bram Moolenaar2c330432020-04-13 14:41:35 +02002313def MultiLineComment(
2314 arg1: string, # comment
2315 arg2 = 1234, # comment
2316 ...rest: list<string> # comment
2317 ): string # comment
2318 return arg1 .. arg2 .. join(rest, '-')
2319enddef
2320
Bram Moolenaar5e774c72020-04-12 21:53:00 +02002321def Test_multiline()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002322 MultiLine('text')->assert_equal('text1234')
2323 MultiLine('text', 777)->assert_equal('text777')
2324 MultiLine('text', 777, 'one')->assert_equal('text777one')
2325 MultiLine('text', 777, 'one', 'two')->assert_equal('text777one-two')
Bram Moolenaar5e774c72020-04-12 21:53:00 +02002326enddef
2327
Bram Moolenaar23e03252020-04-12 22:22:31 +02002328func Test_multiline_not_vim9()
Bram Moolenaar62aec932022-01-29 21:45:34 +00002329 call s:MultiLine('text')->assert_equal('text1234')
2330 call s:MultiLine('text', 777)->assert_equal('text777')
2331 call s:MultiLine('text', 777, 'one')->assert_equal('text777one')
2332 call s:MultiLine('text', 777, 'one', 'two')->assert_equal('text777one-two')
Bram Moolenaar23e03252020-04-12 22:22:31 +02002333endfunc
2334
Bram Moolenaar5e774c72020-04-12 21:53:00 +02002335
Bram Moolenaaree4e0c12020-04-06 21:35:05 +02002336" When using CheckScriptFailure() for the below test, E1010 is generated instead
2337" of E1056.
2338func Test_E1056_1059()
2339 let caught_1056 = 0
2340 try
2341 def F():
2342 return 1
2343 enddef
2344 catch /E1056:/
2345 let caught_1056 = 1
2346 endtry
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002347 eval caught_1056->assert_equal(1)
Bram Moolenaaree4e0c12020-04-06 21:35:05 +02002348
2349 let caught_1059 = 0
2350 try
2351 def F5(items : list)
2352 echo 'a'
2353 enddef
2354 catch /E1059:/
2355 let caught_1059 = 1
2356 endtry
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002357 eval caught_1059->assert_equal(1)
Bram Moolenaaree4e0c12020-04-06 21:35:05 +02002358endfunc
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002359
Bram Moolenaar015f4262020-05-05 21:25:22 +02002360func DelMe()
2361 echo 'DelMe'
2362endfunc
2363
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002364def Test_error_reporting()
2365 # comment lines at the start of the function
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002366 var lines =<< trim END
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002367 " comment
2368 def Func()
2369 # comment
2370 # comment
2371 invalid
2372 enddef
2373 defcompile
2374 END
Bram Moolenaar08052222020-09-14 17:04:31 +02002375 writefile(lines, 'Xdef')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002376 try
2377 source Xdef
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02002378 assert_report('should have failed')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002379 catch /E476:/
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002380 v:exception->assert_match('Invalid command: invalid')
2381 v:throwpoint->assert_match(', line 3$')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002382 endtry
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002383 delfunc! g:Func
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002384
2385 # comment lines after the start of the function
2386 lines =<< trim END
2387 " comment
2388 def Func()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002389 var x = 1234
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002390 # comment
2391 # comment
2392 invalid
2393 enddef
2394 defcompile
2395 END
Bram Moolenaar08052222020-09-14 17:04:31 +02002396 writefile(lines, 'Xdef')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002397 try
2398 source Xdef
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02002399 assert_report('should have failed')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002400 catch /E476:/
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002401 v:exception->assert_match('Invalid command: invalid')
2402 v:throwpoint->assert_match(', line 4$')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002403 endtry
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002404 delfunc! g:Func
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002405
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02002406 lines =<< trim END
2407 vim9script
2408 def Func()
Bram Moolenaare0de1712020-12-02 17:36:54 +01002409 var db = {foo: 1, bar: 2}
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02002410 # comment
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002411 var x = db.asdf
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02002412 enddef
2413 defcompile
2414 Func()
2415 END
Bram Moolenaar08052222020-09-14 17:04:31 +02002416 writefile(lines, 'Xdef')
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02002417 try
2418 source Xdef
2419 assert_report('should have failed')
2420 catch /E716:/
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002421 v:throwpoint->assert_match('_Func, line 3$')
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02002422 endtry
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002423 delfunc! g:Func
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02002424
Bram Moolenaar08052222020-09-14 17:04:31 +02002425 delete('Xdef')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002426enddef
2427
Bram Moolenaar015f4262020-05-05 21:25:22 +02002428def Test_deleted_function()
Bram Moolenaar62aec932022-01-29 21:45:34 +00002429 v9.CheckDefExecFailure([
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002430 'var RefMe: func = function("g:DelMe")',
Bram Moolenaar015f4262020-05-05 21:25:22 +02002431 'delfunc g:DelMe',
2432 'echo RefMe()'], 'E117:')
2433enddef
2434
2435def Test_unknown_function()
Bram Moolenaar62aec932022-01-29 21:45:34 +00002436 v9.CheckDefExecFailure([
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002437 'var Ref: func = function("NotExist")',
Bram Moolenaar9b7bf9e2020-07-11 22:14:59 +02002438 'delfunc g:NotExist'], 'E700:')
Bram Moolenaar015f4262020-05-05 21:25:22 +02002439enddef
2440
Bram Moolenaar62aec932022-01-29 21:45:34 +00002441def s:RefFunc(Ref: func(any): any): string
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02002442 return Ref('more')
2443enddef
2444
2445def Test_closure_simple()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002446 var local = 'some '
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002447 RefFunc((s) => local .. s)->assert_equal('some more')
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02002448enddef
2449
Bram Moolenaar62aec932022-01-29 21:45:34 +00002450def s:MakeRef()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002451 var local = 'some '
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002452 g:Ref = (s) => local .. s
Bram Moolenaarbf67ea12020-05-02 17:52:42 +02002453enddef
2454
2455def Test_closure_ref_after_return()
2456 MakeRef()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002457 g:Ref('thing')->assert_equal('some thing')
Bram Moolenaarbf67ea12020-05-02 17:52:42 +02002458 unlet g:Ref
2459enddef
2460
Bram Moolenaar62aec932022-01-29 21:45:34 +00002461def s:MakeTwoRefs()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002462 var local = ['some']
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002463 g:Extend = (s) => local->add(s)
2464 g:Read = () => local
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002465enddef
2466
2467def Test_closure_two_refs()
2468 MakeTwoRefs()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002469 join(g:Read(), ' ')->assert_equal('some')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002470 g:Extend('more')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002471 join(g:Read(), ' ')->assert_equal('some more')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002472 g:Extend('even')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002473 join(g:Read(), ' ')->assert_equal('some more even')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002474
2475 unlet g:Extend
2476 unlet g:Read
2477enddef
2478
Bram Moolenaar62aec932022-01-29 21:45:34 +00002479def s:ReadRef(Ref: func(): list<string>): string
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002480 return join(Ref(), ' ')
2481enddef
2482
Bram Moolenaar62aec932022-01-29 21:45:34 +00002483def s:ExtendRef(Ref: func(string): list<string>, add: string)
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002484 Ref(add)
2485enddef
2486
2487def Test_closure_two_indirect_refs()
Bram Moolenaarf7779c62020-05-03 15:38:16 +02002488 MakeTwoRefs()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002489 ReadRef(g:Read)->assert_equal('some')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002490 ExtendRef(g:Extend, 'more')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002491 ReadRef(g:Read)->assert_equal('some more')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002492 ExtendRef(g:Extend, 'even')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002493 ReadRef(g:Read)->assert_equal('some more even')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002494
2495 unlet g:Extend
2496 unlet g:Read
2497enddef
Bram Moolenaarbf67ea12020-05-02 17:52:42 +02002498
Bram Moolenaar62aec932022-01-29 21:45:34 +00002499def s:MakeArgRefs(theArg: string)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002500 var local = 'loc_val'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002501 g:UseArg = (s) => theArg .. '/' .. local .. '/' .. s
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02002502enddef
2503
Bram Moolenaar62aec932022-01-29 21:45:34 +00002504def s:MakeArgRefsVarargs(theArg: string, ...rest: list<string>)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002505 var local = 'the_loc'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002506 g:UseVararg = (s) => theArg .. '/' .. local .. '/' .. s .. '/' .. join(rest)
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02002507enddef
2508
2509def Test_closure_using_argument()
2510 MakeArgRefs('arg_val')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002511 g:UseArg('call_val')->assert_equal('arg_val/loc_val/call_val')
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02002512
2513 MakeArgRefsVarargs('arg_val', 'one', 'two')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002514 g:UseVararg('call_val')->assert_equal('arg_val/the_loc/call_val/one two')
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02002515
2516 unlet g:UseArg
2517 unlet g:UseVararg
Bram Moolenaar44ec21c2021-02-12 21:50:57 +01002518
2519 var lines =<< trim END
2520 vim9script
2521 def Test(Fun: func(number): number): list<number>
2522 return map([1, 2, 3], (_, i) => Fun(i))
2523 enddef
2524 def Inc(nr: number): number
2525 return nr + 2
2526 enddef
2527 assert_equal([3, 4, 5], Test(Inc))
2528 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002529 v9.CheckScriptSuccess(lines)
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02002530enddef
2531
Bram Moolenaar62aec932022-01-29 21:45:34 +00002532def s:MakeGetAndAppendRefs()
Bram Moolenaar85d5e2b2020-10-10 14:13:01 +02002533 var local = 'a'
2534
2535 def Append(arg: string)
2536 local ..= arg
2537 enddef
2538 g:Append = Append
2539
2540 def Get(): string
2541 return local
2542 enddef
2543 g:Get = Get
2544enddef
2545
2546def Test_closure_append_get()
2547 MakeGetAndAppendRefs()
2548 g:Get()->assert_equal('a')
2549 g:Append('-b')
2550 g:Get()->assert_equal('a-b')
2551 g:Append('-c')
2552 g:Get()->assert_equal('a-b-c')
2553
2554 unlet g:Append
2555 unlet g:Get
2556enddef
Bram Moolenaarb68b3462020-05-06 21:06:30 +02002557
Bram Moolenaar04b12692020-05-04 23:24:44 +02002558def Test_nested_closure()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002559 var local = 'text'
Bram Moolenaar04b12692020-05-04 23:24:44 +02002560 def Closure(arg: string): string
2561 return local .. arg
2562 enddef
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002563 Closure('!!!')->assert_equal('text!!!')
Bram Moolenaar04b12692020-05-04 23:24:44 +02002564enddef
2565
Bram Moolenaar62aec932022-01-29 21:45:34 +00002566func s:GetResult(Ref)
Bram Moolenaar6f5b6df2020-05-16 21:20:12 +02002567 return a:Ref('some')
2568endfunc
2569
2570def Test_call_closure_not_compiled()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002571 var text = 'text'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002572 g:Ref = (s) => s .. text
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002573 GetResult(g:Ref)->assert_equal('sometext')
Bram Moolenaar6f5b6df2020-05-16 21:20:12 +02002574enddef
2575
Bram Moolenaar7cbfaa52020-09-18 21:25:32 +02002576def Test_double_closure_fails()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002577 var lines =<< trim END
Bram Moolenaar7cbfaa52020-09-18 21:25:32 +02002578 vim9script
2579 def Func()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002580 var name = 0
2581 for i in range(2)
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002582 timer_start(0, () => name)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002583 endfor
Bram Moolenaar7cbfaa52020-09-18 21:25:32 +02002584 enddef
2585 Func()
2586 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002587 v9.CheckScriptSuccess(lines)
Bram Moolenaar7cbfaa52020-09-18 21:25:32 +02002588enddef
2589
Bram Moolenaar85d5e2b2020-10-10 14:13:01 +02002590def Test_nested_closure_used()
2591 var lines =<< trim END
2592 vim9script
2593 def Func()
2594 var x = 'hello'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002595 var Closure = () => x
2596 g:Myclosure = () => Closure()
Bram Moolenaar85d5e2b2020-10-10 14:13:01 +02002597 enddef
2598 Func()
2599 assert_equal('hello', g:Myclosure())
2600 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002601 v9.CheckScriptSuccess(lines)
Bram Moolenaar85d5e2b2020-10-10 14:13:01 +02002602enddef
Bram Moolenaar0876c782020-10-07 19:08:04 +02002603
Bram Moolenaarc70bdab2020-09-26 19:59:38 +02002604def Test_nested_closure_fails()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002605 var lines =<< trim END
Bram Moolenaarc70bdab2020-09-26 19:59:38 +02002606 vim9script
2607 def FuncA()
2608 FuncB(0)
2609 enddef
2610 def FuncB(n: number): list<string>
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002611 return map([0], (_, v) => n)
Bram Moolenaarc70bdab2020-09-26 19:59:38 +02002612 enddef
2613 FuncA()
2614 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002615 v9.CheckScriptFailure(lines, 'E1012:')
Bram Moolenaarc70bdab2020-09-26 19:59:38 +02002616enddef
2617
Bram Moolenaarf112f302020-12-20 17:47:52 +01002618def Test_global_closure()
2619 var lines =<< trim END
2620 vim9script
2621 def ReverseEveryNLines(n: number, line1: number, line2: number)
2622 var mods = 'sil keepj keepp lockm '
2623 var range = ':' .. line1 .. ',' .. line2
2624 def g:Offset(): number
2625 var offset = (line('.') - line1 + 1) % n
2626 return offset != 0 ? offset : n
2627 enddef
2628 exe mods .. range .. 'g/^/exe "m .-" .. g:Offset()'
2629 enddef
2630
2631 new
2632 repeat(['aaa', 'bbb', 'ccc'], 3)->setline(1)
2633 ReverseEveryNLines(3, 1, 9)
2634 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002635 v9.CheckScriptSuccess(lines)
Bram Moolenaarf112f302020-12-20 17:47:52 +01002636 var expected = repeat(['ccc', 'bbb', 'aaa'], 3)
2637 assert_equal(expected, getline(1, 9))
2638 bwipe!
2639enddef
2640
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01002641def Test_global_closure_called_directly()
2642 var lines =<< trim END
2643 vim9script
2644 def Outer()
2645 var x = 1
2646 def g:Inner()
2647 var y = x
2648 x += 1
2649 assert_equal(1, y)
2650 enddef
2651 g:Inner()
2652 assert_equal(2, x)
2653 enddef
2654 Outer()
2655 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002656 v9.CheckScriptSuccess(lines)
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01002657 delfunc g:Inner
2658enddef
2659
Bram Moolenaar69c76172021-12-02 16:38:52 +00002660def Test_closure_called_from_legacy()
2661 var lines =<< trim END
2662 vim9script
2663 def Func()
2664 var outer = 'foo'
2665 var F = () => {
2666 outer = 'bar'
2667 }
2668 execute printf('call %s()', string(F))
2669 enddef
2670 Func()
2671 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002672 v9.CheckScriptFailure(lines, 'E1248')
Bram Moolenaar69c76172021-12-02 16:38:52 +00002673enddef
2674
Bram Moolenaar34c54eb2020-11-25 19:15:19 +01002675def Test_failure_in_called_function()
2676 # this was using the frame index as the return value
2677 var lines =<< trim END
2678 vim9script
2679 au TerminalWinOpen * eval [][0]
2680 def PopupTerm(a: any)
2681 # make sure typvals on stack are string
2682 ['a', 'b', 'c', 'd', 'e', 'f', 'g']->join()
2683 FireEvent()
2684 enddef
2685 def FireEvent()
2686 do TerminalWinOpen
2687 enddef
2688 # use try/catch to make eval fail
2689 try
2690 call PopupTerm(0)
2691 catch
2692 endtry
2693 au! TerminalWinOpen
2694 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002695 v9.CheckScriptSuccess(lines)
Bram Moolenaar34c54eb2020-11-25 19:15:19 +01002696enddef
2697
Bram Moolenaar5366e1a2020-10-01 13:01:34 +02002698def Test_nested_lambda()
2699 var lines =<< trim END
2700 vim9script
2701 def Func()
2702 var x = 4
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002703 var Lambda1 = () => 7
2704 var Lambda2 = () => [Lambda1(), x]
Bram Moolenaar5366e1a2020-10-01 13:01:34 +02002705 var res = Lambda2()
2706 assert_equal([7, 4], res)
2707 enddef
2708 Func()
2709 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002710 v9.CheckScriptSuccess(lines)
Bram Moolenaar5366e1a2020-10-01 13:01:34 +02002711enddef
2712
Bram Moolenaarc04f2a42021-06-09 19:30:03 +02002713def Test_double_nested_lambda()
2714 var lines =<< trim END
2715 vim9script
2716 def F(head: string): func(string): func(string): string
2717 return (sep: string): func(string): string => ((tail: string): string => {
2718 return head .. sep .. tail
2719 })
2720 enddef
2721 assert_equal('hello-there', F('hello')('-')('there'))
2722 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002723 v9.CheckScriptSuccess(lines)
Bram Moolenaarc04f2a42021-06-09 19:30:03 +02002724enddef
2725
Bram Moolenaar074f84c2021-05-18 11:47:44 +02002726def Test_nested_inline_lambda()
Bram Moolenaar074f84c2021-05-18 11:47:44 +02002727 var lines =<< trim END
2728 vim9script
2729 def F(text: string): func(string): func(string): string
2730 return (arg: string): func(string): string => ((sep: string): string => {
Bram Moolenaar23e2e112021-08-03 21:16:18 +02002731 return sep .. arg .. text
Bram Moolenaar074f84c2021-05-18 11:47:44 +02002732 })
2733 enddef
Bram Moolenaar23e2e112021-08-03 21:16:18 +02002734 assert_equal('--there++', F('++')('there')('--'))
Bram Moolenaar074f84c2021-05-18 11:47:44 +02002735 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002736 v9.CheckScriptSuccess(lines)
Bram Moolenaar5245beb2021-07-15 22:03:50 +02002737
2738 lines =<< trim END
2739 vim9script
2740 echo range(4)->mapnew((_, v) => {
2741 return range(v) ->mapnew((_, s) => {
2742 return string(s)
2743 })
2744 })
2745 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002746 v9.CheckScriptSuccess(lines)
Bram Moolenaarc6ba2f92021-07-18 13:42:29 +02002747
2748 lines =<< trim END
2749 vim9script
2750
2751 def s:func()
2752 range(10)
2753 ->mapnew((_, _) => ({
2754 key: range(10)->mapnew((_, _) => {
2755 return ' '
2756 }),
2757 }))
2758 enddef
2759
2760 defcomp
2761 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002762 v9.CheckScriptSuccess(lines)
Bram Moolenaar074f84c2021-05-18 11:47:44 +02002763enddef
2764
Bram Moolenaar52bf81c2020-11-17 18:50:44 +01002765def Shadowed(): list<number>
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002766 var FuncList: list<func: number> = [() => 42]
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01002767 return FuncList->mapnew((_, Shadowed) => Shadowed())
Bram Moolenaar52bf81c2020-11-17 18:50:44 +01002768enddef
2769
2770def Test_lambda_arg_shadows_func()
Bram Moolenaar62aec932022-01-29 21:45:34 +00002771 assert_equal([42], g:Shadowed())
Bram Moolenaar52bf81c2020-11-17 18:50:44 +01002772enddef
2773
Bram Moolenaar62aec932022-01-29 21:45:34 +00002774def s:Line_continuation_in_def(dir: string = ''): string
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002775 var path: string = empty(dir)
2776 \ ? 'empty'
2777 \ : 'full'
2778 return path
Bram Moolenaaracd4c5e2020-06-22 19:39:03 +02002779enddef
2780
2781def Test_line_continuation_in_def()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002782 Line_continuation_in_def('.')->assert_equal('full')
Bram Moolenaaracd4c5e2020-06-22 19:39:03 +02002783enddef
2784
Bram Moolenaar2ea95b62020-11-19 21:47:56 +01002785def Test_script_var_in_lambda()
2786 var lines =<< trim END
2787 vim9script
2788 var script = 'test'
Bram Moolenaarbb8a7ce2021-04-10 20:10:26 +02002789 assert_equal(['test'], map(['one'], (_, _) => script))
Bram Moolenaar2ea95b62020-11-19 21:47:56 +01002790 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002791 v9.CheckScriptSuccess(lines)
Bram Moolenaar2ea95b62020-11-19 21:47:56 +01002792enddef
2793
Bram Moolenaar62aec932022-01-29 21:45:34 +00002794def s:Line_continuation_in_lambda(): list<string>
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002795 var x = range(97, 100)
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01002796 ->mapnew((_, v) => nr2char(v)
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002797 ->toupper())
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02002798 ->reverse()
2799 return x
2800enddef
2801
2802def Test_line_continuation_in_lambda()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002803 Line_continuation_in_lambda()->assert_equal(['D', 'C', 'B', 'A'])
Bram Moolenaarf898f7c2021-01-16 18:09:52 +01002804
2805 var lines =<< trim END
2806 vim9script
2807 var res = [{n: 1, m: 2, s: 'xxx'}]
2808 ->mapnew((_, v: dict<any>): string => printf('%d:%d:%s',
2809 v.n,
2810 v.m,
2811 substitute(v.s, '.*', 'yyy', '')
2812 ))
2813 assert_equal(['1:2:yyy'], res)
2814 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002815 v9.CheckScriptSuccess(lines)
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02002816enddef
2817
Bram Moolenaarb6571982021-01-08 22:24:19 +01002818def Test_list_lambda()
2819 timer_start(1000, (_) => 0)
2820 var body = execute(timer_info()[0].callback
2821 ->string()
2822 ->substitute("('", ' ', '')
2823 ->substitute("')", '', '')
2824 ->substitute('function\zs', ' ', ''))
Bram Moolenaar767034c2021-04-09 17:24:52 +02002825 assert_match('def <lambda>\d\+(_: any): number\n1 return 0\n enddef', body)
Bram Moolenaarb6571982021-01-08 22:24:19 +01002826enddef
2827
Bram Moolenaar3c77b6a2021-07-25 18:07:00 +02002828def Test_lambda_block_variable()
Bram Moolenaar88421d62021-07-24 14:14:52 +02002829 var lines =<< trim END
2830 vim9script
2831 var flist: list<func>
2832 for i in range(10)
2833 var inloop = i
2834 flist[i] = () => inloop
2835 endfor
2836 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002837 v9.CheckScriptSuccess(lines)
Bram Moolenaar88421d62021-07-24 14:14:52 +02002838
2839 lines =<< trim END
2840 vim9script
2841 if true
2842 var outloop = 5
2843 var flist: list<func>
2844 for i in range(10)
2845 flist[i] = () => outloop
2846 endfor
2847 endif
2848 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002849 v9.CheckScriptSuccess(lines)
Bram Moolenaar88421d62021-07-24 14:14:52 +02002850
2851 lines =<< trim END
2852 vim9script
2853 if true
2854 var outloop = 5
2855 endif
2856 var flist: list<func>
2857 for i in range(10)
2858 flist[i] = () => outloop
2859 endfor
2860 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002861 v9.CheckScriptFailure(lines, 'E1001: Variable not found: outloop', 1)
Bram Moolenaar3c77b6a2021-07-25 18:07:00 +02002862
2863 lines =<< trim END
2864 vim9script
2865 for i in range(10)
2866 var Ref = () => 0
2867 endfor
2868 assert_equal(0, ((i) => 0)(0))
2869 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002870 v9.CheckScriptSuccess(lines)
Bram Moolenaar88421d62021-07-24 14:14:52 +02002871enddef
2872
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02002873def Test_legacy_lambda()
2874 legacy echo {x -> 'hello ' .. x}('foo')
Bram Moolenaardc4c2302021-04-25 13:54:42 +02002875
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02002876 var lines =<< trim END
2877 echo {x -> 'hello ' .. x}('foo')
2878 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002879 v9.CheckDefAndScriptFailure(lines, 'E720:')
Bram Moolenaardc4c2302021-04-25 13:54:42 +02002880
2881 lines =<< trim END
2882 vim9script
2883 def Func()
2884 echo (() => 'no error')()
2885 enddef
2886 legacy call s:Func()
2887 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002888 v9.CheckScriptSuccess(lines)
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02002889enddef
2890
Bram Moolenaarce024c32021-06-26 13:00:49 +02002891def Test_legacy()
2892 var lines =<< trim END
2893 vim9script
2894 func g:LegacyFunction()
2895 let g:legacyvar = 1
2896 endfunc
2897 def Testit()
2898 legacy call g:LegacyFunction()
2899 enddef
2900 Testit()
2901 assert_equal(1, g:legacyvar)
2902 unlet g:legacyvar
2903 delfunc g:LegacyFunction
2904 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002905 v9.CheckScriptSuccess(lines)
Bram Moolenaarce024c32021-06-26 13:00:49 +02002906enddef
2907
Bram Moolenaarc3cb1c92021-06-02 16:47:53 +02002908def Test_legacy_errors()
2909 for cmd in ['if', 'elseif', 'else', 'endif',
2910 'for', 'endfor', 'continue', 'break',
2911 'while', 'endwhile',
2912 'try', 'catch', 'finally', 'endtry']
Bram Moolenaar62aec932022-01-29 21:45:34 +00002913 v9.CheckDefFailure(['legacy ' .. cmd .. ' expr'], 'E1189:')
Bram Moolenaarc3cb1c92021-06-02 16:47:53 +02002914 endfor
2915enddef
2916
Bram Moolenaarb1b6f4d2021-09-13 18:25:54 +02002917def Test_call_legacy_with_dict()
2918 var lines =<< trim END
2919 vim9script
2920 func Legacy() dict
2921 let g:result = self.value
2922 endfunc
2923 def TestDirect()
2924 var d = {value: 'yes', func: Legacy}
2925 d.func()
2926 enddef
2927 TestDirect()
2928 assert_equal('yes', g:result)
2929 unlet g:result
2930
2931 def TestIndirect()
2932 var d = {value: 'foo', func: Legacy}
2933 var Fi = d.func
2934 Fi()
2935 enddef
2936 TestIndirect()
2937 assert_equal('foo', g:result)
2938 unlet g:result
2939
2940 var d = {value: 'bar', func: Legacy}
2941 d.func()
2942 assert_equal('bar', g:result)
2943 unlet g:result
2944 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002945 v9.CheckScriptSuccess(lines)
Bram Moolenaarb1b6f4d2021-09-13 18:25:54 +02002946enddef
2947
Bram Moolenaar62aec932022-01-29 21:45:34 +00002948def s:DoFilterThis(a: string): list<string>
Bram Moolenaarab360522021-01-10 14:02:28 +01002949 # closure nested inside another closure using argument
2950 var Filter = (l) => filter(l, (_, v) => stridx(v, a) == 0)
2951 return ['x', 'y', 'a', 'x2', 'c']->Filter()
2952enddef
2953
2954def Test_nested_closure_using_argument()
2955 assert_equal(['x', 'x2'], DoFilterThis('x'))
2956enddef
2957
Bram Moolenaar0186e582021-01-10 18:33:11 +01002958def Test_triple_nested_closure()
2959 var what = 'x'
2960 var Match = (val: string, cmp: string): bool => stridx(val, cmp) == 0
2961 var Filter = (l) => filter(l, (_, v) => Match(v, what))
2962 assert_equal(['x', 'x2'], ['x', 'y', 'a', 'x2', 'c']->Filter())
2963enddef
2964
Bram Moolenaar8f510af2020-07-05 18:48:23 +02002965func Test_silent_echo()
Bram Moolenaar47e7d702020-07-05 18:18:42 +02002966 CheckScreendump
Bram Moolenaar3b309f12021-12-13 18:19:55 +00002967 call Run_Test_silent_echo()
2968endfunc
Bram Moolenaar47e7d702020-07-05 18:18:42 +02002969
Bram Moolenaar3b309f12021-12-13 18:19:55 +00002970def Run_Test_silent_echo()
2971 var lines =<< trim END
Bram Moolenaar47e7d702020-07-05 18:18:42 +02002972 vim9script
2973 def EchoNothing()
2974 silent echo ''
2975 enddef
2976 defcompile
2977 END
Bram Moolenaar3b309f12021-12-13 18:19:55 +00002978 writefile(lines, 'XTest_silent_echo')
Bram Moolenaar47e7d702020-07-05 18:18:42 +02002979
Bram Moolenaar3b309f12021-12-13 18:19:55 +00002980 # Check that the balloon shows up after a mouse move
Bram Moolenaar62aec932022-01-29 21:45:34 +00002981 var buf = g:RunVimInTerminal('-S XTest_silent_echo', {'rows': 6})
Bram Moolenaar3b309f12021-12-13 18:19:55 +00002982 term_sendkeys(buf, ":abc")
Bram Moolenaar62aec932022-01-29 21:45:34 +00002983 g:VerifyScreenDump(buf, 'Test_vim9_silent_echo', {})
Bram Moolenaar47e7d702020-07-05 18:18:42 +02002984
Bram Moolenaar3b309f12021-12-13 18:19:55 +00002985 # clean up
Bram Moolenaar62aec932022-01-29 21:45:34 +00002986 g:StopVimInTerminal(buf)
Bram Moolenaar3b309f12021-12-13 18:19:55 +00002987 delete('XTest_silent_echo')
2988enddef
Bram Moolenaar47e7d702020-07-05 18:18:42 +02002989
Bram Moolenaar171fb922020-10-28 16:54:47 +01002990def SilentlyError()
2991 execute('silent! invalid')
2992 g:did_it = 'yes'
2993enddef
2994
Bram Moolenaar62aec932022-01-29 21:45:34 +00002995func s:UserError()
Bram Moolenaar28ee8922020-10-28 20:20:00 +01002996 silent! invalid
2997endfunc
2998
2999def SilentlyUserError()
3000 UserError()
3001 g:did_it = 'yes'
3002enddef
Bram Moolenaar171fb922020-10-28 16:54:47 +01003003
3004" This can't be a :def function, because the assert would not be reached.
Bram Moolenaar171fb922020-10-28 16:54:47 +01003005func Test_ignore_silent_error()
3006 let g:did_it = 'no'
3007 call SilentlyError()
3008 call assert_equal('yes', g:did_it)
3009
Bram Moolenaar28ee8922020-10-28 20:20:00 +01003010 let g:did_it = 'no'
3011 call SilentlyUserError()
3012 call assert_equal('yes', g:did_it)
Bram Moolenaar171fb922020-10-28 16:54:47 +01003013
3014 unlet g:did_it
3015endfunc
3016
Bram Moolenaarcd030c42020-10-30 21:49:40 +01003017def Test_ignore_silent_error_in_filter()
3018 var lines =<< trim END
3019 vim9script
3020 def Filter(winid: number, key: string): bool
3021 if key == 'o'
3022 silent! eval [][0]
3023 return true
3024 endif
3025 return popup_filter_menu(winid, key)
3026 enddef
3027
Bram Moolenaare0de1712020-12-02 17:36:54 +01003028 popup_create('popup', {filter: Filter})
Bram Moolenaarcd030c42020-10-30 21:49:40 +01003029 feedkeys("o\r", 'xnt')
3030 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003031 v9.CheckScriptSuccess(lines)
Bram Moolenaarcd030c42020-10-30 21:49:40 +01003032enddef
3033
Bram Moolenaar62aec932022-01-29 21:45:34 +00003034def s:Fibonacci(n: number): number
Bram Moolenaar4b9bd692020-09-05 21:57:53 +02003035 if n < 2
3036 return n
3037 else
3038 return Fibonacci(n - 1) + Fibonacci(n - 2)
3039 endif
3040enddef
3041
Bram Moolenaar985116a2020-07-12 17:31:09 +02003042def Test_recursive_call()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02003043 Fibonacci(20)->assert_equal(6765)
Bram Moolenaar985116a2020-07-12 17:31:09 +02003044enddef
3045
Bram Moolenaar62aec932022-01-29 21:45:34 +00003046def s:TreeWalk(dir: string): list<any>
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01003047 return readdir(dir)->mapnew((_, val) =>
Bram Moolenaar08f7a412020-07-13 20:41:08 +02003048 fnamemodify(dir .. '/' .. val, ':p')->isdirectory()
Bram Moolenaar2bede172020-11-19 18:53:18 +01003049 ? {[val]: TreeWalk(dir .. '/' .. val)}
Bram Moolenaar08f7a412020-07-13 20:41:08 +02003050 : val
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01003051 )
Bram Moolenaar08f7a412020-07-13 20:41:08 +02003052enddef
3053
3054def Test_closure_in_map()
3055 mkdir('XclosureDir/tdir', 'p')
3056 writefile(['111'], 'XclosureDir/file1')
3057 writefile(['222'], 'XclosureDir/file2')
3058 writefile(['333'], 'XclosureDir/tdir/file3')
3059
Bram Moolenaare0de1712020-12-02 17:36:54 +01003060 TreeWalk('XclosureDir')->assert_equal(['file1', 'file2', {tdir: ['file3']}])
Bram Moolenaar08f7a412020-07-13 20:41:08 +02003061
3062 delete('XclosureDir', 'rf')
3063enddef
3064
Bram Moolenaar7b5d5442020-10-04 13:42:34 +02003065def Test_invalid_function_name()
3066 var lines =<< trim END
3067 vim9script
3068 def s: list<string>
3069 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003070 v9.CheckScriptFailure(lines, 'E129:')
Bram Moolenaar7b5d5442020-10-04 13:42:34 +02003071
3072 lines =<< trim END
3073 vim9script
3074 def g: list<string>
3075 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003076 v9.CheckScriptFailure(lines, 'E129:')
Bram Moolenaar7b5d5442020-10-04 13:42:34 +02003077
3078 lines =<< trim END
3079 vim9script
3080 def <SID>: list<string>
3081 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003082 v9.CheckScriptFailure(lines, 'E884:')
Bram Moolenaar7b5d5442020-10-04 13:42:34 +02003083
3084 lines =<< trim END
3085 vim9script
3086 def F list<string>
3087 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003088 v9.CheckScriptFailure(lines, 'E488:')
Bram Moolenaar7b5d5442020-10-04 13:42:34 +02003089enddef
3090
Bram Moolenaara90afb92020-07-15 22:38:56 +02003091def Test_partial_call()
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02003092 var lines =<< trim END
3093 var Xsetlist: func
3094 Xsetlist = function('setloclist', [0])
3095 Xsetlist([], ' ', {title: 'test'})
3096 getloclist(0, {title: 1})->assert_equal({title: 'test'})
Bram Moolenaara90afb92020-07-15 22:38:56 +02003097
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02003098 Xsetlist = function('setloclist', [0, [], ' '])
3099 Xsetlist({title: 'test'})
3100 getloclist(0, {title: 1})->assert_equal({title: 'test'})
Bram Moolenaara90afb92020-07-15 22:38:56 +02003101
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02003102 Xsetlist = function('setqflist')
3103 Xsetlist([], ' ', {title: 'test'})
3104 getqflist({title: 1})->assert_equal({title: 'test'})
Bram Moolenaara90afb92020-07-15 22:38:56 +02003105
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02003106 Xsetlist = function('setqflist', [[], ' '])
3107 Xsetlist({title: 'test'})
3108 getqflist({title: 1})->assert_equal({title: 'test'})
Bram Moolenaar6abd3dc2020-10-04 14:17:32 +02003109
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02003110 var Len: func: number = function('len', ['word'])
3111 assert_equal(4, Len())
3112
3113 var RepeatFunc = function('repeat', ['o'])
3114 assert_equal('ooooo', RepeatFunc(5))
3115 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003116 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarc66f6452021-08-19 21:08:30 +02003117
3118 lines =<< trim END
3119 vim9script
3120 def Foo(Parser: any)
3121 enddef
3122 var Expr: func(dict<any>): dict<any>
3123 const Call = Foo(Expr)
3124 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003125 v9.CheckScriptFailure(lines, 'E1235:')
Bram Moolenaara90afb92020-07-15 22:38:56 +02003126enddef
3127
Bram Moolenaarfe1bfc92022-02-06 13:55:03 +00003128" Using "idx" from a legacy global function does not work.
3129" This caused a crash when called from legacy context.
3130func Test_partial_call_fails()
3131 let lines =<< trim END
3132 vim9script
3133
3134 var l = ['a', 'b', 'c']
3135 def Iter(container: any): any
3136 var idx = -1
3137 var obj = {state: container}
3138 def g:__NextItem__(self: dict<any>): any
3139 ++idx
3140 return self.state[idx]
3141 enddef
3142 obj.__next__ = function('g:__NextItem__', [obj])
3143 return obj
3144 enddef
3145
3146 var it = Iter(l)
3147 echo it.__next__()
3148 END
3149 call writefile(lines, 'XpartialCall')
3150 try
3151 source XpartialCall
3152 catch /E1248:/
3153 endtry
3154 call delete('XpartialCall')
3155endfunc
3156
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02003157def Test_cmd_modifier()
3158 tab echo '0'
Bram Moolenaar62aec932022-01-29 21:45:34 +00003159 v9.CheckDefFailure(['5tab echo 3'], 'E16:')
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02003160enddef
3161
3162def Test_restore_modifiers()
3163 # check that when compiling a :def function command modifiers are not messed
3164 # up.
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02003165 var lines =<< trim END
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02003166 vim9script
3167 set eventignore=
3168 autocmd QuickFixCmdPost * copen
3169 def AutocmdsDisabled()
Bram Moolenaarc3235272021-07-10 19:42:03 +02003170 eval 1 + 2
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02003171 enddef
3172 func Func()
3173 noautocmd call s:AutocmdsDisabled()
3174 let g:ei_after = &eventignore
3175 endfunc
3176 Func()
3177 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003178 v9.CheckScriptSuccess(lines)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02003179 g:ei_after->assert_equal('')
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02003180enddef
3181
Bram Moolenaardfa3d552020-09-10 22:05:08 +02003182def StackTop()
Bram Moolenaarc3235272021-07-10 19:42:03 +02003183 eval 1 + 2
3184 eval 2 + 3
Bram Moolenaardfa3d552020-09-10 22:05:08 +02003185 # call not on fourth line
Bram Moolenaar62aec932022-01-29 21:45:34 +00003186 g:StackBot()
Bram Moolenaardfa3d552020-09-10 22:05:08 +02003187enddef
3188
3189def StackBot()
3190 # throw an error
3191 eval [][0]
3192enddef
3193
3194def Test_callstack_def()
3195 try
Bram Moolenaar62aec932022-01-29 21:45:34 +00003196 g:StackTop()
Bram Moolenaardfa3d552020-09-10 22:05:08 +02003197 catch
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02003198 v:throwpoint->assert_match('Test_callstack_def\[2\]..StackTop\[4\]..StackBot, line 2')
Bram Moolenaardfa3d552020-09-10 22:05:08 +02003199 endtry
3200enddef
3201
Bram Moolenaare8211a32020-10-09 22:04:29 +02003202" Re-using spot for variable used in block
3203def Test_block_scoped_var()
3204 var lines =<< trim END
3205 vim9script
3206 def Func()
3207 var x = ['a', 'b', 'c']
3208 if 1
3209 var y = 'x'
Bram Moolenaarbb8a7ce2021-04-10 20:10:26 +02003210 map(x, (_, _) => y)
Bram Moolenaare8211a32020-10-09 22:04:29 +02003211 endif
3212 var z = x
3213 assert_equal(['x', 'x', 'x'], z)
3214 enddef
3215 Func()
3216 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003217 v9.CheckScriptSuccess(lines)
Bram Moolenaare8211a32020-10-09 22:04:29 +02003218enddef
3219
Bram Moolenaareeece9e2020-11-20 19:26:48 +01003220def Test_reset_did_emsg()
3221 var lines =<< trim END
3222 @s = 'blah'
3223 au BufWinLeave * #
3224 def Func()
3225 var winid = popup_create('popup', {})
3226 exe '*s'
3227 popup_close(winid)
3228 enddef
3229 Func()
3230 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003231 v9.CheckScriptFailure(lines, 'E492:', 8)
Bram Moolenaar2d870f82020-12-05 13:41:01 +01003232 delfunc! g:Func
Bram Moolenaareeece9e2020-11-20 19:26:48 +01003233enddef
3234
Bram Moolenaar57f799e2020-12-12 20:42:19 +01003235def Test_did_emsg_reset()
3236 # executing an autocommand resets did_emsg, this should not result in a
3237 # builtin function considered failing
3238 var lines =<< trim END
3239 vim9script
3240 au BufWinLeave * #
3241 def Func()
Bram Moolenaar767034c2021-04-09 17:24:52 +02003242 popup_menu('', {callback: (a, b) => popup_create('', {})->popup_close()})
Bram Moolenaar57f799e2020-12-12 20:42:19 +01003243 eval [][0]
3244 enddef
3245 nno <F3> <cmd>call <sid>Func()<cr>
3246 feedkeys("\<F3>\e", 'xt')
3247 END
3248 writefile(lines, 'XemsgReset')
3249 assert_fails('so XemsgReset', ['E684:', 'E684:'], lines, 2)
3250 delete('XemsgReset')
3251 nunmap <F3>
3252 au! BufWinLeave
3253enddef
3254
Bram Moolenaar56602ba2020-12-05 21:22:08 +01003255def Test_abort_with_silent_call()
3256 var lines =<< trim END
3257 vim9script
3258 g:result = 'none'
3259 def Func()
3260 g:result += 3
3261 g:result = 'yes'
3262 enddef
3263 # error is silenced, but function aborts on error
3264 silent! Func()
3265 assert_equal('none', g:result)
3266 unlet g:result
3267 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003268 v9.CheckScriptSuccess(lines)
Bram Moolenaar56602ba2020-12-05 21:22:08 +01003269enddef
3270
Bram Moolenaarf665e972020-12-05 19:17:16 +01003271def Test_continues_with_silent_error()
3272 var lines =<< trim END
3273 vim9script
3274 g:result = 'none'
3275 def Func()
3276 silent! g:result += 3
3277 g:result = 'yes'
3278 enddef
3279 # error is silenced, function does not abort
3280 Func()
3281 assert_equal('yes', g:result)
3282 unlet g:result
3283 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003284 v9.CheckScriptSuccess(lines)
Bram Moolenaarf665e972020-12-05 19:17:16 +01003285enddef
3286
Bram Moolenaaraf0df472020-12-02 20:51:22 +01003287def Test_abort_even_with_silent()
3288 var lines =<< trim END
3289 vim9script
3290 g:result = 'none'
3291 def Func()
3292 eval {-> ''}() .. '' .. {}['X']
3293 g:result = 'yes'
3294 enddef
Bram Moolenaarf665e972020-12-05 19:17:16 +01003295 silent! Func()
Bram Moolenaaraf0df472020-12-02 20:51:22 +01003296 assert_equal('none', g:result)
Bram Moolenaar4029cab2020-12-05 18:13:27 +01003297 unlet g:result
3298 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003299 v9.CheckScriptSuccess(lines)
Bram Moolenaar4029cab2020-12-05 18:13:27 +01003300enddef
3301
Bram Moolenaarf665e972020-12-05 19:17:16 +01003302def Test_cmdmod_silent_restored()
3303 var lines =<< trim END
3304 vim9script
3305 def Func()
3306 g:result = 'none'
3307 silent! g:result += 3
3308 g:result = 'none'
3309 g:result += 3
3310 enddef
3311 Func()
3312 END
3313 # can't use CheckScriptFailure, it ignores the :silent!
3314 var fname = 'Xdefsilent'
3315 writefile(lines, fname)
3316 var caught = 'no'
3317 try
3318 exe 'source ' .. fname
3319 catch /E1030:/
3320 caught = 'yes'
3321 assert_match('Func, line 4', v:throwpoint)
3322 endtry
3323 assert_equal('yes', caught)
3324 delete(fname)
3325enddef
3326
Bram Moolenaar2fecb532021-03-24 22:00:56 +01003327def Test_cmdmod_silent_nested()
3328 var lines =<< trim END
3329 vim9script
3330 var result = ''
3331
3332 def Error()
3333 result ..= 'Eb'
3334 eval [][0]
3335 result ..= 'Ea'
3336 enddef
3337
3338 def Crash()
3339 result ..= 'Cb'
3340 sil! Error()
3341 result ..= 'Ca'
3342 enddef
3343
3344 Crash()
3345 assert_equal('CbEbEaCa', result)
3346 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003347 v9.CheckScriptSuccess(lines)
Bram Moolenaar2fecb532021-03-24 22:00:56 +01003348enddef
3349
Bram Moolenaar4029cab2020-12-05 18:13:27 +01003350def Test_dict_member_with_silent()
3351 var lines =<< trim END
3352 vim9script
3353 g:result = 'none'
3354 var d: dict<any>
3355 def Func()
3356 try
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01003357 g:result = map([], (_, v) => ({}[v]))->join() .. d['']
Bram Moolenaar4029cab2020-12-05 18:13:27 +01003358 catch
3359 endtry
3360 enddef
3361 silent! Func()
3362 assert_equal('0', g:result)
3363 unlet g:result
Bram Moolenaaraf0df472020-12-02 20:51:22 +01003364 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003365 v9.CheckScriptSuccess(lines)
Bram Moolenaaraf0df472020-12-02 20:51:22 +01003366enddef
3367
Bram Moolenaarf9041332021-01-21 19:41:16 +01003368def Test_skip_cmds_with_silent()
3369 var lines =<< trim END
3370 vim9script
3371
3372 def Func(b: bool)
3373 Crash()
3374 enddef
3375
3376 def Crash()
3377 sil! :/not found/d _
3378 sil! :/not found/put _
3379 enddef
3380
3381 Func(true)
3382 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003383 v9.CheckScriptSuccess(lines)
Bram Moolenaarf9041332021-01-21 19:41:16 +01003384enddef
3385
Bram Moolenaar5b3d1bb2020-12-22 12:20:08 +01003386def Test_opfunc()
Bram Moolenaar848fadd2022-01-30 15:28:30 +00003387 nnoremap <F3> <cmd>set opfunc=g:Opfunc<cr>g@
Bram Moolenaar5b3d1bb2020-12-22 12:20:08 +01003388 def g:Opfunc(_: any): string
3389 setline(1, 'ASDF')
3390 return ''
3391 enddef
3392 new
3393 setline(1, 'asdf')
3394 feedkeys("\<F3>$", 'x')
3395 assert_equal('ASDF', getline(1))
3396
3397 bwipe!
3398 nunmap <F3>
3399enddef
3400
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003401func Test_opfunc_error()
3402 CheckScreendump
3403 call Run_Test_opfunc_error()
3404endfunc
3405
3406def Run_Test_opfunc_error()
3407 # test that the error from Opfunc() is displayed right away
3408 var lines =<< trim END
3409 vim9script
3410
3411 def Opfunc(type: string)
3412 try
3413 eval [][0]
3414 catch /nothing/ # error not caught
3415 endtry
3416 enddef
3417 &operatorfunc = Opfunc
3418 nnoremap <expr> l <SID>L()
3419 def L(): string
3420 return 'l'
3421 enddef
3422 'x'->repeat(10)->setline(1)
3423 feedkeys('g@l', 'n')
3424 feedkeys('llll')
3425 END
3426 call writefile(lines, 'XTest_opfunc_error')
3427
Bram Moolenaar62aec932022-01-29 21:45:34 +00003428 var buf = g:RunVimInTerminal('-S XTest_opfunc_error', {rows: 6, wait_for_ruler: 0})
3429 g:WaitForAssert(() => assert_match('Press ENTER', term_getline(buf, 6)))
3430 g:WaitForAssert(() => assert_match('E684: list index out of range: 0', term_getline(buf, 5)))
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003431
3432 # clean up
Bram Moolenaar62aec932022-01-29 21:45:34 +00003433 g:StopVimInTerminal(buf)
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003434 delete('XTest_opfunc_error')
3435enddef
3436
Bram Moolenaar077a4232020-12-22 18:33:27 +01003437" this was crashing on exit
3438def Test_nested_lambda_in_closure()
3439 var lines =<< trim END
3440 vim9script
Bram Moolenaar227c58a2021-04-28 20:40:44 +02003441 command WriteDone writefile(['Done'], 'XnestedDone')
Bram Moolenaar077a4232020-12-22 18:33:27 +01003442 def Outer()
3443 def g:Inner()
3444 echo map([1, 2, 3], {_, v -> v + 1})
3445 enddef
3446 g:Inner()
3447 enddef
3448 defcompile
Bram Moolenaar227c58a2021-04-28 20:40:44 +02003449 # not reached
Bram Moolenaar077a4232020-12-22 18:33:27 +01003450 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003451 if !g:RunVim([], lines, '--clean -c WriteDone -c quit')
Bram Moolenaar077a4232020-12-22 18:33:27 +01003452 return
3453 endif
3454 assert_equal(['Done'], readfile('XnestedDone'))
3455 delete('XnestedDone')
3456enddef
3457
Bram Moolenaar92368aa2022-02-07 17:50:39 +00003458def Test_nested_closure_funcref()
3459 var lines =<< trim END
3460 vim9script
3461 def Func()
3462 var n: number
3463 def Nested()
3464 ++n
3465 enddef
3466 Nested()
3467 g:result_one = n
3468 var Ref = function(Nested)
3469 Ref()
3470 g:result_two = n
3471 enddef
3472 Func()
3473 END
3474 v9.CheckScriptSuccess(lines)
3475 assert_equal(1, g:result_one)
3476 assert_equal(2, g:result_two)
3477 unlet g:result_one g:result_two
3478enddef
3479
Bram Moolenaar04947cc2021-03-06 19:26:46 +01003480def Test_check_func_arg_types()
3481 var lines =<< trim END
3482 vim9script
3483 def F1(x: string): string
3484 return x
3485 enddef
3486
3487 def F2(x: number): number
3488 return x + 1
3489 enddef
3490
3491 def G(g: func): dict<func>
3492 return {f: g}
3493 enddef
3494
3495 def H(d: dict<func>): string
3496 return d.f('a')
3497 enddef
3498 END
3499
Bram Moolenaar62aec932022-01-29 21:45:34 +00003500 v9.CheckScriptSuccess(lines + ['echo H(G(F1))'])
3501 v9.CheckScriptFailure(lines + ['echo H(G(F2))'], 'E1013:')
Bram Moolenaar04947cc2021-03-06 19:26:46 +01003502enddef
3503
Bram Moolenaar6e48b842021-08-10 22:52:02 +02003504def Test_list_any_type_checked()
3505 var lines =<< trim END
3506 vim9script
3507 def Foo()
3508 --decl--
3509 Bar(l)
3510 enddef
3511 def Bar(ll: list<dict<any>>)
3512 enddef
3513 Foo()
3514 END
Bram Moolenaar2d3ac2e2022-02-03 12:34:05 +00003515 # "any" could be "dict<any>", thus OK
Bram Moolenaar6e48b842021-08-10 22:52:02 +02003516 lines[2] = 'var l: list<any>'
Bram Moolenaar2d3ac2e2022-02-03 12:34:05 +00003517 v9.CheckScriptSuccess(lines)
Bram Moolenaar6e48b842021-08-10 22:52:02 +02003518 lines[2] = 'var l: list<any> = []'
Bram Moolenaar2d3ac2e2022-02-03 12:34:05 +00003519 v9.CheckScriptSuccess(lines)
Bram Moolenaar6e48b842021-08-10 22:52:02 +02003520
3521 lines[2] = 'var l: list<any> = [11]'
Bram Moolenaar62aec932022-01-29 21:45:34 +00003522 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected list<dict<any>> but got list<number>', 2)
Bram Moolenaar6e48b842021-08-10 22:52:02 +02003523enddef
3524
Bram Moolenaar701cc6c2021-04-10 13:33:48 +02003525def Test_compile_error()
3526 var lines =<< trim END
3527 def g:Broken()
3528 echo 'a' + {}
3529 enddef
3530 call g:Broken()
3531 END
3532 # First call: compilation error
Bram Moolenaar62aec932022-01-29 21:45:34 +00003533 v9.CheckScriptFailure(lines, 'E1051: Wrong argument type for +')
Bram Moolenaar701cc6c2021-04-10 13:33:48 +02003534
3535 # Second call won't try compiling again
3536 assert_fails('call g:Broken()', 'E1091: Function is not compiled: Broken')
Bram Moolenaar599410c2021-04-10 14:03:43 +02003537 delfunc g:Broken
3538
3539 # No error when compiling with :silent!
3540 lines =<< trim END
3541 def g:Broken()
3542 echo 'a' + []
3543 enddef
3544 silent! defcompile
3545 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003546 v9.CheckScriptSuccess(lines)
Bram Moolenaar599410c2021-04-10 14:03:43 +02003547
3548 # Calling the function won't try compiling again
3549 assert_fails('call g:Broken()', 'E1091: Function is not compiled: Broken')
3550 delfunc g:Broken
Bram Moolenaar701cc6c2021-04-10 13:33:48 +02003551enddef
3552
Bram Moolenaar962c43b2021-04-10 17:18:09 +02003553def Test_ignored_argument()
3554 var lines =<< trim END
3555 vim9script
3556 def Ignore(_, _): string
3557 return 'yes'
3558 enddef
3559 assert_equal('yes', Ignore(1, 2))
3560
3561 func Ok(_)
3562 return a:_
3563 endfunc
3564 assert_equal('ok', Ok('ok'))
3565
3566 func Oktoo()
3567 let _ = 'too'
3568 return _
3569 endfunc
3570 assert_equal('too', Oktoo())
Bram Moolenaarda479c72021-04-10 21:01:38 +02003571
3572 assert_equal([[1], [2], [3]], range(3)->mapnew((_, v) => [v]->map((_, w) => w + 1)))
Bram Moolenaar962c43b2021-04-10 17:18:09 +02003573 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003574 v9.CheckScriptSuccess(lines)
Bram Moolenaar962c43b2021-04-10 17:18:09 +02003575
3576 lines =<< trim END
3577 def Ignore(_: string): string
3578 return _
3579 enddef
3580 defcompile
3581 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003582 v9.CheckScriptFailure(lines, 'E1181:', 1)
Bram Moolenaar962c43b2021-04-10 17:18:09 +02003583
3584 lines =<< trim END
3585 var _ = 1
3586 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003587 v9.CheckDefAndScriptFailure(lines, 'E1181:', 1)
Yegappan Lakshmanan34fcb692021-05-25 20:14:00 +02003588
3589 lines =<< trim END
3590 var x = _
3591 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003592 v9.CheckDefAndScriptFailure(lines, 'E1181:', 1)
Bram Moolenaar962c43b2021-04-10 17:18:09 +02003593enddef
3594
Bram Moolenaarbb8a7ce2021-04-10 20:10:26 +02003595def Test_too_many_arguments()
3596 var lines =<< trim END
3597 echo [0, 1, 2]->map(() => 123)
3598 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003599 v9.CheckDefExecAndScriptFailure(lines, 'E1106: 2 arguments too many', 1)
Bram Moolenaarbb8a7ce2021-04-10 20:10:26 +02003600
3601 lines =<< trim END
3602 echo [0, 1, 2]->map((_) => 123)
3603 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003604 v9.CheckDefExecAndScriptFailure(lines, 'E1106: One argument too many', 1)
Bram Moolenaarbb8a7ce2021-04-10 20:10:26 +02003605enddef
Bram Moolenaar077a4232020-12-22 18:33:27 +01003606
Bram Moolenaara6aa1642021-04-23 19:32:23 +02003607def Test_closing_brace_at_start_of_line()
3608 var lines =<< trim END
3609 def Func()
3610 enddef
3611 Func(
3612 )
3613 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003614 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaara6aa1642021-04-23 19:32:23 +02003615enddef
3616
Bram Moolenaar62aec932022-01-29 21:45:34 +00003617func s:CreateMydict()
Bram Moolenaarb033ee22021-08-15 16:08:36 +02003618 let g:mydict = {}
3619 func g:mydict.afunc()
3620 let g:result = self.key
3621 endfunc
3622endfunc
3623
3624def Test_numbered_function_reference()
3625 CreateMydict()
3626 var output = execute('legacy func g:mydict.afunc')
3627 var funcName = 'g:' .. substitute(output, '.*function \(\d\+\).*', '\1', '')
3628 execute 'function(' .. funcName .. ', [], {key: 42})()'
3629 # check that the function still exists
3630 assert_equal(output, execute('legacy func g:mydict.afunc'))
3631 unlet g:mydict
3632enddef
3633
Bram Moolenaard3a11782022-01-05 16:50:40 +00003634def Test_go_beyond_end_of_cmd()
3635 # this was reading the byte after the end of the line
3636 var lines =<< trim END
3637 def F()
3638 cal
3639 enddef
3640 defcompile
3641 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003642 v9.CheckScriptFailure(lines, 'E476:')
Bram Moolenaard3a11782022-01-05 16:50:40 +00003643enddef
3644
Bram Moolenaar20677332021-06-06 17:02:53 +02003645if has('python3')
3646 def Test_python3_heredoc()
3647 py3 << trim EOF
3648 import vim
3649 vim.vars['didit'] = 'yes'
3650 EOF
3651 assert_equal('yes', g:didit)
3652
3653 python3 << trim EOF
3654 import vim
3655 vim.vars['didit'] = 'again'
3656 EOF
3657 assert_equal('again', g:didit)
3658 enddef
3659endif
3660
3661" This messes up syntax highlight, keep near the end.
3662if has('lua')
3663 def Test_lua_heredoc()
3664 g:d = {}
3665 lua << trim EOF
3666 x = vim.eval('g:d')
3667 x['key'] = 'val'
3668 EOF
3669 assert_equal('val', g:d.key)
3670 enddef
3671endif
3672
Bram Moolenaarf7779c62020-05-03 15:38:16 +02003673
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02003674" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker