blob: 4d5ff14b144b02015481800abecec0cf0a9735f8 [file] [log] [blame]
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001" Test various aspects of the Vim9 script language.
2
3source check.vim
Bram Moolenaarad304702020-09-06 18:22:53 +02004source term_util.vim
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02005source view_util.vim
Bram Moolenaar62aec932022-01-29 21:45:34 +00006import './vim9.vim' as v9
Bram Moolenaar47e7d702020-07-05 18:18:42 +02007source screendump.vim
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02008
9func Test_def_basic()
10 def SomeFunc(): string
11 return 'yes'
12 enddef
Bram Moolenaarc0c71e92020-09-11 19:09:48 +020013 call SomeFunc()->assert_equal('yes')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +020014endfunc
15
Bram Moolenaar2b9b17e2020-10-13 18:38:11 +020016func Test_compiling_error()
17 " use a terminal to see the whole error message
Bram Moolenaarf4e8cdd2020-10-12 22:07:13 +020018 CheckRunVimInTerminal
19
Bram Moolenaar2b9b17e2020-10-13 18:38:11 +020020 call TestCompilingError()
Bram Moolenaare8c46602021-04-05 22:27:37 +020021 call TestCompilingErrorInTry()
Bram Moolenaar2b9b17e2020-10-13 18:38:11 +020022endfunc
23
24def TestCompilingError()
Bram Moolenaarf4e8cdd2020-10-12 22:07:13 +020025 var lines =<< trim END
26 vim9script
27 def Fails()
28 echo nothing
29 enddef
30 defcompile
31 END
Bram Moolenaarf5fec052022-09-11 11:49:22 +010032 writefile(lines, 'XTest_compile_error', 'D')
Bram Moolenaar62aec932022-01-29 21:45:34 +000033 var buf = g:RunVimInTerminal('-S XTest_compile_error',
Bram Moolenaare0de1712020-12-02 17:36:54 +010034 {rows: 10, wait_for_ruler: 0})
Bram Moolenaar62aec932022-01-29 21:45:34 +000035 g:WaitForAssert(() => assert_match('Error detected while compiling command line.*Fails.*Variable not found: nothing',
36 g:Term_getlines(buf, range(1, 9))))
Bram Moolenaarf4e8cdd2020-10-12 22:07:13 +020037
38 # clean up
Bram Moolenaar62aec932022-01-29 21:45:34 +000039 g:StopVimInTerminal(buf)
Bram Moolenaare8c46602021-04-05 22:27:37 +020040enddef
41
42def TestCompilingErrorInTry()
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +010043 var dir = 'Xcompdir/autoload'
Bram Moolenaarf5fec052022-09-11 11:49:22 +010044 mkdir(dir, 'pR')
Bram Moolenaare8c46602021-04-05 22:27:37 +020045
46 var lines =<< trim END
47 vim9script
Bram Moolenaard8fe6d32022-01-30 18:40:44 +000048 export def OnlyCompiled()
Bram Moolenaare8c46602021-04-05 22:27:37 +020049 g:runtime = 'yes'
50 invalid
51 enddef
52 END
53 writefile(lines, dir .. '/script.vim')
54
55 lines =<< trim END
56 vim9script
57 todo
58 try
59 script#OnlyCompiled()
60 catch /nothing/
61 endtry
62 END
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +010063 lines[1] = 'set rtp=' .. getcwd() .. '/Xcompdir'
Bram Moolenaarf5fec052022-09-11 11:49:22 +010064 writefile(lines, 'XTest_compile_error', 'D')
Bram Moolenaare8c46602021-04-05 22:27:37 +020065
Bram Moolenaar62aec932022-01-29 21:45:34 +000066 var buf = g:RunVimInTerminal('-S XTest_compile_error', {rows: 10, wait_for_ruler: 0})
67 g:WaitForAssert(() => assert_match('Error detected while compiling command line.*function script#OnlyCompiled.*Invalid command: invalid',
68 g:Term_getlines(buf, range(1, 9))))
Bram Moolenaare8c46602021-04-05 22:27:37 +020069
70 # clean up
Bram Moolenaar62aec932022-01-29 21:45:34 +000071 g:StopVimInTerminal(buf)
Bram Moolenaarf4e8cdd2020-10-12 22:07:13 +020072enddef
73
Bram Moolenaarad6d9cc2022-08-08 21:43:11 +010074def Test_comment_error()
75 v9.CheckDefFailure(['#{ comment'], 'E1170:')
76enddef
77
Bram Moolenaarb55d6182021-06-08 22:01:53 +020078def Test_compile_error_in_called_function()
79 var lines =<< trim END
80 vim9script
81 var n: number
82 def Foo()
83 &hls = n
84 enddef
85 def Bar()
86 Foo()
87 enddef
88 silent! Foo()
89 Bar()
90 END
Bram Moolenaar62aec932022-01-29 21:45:34 +000091 v9.CheckScriptFailureList(lines, ['E1012:', 'E1191:'])
Bram Moolenaarb55d6182021-06-08 22:01:53 +020092enddef
93
Bram Moolenaar22f17a22021-06-21 20:48:58 +020094def Test_wrong_function_name()
95 var lines =<< trim END
96 vim9script
97 func _Foo()
98 echo 'foo'
99 endfunc
100 END
Bram Moolenaar3787f262022-02-07 21:54:01 +0000101 v9.CheckScriptFailure(lines, 'E1267:')
Bram Moolenaar22f17a22021-06-21 20:48:58 +0200102
103 lines =<< trim END
104 vim9script
105 def _Foo()
106 echo 'foo'
107 enddef
108 END
Bram Moolenaar3787f262022-02-07 21:54:01 +0000109 v9.CheckScriptFailure(lines, 'E1267:')
Bram Moolenaardea5ab02022-02-23 22:12:02 +0000110
111 lines =<< trim END
112 vim9script
113 var Object = {}
114 function Object.Method()
115 endfunction
116 END
117 v9.CheckScriptFailure(lines, 'E1182:')
118
119 lines =<< trim END
120 vim9script
121 var Object = {}
122 def Object.Method()
123 enddef
124 END
125 v9.CheckScriptFailure(lines, 'E1182:')
126
127 lines =<< trim END
128 vim9script
129 g:Object = {}
130 function g:Object.Method()
131 endfunction
132 END
133 v9.CheckScriptFailure(lines, 'E1182:')
134
135 lines =<< trim END
136 let s:Object = {}
137 def Define()
138 function s:Object.Method()
139 endfunction
140 enddef
141 defcompile
142 END
143 v9.CheckScriptFailure(lines, 'E1182:')
144 delfunc g:Define
145
146 lines =<< trim END
147 let s:Object = {}
148 def Define()
149 def Object.Method()
150 enddef
151 enddef
152 defcompile
153 END
154 v9.CheckScriptFailure(lines, 'E1182:')
155 delfunc g:Define
156
157 lines =<< trim END
158 let g:Object = {}
159 def Define()
160 function g:Object.Method()
161 endfunction
162 enddef
163 defcompile
164 END
165 v9.CheckScriptFailure(lines, 'E1182:')
166 delfunc g:Define
Bram Moolenaar22f17a22021-06-21 20:48:58 +0200167enddef
168
Bram Moolenaarf48b2fa2021-04-12 22:02:36 +0200169def Test_autoload_name_mismatch()
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +0100170 var dir = 'Xnamedir/autoload'
Bram Moolenaarf5fec052022-09-11 11:49:22 +0100171 mkdir(dir, 'pR')
Bram Moolenaarf48b2fa2021-04-12 22:02:36 +0200172
173 var lines =<< trim END
174 vim9script
Bram Moolenaard8fe6d32022-01-30 18:40:44 +0000175 export def NoFunction()
Bram Moolenaarf48b2fa2021-04-12 22:02:36 +0200176 # comment
177 g:runtime = 'yes'
178 enddef
179 END
180 writefile(lines, dir .. '/script.vim')
181
182 var save_rtp = &rtp
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +0100183 exe 'set rtp=' .. getcwd() .. '/Xnamedir'
Bram Moolenaarf48b2fa2021-04-12 22:02:36 +0200184 lines =<< trim END
185 call script#Function()
186 END
Bram Moolenaard8fe6d32022-01-30 18:40:44 +0000187 v9.CheckScriptFailure(lines, 'E117:', 1)
Bram Moolenaarf48b2fa2021-04-12 22:02:36 +0200188
189 &rtp = save_rtp
Bram Moolenaarf48b2fa2021-04-12 22:02:36 +0200190enddef
191
Bram Moolenaarf0a40692021-06-11 22:05:47 +0200192def Test_autoload_names()
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +0100193 var dir = 'Xandir/autoload'
Bram Moolenaarf5fec052022-09-11 11:49:22 +0100194 mkdir(dir, 'pR')
Bram Moolenaarf0a40692021-06-11 22:05:47 +0200195
196 var lines =<< trim END
197 func foobar#function()
198 return 'yes'
199 endfunc
200 let foobar#var = 'no'
201 END
202 writefile(lines, dir .. '/foobar.vim')
203
204 var save_rtp = &rtp
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +0100205 exe 'set rtp=' .. getcwd() .. '/Xandir'
Bram Moolenaarf0a40692021-06-11 22:05:47 +0200206
207 lines =<< trim END
208 assert_equal('yes', foobar#function())
209 var Function = foobar#function
210 assert_equal('yes', Function())
211
212 assert_equal('no', foobar#var)
213 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000214 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarf0a40692021-06-11 22:05:47 +0200215
216 &rtp = save_rtp
Bram Moolenaarf0a40692021-06-11 22:05:47 +0200217enddef
218
Bram Moolenaar88c89c72021-08-14 14:01:05 +0200219def Test_autoload_error_in_script()
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +0100220 var dir = 'Xaedir/autoload'
Bram Moolenaarf5fec052022-09-11 11:49:22 +0100221 mkdir(dir, 'pR')
Bram Moolenaar88c89c72021-08-14 14:01:05 +0200222
223 var lines =<< trim END
224 func scripterror#function()
225 let g:called_function = 'yes'
226 endfunc
227 let 0 = 1
228 END
229 writefile(lines, dir .. '/scripterror.vim')
230
231 var save_rtp = &rtp
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +0100232 exe 'set rtp=' .. getcwd() .. '/Xaedir'
Bram Moolenaar88c89c72021-08-14 14:01:05 +0200233
234 g:called_function = 'no'
235 # The error in the autoload script cannot be checked with assert_fails(), use
236 # CheckDefSuccess() instead of CheckDefFailure()
237 try
Bram Moolenaar62aec932022-01-29 21:45:34 +0000238 v9.CheckDefSuccess(['scripterror#function()'])
Bram Moolenaar88c89c72021-08-14 14:01:05 +0200239 catch
240 assert_match('E121: Undefined variable: 0', v:exception)
241 endtry
242 assert_equal('no', g:called_function)
243
244 lines =<< trim END
245 func scriptcaught#function()
246 let g:called_function = 'yes'
247 endfunc
248 try
249 let 0 = 1
250 catch
251 let g:caught = v:exception
252 endtry
253 END
254 writefile(lines, dir .. '/scriptcaught.vim')
255
256 g:called_function = 'no'
Bram Moolenaar62aec932022-01-29 21:45:34 +0000257 v9.CheckDefSuccess(['scriptcaught#function()'])
Bram Moolenaar88c89c72021-08-14 14:01:05 +0200258 assert_match('E121: Undefined variable: 0', g:caught)
259 assert_equal('yes', g:called_function)
260
261 &rtp = save_rtp
Bram Moolenaar88c89c72021-08-14 14:01:05 +0200262enddef
263
Bram Moolenaar62aec932022-01-29 21:45:34 +0000264def s:CallRecursive(n: number): number
Bram Moolenaar0ba48e82020-11-17 18:23:19 +0100265 return CallRecursive(n + 1)
266enddef
267
Bram Moolenaar62aec932022-01-29 21:45:34 +0000268def s:CallMapRecursive(l: list<number>): number
Bram Moolenaar2949cfd2020-12-31 21:28:47 +0100269 return map(l, (_, v) => CallMapRecursive([v]))[0]
Bram Moolenaar0ba48e82020-11-17 18:23:19 +0100270enddef
271
272def Test_funcdepth_error()
273 set maxfuncdepth=10
274
275 var caught = false
276 try
277 CallRecursive(1)
278 catch /E132:/
279 caught = true
280 endtry
281 assert_true(caught)
282
283 caught = false
284 try
285 CallMapRecursive([1])
286 catch /E132:/
287 caught = true
288 endtry
289 assert_true(caught)
290
291 set maxfuncdepth&
292enddef
293
Bram Moolenaar5178b1b2021-01-01 18:43:51 +0100294def Test_endfunc_enddef()
295 var lines =<< trim END
296 def Test()
297 echo 'test'
298 endfunc
299 enddef
300 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000301 v9.CheckScriptFailure(lines, 'E1151:', 3)
Bram Moolenaar5178b1b2021-01-01 18:43:51 +0100302
303 lines =<< trim END
304 def Test()
305 func Nested()
306 echo 'test'
307 enddef
308 enddef
309 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000310 v9.CheckScriptFailure(lines, 'E1152:', 4)
Bram Moolenaar49f1e9e2021-03-22 20:49:02 +0100311
312 lines =<< trim END
313 def Ok()
314 echo 'hello'
315 enddef | echo 'there'
316 def Bad()
317 echo 'hello'
318 enddef there
319 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000320 v9.CheckScriptFailure(lines, 'E1173: Text found after enddef: there', 6)
Bram Moolenaar5178b1b2021-01-01 18:43:51 +0100321enddef
322
Bram Moolenaarb8ba9b92021-01-01 18:54:34 +0100323def Test_missing_endfunc_enddef()
324 var lines =<< trim END
325 vim9script
326 def Test()
327 echo 'test'
328 endef
329 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000330 v9.CheckScriptFailure(lines, 'E1057:', 2)
Bram Moolenaarb8ba9b92021-01-01 18:54:34 +0100331
332 lines =<< trim END
333 vim9script
334 func Some()
335 echo 'test'
336 enfffunc
337 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000338 v9.CheckScriptFailure(lines, 'E126:', 2)
Bram Moolenaarb8ba9b92021-01-01 18:54:34 +0100339enddef
340
Bram Moolenaar4efd9942021-01-24 21:14:20 +0100341def Test_white_space_before_paren()
342 var lines =<< trim END
343 vim9script
344 def Test ()
345 echo 'test'
346 enddef
347 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000348 v9.CheckScriptFailure(lines, 'E1068:', 2)
Bram Moolenaar4efd9942021-01-24 21:14:20 +0100349
350 lines =<< trim END
351 vim9script
352 func Test ()
353 echo 'test'
354 endfunc
355 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000356 v9.CheckScriptFailure(lines, 'E1068:', 2)
Bram Moolenaar4efd9942021-01-24 21:14:20 +0100357
358 lines =<< trim END
359 def Test ()
360 echo 'test'
361 enddef
362 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000363 v9.CheckScriptFailure(lines, 'E1068:', 1)
Bram Moolenaar4efd9942021-01-24 21:14:20 +0100364
365 lines =<< trim END
366 func Test ()
367 echo 'test'
368 endfunc
369 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000370 v9.CheckScriptSuccess(lines)
Bram Moolenaar4efd9942021-01-24 21:14:20 +0100371enddef
372
Bram Moolenaar832ea892021-01-08 21:55:26 +0100373def Test_enddef_dict_key()
374 var d = {
375 enddef: 'x',
376 endfunc: 'y',
377 }
378 assert_equal({enddef: 'x', endfunc: 'y'}, d)
379enddef
380
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200381def ReturnString(): string
382 return 'string'
383enddef
384
385def ReturnNumber(): number
386 return 123
387enddef
388
389let g:notNumber = 'string'
390
391def ReturnGlobal(): number
392 return g:notNumber
393enddef
394
395def Test_return_something()
Bram Moolenaar62aec932022-01-29 21:45:34 +0000396 g:ReturnString()->assert_equal('string')
397 g:ReturnNumber()->assert_equal(123)
Bram Moolenaar848fadd2022-01-30 15:28:30 +0000398 assert_fails('g:ReturnGlobal()', 'E1012: Type mismatch; expected number but got string', '', 1, 'ReturnGlobal')
Bram Moolenaaref7aadb2022-01-18 18:46:07 +0000399
400 var lines =<< trim END
401 vim9script
402
403 def Msg()
404 echomsg 'in Msg()...'
405 enddef
406
407 def Func()
408 return Msg()
409 enddef
410 defcompile
411 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000412 v9.CheckScriptFailure(lines, 'E1096:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200413enddef
414
Bram Moolenaare32e5162021-01-21 20:21:29 +0100415def Test_check_argument_type()
416 var lines =<< trim END
417 vim9script
418 def Val(a: number, b: number): number
419 return 0
420 enddef
421 def Func()
422 var x: any = true
423 Val(0, x)
424 enddef
425 disass Func
426 Func()
427 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000428 v9.CheckScriptFailure(lines, 'E1013: Argument 2: type mismatch, expected number but got bool', 2)
Bram Moolenaare32e5162021-01-21 20:21:29 +0100429enddef
430
Bram Moolenaarefd88552020-06-18 20:50:10 +0200431def Test_missing_return()
Bram Moolenaar62aec932022-01-29 21:45:34 +0000432 v9.CheckDefFailure(['def Missing(): number',
Bram Moolenaarefd88552020-06-18 20:50:10 +0200433 ' if g:cond',
434 ' echo "no return"',
435 ' else',
436 ' return 0',
Bram Moolenaar2984ed32022-08-20 14:51:17 +0100437 ' endif',
Bram Moolenaarefd88552020-06-18 20:50:10 +0200438 'enddef'], 'E1027:')
Bram Moolenaar62aec932022-01-29 21:45:34 +0000439 v9.CheckDefFailure(['def Missing(): number',
Bram Moolenaarefd88552020-06-18 20:50:10 +0200440 ' if g:cond',
441 ' return 1',
442 ' else',
443 ' echo "no return"',
Bram Moolenaar2984ed32022-08-20 14:51:17 +0100444 ' endif',
Bram Moolenaarefd88552020-06-18 20:50:10 +0200445 'enddef'], 'E1027:')
Bram Moolenaar62aec932022-01-29 21:45:34 +0000446 v9.CheckDefFailure(['def Missing(): number',
Bram Moolenaarefd88552020-06-18 20:50:10 +0200447 ' if g:cond',
448 ' return 1',
449 ' else',
450 ' return 2',
Bram Moolenaar2984ed32022-08-20 14:51:17 +0100451 ' endif',
452 ' return 3',
Bram Moolenaarefd88552020-06-18 20:50:10 +0200453 'enddef'], 'E1095:')
454enddef
455
Bram Moolenaar403dc312020-10-17 19:29:51 +0200456def Test_return_bool()
457 var lines =<< trim END
458 vim9script
459 def MenuFilter(id: number, key: string): bool
460 return popup_filter_menu(id, key)
461 enddef
462 def YesnoFilter(id: number, key: string): bool
463 return popup_filter_yesno(id, key)
464 enddef
465 defcompile
466 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000467 v9.CheckScriptSuccess(lines)
Bram Moolenaar403dc312020-10-17 19:29:51 +0200468enddef
469
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200470let s:nothing = 0
471def ReturnNothing()
472 s:nothing = 1
473 if true
474 return
475 endif
476 s:nothing = 2
477enddef
478
479def Test_return_nothing()
Bram Moolenaar62aec932022-01-29 21:45:34 +0000480 g:ReturnNothing()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200481 s:nothing->assert_equal(1)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200482enddef
483
Bram Moolenaar648ea762021-01-15 19:04:32 +0100484def Test_return_invalid()
485 var lines =<< trim END
486 vim9script
487 def Func(): invalid
488 return xxx
489 enddef
490 defcompile
491 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000492 v9.CheckScriptFailure(lines, 'E1010:', 2)
Bram Moolenaar31842cd2021-02-12 22:10:21 +0100493
494 lines =<< trim END
495 vim9script
496 def Test(Fun: func(number): number): list<number>
497 return map([1, 2, 3], (_, i) => Fun(i))
498 enddef
499 defcompile
500 def Inc(nr: number): nr
501 return nr + 2
502 enddef
503 echo Test(Inc)
504 END
505 # doing this twice was leaking memory
Bram Moolenaar62aec932022-01-29 21:45:34 +0000506 v9.CheckScriptFailure(lines, 'E1010:')
507 v9.CheckScriptFailure(lines, 'E1010:')
Bram Moolenaar648ea762021-01-15 19:04:32 +0100508enddef
509
Bram Moolenaarefc084e2021-09-09 22:30:52 +0200510def Test_return_list_any()
Bram Moolenaar114dbda2022-01-03 12:28:03 +0000511 # This used to fail but now the actual list type is checked, and since it has
512 # an item of type string it can be used as list<string>.
Bram Moolenaarefc084e2021-09-09 22:30:52 +0200513 var lines =<< trim END
514 vim9script
515 def Func(): list<string>
516 var l: list<any>
517 l->add('string')
518 return l
519 enddef
520 echo Func()
521 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000522 v9.CheckScriptSuccess(lines)
Bram Moolenaar114dbda2022-01-03 12:28:03 +0000523
Bram Moolenaarefc084e2021-09-09 22:30:52 +0200524 lines =<< trim END
525 vim9script
526 def Func(): list<string>
527 var l: list<any>
528 l += ['string']
529 return l
530 enddef
531 echo Func()
532 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000533 v9.CheckScriptSuccess(lines)
Bram Moolenaarefc084e2021-09-09 22:30:52 +0200534enddef
535
Bram Moolenaar1a572e92022-03-15 12:28:10 +0000536def Test_return_any_two_types()
537 var lines =<< trim END
538 vim9script
539
540 def G(Fn: func(string): any)
541 g:result = Fn("hello")
542 enddef
543
544 def F(a: number, b: string): any
545 echo b
546 if a > 0
547 return 1
548 else
549 return []
550 endif
551 enddef
552
553 G(function(F, [1]))
554 END
555 v9.CheckScriptSuccess(lines)
556 assert_equal(1, g:result)
557 unlet g:result
558enddef
559
Bram Moolenaar62aec932022-01-29 21:45:34 +0000560func s:Increment()
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200561 let g:counter += 1
562endfunc
563
564def Test_call_ufunc_count()
565 g:counter = 1
566 Increment()
567 Increment()
568 Increment()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200569 # works with and without :call
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200570 g:counter->assert_equal(4)
571 eval g:counter->assert_equal(4)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200572 unlet g:counter
573enddef
574
Bram Moolenaar1983f1a2022-02-28 20:55:02 +0000575def Test_call_ufunc_failure()
576 var lines =<< trim END
577 vim9script
578 def Tryit()
579 g:Global(1, 2, 3)
580 enddef
581
582 func g:Global(a, b, c)
583 echo a:a a:b a:c
584 endfunc
585
586 defcompile
587
588 func! g:Global(a, b)
589 echo a:a a:b
590 endfunc
591 Tryit()
592 END
593 v9.CheckScriptFailure(lines, 'E118: Too many arguments for function: Global')
594 delfunc g:Global
595
596 lines =<< trim END
597 vim9script
598
599 g:Ref = function('len')
600 def Tryit()
601 g:Ref('x')
602 enddef
603
604 defcompile
605
606 g:Ref = function('add')
607 Tryit()
608 END
609 v9.CheckScriptFailure(lines, 'E119: Not enough arguments for function: add')
610 unlet g:Ref
611enddef
612
Bram Moolenaar62aec932022-01-29 21:45:34 +0000613def s:MyVarargs(arg: string, ...rest: list<string>): string
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200614 var res = arg
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200615 for s in rest
616 res ..= ',' .. s
617 endfor
618 return res
619enddef
620
621def Test_call_varargs()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200622 MyVarargs('one')->assert_equal('one')
623 MyVarargs('one', 'two')->assert_equal('one,two')
624 MyVarargs('one', 'two', 'three')->assert_equal('one,two,three')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200625enddef
626
Bram Moolenaar01dd6c32021-09-05 16:36:23 +0200627def Test_call_white_space()
Bram Moolenaar62aec932022-01-29 21:45:34 +0000628 v9.CheckDefAndScriptFailure(["call Test ('text')"], ['E476:', 'E1068:'])
Bram Moolenaar01dd6c32021-09-05 16:36:23 +0200629enddef
630
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200631def MyDefaultArgs(name = 'string'): string
632 return name
633enddef
634
Bram Moolenaar62aec932022-01-29 21:45:34 +0000635def s:MyDefaultSecond(name: string, second: bool = true): string
Bram Moolenaare30f64b2020-07-15 19:48:20 +0200636 return second ? name : 'none'
637enddef
638
Bram Moolenaar38a3bfa2021-03-29 22:14:55 +0200639
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200640def Test_call_default_args()
Bram Moolenaar62aec932022-01-29 21:45:34 +0000641 g:MyDefaultArgs()->assert_equal('string')
642 g:MyDefaultArgs(v:none)->assert_equal('string')
643 g:MyDefaultArgs('one')->assert_equal('one')
644 assert_fails('g:MyDefaultArgs("one", "two")', 'E118:', '', 4, 'Test_call_default_args')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200645
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200646 MyDefaultSecond('test')->assert_equal('test')
647 MyDefaultSecond('test', true)->assert_equal('test')
648 MyDefaultSecond('test', false)->assert_equal('none')
Bram Moolenaare30f64b2020-07-15 19:48:20 +0200649
Bram Moolenaar38a3bfa2021-03-29 22:14:55 +0200650 var lines =<< trim END
651 def MyDefaultThird(name: string, aa = 'aa', bb = 'bb'): string
652 return name .. aa .. bb
653 enddef
654
655 MyDefaultThird('->')->assert_equal('->aabb')
656 MyDefaultThird('->', v:none)->assert_equal('->aabb')
657 MyDefaultThird('->', 'xx')->assert_equal('->xxbb')
658 MyDefaultThird('->', v:none, v:none)->assert_equal('->aabb')
659 MyDefaultThird('->', 'xx', v:none)->assert_equal('->xxbb')
660 MyDefaultThird('->', v:none, 'yy')->assert_equal('->aayy')
661 MyDefaultThird('->', 'xx', 'yy')->assert_equal('->xxyy')
Bram Moolenaare28d9b32021-07-03 18:56:53 +0200662
663 def DefArg(mandatory: any, optional = mandatory): string
664 return mandatory .. optional
665 enddef
666 DefArg(1234)->assert_equal('12341234')
667 DefArg("ok")->assert_equal('okok')
Bram Moolenaar38a3bfa2021-03-29 22:14:55 +0200668 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000669 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar38a3bfa2021-03-29 22:14:55 +0200670
Bram Moolenaar62aec932022-01-29 21:45:34 +0000671 v9.CheckScriptFailure(['def Func(arg: number = asdf)', 'enddef', 'defcompile'], 'E1001:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +0100672 delfunc g:Func
Bram Moolenaar62aec932022-01-29 21:45:34 +0000673 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 +0100674 delfunc g:Func
Bram Moolenaar62aec932022-01-29 21:45:34 +0000675 v9.CheckDefFailure(['def Func(x: number = )', 'enddef'], 'E15:')
Bram Moolenaar12bce952021-03-11 20:04:04 +0100676
Bram Moolenaar38a3bfa2021-03-29 22:14:55 +0200677 lines =<< trim END
Bram Moolenaar12bce952021-03-11 20:04:04 +0100678 vim9script
679 def Func(a = b == 0 ? 1 : 2, b = 0)
680 enddef
681 defcompile
682 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000683 v9.CheckScriptFailure(lines, 'E1001: Variable not found: b')
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000684
Bram Moolenaarfa46ead2021-12-22 13:18:39 +0000685 # using script variable requires matching type or type cast when executed
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000686 lines =<< trim END
687 vim9script
688 var a: any
689 def Func(arg: string = a)
690 echo arg
691 enddef
692 defcompile
693 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000694 v9.CheckScriptSuccess(lines + ['a = "text"', 'Func()'])
695 v9.CheckScriptFailure(lines + ['a = 123', 'Func()'], 'E1013: Argument 1: type mismatch, expected string but got number')
Bram Moolenaar59618fe2021-12-21 12:32:17 +0000696
697 # using global variable does not require type cast
698 lines =<< trim END
699 vim9script
700 def Func(arg: string = g:str)
701 echo arg
702 enddef
703 g:str = 'works'
704 Func()
705 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000706 v9.CheckScriptSuccess(lines)
Bram Moolenaar04b12692020-05-04 23:24:44 +0200707enddef
708
Bram Moolenaar62aec932022-01-29 21:45:34 +0000709def s:FuncWithComment( # comment
Bram Moolenaarcef12702021-01-04 14:09:43 +0100710 a: number, #comment
711 b: bool, # comment
712 c: string) #comment
713 assert_equal(4, a)
714 assert_equal(true, b)
715 assert_equal('yes', c)
716enddef
717
718def Test_func_with_comments()
719 FuncWithComment(4, true, 'yes')
720
721 var lines =<< trim END
722 def Func(# comment
723 arg: string)
724 enddef
725 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000726 v9.CheckScriptFailure(lines, 'E125:', 1)
Bram Moolenaarcef12702021-01-04 14:09:43 +0100727
728 lines =<< trim END
729 def Func(
730 arg: string# comment
731 )
732 enddef
733 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000734 v9.CheckScriptFailure(lines, 'E475:', 2)
Bram Moolenaarcef12702021-01-04 14:09:43 +0100735
736 lines =<< trim END
737 def Func(
738 arg: string
739 )# comment
740 enddef
741 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000742 v9.CheckScriptFailure(lines, 'E488:', 3)
Bram Moolenaarcef12702021-01-04 14:09:43 +0100743enddef
744
Bram Moolenaar04b12692020-05-04 23:24:44 +0200745def Test_nested_function()
Bram Moolenaar38453522021-11-28 22:00:12 +0000746 def NestedDef(arg: string): string
Bram Moolenaar04b12692020-05-04 23:24:44 +0200747 return 'nested ' .. arg
748 enddef
Bram Moolenaar38453522021-11-28 22:00:12 +0000749 NestedDef(':def')->assert_equal('nested :def')
750
751 func NestedFunc(arg)
752 return 'nested ' .. a:arg
753 endfunc
754 NestedFunc(':func')->assert_equal('nested :func')
Bram Moolenaar04b12692020-05-04 23:24:44 +0200755
Bram Moolenaar62aec932022-01-29 21:45:34 +0000756 v9.CheckDefFailure(['def Nested()', 'enddef', 'Nested(66)'], 'E118:')
757 v9.CheckDefFailure(['def Nested(arg: string)', 'enddef', 'Nested()'], 'E119:')
Bram Moolenaar0e65d3d2020-05-05 17:53:16 +0200758
Bram Moolenaar62aec932022-01-29 21:45:34 +0000759 v9.CheckDefFailure(['def s:Nested()', 'enddef'], 'E1075:')
760 v9.CheckDefFailure(['def b:Nested()', 'enddef'], 'E1075:')
Bram Moolenaar8b848ca2020-09-10 22:28:01 +0200761
Bram Moolenaar54021752020-12-06 18:50:36 +0100762 var lines =<< trim END
763 def Outer()
764 def Inner()
765 # comment
766 enddef
767 def Inner()
768 enddef
769 enddef
770 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000771 v9.CheckDefFailure(lines, 'E1073:')
Bram Moolenaar54021752020-12-06 18:50:36 +0100772
773 lines =<< trim END
774 def Outer()
775 def Inner()
776 # comment
777 enddef
778 def! Inner()
779 enddef
780 enddef
781 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000782 v9.CheckDefFailure(lines, 'E1117:')
Bram Moolenaar54021752020-12-06 18:50:36 +0100783
Bram Moolenaardb8e5c22021-12-25 19:58:22 +0000784 lines =<< trim END
785 vim9script
786 def Outer()
787 def Inner()
788 g:result = 'ok'
789 enddef
790 Inner()
791 enddef
792 Outer()
793 Inner()
794 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000795 v9.CheckScriptFailure(lines, 'E117: Unknown function: Inner')
Bram Moolenaardb8e5c22021-12-25 19:58:22 +0000796 assert_equal('ok', g:result)
797 unlet g:result
798
Bram Moolenaarf681cfb2022-02-07 20:30:57 +0000799 lines =<< trim END
800 vim9script
801 def Outer()
802 def _Inner()
803 echo 'bad'
804 enddef
Bram Moolenaar3787f262022-02-07 21:54:01 +0000805 _Inner()
Bram Moolenaarf681cfb2022-02-07 20:30:57 +0000806 enddef
807 defcompile
808 END
Bram Moolenaar3787f262022-02-07 21:54:01 +0000809 v9.CheckScriptFailure(lines, 'E1267:')
Bram Moolenaarf681cfb2022-02-07 20:30:57 +0000810
811 lines =<< trim END
812 vim9script
813 def Outer()
814 def g:inner()
815 echo 'bad'
816 enddef
Bram Moolenaar3787f262022-02-07 21:54:01 +0000817 g:inner()
Bram Moolenaarf681cfb2022-02-07 20:30:57 +0000818 enddef
819 defcompile
820 END
Bram Moolenaar3787f262022-02-07 21:54:01 +0000821 v9.CheckScriptFailure(lines, 'E1267:')
822
823 lines =<< trim END
824 vim9script
825 def g:_Func()
826 echo 'bad'
827 enddef
828 END
829 v9.CheckScriptFailure(lines, 'E1267:')
830
831 lines =<< trim END
832 vim9script
Bram Moolenaara749a422022-02-12 19:52:25 +0000833 def _Func()
Bram Moolenaar3787f262022-02-07 21:54:01 +0000834 echo 'bad'
835 enddef
836 END
837 v9.CheckScriptFailure(lines, 'E1267:')
Bram Moolenaarf681cfb2022-02-07 20:30:57 +0000838
Bram Moolenaar54021752020-12-06 18:50:36 +0100839 # nested function inside conditional
Bram Moolenaar54021752020-12-06 18:50:36 +0100840 lines =<< trim END
841 vim9script
842 var thecount = 0
843 if true
844 def Test(): number
845 def TheFunc(): number
846 thecount += 1
847 return thecount
848 enddef
849 return TheFunc()
850 enddef
851 endif
852 defcompile
853 assert_equal(1, Test())
854 assert_equal(2, Test())
855 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000856 v9.CheckScriptSuccess(lines)
Bram Moolenaar8863bda2021-03-17 18:42:08 +0100857
858 # also works when "thecount" is inside the "if" block
859 lines =<< trim END
860 vim9script
861 if true
862 var thecount = 0
863 def Test(): number
864 def TheFunc(): number
865 thecount += 1
866 return thecount
867 enddef
868 return TheFunc()
869 enddef
870 endif
871 defcompile
872 assert_equal(1, Test())
873 assert_equal(2, Test())
874 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000875 v9.CheckScriptSuccess(lines)
Bram Moolenaar4bba16d2021-08-15 19:28:05 +0200876
Bram Moolenaara915fa02022-03-23 11:29:15 +0000877 # nested function with recursive call
878 lines =<< trim END
879 vim9script
880
881 def MyFunc(): number
882 def Fib(n: number): number
883 if n < 2
884 return 1
885 endif
886 return Fib(n - 2) + Fib(n - 1)
887 enddef
888
889 return Fib(5)
890 enddef
891
892 assert_equal(8, MyFunc())
893 END
894 v9.CheckScriptSuccess(lines)
895
Bram Moolenaar4bba16d2021-08-15 19:28:05 +0200896 lines =<< trim END
897 vim9script
898 def Outer()
899 def Inner()
900 echo 'hello'
901 enddef burp
902 enddef
903 defcompile
904 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000905 v9.CheckScriptFailure(lines, 'E1173: Text found after enddef: burp', 3)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200906enddef
907
Bram Moolenaar1889f492022-08-16 19:34:44 +0100908def Test_nested_function_fails()
909 var lines =<< trim END
910 def T()
911 def Func(g: string):string
912 enddef
913 Func()
914 enddef
915 silent! defcompile
916 END
917 v9.CheckScriptFailure(lines, 'E1069:')
918enddef
919
Bram Moolenaaradc8e442020-12-31 18:28:18 +0100920def Test_not_nested_function()
921 echo printf('%d',
922 function('len')('xxx'))
923enddef
924
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200925func Test_call_default_args_from_func()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200926 call MyDefaultArgs()->assert_equal('string')
927 call MyDefaultArgs('one')->assert_equal('one')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +0200928 call assert_fails('call MyDefaultArgs("one", "two")', 'E118:', '', 3, 'Test_call_default_args_from_func')
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200929endfunc
930
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200931def Test_nested_global_function()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200932 var lines =<< trim END
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200933 vim9script
934 def Outer()
935 def g:Inner(): string
936 return 'inner'
937 enddef
938 enddef
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200939 defcompile
940 Outer()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200941 g:Inner()->assert_equal('inner')
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200942 delfunc g:Inner
943 Outer()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200944 g:Inner()->assert_equal('inner')
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200945 delfunc g:Inner
946 Outer()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200947 g:Inner()->assert_equal('inner')
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200948 delfunc g:Inner
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200949 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000950 v9.CheckScriptSuccess(lines)
Bram Moolenaar2c79e9d2020-08-01 18:57:52 +0200951
952 lines =<< trim END
953 vim9script
954 def Outer()
Bram Moolenaar38453522021-11-28 22:00:12 +0000955 func g:Inner()
956 return 'inner'
957 endfunc
958 enddef
959 defcompile
960 Outer()
961 g:Inner()->assert_equal('inner')
962 delfunc g:Inner
963 Outer()
964 g:Inner()->assert_equal('inner')
965 delfunc g:Inner
966 Outer()
967 g:Inner()->assert_equal('inner')
968 delfunc g:Inner
969 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000970 v9.CheckScriptSuccess(lines)
Bram Moolenaar38453522021-11-28 22:00:12 +0000971
972 lines =<< trim END
973 vim9script
974 def Outer()
Bram Moolenaar2c79e9d2020-08-01 18:57:52 +0200975 def g:Inner(): string
976 return 'inner'
977 enddef
978 enddef
979 defcompile
980 Outer()
981 Outer()
982 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000983 v9.CheckScriptFailure(lines, "E122:")
Bram Moolenaarcd45ed02020-12-22 17:35:54 +0100984 delfunc g:Inner
Bram Moolenaarad486a02020-08-01 23:22:18 +0200985
986 lines =<< trim END
987 vim9script
Bram Moolenaar58a52f22020-12-22 18:56:55 +0100988 def Outer()
989 def g:Inner()
Bram Moolenaar2949cfd2020-12-31 21:28:47 +0100990 echo map([1, 2, 3], (_, v) => v + 1)
Bram Moolenaar58a52f22020-12-22 18:56:55 +0100991 enddef
992 g:Inner()
993 enddef
994 Outer()
995 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000996 v9.CheckScriptSuccess(lines)
Bram Moolenaar58a52f22020-12-22 18:56:55 +0100997 delfunc g:Inner
998
999 lines =<< trim END
1000 vim9script
Bram Moolenaarad486a02020-08-01 23:22:18 +02001001 def Func()
1002 echo 'script'
1003 enddef
1004 def Outer()
1005 def Func()
1006 echo 'inner'
1007 enddef
1008 enddef
1009 defcompile
1010 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001011 v9.CheckScriptFailure(lines, "E1073:", 1)
Bram Moolenaard604d782021-11-20 21:46:20 +00001012
1013 lines =<< trim END
1014 vim9script
1015 def Func()
1016 echo 'script'
1017 enddef
1018 def Func()
1019 echo 'script'
1020 enddef
1021 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001022 v9.CheckScriptFailure(lines, "E1073:", 5)
Bram Moolenaar38ddf332020-07-31 22:05:04 +02001023enddef
1024
Bram Moolenaar6abdcf82020-11-22 18:15:44 +01001025def DefListAll()
1026 def
1027enddef
1028
1029def DefListOne()
1030 def DefListOne
1031enddef
1032
1033def DefListMatches()
1034 def /DefList
1035enddef
1036
1037def Test_nested_def_list()
1038 var funcs = split(execute('call DefListAll()'), "\n")
1039 assert_true(len(funcs) > 10)
1040 assert_true(funcs->index('def DefListAll()') >= 0)
1041
1042 funcs = split(execute('call DefListOne()'), "\n")
1043 assert_equal([' def DefListOne()', '1 def DefListOne', ' enddef'], funcs)
1044
1045 funcs = split(execute('call DefListMatches()'), "\n")
1046 assert_true(len(funcs) >= 3)
1047 assert_true(funcs->index('def DefListAll()') >= 0)
1048 assert_true(funcs->index('def DefListOne()') >= 0)
1049 assert_true(funcs->index('def DefListMatches()') >= 0)
Bram Moolenaar54021752020-12-06 18:50:36 +01001050
1051 var lines =<< trim END
1052 vim9script
1053 def Func()
1054 def +Func+
1055 enddef
1056 defcompile
1057 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001058 v9.CheckScriptFailure(lines, 'E476:', 1)
Bram Moolenaar6abdcf82020-11-22 18:15:44 +01001059enddef
1060
Bram Moolenaare08be092022-02-17 13:08:26 +00001061def Test_global_function_not_found()
1062 var lines =<< trim END
1063 g:Ref = 123
1064 call g:Ref()
1065 END
1066 v9.CheckDefExecAndScriptFailure(lines, ['E117:', 'E1085:'], 2)
1067enddef
1068
Bram Moolenaar333894b2020-08-01 18:53:07 +02001069def Test_global_local_function()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001070 var lines =<< trim END
Bram Moolenaar333894b2020-08-01 18:53:07 +02001071 vim9script
1072 def g:Func(): string
1073 return 'global'
1074 enddef
1075 def Func(): string
1076 return 'local'
1077 enddef
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001078 g:Func()->assert_equal('global')
1079 Func()->assert_equal('local')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001080 delfunc g:Func
Bram Moolenaar333894b2020-08-01 18:53:07 +02001081 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001082 v9.CheckScriptSuccess(lines)
Bram Moolenaar035d6e92020-08-11 22:30:42 +02001083
1084 lines =<< trim END
1085 vim9script
1086 def g:Funcy()
1087 echo 'funcy'
1088 enddef
Bram Moolenaara749a422022-02-12 19:52:25 +00001089 Funcy()
Bram Moolenaar035d6e92020-08-11 22:30:42 +02001090 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001091 v9.CheckScriptFailure(lines, 'E117:')
Bram Moolenaar333894b2020-08-01 18:53:07 +02001092enddef
1093
Bram Moolenaar0f769812020-09-12 18:32:34 +02001094def Test_local_function_shadows_global()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001095 var lines =<< trim END
Bram Moolenaar0f769812020-09-12 18:32:34 +02001096 vim9script
1097 def g:Gfunc(): string
1098 return 'global'
1099 enddef
1100 def AnotherFunc(): number
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001101 var Gfunc = function('len')
Bram Moolenaar0f769812020-09-12 18:32:34 +02001102 return Gfunc('testing')
1103 enddef
1104 g:Gfunc()->assert_equal('global')
1105 AnotherFunc()->assert_equal(7)
1106 delfunc g:Gfunc
1107 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001108 v9.CheckScriptSuccess(lines)
Bram Moolenaar0f769812020-09-12 18:32:34 +02001109
1110 lines =<< trim END
1111 vim9script
1112 def g:Func(): string
1113 return 'global'
1114 enddef
1115 def AnotherFunc()
1116 g:Func = function('len')
1117 enddef
1118 AnotherFunc()
1119 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001120 v9.CheckScriptFailure(lines, 'E705:')
Bram Moolenaar0f769812020-09-12 18:32:34 +02001121 delfunc g:Func
Bram Moolenaar0865b152021-04-05 15:38:51 +02001122
Bram Moolenaar62aec932022-01-29 21:45:34 +00001123 # global function is not found with g: prefix
Bram Moolenaar0865b152021-04-05 15:38:51 +02001124 lines =<< trim END
1125 vim9script
1126 def g:Func(): string
1127 return 'global'
1128 enddef
1129 def AnotherFunc(): string
1130 return Func()
1131 enddef
1132 assert_equal('global', AnotherFunc())
Bram Moolenaar0865b152021-04-05 15:38:51 +02001133 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001134 v9.CheckScriptFailure(lines, 'E117:')
1135 delfunc g:Func
Bram Moolenaar0865b152021-04-05 15:38:51 +02001136
1137 lines =<< trim END
1138 vim9script
1139 def g:Func(): string
1140 return 'global'
1141 enddef
Bram Moolenaar848fadd2022-01-30 15:28:30 +00001142 assert_equal('global', g:Func())
Bram Moolenaar0865b152021-04-05 15:38:51 +02001143 delfunc g:Func
1144 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001145 v9.CheckScriptSuccess(lines)
Bram Moolenaar58493cf2022-01-06 12:23:30 +00001146
1147 # This does not shadow "i" which is visible only inside the for loop
1148 lines =<< trim END
1149 vim9script
1150
1151 def Foo(i: number)
1152 echo i
1153 enddef
1154
1155 for i in range(3)
1156 # Foo() is compiled here
1157 Foo(i)
1158 endfor
1159 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001160 v9.CheckScriptSuccess(lines)
Bram Moolenaar0f769812020-09-12 18:32:34 +02001161enddef
1162
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001163func TakesOneArg(arg)
1164 echo a:arg
1165endfunc
1166
1167def Test_call_wrong_args()
Bram Moolenaar62aec932022-01-29 21:45:34 +00001168 v9.CheckDefFailure(['g:TakesOneArg()'], 'E119:')
1169 v9.CheckDefFailure(['g:TakesOneArg(11, 22)'], 'E118:')
1170 v9.CheckDefFailure(['bufnr(xxx)'], 'E1001:')
1171 v9.CheckScriptFailure(['def Func(Ref: func(s: string))'], 'E475:')
Bram Moolenaaree8580e2020-08-28 17:19:07 +02001172
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001173 var lines =<< trim END
Bram Moolenaaree8580e2020-08-28 17:19:07 +02001174 vim9script
1175 def Func(s: string)
1176 echo s
1177 enddef
1178 Func([])
1179 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001180 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected string but got list<unknown>', 5)
Bram Moolenaarb185a402020-09-18 22:42:00 +02001181
Bram Moolenaar9a015112021-12-31 14:06:45 +00001182 # argument name declared earlier is found when declaring a function
Bram Moolenaarb185a402020-09-18 22:42:00 +02001183 lines =<< trim END
1184 vim9script
Bram Moolenaarb4893b82021-02-21 22:20:24 +01001185 var name = 'piet'
1186 def FuncOne(name: string)
Bram Moolenaar3a5988c2022-02-08 19:23:35 +00001187 echo name
Bram Moolenaarb4893b82021-02-21 22:20:24 +01001188 enddef
1189 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001190 v9.CheckScriptFailure(lines, 'E1168:')
Bram Moolenaarb4893b82021-02-21 22:20:24 +01001191
Bram Moolenaar3a5988c2022-02-08 19:23:35 +00001192 # same, inside the same block
1193 lines =<< trim END
1194 vim9script
1195 if true
1196 var name = 'piet'
1197 def FuncOne(name: string)
1198 echo name
1199 enddef
1200 endif
1201 END
1202 v9.CheckScriptFailure(lines, 'E1168:')
1203
1204 # variable in other block is OK
1205 lines =<< trim END
1206 vim9script
1207 if true
1208 var name = 'piet'
1209 endif
1210 def FuncOne(name: string)
1211 echo name
1212 enddef
1213 END
1214 v9.CheckScriptSuccess(lines)
1215
Bram Moolenaardce24412022-02-08 20:35:30 +00001216 # with another variable in another block
1217 lines =<< trim END
1218 vim9script
1219 if true
1220 var name = 'piet'
1221 # define a function so that the variable isn't cleared
1222 def GetItem(): string
1223 return item
1224 enddef
1225 endif
1226 if true
1227 var name = 'peter'
1228 def FuncOne(name: string)
1229 echo name
1230 enddef
1231 endif
1232 END
1233 v9.CheckScriptFailure(lines, 'E1168:')
1234
1235 # only variable in another block is OK
1236 lines =<< trim END
1237 vim9script
1238 if true
1239 var name = 'piet'
1240 # define a function so that the variable isn't cleared
1241 def GetItem(): string
1242 return item
1243 enddef
1244 endif
1245 if true
1246 def FuncOne(name: string)
1247 echo name
1248 enddef
1249 endif
1250 END
1251 v9.CheckScriptSuccess(lines)
1252
Bram Moolenaar9a015112021-12-31 14:06:45 +00001253 # argument name declared later is only found when compiling
1254 lines =<< trim END
1255 vim9script
1256 def FuncOne(name: string)
1257 echo nr
1258 enddef
1259 var name = 'piet'
1260 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001261 v9.CheckScriptSuccess(lines)
1262 v9.CheckScriptFailure(lines + ['defcompile'], 'E1168:')
Bram Moolenaar9a015112021-12-31 14:06:45 +00001263
Bram Moolenaarb4893b82021-02-21 22:20:24 +01001264 lines =<< trim END
1265 vim9script
Bram Moolenaarb185a402020-09-18 22:42:00 +02001266 def FuncOne(nr: number)
1267 echo nr
1268 enddef
1269 def FuncTwo()
1270 FuncOne()
1271 enddef
1272 defcompile
1273 END
1274 writefile(lines, 'Xscript')
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001275 var didCatch = false
Bram Moolenaarb185a402020-09-18 22:42:00 +02001276 try
1277 source Xscript
1278 catch
1279 assert_match('E119: Not enough arguments for function: <SNR>\d\+_FuncOne', v:exception)
1280 assert_match('Xscript\[8\]..function <SNR>\d\+_FuncTwo, line 1', v:throwpoint)
1281 didCatch = true
1282 endtry
1283 assert_true(didCatch)
1284
1285 lines =<< trim END
1286 vim9script
1287 def FuncOne(nr: number)
1288 echo nr
1289 enddef
1290 def FuncTwo()
1291 FuncOne(1, 2)
1292 enddef
1293 defcompile
1294 END
Bram Moolenaarf5fec052022-09-11 11:49:22 +01001295 writefile(lines, 'Xscript', 'D')
Bram Moolenaarb185a402020-09-18 22:42:00 +02001296 didCatch = false
1297 try
1298 source Xscript
1299 catch
1300 assert_match('E118: Too many arguments for function: <SNR>\d\+_FuncOne', v:exception)
1301 assert_match('Xscript\[8\]..function <SNR>\d\+_FuncTwo, line 1', v:throwpoint)
1302 didCatch = true
1303 endtry
1304 assert_true(didCatch)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001305enddef
1306
Bram Moolenaar50824712020-12-20 21:10:17 +01001307def Test_call_funcref_wrong_args()
1308 var head =<< trim END
1309 vim9script
1310 def Func3(a1: string, a2: number, a3: list<number>)
1311 echo a1 .. a2 .. a3[0]
1312 enddef
1313 def Testme()
1314 var funcMap: dict<func> = {func: Func3}
1315 END
1316 var tail =<< trim END
1317 enddef
1318 Testme()
1319 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001320 v9.CheckScriptSuccess(head + ["funcMap['func']('str', 123, [1, 2, 3])"] + tail)
Bram Moolenaar50824712020-12-20 21:10:17 +01001321
Bram Moolenaar62aec932022-01-29 21:45:34 +00001322 v9.CheckScriptFailure(head + ["funcMap['func']('str', 123)"] + tail, 'E119:')
1323 v9.CheckScriptFailure(head + ["funcMap['func']('str', 123, [1], 4)"] + tail, 'E118:')
Bram Moolenaar32b3f822021-01-06 21:59:39 +01001324
1325 var lines =<< trim END
1326 vim9script
1327 var Ref: func(number): any
1328 Ref = (j) => !j
1329 echo Ref(false)
1330 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001331 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected number but got bool', 4)
Bram Moolenaar32b3f822021-01-06 21:59:39 +01001332
1333 lines =<< trim END
1334 vim9script
1335 var Ref: func(number): any
1336 Ref = (j) => !j
1337 call Ref(false)
1338 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001339 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected number but got bool', 4)
Bram Moolenaar50824712020-12-20 21:10:17 +01001340enddef
1341
Bram Moolenaarb4d16cb2020-11-05 18:45:46 +01001342def Test_call_lambda_args()
Bram Moolenaar2a389082021-04-09 20:24:31 +02001343 var lines =<< trim END
1344 var Callback = (..._) => 'anything'
1345 assert_equal('anything', Callback())
1346 assert_equal('anything', Callback(1))
1347 assert_equal('anything', Callback('a', 2))
Bram Moolenaar1088b692021-04-09 22:12:44 +02001348
1349 assert_equal('xyz', ((a: string): string => a)('xyz'))
Bram Moolenaar2a389082021-04-09 20:24:31 +02001350 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001351 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar2a389082021-04-09 20:24:31 +02001352
Bram Moolenaar62aec932022-01-29 21:45:34 +00001353 v9.CheckDefFailure(['echo ((i) => 0)()'],
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001354 'E119: Not enough arguments for function: ((i) => 0)()')
Bram Moolenaarb4d16cb2020-11-05 18:45:46 +01001355
Bram Moolenaar2a389082021-04-09 20:24:31 +02001356 lines =<< trim END
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001357 var Ref = (x: number, y: number) => x + y
Bram Moolenaarb4d16cb2020-11-05 18:45:46 +01001358 echo Ref(1, 'x')
1359 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001360 v9.CheckDefFailure(lines, 'E1013: Argument 2: type mismatch, expected number but got string')
Bram Moolenaare68b02a2021-01-03 13:09:51 +01001361
1362 lines =<< trim END
1363 var Ref: func(job, string, number)
1364 Ref = (x, y) => 0
1365 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001366 v9.CheckDefAndScriptFailure(lines, 'E1012:')
Bram Moolenaare68b02a2021-01-03 13:09:51 +01001367
1368 lines =<< trim END
1369 var Ref: func(job, string)
1370 Ref = (x, y, z) => 0
1371 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001372 v9.CheckDefAndScriptFailure(lines, 'E1012:')
Bram Moolenaar057e84a2021-02-28 16:55:11 +01001373
1374 lines =<< trim END
1375 var one = 1
1376 var l = [1, 2, 3]
1377 echo map(l, (one) => one)
1378 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001379 v9.CheckDefFailure(lines, 'E1167:')
1380 v9.CheckScriptFailure(['vim9script'] + lines, 'E1168:')
Bram Moolenaar057e84a2021-02-28 16:55:11 +01001381
1382 lines =<< trim END
Bram Moolenaar14ded112021-06-26 19:25:49 +02001383 var Ref: func(any, ?any): bool
1384 Ref = (_, y = 1) => false
1385 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001386 v9.CheckDefAndScriptFailure(lines, 'E1172:')
Bram Moolenaar14ded112021-06-26 19:25:49 +02001387
1388 lines =<< trim END
Bram Moolenaar015cf102021-06-26 21:52:02 +02001389 var a = 0
1390 var b = (a == 0 ? 1 : 2)
1391 assert_equal(1, b)
Bram Moolenaar98f9a5f2021-06-26 22:22:38 +02001392 var txt = 'a'
1393 b = (txt =~ 'x' ? 1 : 2)
1394 assert_equal(2, b)
Bram Moolenaar015cf102021-06-26 21:52:02 +02001395 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001396 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar015cf102021-06-26 21:52:02 +02001397
1398 lines =<< trim END
Bram Moolenaar057e84a2021-02-28 16:55:11 +01001399 def ShadowLocal()
1400 var one = 1
1401 var l = [1, 2, 3]
1402 echo map(l, (one) => one)
1403 enddef
1404 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001405 v9.CheckDefFailure(lines, 'E1167:')
Bram Moolenaar057e84a2021-02-28 16:55:11 +01001406
1407 lines =<< trim END
1408 def Shadowarg(one: number)
1409 var l = [1, 2, 3]
1410 echo map(l, (one) => one)
1411 enddef
1412 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001413 v9.CheckDefFailure(lines, 'E1167:')
Bram Moolenaar767034c2021-04-09 17:24:52 +02001414
1415 lines =<< trim END
1416 echo ((a) => a)('aa', 'bb')
1417 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001418 v9.CheckDefAndScriptFailure(lines, 'E118:', 1)
Bram Moolenaarc4c56422021-07-21 20:38:46 +02001419
1420 lines =<< trim END
1421 echo 'aa'->((a) => a)('bb')
1422 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001423 v9.CheckDefFailure(lines, 'E118: Too many arguments for function: ->((a) => a)(''bb'')', 1)
1424 v9.CheckScriptFailure(['vim9script'] + lines, 'E118: Too many arguments for function: <lambda>', 2)
Bram Moolenaarb4d16cb2020-11-05 18:45:46 +01001425enddef
1426
Bram Moolenaara755fdb2021-11-20 21:35:41 +00001427def Test_lambda_line_nr()
1428 var lines =<< trim END
1429 vim9script
1430 # comment
1431 # comment
1432 var id = timer_start(1'000, (_) => 0)
1433 var out = execute('verbose ' .. timer_info(id)[0].callback
1434 ->string()
1435 ->substitute("('\\|')", ' ', 'g'))
1436 assert_match('Last set from .* line 4', out)
1437 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001438 v9.CheckScriptSuccess(lines)
Bram Moolenaara755fdb2021-11-20 21:35:41 +00001439enddef
1440
Bram Moolenaar5f91e742021-03-17 21:29:29 +01001441def FilterWithCond(x: string, Cond: func(string): bool): bool
1442 return Cond(x)
1443enddef
1444
Bram Moolenaar0346b792021-01-31 22:18:29 +01001445def Test_lambda_return_type()
1446 var lines =<< trim END
1447 var Ref = (): => 123
1448 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001449 v9.CheckDefAndScriptFailure(lines, 'E1157:', 1)
Bram Moolenaar5f91e742021-03-17 21:29:29 +01001450
Yegappan Lakshmanan611728f2021-05-24 15:15:47 +02001451 # no space before the return type
1452 lines =<< trim END
1453 var Ref = (x):number => x + 1
1454 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001455 v9.CheckDefAndScriptFailure(lines, 'E1069:', 1)
Yegappan Lakshmanan611728f2021-05-24 15:15:47 +02001456
Bram Moolenaar5f91e742021-03-17 21:29:29 +01001457 # this works
1458 for x in ['foo', 'boo']
Bram Moolenaar62aec932022-01-29 21:45:34 +00001459 echo g:FilterWithCond(x, (v) => v =~ '^b')
Bram Moolenaar5f91e742021-03-17 21:29:29 +01001460 endfor
1461
1462 # this fails
1463 lines =<< trim END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001464 echo g:FilterWithCond('foo', (v) => v .. '^b')
Bram Moolenaar5f91e742021-03-17 21:29:29 +01001465 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001466 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 +02001467
1468 lines =<< trim END
1469 var Lambda1 = (x) => {
1470 return x
1471 }
1472 assert_equal('asdf', Lambda1('asdf'))
1473 var Lambda2 = (x): string => {
1474 return x
1475 }
1476 assert_equal('foo', Lambda2('foo'))
1477 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001478 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaara9931532021-06-12 15:58:16 +02001479
1480 lines =<< trim END
1481 var Lambda = (x): string => {
1482 return x
1483 }
1484 echo Lambda(['foo'])
1485 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001486 v9.CheckDefExecAndScriptFailure(lines, 'E1012:')
Bram Moolenaar0346b792021-01-31 22:18:29 +01001487enddef
1488
Bram Moolenaar709664c2020-12-12 14:33:41 +01001489def Test_lambda_uses_assigned_var()
Bram Moolenaar62aec932022-01-29 21:45:34 +00001490 v9.CheckDefSuccess([
Bram Moolenaar2984ed32022-08-20 14:51:17 +01001491 'var x: any = "aaa"',
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001492 'x = filter(["bbb"], (_, v) => v =~ x)'])
Bram Moolenaar709664c2020-12-12 14:33:41 +01001493enddef
1494
Bram Moolenaarf5f4e852022-09-22 22:03:14 +01001495def Test_lambda_invalid_block()
1496 var lines =<< trim END
1497 timer_start(0, (_) => { # echo
1498 echo 'yes'
1499 })
1500 END
1501 v9.CheckDefAndScriptSuccess(lines)
1502
1503 lines =<< trim END
1504 timer_start(0, (_) => { " echo
1505 echo 'yes'
1506 })
1507 END
1508 v9.CheckDefAndScriptFailure(lines, 'E488: Trailing characters: " echo')
1509
1510 lines =<< trim END
1511 timer_start(0, (_) => { | echo
1512 echo 'yes'
1513 })
1514 END
1515 v9.CheckDefAndScriptFailure(lines, 'E488: Trailing characters: | echo')
1516enddef
1517
Bram Moolenaar18062fc2021-03-05 21:35:47 +01001518def Test_pass_legacy_lambda_to_def_func()
1519 var lines =<< trim END
1520 vim9script
1521 func Foo()
1522 eval s:Bar({x -> 0})
1523 endfunc
1524 def Bar(y: any)
1525 enddef
1526 Foo()
1527 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001528 v9.CheckScriptSuccess(lines)
Bram Moolenaar831bdf82021-06-22 19:32:17 +02001529
1530 lines =<< trim END
1531 vim9script
Bram Moolenaar1d9cef72022-03-17 16:30:03 +00001532 def g:TestFunc(F: func)
Bram Moolenaar831bdf82021-06-22 19:32:17 +02001533 enddef
1534 legacy call g:TestFunc({-> 0})
1535 delfunc g:TestFunc
1536
Bram Moolenaar1d9cef72022-03-17 16:30:03 +00001537 def g:TestFunc(F: func(number))
Bram Moolenaar831bdf82021-06-22 19:32:17 +02001538 enddef
1539 legacy call g:TestFunc({nr -> 0})
1540 delfunc g:TestFunc
1541 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001542 v9.CheckScriptSuccess(lines)
Bram Moolenaar18062fc2021-03-05 21:35:47 +01001543enddef
1544
Bram Moolenaar844fb642021-10-23 13:32:30 +01001545def Test_lambda_in_reduce_line_break()
1546 # this was using freed memory
1547 var lines =<< trim END
1548 vim9script
1549 const result: dict<number> =
1550 ['Bob', 'Sam', 'Cat', 'Bob', 'Cat', 'Cat']
1551 ->reduce((acc, val) => {
1552 if has_key(acc, val)
1553 acc[val] += 1
1554 return acc
1555 else
1556 acc[val] = 1
1557 return acc
1558 endif
1559 }, {})
1560 assert_equal({Bob: 2, Sam: 1, Cat: 3}, result)
1561 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001562 v9.CheckScriptSuccess(lines)
Bram Moolenaar844fb642021-10-23 13:32:30 +01001563enddef
1564
Bram Moolenaardcb53be2021-12-09 14:23:43 +00001565def Test_set_opfunc_to_lambda()
1566 var lines =<< trim END
1567 vim9script
1568 nnoremap <expr> <F4> <SID>CountSpaces() .. '_'
1569 def CountSpaces(type = ''): string
1570 if type == ''
1571 &operatorfunc = (t) => CountSpaces(t)
1572 return 'g@'
1573 endif
1574 normal! '[V']y
1575 g:result = getreg('"')->count(' ')
1576 return ''
1577 enddef
1578 new
1579 'a b c d e'->setline(1)
1580 feedkeys("\<F4>", 'x')
1581 assert_equal(4, g:result)
1582 bwipe!
1583 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001584 v9.CheckScriptSuccess(lines)
Bram Moolenaardcb53be2021-12-09 14:23:43 +00001585enddef
1586
Bram Moolenaaref082e12021-12-12 21:02:03 +00001587def Test_set_opfunc_to_global_function()
1588 var lines =<< trim END
1589 vim9script
1590 def g:CountSpaces(type = ''): string
1591 normal! '[V']y
1592 g:result = getreg('"')->count(' ')
1593 return ''
1594 enddef
Bram Moolenaarb15cf442021-12-16 15:49:43 +00001595 # global function works at script level
Bram Moolenaaref082e12021-12-12 21:02:03 +00001596 &operatorfunc = g:CountSpaces
1597 new
1598 'a b c d e'->setline(1)
1599 feedkeys("g@_", 'x')
1600 assert_equal(4, g:result)
Bram Moolenaarb15cf442021-12-16 15:49:43 +00001601
1602 &operatorfunc = ''
1603 g:result = 0
1604 # global function works in :def function
1605 def Func()
1606 &operatorfunc = g:CountSpaces
1607 enddef
1608 Func()
1609 feedkeys("g@_", 'x')
1610 assert_equal(4, g:result)
1611
Bram Moolenaaref082e12021-12-12 21:02:03 +00001612 bwipe!
1613 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001614 v9.CheckScriptSuccess(lines)
Bram Moolenaaref082e12021-12-12 21:02:03 +00001615 &operatorfunc = ''
1616enddef
1617
Bram Moolenaar33b968d2021-12-13 11:31:04 +00001618def Test_use_script_func_name_with_prefix()
1619 var lines =<< trim END
1620 vim9script
Bram Moolenaara749a422022-02-12 19:52:25 +00001621 func g:Getit()
Bram Moolenaar33b968d2021-12-13 11:31:04 +00001622 return 'it'
1623 endfunc
Bram Moolenaara749a422022-02-12 19:52:25 +00001624 var Fn = g:Getit
Bram Moolenaar33b968d2021-12-13 11:31:04 +00001625 assert_equal('it', Fn())
1626 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001627 v9.CheckScriptSuccess(lines)
Bram Moolenaar33b968d2021-12-13 11:31:04 +00001628enddef
1629
Bram Moolenaardd297bc2021-12-10 10:37:38 +00001630def Test_lambda_type_allocated()
1631 # Check that unreferencing a partial using a lambda can use the variable type
1632 # after the lambda has been freed and does not leak memory.
1633 var lines =<< trim END
1634 vim9script
1635
1636 func MyomniFunc1(val, findstart, base)
1637 return a:findstart ? 0 : []
1638 endfunc
1639
1640 var Lambda = (a, b) => MyomniFunc1(19, a, b)
1641 &omnifunc = Lambda
1642 Lambda = (a, b) => MyomniFunc1(20, a, b)
1643 &omnifunc = string(Lambda)
1644 Lambda = (a, b) => strlen(a)
1645 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001646 v9.CheckScriptSuccess(lines)
Bram Moolenaardd297bc2021-12-10 10:37:38 +00001647enddef
1648
Bram Moolenaara7583c42022-05-07 21:14:05 +01001649def Test_define_lambda_in_execute()
1650 var lines =<< trim [CODE]
1651 vim9script
1652
1653 def BuildFuncMultiLine(): func
1654 var x =<< trim END
1655 g:SomeRandomFunc = (d: dict<any>) => {
1656 return d.k1 + d.k2
1657 }
1658 END
1659 execute(x)
1660 return g:SomeRandomFunc
1661 enddef
1662 var ResultPlus = BuildFuncMultiLine()
1663 assert_equal(7, ResultPlus({k1: 3, k2: 4}))
1664 [CODE]
1665 v9.CheckScriptSuccess(lines)
1666 unlet g:SomeRandomFunc
1667enddef
1668
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001669" Default arg and varargs
1670def MyDefVarargs(one: string, two = 'foo', ...rest: list<string>): string
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001671 var res = one .. ',' .. two
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001672 for s in rest
1673 res ..= ',' .. s
1674 endfor
1675 return res
1676enddef
1677
1678def Test_call_def_varargs()
Bram Moolenaar62aec932022-01-29 21:45:34 +00001679 assert_fails('g:MyDefVarargs()', 'E119:', '', 1, 'Test_call_def_varargs')
1680 g:MyDefVarargs('one')->assert_equal('one,foo')
1681 g:MyDefVarargs('one', 'two')->assert_equal('one,two')
1682 g:MyDefVarargs('one', 'two', 'three')->assert_equal('one,two,three')
1683 v9.CheckDefFailure(['g:MyDefVarargs("one", 22)'],
Bram Moolenaar77072282020-09-16 17:55:40 +02001684 'E1013: Argument 2: type mismatch, expected string but got number')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001685 v9.CheckDefFailure(['g:MyDefVarargs("one", "two", 123)'],
Bram Moolenaar77072282020-09-16 17:55:40 +02001686 'E1013: Argument 3: type mismatch, expected string but got number')
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001687
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001688 var lines =<< trim END
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001689 vim9script
1690 def Func(...l: list<string>)
1691 echo l
1692 enddef
1693 Func('a', 'b', 'c')
1694 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001695 v9.CheckScriptSuccess(lines)
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001696
1697 lines =<< trim END
1698 vim9script
1699 def Func(...l: list<string>)
1700 echo l
1701 enddef
1702 Func()
1703 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001704 v9.CheckScriptSuccess(lines)
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001705
1706 lines =<< trim END
1707 vim9script
Bram Moolenaar2a389082021-04-09 20:24:31 +02001708 def Func(...l: list<any>)
Bram Moolenaar2f8cbc42020-09-16 17:22:59 +02001709 echo l
1710 enddef
1711 Func(0)
1712 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001713 v9.CheckScriptSuccess(lines)
Bram Moolenaar2f8cbc42020-09-16 17:22:59 +02001714
1715 lines =<< trim END
1716 vim9script
Bram Moolenaar2a389082021-04-09 20:24:31 +02001717 def Func(...l: any)
1718 echo l
1719 enddef
1720 Func(0)
1721 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001722 v9.CheckScriptFailure(lines, 'E1180:', 2)
Bram Moolenaar2a389082021-04-09 20:24:31 +02001723
1724 lines =<< trim END
1725 vim9script
Bram Moolenaar28022722020-09-21 22:02:49 +02001726 def Func(..._l: list<string>)
1727 echo _l
1728 enddef
1729 Func('a', 'b', 'c')
1730 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001731 v9.CheckScriptSuccess(lines)
Bram Moolenaar28022722020-09-21 22:02:49 +02001732
1733 lines =<< trim END
1734 vim9script
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001735 def Func(...l: list<string>)
1736 echo l
1737 enddef
1738 Func(1, 2, 3)
1739 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001740 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch')
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001741
1742 lines =<< trim END
1743 vim9script
1744 def Func(...l: list<string>)
1745 echo l
1746 enddef
1747 Func('a', 9)
1748 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001749 v9.CheckScriptFailure(lines, 'E1013: Argument 2: type mismatch')
Bram Moolenaar24aa48b2020-07-25 16:33:02 +02001750
1751 lines =<< trim END
1752 vim9script
1753 def Func(...l: list<string>)
1754 echo l
1755 enddef
1756 Func(1, 'a')
1757 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001758 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch')
Bram Moolenaar4f53b792021-02-07 15:59:49 +01001759
1760 lines =<< trim END
1761 vim9script
1762 def Func( # some comment
1763 ...l = []
1764 )
1765 echo l
1766 enddef
1767 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001768 v9.CheckScriptFailure(lines, 'E1160:')
Bram Moolenaar6ce46b92021-08-07 15:35:36 +02001769
1770 lines =<< trim END
1771 vim9script
1772 def DoIt()
1773 g:Later('')
1774 enddef
1775 defcompile
1776 def g:Later(...l: list<number>)
1777 enddef
1778 DoIt()
1779 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001780 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected number but got string')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001781enddef
1782
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001783let s:value = ''
1784
1785def FuncOneDefArg(opt = 'text')
1786 s:value = opt
1787enddef
1788
1789def FuncTwoDefArg(nr = 123, opt = 'text'): string
1790 return nr .. opt
1791enddef
1792
1793def FuncVarargs(...arg: list<string>): string
1794 return join(arg, ',')
1795enddef
1796
1797def Test_func_type_varargs()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001798 var RefDefArg: func(?string)
Bram Moolenaar848fadd2022-01-30 15:28:30 +00001799 RefDefArg = g:FuncOneDefArg
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001800 RefDefArg()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001801 s:value->assert_equal('text')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001802 RefDefArg('some')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001803 s:value->assert_equal('some')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001804
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001805 var RefDef2Arg: func(?number, ?string): string
Bram Moolenaar848fadd2022-01-30 15:28:30 +00001806 RefDef2Arg = g:FuncTwoDefArg
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001807 RefDef2Arg()->assert_equal('123text')
1808 RefDef2Arg(99)->assert_equal('99text')
1809 RefDef2Arg(77, 'some')->assert_equal('77some')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001810
Bram Moolenaar62aec932022-01-29 21:45:34 +00001811 v9.CheckDefFailure(['var RefWrong: func(string?)'], 'E1010:')
1812 v9.CheckDefFailure(['var RefWrong: func(?string, string)'], 'E1007:')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001813
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001814 var RefVarargs: func(...list<string>): string
Bram Moolenaar848fadd2022-01-30 15:28:30 +00001815 RefVarargs = g:FuncVarargs
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001816 RefVarargs()->assert_equal('')
1817 RefVarargs('one')->assert_equal('one')
1818 RefVarargs('one', 'two')->assert_equal('one,two')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001819
Bram Moolenaar62aec932022-01-29 21:45:34 +00001820 v9.CheckDefFailure(['var RefWrong: func(...list<string>, string)'], 'E110:')
1821 v9.CheckDefFailure(['var RefWrong: func(...list<string>, ?string)'], 'E110:')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +02001822enddef
1823
Bram Moolenaar0b76b422020-04-07 22:05:08 +02001824" Only varargs
1825def MyVarargsOnly(...args: list<string>): string
1826 return join(args, ',')
1827enddef
1828
1829def Test_call_varargs_only()
Bram Moolenaar62aec932022-01-29 21:45:34 +00001830 g:MyVarargsOnly()->assert_equal('')
1831 g:MyVarargsOnly('one')->assert_equal('one')
1832 g:MyVarargsOnly('one', 'two')->assert_equal('one,two')
1833 v9.CheckDefFailure(['g:MyVarargsOnly(1)'], 'E1013: Argument 1: type mismatch, expected string but got number')
1834 v9.CheckDefFailure(['g:MyVarargsOnly("one", 2)'], 'E1013: Argument 2: type mismatch, expected string but got number')
Bram Moolenaar0b76b422020-04-07 22:05:08 +02001835enddef
1836
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001837def Test_using_var_as_arg()
Bram Moolenaard2939812021-12-30 17:09:05 +00001838 var lines =<< trim END
1839 def Func(x: number)
1840 var x = 234
1841 enddef
1842 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001843 v9.CheckDefFailure(lines, 'E1006:')
Bram Moolenaard2939812021-12-30 17:09:05 +00001844
1845 lines =<< trim END
1846 def Func(Ref: number)
1847 def Ref()
1848 enddef
1849 enddef
1850 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001851 v9.CheckDefFailure(lines, 'E1073:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001852enddef
1853
Bram Moolenaar62aec932022-01-29 21:45:34 +00001854def s:DictArg(arg: dict<string>)
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +02001855 arg['key'] = 'value'
1856enddef
1857
Bram Moolenaar62aec932022-01-29 21:45:34 +00001858def s:ListArg(arg: list<string>)
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +02001859 arg[0] = 'value'
1860enddef
1861
1862def Test_assign_to_argument()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001863 # works for dict and list
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001864 var d: dict<string> = {}
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +02001865 DictArg(d)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001866 d['key']->assert_equal('value')
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001867 var l: list<string> = []
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +02001868 ListArg(l)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001869 l[0]->assert_equal('value')
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +02001870
Bram Moolenaar62aec932022-01-29 21:45:34 +00001871 v9.CheckScriptFailure(['def Func(arg: number)', 'arg = 3', 'enddef', 'defcompile'], 'E1090:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001872 delfunc! g:Func
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +02001873enddef
1874
Bram Moolenaarb816dae2020-09-20 22:04:00 +02001875" These argument names are reserved in legacy functions.
Bram Moolenaar62aec932022-01-29 21:45:34 +00001876def s:WithReservedNames(firstline: string, lastline: string): string
Bram Moolenaarb816dae2020-09-20 22:04:00 +02001877 return firstline .. lastline
1878enddef
1879
1880def Test_argument_names()
1881 assert_equal('OK', WithReservedNames('O', 'K'))
1882enddef
1883
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001884def Test_call_func_defined_later()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001885 g:DefinedLater('one')->assert_equal('one')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +02001886 assert_fails('NotDefined("one")', 'E117:', '', 2, 'Test_call_func_defined_later')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001887enddef
1888
Bram Moolenaar1df8b3f2020-04-23 18:13:23 +02001889func DefinedLater(arg)
1890 return a:arg
1891endfunc
1892
1893def Test_call_funcref()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001894 g:SomeFunc('abc')->assert_equal(3)
Bram Moolenaar9bd5d872020-09-06 21:47:48 +02001895 assert_fails('NotAFunc()', 'E117:', '', 2, 'Test_call_funcref') # comment after call
Bram Moolenaar2ef91562021-12-11 16:14:07 +00001896 assert_fails('g:NotAFunc()', 'E1085:', '', 3, 'Test_call_funcref')
Bram Moolenaar2f1980f2020-07-22 19:30:06 +02001897
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001898 var lines =<< trim END
Bram Moolenaar2f1980f2020-07-22 19:30:06 +02001899 vim9script
1900 def RetNumber(): number
1901 return 123
1902 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001903 var Funcref: func: number = function('RetNumber')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001904 Funcref()->assert_equal(123)
Bram Moolenaar2f1980f2020-07-22 19:30:06 +02001905 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001906 v9.CheckScriptSuccess(lines)
Bram Moolenaar0f60e802020-07-22 20:16:11 +02001907
1908 lines =<< trim END
1909 vim9script
1910 def RetNumber(): number
1911 return 123
1912 enddef
1913 def Bar(F: func: number): number
1914 return F()
1915 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001916 var Funcref = function('RetNumber')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001917 Bar(Funcref)->assert_equal(123)
Bram Moolenaar0f60e802020-07-22 20:16:11 +02001918 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001919 v9.CheckScriptSuccess(lines)
Bram Moolenaarbfba8652020-07-23 20:09:10 +02001920
1921 lines =<< trim END
1922 vim9script
1923 def UseNumber(nr: number)
1924 echo nr
1925 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001926 var Funcref: func(number) = function('UseNumber')
Bram Moolenaarbfba8652020-07-23 20:09:10 +02001927 Funcref(123)
1928 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001929 v9.CheckScriptSuccess(lines)
Bram Moolenaarb8070e32020-07-23 20:56:04 +02001930
1931 lines =<< trim END
1932 vim9script
1933 def UseNumber(nr: number)
1934 echo nr
1935 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001936 var Funcref: func(string) = function('UseNumber')
Bram Moolenaarb8070e32020-07-23 20:56:04 +02001937 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001938 v9.CheckScriptFailure(lines, 'E1012: Type mismatch; expected func(string) but got func(number)')
Bram Moolenaar4fc224c2020-07-26 17:56:25 +02001939
1940 lines =<< trim END
1941 vim9script
1942 def EchoNr(nr = 34)
1943 g:echo = nr
1944 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001945 var Funcref: func(?number) = function('EchoNr')
Bram Moolenaar4fc224c2020-07-26 17:56:25 +02001946 Funcref()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001947 g:echo->assert_equal(34)
Bram Moolenaar4fc224c2020-07-26 17:56:25 +02001948 Funcref(123)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001949 g:echo->assert_equal(123)
Bram Moolenaar4fc224c2020-07-26 17:56:25 +02001950 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001951 v9.CheckScriptSuccess(lines)
Bram Moolenaarace61322020-07-26 18:16:58 +02001952
1953 lines =<< trim END
1954 vim9script
1955 def EchoList(...l: list<number>)
1956 g:echo = l
1957 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001958 var Funcref: func(...list<number>) = function('EchoList')
Bram Moolenaarace61322020-07-26 18:16:58 +02001959 Funcref()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001960 g:echo->assert_equal([])
Bram Moolenaarace61322020-07-26 18:16:58 +02001961 Funcref(1, 2, 3)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001962 g:echo->assert_equal([1, 2, 3])
Bram Moolenaarace61322020-07-26 18:16:58 +02001963 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001964 v9.CheckScriptSuccess(lines)
Bram Moolenaar01865ad2020-07-26 18:33:09 +02001965
1966 lines =<< trim END
1967 vim9script
1968 def OptAndVar(nr: number, opt = 12, ...l: list<number>): number
1969 g:optarg = opt
1970 g:listarg = l
1971 return nr
1972 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001973 var Funcref: func(number, ?number, ...list<number>): number = function('OptAndVar')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001974 Funcref(10)->assert_equal(10)
1975 g:optarg->assert_equal(12)
1976 g:listarg->assert_equal([])
Bram Moolenaar01865ad2020-07-26 18:33:09 +02001977
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001978 Funcref(11, 22)->assert_equal(11)
1979 g:optarg->assert_equal(22)
1980 g:listarg->assert_equal([])
Bram Moolenaar01865ad2020-07-26 18:33:09 +02001981
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001982 Funcref(17, 18, 1, 2, 3)->assert_equal(17)
1983 g:optarg->assert_equal(18)
1984 g:listarg->assert_equal([1, 2, 3])
Bram Moolenaar01865ad2020-07-26 18:33:09 +02001985 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001986 v9.CheckScriptSuccess(lines)
Kota Kato948a3892022-08-16 16:09:59 +01001987
1988 lines =<< trim END
1989 function s:func(num)
1990 return a:num * 2
1991 endfunction
1992
1993 def s:CallFuncref()
1994 var Funcref = function('s:func')
1995 Funcref(3)->assert_equal(6)
1996 enddef
1997 call s:CallFuncref()
1998 END
1999 v9.CheckScriptSuccess(lines)
2000
2001 lines =<< trim END
2002 function s:func(num)
2003 return a:num * 2
2004 endfunction
2005
2006 def s:CallFuncref()
2007 var Funcref = function(s:func)
2008 Funcref(3)->assert_equal(6)
2009 enddef
2010 call s:CallFuncref()
2011 END
2012 v9.CheckScriptSuccess(lines)
2013
2014 lines =<< trim END
2015 function s:func(num)
2016 return a:num * 2
2017 endfunction
2018
2019 def s:CallFuncref()
2020 var Funcref = s:func
2021 Funcref(3)->assert_equal(6)
2022 enddef
2023 call s:CallFuncref()
2024 END
2025 v9.CheckScriptSuccess(lines)
Bram Moolenaar1df8b3f2020-04-23 18:13:23 +02002026enddef
2027
2028let SomeFunc = function('len')
2029let NotAFunc = 'text'
2030
Bram Moolenaar99aaf0c2020-04-12 14:39:53 +02002031def CombineFuncrefTypes()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002032 # same arguments, different return type
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002033 var Ref1: func(bool): string
2034 var Ref2: func(bool): number
2035 var Ref3: func(bool): any
Bram Moolenaar99aaf0c2020-04-12 14:39:53 +02002036 Ref3 = g:cond ? Ref1 : Ref2
2037
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002038 # different number of arguments
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002039 var Refa1: func(bool): number
2040 var Refa2: func(bool, number): number
2041 var Refa3: func: number
Bram Moolenaar99aaf0c2020-04-12 14:39:53 +02002042 Refa3 = g:cond ? Refa1 : Refa2
2043
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002044 # different argument types
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002045 var Refb1: func(bool, string): number
2046 var Refb2: func(string, number): number
2047 var Refb3: func(any, any): number
Bram Moolenaar99aaf0c2020-04-12 14:39:53 +02002048 Refb3 = g:cond ? Refb1 : Refb2
2049enddef
2050
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002051def FuncWithForwardCall()
Bram Moolenaar1df8b3f2020-04-23 18:13:23 +02002052 return g:DefinedEvenLater("yes")
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002053enddef
2054
2055def DefinedEvenLater(arg: string): string
2056 return arg
2057enddef
2058
2059def Test_error_in_nested_function()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002060 # Error in called function requires unwinding the call stack.
Bram Moolenaar848fadd2022-01-30 15:28:30 +00002061 assert_fails('g:FuncWithForwardCall()', 'E1096:', '', 1, 'FuncWithForwardCall')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002062enddef
2063
Bram Moolenaar4bf10062021-12-28 17:23:12 +00002064def Test_nested_function_with_nextcmd()
Bram Moolenaar9c23f9b2021-12-26 14:23:22 +00002065 var lines =<< trim END
2066 vim9script
2067 # Define an outer function
2068 def FirstFunction()
2069 # Define an inner function
2070 def SecondFunction()
2071 # the function has a body, a double free is detected.
2072 AAAAA
2073
2074 # enddef followed by | or } followed by # one or more characters
2075 enddef|BBBB
2076 enddef
2077
2078 # Compile all functions
2079 defcompile
2080 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002081 v9.CheckScriptFailure(lines, 'E1173: Text found after enddef: BBBB')
Bram Moolenaar9c23f9b2021-12-26 14:23:22 +00002082enddef
2083
Bram Moolenaar4bf10062021-12-28 17:23:12 +00002084def Test_nested_function_with_args_split()
2085 var lines =<< trim END
2086 vim9script
2087 def FirstFunction()
2088 def SecondFunction(
2089 )
2090 # had a double free if the right parenthesis of the nested function is
2091 # on the next line
2092
2093 enddef|BBBB
2094 enddef
2095 # Compile all functions
2096 defcompile
2097 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002098 v9.CheckScriptFailure(lines, 'E1173: Text found after enddef: BBBB')
Bram Moolenaar7473a842021-12-28 17:55:26 +00002099
2100 lines =<< trim END
2101 vim9script
2102 def FirstFunction()
2103 func SecondFunction()
2104 endfunc|BBBB
2105 enddef
2106 defcompile
2107 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002108 v9.CheckScriptFailure(lines, 'E1173: Text found after endfunction: BBBB')
Bram Moolenaar4bf10062021-12-28 17:23:12 +00002109enddef
2110
Bram Moolenaar9f1a39a2022-01-08 15:39:39 +00002111def Test_error_in_function_args()
2112 var lines =<< trim END
2113 def FirstFunction()
2114 def SecondFunction(J =
2115 # Nois
2116 # one
2117
2118 enddef|BBBB
2119 enddef
2120 # Compile all functions
2121 defcompile
2122 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002123 v9.CheckScriptFailure(lines, 'E488:')
Bram Moolenaar9f1a39a2022-01-08 15:39:39 +00002124enddef
2125
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002126def Test_return_type_wrong()
Bram Moolenaar62aec932022-01-29 21:45:34 +00002127 v9.CheckScriptFailure([
Bram Moolenaar5a849da2020-08-08 16:47:30 +02002128 'def Func(): number',
2129 'return "a"',
2130 'enddef',
2131 'defcompile'], 'expected number but got string')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002132 delfunc! g:Func
Bram Moolenaar62aec932022-01-29 21:45:34 +00002133 v9.CheckScriptFailure([
Bram Moolenaar5a849da2020-08-08 16:47:30 +02002134 'def Func(): string',
2135 'return 1',
2136 'enddef',
2137 'defcompile'], 'expected string but got number')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002138 delfunc! g:Func
Bram Moolenaar62aec932022-01-29 21:45:34 +00002139 v9.CheckScriptFailure([
Bram Moolenaar5a849da2020-08-08 16:47:30 +02002140 'def Func(): void',
2141 'return "a"',
2142 'enddef',
2143 'defcompile'],
2144 'E1096: Returning a value in a function without a return type')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002145 delfunc! g:Func
Bram Moolenaar62aec932022-01-29 21:45:34 +00002146 v9.CheckScriptFailure([
Bram Moolenaar5a849da2020-08-08 16:47:30 +02002147 'def Func()',
2148 'return "a"',
2149 'enddef',
2150 'defcompile'],
2151 'E1096: Returning a value in a function without a return type')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002152 delfunc! g:Func
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002153
Bram Moolenaar62aec932022-01-29 21:45:34 +00002154 v9.CheckScriptFailure([
Bram Moolenaar5a849da2020-08-08 16:47:30 +02002155 'def Func(): number',
2156 'return',
2157 'enddef',
2158 'defcompile'], 'E1003:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002159 delfunc! g:Func
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002160
Bram Moolenaar62aec932022-01-29 21:45:34 +00002161 v9.CheckScriptFailure([
Bram Moolenaar33ea9fd2021-08-08 19:07:37 +02002162 'def Func():number',
2163 'return 123',
2164 'enddef',
2165 'defcompile'], 'E1069:')
2166 delfunc! g:Func
2167
Bram Moolenaar62aec932022-01-29 21:45:34 +00002168 v9.CheckScriptFailure([
Bram Moolenaar33ea9fd2021-08-08 19:07:37 +02002169 'def Func() :number',
2170 'return 123',
2171 'enddef',
2172 'defcompile'], 'E1059:')
2173 delfunc! g:Func
2174
Bram Moolenaar62aec932022-01-29 21:45:34 +00002175 v9.CheckScriptFailure([
Bram Moolenaar33ea9fd2021-08-08 19:07:37 +02002176 'def Func() : number',
2177 'return 123',
2178 'enddef',
2179 'defcompile'], 'E1059:')
2180 delfunc! g:Func
2181
Bram Moolenaar62e0e2e2022-08-20 12:07:58 +01002182 v9.CheckScriptFailure(['def Func(): list', 'return []', 'enddef'], 'E1008: Missing <type> after list')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002183 delfunc! g:Func
Bram Moolenaar62e0e2e2022-08-20 12:07:58 +01002184 v9.CheckScriptFailure(['def Func(): dict', 'return {}', 'enddef'], 'E1008: Missing <type> after dict')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002185 delfunc! g:Func
Bram Moolenaar62aec932022-01-29 21:45:34 +00002186 v9.CheckScriptFailure(['def Func()', 'return 1'], 'E1057:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002187 delfunc! g:Func
Bram Moolenaar5a849da2020-08-08 16:47:30 +02002188
Bram Moolenaar62aec932022-01-29 21:45:34 +00002189 v9.CheckScriptFailure([
Bram Moolenaar5a849da2020-08-08 16:47:30 +02002190 'vim9script',
2191 'def FuncB()',
2192 ' return 123',
2193 'enddef',
2194 'def FuncA()',
2195 ' FuncB()',
2196 'enddef',
2197 'defcompile'], 'E1096:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002198enddef
2199
2200def Test_arg_type_wrong()
Bram Moolenaar62e0e2e2022-08-20 12:07:58 +01002201 v9.CheckScriptFailure(['def Func3(items: list)', 'echo "a"', 'enddef'], 'E1008: Missing <type> after list')
Bram Moolenaar62aec932022-01-29 21:45:34 +00002202 v9.CheckScriptFailure(['def Func4(...)', 'echo "a"', 'enddef'], 'E1055: Missing name after ...')
2203 v9.CheckScriptFailure(['def Func5(items:string)', 'echo "a"'], 'E1069:')
2204 v9.CheckScriptFailure(['def Func5(items)', 'echo "a"'], 'E1077:')
2205 v9.CheckScriptFailure(['def Func6(...x:list<number>)', 'echo "a"', 'enddef'], 'E1069:')
2206 v9.CheckScriptFailure(['def Func7(...x: int)', 'echo "a"', 'enddef'], 'E1010:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002207enddef
2208
Bram Moolenaar86cdb8a2021-04-06 19:01:03 +02002209def Test_white_space_before_comma()
2210 var lines =<< trim END
2211 vim9script
2212 def Func(a: number , b: number)
2213 enddef
2214 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002215 v9.CheckScriptFailure(lines, 'E1068:')
Yegappan Lakshmanan611728f2021-05-24 15:15:47 +02002216 call assert_fails('vim9cmd echo stridx("a" .. "b" , "a")', 'E1068:')
Bram Moolenaar86cdb8a2021-04-06 19:01:03 +02002217enddef
2218
Bram Moolenaar608d78f2021-03-06 22:33:12 +01002219def Test_white_space_after_comma()
2220 var lines =<< trim END
2221 vim9script
2222 def Func(a: number,b: number)
2223 enddef
2224 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002225 v9.CheckScriptFailure(lines, 'E1069:')
Bram Moolenaar608d78f2021-03-06 22:33:12 +01002226
2227 # OK in legacy function
2228 lines =<< trim END
2229 vim9script
2230 func Func(a,b)
2231 endfunc
2232 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002233 v9.CheckScriptSuccess(lines)
Bram Moolenaar608d78f2021-03-06 22:33:12 +01002234enddef
2235
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002236def Test_vim9script_call()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002237 var lines =<< trim END
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002238 vim9script
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002239 var name = ''
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002240 def MyFunc(arg: string)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002241 name = arg
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002242 enddef
2243 MyFunc('foobar')
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002244 name->assert_equal('foobar')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002245
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002246 var str = 'barfoo'
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002247 str->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002248 name->assert_equal('barfoo')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002249
Bram Moolenaar67979662020-06-20 22:50:47 +02002250 g:value = 'value'
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002251 g:value->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002252 name->assert_equal('value')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002253
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002254 var listvar = []
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002255 def ListFunc(arg: list<number>)
2256 listvar = arg
2257 enddef
2258 [1, 2, 3]->ListFunc()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002259 listvar->assert_equal([1, 2, 3])
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002260
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002261 var dictvar = {}
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002262 def DictFunc(arg: dict<number>)
2263 dictvar = arg
2264 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +01002265 {a: 1, b: 2}->DictFunc()
2266 dictvar->assert_equal({a: 1, b: 2})
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002267 def CompiledDict()
Bram Moolenaare0de1712020-12-02 17:36:54 +01002268 {a: 3, b: 4}->DictFunc()
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002269 enddef
2270 CompiledDict()
Bram Moolenaare0de1712020-12-02 17:36:54 +01002271 dictvar->assert_equal({a: 3, b: 4})
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002272
Bram Moolenaare0de1712020-12-02 17:36:54 +01002273 {a: 3, b: 4}->DictFunc()
2274 dictvar->assert_equal({a: 3, b: 4})
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002275
2276 ('text')->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002277 name->assert_equal('text')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002278 ("some")->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002279 name->assert_equal('some')
Bram Moolenaare6b53242020-07-01 17:28:33 +02002280
Bram Moolenaar13e12b82020-07-24 18:47:22 +02002281 # line starting with single quote is not a mark
Bram Moolenaar10409562020-07-29 20:00:38 +02002282 # line starting with double quote can be a method call
Bram Moolenaar3d48e252020-07-15 14:15:52 +02002283 'asdfasdf'->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002284 name->assert_equal('asdfasdf')
Bram Moolenaar10409562020-07-29 20:00:38 +02002285 "xyz"->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002286 name->assert_equal('xyz')
Bram Moolenaar3d48e252020-07-15 14:15:52 +02002287
2288 def UseString()
2289 'xyork'->MyFunc()
2290 enddef
2291 UseString()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002292 name->assert_equal('xyork')
Bram Moolenaar3d48e252020-07-15 14:15:52 +02002293
Bram Moolenaar10409562020-07-29 20:00:38 +02002294 def UseString2()
2295 "knife"->MyFunc()
2296 enddef
2297 UseString2()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002298 name->assert_equal('knife')
Bram Moolenaar10409562020-07-29 20:00:38 +02002299
Bram Moolenaar13e12b82020-07-24 18:47:22 +02002300 # prepending a colon makes it a mark
2301 new
2302 setline(1, ['aaa', 'bbb', 'ccc'])
2303 normal! 3Gmt1G
2304 :'t
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002305 getcurpos()[1]->assert_equal(3)
Bram Moolenaar13e12b82020-07-24 18:47:22 +02002306 bwipe!
2307
Bram Moolenaare6b53242020-07-01 17:28:33 +02002308 MyFunc(
2309 'continued'
2310 )
2311 assert_equal('continued',
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002312 name
Bram Moolenaare6b53242020-07-01 17:28:33 +02002313 )
2314
2315 call MyFunc(
2316 'more'
2317 ..
2318 'lines'
2319 )
2320 assert_equal(
2321 'morelines',
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002322 name)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002323 END
Bram Moolenaarf5fec052022-09-11 11:49:22 +01002324 writefile(lines, 'Xcall.vim', 'D')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002325 source Xcall.vim
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002326enddef
2327
2328def Test_vim9script_call_fail_decl()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002329 var lines =<< trim END
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002330 vim9script
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002331 var name = ''
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002332 def MyFunc(arg: string)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002333 var name = 123
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002334 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +02002335 defcompile
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002336 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002337 v9.CheckScriptFailure(lines, 'E1054:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002338enddef
2339
Bram Moolenaar65b95452020-07-19 14:03:09 +02002340def Test_vim9script_call_fail_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002341 var lines =<< trim END
Bram Moolenaar65b95452020-07-19 14:03:09 +02002342 vim9script
2343 def MyFunc(arg: string)
2344 echo arg
2345 enddef
2346 MyFunc(1234)
2347 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002348 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected string but got number')
Bram Moolenaar65b95452020-07-19 14:03:09 +02002349enddef
2350
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002351def Test_vim9script_call_fail_const()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002352 var lines =<< trim END
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002353 vim9script
2354 const var = ''
2355 def MyFunc(arg: string)
2356 var = 'asdf'
2357 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +02002358 defcompile
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002359 END
Bram Moolenaarf5fec052022-09-11 11:49:22 +01002360 writefile(lines, 'Xcall_const.vim', 'D')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +02002361 assert_fails('source Xcall_const.vim', 'E46:', '', 1, 'MyFunc')
Bram Moolenaar3bdc90b2020-12-22 20:35:40 +01002362
2363 lines =<< trim END
2364 const g:Aconst = 77
2365 def Change()
2366 # comment
2367 g:Aconst = 99
2368 enddef
2369 call Change()
2370 unlet g:Aconst
2371 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002372 v9.CheckScriptFailure(lines, 'E741: Value is locked: Aconst', 2)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002373enddef
2374
2375" Test that inside :function a Python function can be defined, :def is not
2376" recognized.
2377func Test_function_python()
2378 CheckFeature python3
Bram Moolenaar727345e2020-09-27 23:33:59 +02002379 let py = 'python3'
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002380 execute py "<< EOF"
2381def do_something():
2382 return 1
2383EOF
2384endfunc
2385
2386def Test_delfunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002387 var lines =<< trim END
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002388 vim9script
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02002389 def g:GoneSoon()
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002390 echo 'hello'
2391 enddef
2392
2393 def CallGoneSoon()
Bram Moolenaar62aec932022-01-29 21:45:34 +00002394 g:GoneSoon()
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002395 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +02002396 defcompile
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002397
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02002398 delfunc g:GoneSoon
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002399 CallGoneSoon()
2400 END
Bram Moolenaarf5fec052022-09-11 11:49:22 +01002401 writefile(lines, 'XToDelFunc', 'D')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +02002402 assert_fails('so XToDelFunc', 'E933:', '', 1, 'CallGoneSoon')
2403 assert_fails('so XToDelFunc', 'E933:', '', 1, 'CallGoneSoon')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002404enddef
2405
Bram Moolenaar7509ad82021-12-14 18:14:37 +00002406func Test_free_dict_while_in_funcstack()
2407 " relies on the sleep command
2408 CheckUnix
2409 call Run_Test_free_dict_while_in_funcstack()
2410endfunc
2411
2412def Run_Test_free_dict_while_in_funcstack()
Bram Moolenaar7509ad82021-12-14 18:14:37 +00002413 # this was freeing the TermRun() default argument dictionary while it was
2414 # still referenced in a funcstack_T
2415 var lines =<< trim END
2416 vim9script
2417
2418 &updatetime = 400
2419 def TermRun(_ = {})
2420 def Post()
2421 enddef
2422 def Exec()
2423 term_start('sleep 1', {
2424 term_finish: 'close',
2425 exit_cb: (_, _) => Post(),
2426 })
2427 enddef
2428 Exec()
2429 enddef
2430 nnoremap <F4> <Cmd>call <SID>TermRun()<CR>
2431 timer_start(100, (_) => feedkeys("\<F4>"))
2432 timer_start(1000, (_) => feedkeys("\<F4>"))
2433 sleep 1500m
2434 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002435 v9.CheckScriptSuccess(lines)
Bram Moolenaar7509ad82021-12-14 18:14:37 +00002436 nunmap <F4>
2437 set updatetime&
2438enddef
2439
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002440def Test_redef_failure()
Bram Moolenaard2c61702020-09-06 15:58:36 +02002441 writefile(['def Func0(): string', 'return "Func0"', 'enddef'], 'Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002442 so Xdef
Bram Moolenaard2c61702020-09-06 15:58:36 +02002443 writefile(['def Func1(): string', 'return "Func1"', 'enddef'], 'Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002444 so Xdef
Bram Moolenaard2c61702020-09-06 15:58:36 +02002445 writefile(['def! Func0(): string', 'enddef', 'defcompile'], 'Xdef')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +02002446 assert_fails('so Xdef', 'E1027:', '', 1, 'Func0')
Bram Moolenaard2c61702020-09-06 15:58:36 +02002447 writefile(['def Func2(): string', 'return "Func2"', 'enddef'], 'Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002448 so Xdef
Bram Moolenaard2c61702020-09-06 15:58:36 +02002449 delete('Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002450
Bram Moolenaar701cc6c2021-04-10 13:33:48 +02002451 assert_fails('g:Func0()', 'E1091:')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002452 g:Func1()->assert_equal('Func1')
2453 g:Func2()->assert_equal('Func2')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002454
2455 delfunc! Func0
2456 delfunc! Func1
2457 delfunc! Func2
2458enddef
2459
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02002460def Test_vim9script_func()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002461 var lines =<< trim END
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02002462 vim9script
2463 func Func(arg)
2464 echo a:arg
2465 endfunc
2466 Func('text')
2467 END
Bram Moolenaarf5fec052022-09-11 11:49:22 +01002468 writefile(lines, 'XVim9Func', 'D')
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02002469 so XVim9Func
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02002470enddef
2471
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002472let s:funcResult = 0
2473
2474def FuncNoArgNoRet()
Bram Moolenaar53900992020-08-22 19:02:02 +02002475 s:funcResult = 11
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002476enddef
2477
2478def FuncNoArgRetNumber(): number
Bram Moolenaar53900992020-08-22 19:02:02 +02002479 s:funcResult = 22
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002480 return 1234
2481enddef
2482
Bram Moolenaarec5929d2020-04-07 20:53:39 +02002483def FuncNoArgRetString(): string
Bram Moolenaar53900992020-08-22 19:02:02 +02002484 s:funcResult = 45
Bram Moolenaarec5929d2020-04-07 20:53:39 +02002485 return 'text'
2486enddef
2487
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002488def FuncOneArgNoRet(arg: number)
Bram Moolenaar53900992020-08-22 19:02:02 +02002489 s:funcResult = arg
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002490enddef
2491
2492def FuncOneArgRetNumber(arg: number): number
Bram Moolenaar53900992020-08-22 19:02:02 +02002493 s:funcResult = arg
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002494 return arg
2495enddef
2496
Bram Moolenaar08938ee2020-04-11 23:17:17 +02002497def FuncTwoArgNoRet(one: bool, two: number)
Bram Moolenaar53900992020-08-22 19:02:02 +02002498 s:funcResult = two
Bram Moolenaar08938ee2020-04-11 23:17:17 +02002499enddef
2500
Bram Moolenaar62aec932022-01-29 21:45:34 +00002501def s:FuncOneArgRetString(arg: string): string
Bram Moolenaarec5929d2020-04-07 20:53:39 +02002502 return arg
2503enddef
2504
Bram Moolenaar62aec932022-01-29 21:45:34 +00002505def s:FuncOneArgRetAny(arg: any): any
Bram Moolenaar89228602020-04-05 22:14:54 +02002506 return arg
2507enddef
2508
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002509def Test_func_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002510 var Ref1: func()
Bram Moolenaar53900992020-08-22 19:02:02 +02002511 s:funcResult = 0
Bram Moolenaar62aec932022-01-29 21:45:34 +00002512 Ref1 = g:FuncNoArgNoRet
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002513 Ref1()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002514 s:funcResult->assert_equal(11)
Bram Moolenaar4c683752020-04-05 21:38:23 +02002515
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002516 var Ref2: func
Bram Moolenaar53900992020-08-22 19:02:02 +02002517 s:funcResult = 0
Bram Moolenaar62aec932022-01-29 21:45:34 +00002518 Ref2 = g:FuncNoArgNoRet
Bram Moolenaar4c683752020-04-05 21:38:23 +02002519 Ref2()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002520 s:funcResult->assert_equal(11)
Bram Moolenaar4c683752020-04-05 21:38:23 +02002521
Bram Moolenaar53900992020-08-22 19:02:02 +02002522 s:funcResult = 0
Bram Moolenaar62aec932022-01-29 21:45:34 +00002523 Ref2 = g:FuncOneArgNoRet
Bram Moolenaar4c683752020-04-05 21:38:23 +02002524 Ref2(12)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002525 s:funcResult->assert_equal(12)
Bram Moolenaar4c683752020-04-05 21:38:23 +02002526
Bram Moolenaar53900992020-08-22 19:02:02 +02002527 s:funcResult = 0
Bram Moolenaar62aec932022-01-29 21:45:34 +00002528 Ref2 = g:FuncNoArgRetNumber
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002529 Ref2()->assert_equal(1234)
2530 s:funcResult->assert_equal(22)
Bram Moolenaar4c683752020-04-05 21:38:23 +02002531
Bram Moolenaar53900992020-08-22 19:02:02 +02002532 s:funcResult = 0
Bram Moolenaar848fadd2022-01-30 15:28:30 +00002533 Ref2 = g:FuncOneArgRetNumber
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002534 Ref2(13)->assert_equal(13)
2535 s:funcResult->assert_equal(13)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002536enddef
2537
Bram Moolenaar9978d472020-07-05 16:01:56 +02002538def Test_repeat_return_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002539 var res = 0
Bram Moolenaar9978d472020-07-05 16:01:56 +02002540 for n in repeat([1], 3)
2541 res += n
2542 endfor
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002543 res->assert_equal(3)
Bram Moolenaarfce82b32020-07-05 16:07:21 +02002544
2545 res = 0
Bakudankun375141e2022-09-09 18:46:47 +01002546 for n in repeat(0z01, 3)->blob2list()
2547 res += n
2548 endfor
2549 res->assert_equal(3)
2550
2551 res = 0
Bram Moolenaarfce82b32020-07-05 16:07:21 +02002552 for n in add([1, 2], 3)
2553 res += n
2554 endfor
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002555 res->assert_equal(6)
Bram Moolenaar9978d472020-07-05 16:01:56 +02002556enddef
2557
Bram Moolenaar846178a2020-07-05 17:04:13 +02002558def Test_argv_return_type()
2559 next fileone filetwo
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002560 var res = ''
Bram Moolenaar846178a2020-07-05 17:04:13 +02002561 for name in argv()
2562 res ..= name
2563 endfor
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002564 res->assert_equal('fileonefiletwo')
Bram Moolenaar846178a2020-07-05 17:04:13 +02002565enddef
2566
Bram Moolenaarec5929d2020-04-07 20:53:39 +02002567def Test_func_type_part()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002568 var RefVoid: func: void
Bram Moolenaar62aec932022-01-29 21:45:34 +00002569 RefVoid = g:FuncNoArgNoRet
2570 RefVoid = g:FuncOneArgNoRet
2571 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 +00002572 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 +02002573
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002574 var RefAny: func(): any
Bram Moolenaar62aec932022-01-29 21:45:34 +00002575 RefAny = g:FuncNoArgRetNumber
Bram Moolenaar848fadd2022-01-30 15:28:30 +00002576 RefAny = g:FuncNoArgRetString
Bram Moolenaar62aec932022-01-29 21:45:34 +00002577 v9.CheckDefFailure(['var RefAny: func(): any', 'RefAny = g:FuncNoArgNoRet'], 'E1012: Type mismatch; expected func(): any but got func()')
2578 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 +02002579
Bram Moolenaar6abd3dc2020-10-04 14:17:32 +02002580 var RefAnyNoArgs: func: any = RefAny
2581
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002582 var RefNr: func: number
Bram Moolenaar62aec932022-01-29 21:45:34 +00002583 RefNr = g:FuncNoArgRetNumber
Bram Moolenaar848fadd2022-01-30 15:28:30 +00002584 RefNr = g:FuncOneArgRetNumber
Bram Moolenaar62aec932022-01-29 21:45:34 +00002585 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 +00002586 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 +02002587
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002588 var RefStr: func: string
Bram Moolenaar848fadd2022-01-30 15:28:30 +00002589 RefStr = g:FuncNoArgRetString
Bram Moolenaarec5929d2020-04-07 20:53:39 +02002590 RefStr = FuncOneArgRetString
Bram Moolenaar62aec932022-01-29 21:45:34 +00002591 v9.CheckDefFailure(['var RefStr: func: string', 'RefStr = g:FuncNoArgNoRet'], 'E1012: Type mismatch; expected func(...): string but got func()')
2592 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 +02002593enddef
2594
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002595def Test_func_type_fails()
Bram Moolenaar62aec932022-01-29 21:45:34 +00002596 v9.CheckDefFailure(['var ref1: func()'], 'E704:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002597
Bram Moolenaar62aec932022-01-29 21:45:34 +00002598 v9.CheckDefFailure(['var Ref1: func()', 'Ref1 = g:FuncNoArgRetNumber'], 'E1012: Type mismatch; expected func() but got func(): number')
2599 v9.CheckDefFailure(['var Ref1: func()', 'Ref1 = g:FuncOneArgNoRet'], 'E1012: Type mismatch; expected func() but got func(number)')
Bram Moolenaar848fadd2022-01-30 15:28:30 +00002600 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 +00002601 v9.CheckDefFailure(['var Ref1: func(bool)', 'Ref1 = g:FuncTwoArgNoRet'], 'E1012: Type mismatch; expected func(bool) but got func(bool, number)')
2602 v9.CheckDefFailure(['var Ref1: func(?bool)', 'Ref1 = g:FuncTwoArgNoRet'], 'E1012: Type mismatch; expected func(?bool) but got func(bool, number)')
2603 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 +02002604
Bram Moolenaar62aec932022-01-29 21:45:34 +00002605 v9.CheckDefFailure(['var RefWrong: func(string ,number)'], 'E1068:')
2606 v9.CheckDefFailure(['var RefWrong: func(string,number)'], 'E1069:')
2607 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:')
2608 v9.CheckDefFailure(['var RefWrong: func(bool):string'], 'E1069:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002609enddef
2610
Bram Moolenaar89228602020-04-05 22:14:54 +02002611def Test_func_return_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002612 var nr: number
Bram Moolenaar62aec932022-01-29 21:45:34 +00002613 nr = g:FuncNoArgRetNumber()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002614 nr->assert_equal(1234)
Bram Moolenaar89228602020-04-05 22:14:54 +02002615
2616 nr = FuncOneArgRetAny(122)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002617 nr->assert_equal(122)
Bram Moolenaar89228602020-04-05 22:14:54 +02002618
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002619 var str: string
Bram Moolenaar89228602020-04-05 22:14:54 +02002620 str = FuncOneArgRetAny('yes')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002621 str->assert_equal('yes')
Bram Moolenaar89228602020-04-05 22:14:54 +02002622
Bram Moolenaar62aec932022-01-29 21:45:34 +00002623 v9.CheckDefFailure(['var str: string', 'str = g:FuncNoArgRetNumber()'], 'E1012: Type mismatch; expected string but got number')
Bram Moolenaar89228602020-04-05 22:14:54 +02002624enddef
2625
Bram Moolenaar6abd3dc2020-10-04 14:17:32 +02002626def Test_func_common_type()
2627 def FuncOne(n: number): number
2628 return n
2629 enddef
2630 def FuncTwo(s: string): number
2631 return len(s)
2632 enddef
2633 def FuncThree(n: number, s: string): number
2634 return n + len(s)
2635 enddef
2636 var list = [FuncOne, FuncTwo, FuncThree]
2637 assert_equal(8, list[0](8))
2638 assert_equal(4, list[1]('word'))
2639 assert_equal(7, list[2](3, 'word'))
2640enddef
2641
Bram Moolenaar62aec932022-01-29 21:45:34 +00002642def s:MultiLine(
Bram Moolenaar5e774c72020-04-12 21:53:00 +02002643 arg1: string,
2644 arg2 = 1234,
2645 ...rest: list<string>
2646 ): string
2647 return arg1 .. arg2 .. join(rest, '-')
2648enddef
2649
Bram Moolenaar2c330432020-04-13 14:41:35 +02002650def MultiLineComment(
2651 arg1: string, # comment
2652 arg2 = 1234, # comment
2653 ...rest: list<string> # comment
2654 ): string # comment
2655 return arg1 .. arg2 .. join(rest, '-')
2656enddef
2657
Bram Moolenaar5e774c72020-04-12 21:53:00 +02002658def Test_multiline()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002659 MultiLine('text')->assert_equal('text1234')
2660 MultiLine('text', 777)->assert_equal('text777')
2661 MultiLine('text', 777, 'one')->assert_equal('text777one')
2662 MultiLine('text', 777, 'one', 'two')->assert_equal('text777one-two')
Bram Moolenaar5e774c72020-04-12 21:53:00 +02002663enddef
2664
Bram Moolenaar23e03252020-04-12 22:22:31 +02002665func Test_multiline_not_vim9()
Bram Moolenaar62aec932022-01-29 21:45:34 +00002666 call s:MultiLine('text')->assert_equal('text1234')
2667 call s:MultiLine('text', 777)->assert_equal('text777')
2668 call s:MultiLine('text', 777, 'one')->assert_equal('text777one')
2669 call s:MultiLine('text', 777, 'one', 'two')->assert_equal('text777one-two')
Bram Moolenaar23e03252020-04-12 22:22:31 +02002670endfunc
2671
Bram Moolenaar5e774c72020-04-12 21:53:00 +02002672
Bram Moolenaaree4e0c12020-04-06 21:35:05 +02002673" When using CheckScriptFailure() for the below test, E1010 is generated instead
2674" of E1056.
2675func Test_E1056_1059()
2676 let caught_1056 = 0
2677 try
2678 def F():
2679 return 1
2680 enddef
2681 catch /E1056:/
2682 let caught_1056 = 1
2683 endtry
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002684 eval caught_1056->assert_equal(1)
Bram Moolenaaree4e0c12020-04-06 21:35:05 +02002685
2686 let caught_1059 = 0
2687 try
2688 def F5(items : list)
2689 echo 'a'
2690 enddef
2691 catch /E1059:/
2692 let caught_1059 = 1
2693 endtry
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002694 eval caught_1059->assert_equal(1)
Bram Moolenaaree4e0c12020-04-06 21:35:05 +02002695endfunc
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002696
Bram Moolenaar015f4262020-05-05 21:25:22 +02002697func DelMe()
2698 echo 'DelMe'
2699endfunc
2700
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002701def Test_error_reporting()
2702 # comment lines at the start of the function
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002703 var lines =<< trim END
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002704 " comment
2705 def Func()
2706 # comment
2707 # comment
2708 invalid
2709 enddef
2710 defcompile
2711 END
Bram Moolenaarf5fec052022-09-11 11:49:22 +01002712 writefile(lines, 'Xdef', 'D')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002713 try
2714 source Xdef
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02002715 assert_report('should have failed')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002716 catch /E476:/
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002717 v:exception->assert_match('Invalid command: invalid')
2718 v:throwpoint->assert_match(', line 3$')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002719 endtry
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002720 delfunc! g:Func
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002721
2722 # comment lines after the start of the function
2723 lines =<< trim END
2724 " comment
2725 def Func()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002726 var x = 1234
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002727 # comment
2728 # comment
2729 invalid
2730 enddef
2731 defcompile
2732 END
Bram Moolenaar08052222020-09-14 17:04:31 +02002733 writefile(lines, 'Xdef')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002734 try
2735 source Xdef
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02002736 assert_report('should have failed')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002737 catch /E476:/
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002738 v:exception->assert_match('Invalid command: invalid')
2739 v:throwpoint->assert_match(', line 4$')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002740 endtry
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002741 delfunc! g:Func
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002742
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02002743 lines =<< trim END
2744 vim9script
2745 def Func()
Bram Moolenaare0de1712020-12-02 17:36:54 +01002746 var db = {foo: 1, bar: 2}
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02002747 # comment
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002748 var x = db.asdf
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02002749 enddef
2750 defcompile
2751 Func()
2752 END
Bram Moolenaar08052222020-09-14 17:04:31 +02002753 writefile(lines, 'Xdef')
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02002754 try
2755 source Xdef
2756 assert_report('should have failed')
2757 catch /E716:/
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002758 v:throwpoint->assert_match('_Func, line 3$')
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02002759 endtry
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002760 delfunc! g:Func
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02002761enddef
2762
Bram Moolenaar015f4262020-05-05 21:25:22 +02002763def Test_deleted_function()
Bram Moolenaar62aec932022-01-29 21:45:34 +00002764 v9.CheckDefExecFailure([
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002765 'var RefMe: func = function("g:DelMe")',
Bram Moolenaar015f4262020-05-05 21:25:22 +02002766 'delfunc g:DelMe',
2767 'echo RefMe()'], 'E117:')
2768enddef
2769
2770def Test_unknown_function()
Bram Moolenaar62aec932022-01-29 21:45:34 +00002771 v9.CheckDefExecFailure([
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002772 'var Ref: func = function("NotExist")',
Bram Moolenaar9b7bf9e2020-07-11 22:14:59 +02002773 'delfunc g:NotExist'], 'E700:')
Bram Moolenaar015f4262020-05-05 21:25:22 +02002774enddef
2775
Bram Moolenaar62aec932022-01-29 21:45:34 +00002776def s:RefFunc(Ref: func(any): any): string
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02002777 return Ref('more')
2778enddef
2779
2780def Test_closure_simple()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002781 var local = 'some '
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002782 RefFunc((s) => local .. s)->assert_equal('some more')
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02002783enddef
2784
Bram Moolenaar62aec932022-01-29 21:45:34 +00002785def s:MakeRef()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002786 var local = 'some '
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002787 g:Ref = (s) => local .. s
Bram Moolenaarbf67ea12020-05-02 17:52:42 +02002788enddef
2789
2790def Test_closure_ref_after_return()
2791 MakeRef()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002792 g:Ref('thing')->assert_equal('some thing')
Bram Moolenaarbf67ea12020-05-02 17:52:42 +02002793 unlet g:Ref
2794enddef
2795
Bram Moolenaar62aec932022-01-29 21:45:34 +00002796def s:MakeTwoRefs()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002797 var local = ['some']
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002798 g:Extend = (s) => local->add(s)
2799 g:Read = () => local
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002800enddef
2801
2802def Test_closure_two_refs()
2803 MakeTwoRefs()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002804 join(g:Read(), ' ')->assert_equal('some')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002805 g:Extend('more')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002806 join(g:Read(), ' ')->assert_equal('some more')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002807 g:Extend('even')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002808 join(g:Read(), ' ')->assert_equal('some more even')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002809
2810 unlet g:Extend
2811 unlet g:Read
2812enddef
2813
Bram Moolenaar62aec932022-01-29 21:45:34 +00002814def s:ReadRef(Ref: func(): list<string>): string
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002815 return join(Ref(), ' ')
2816enddef
2817
Bram Moolenaar62aec932022-01-29 21:45:34 +00002818def s:ExtendRef(Ref: func(string): list<string>, add: string)
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002819 Ref(add)
2820enddef
2821
2822def Test_closure_two_indirect_refs()
Bram Moolenaarf7779c62020-05-03 15:38:16 +02002823 MakeTwoRefs()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002824 ReadRef(g:Read)->assert_equal('some')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002825 ExtendRef(g:Extend, 'more')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002826 ReadRef(g:Read)->assert_equal('some more')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002827 ExtendRef(g:Extend, 'even')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002828 ReadRef(g:Read)->assert_equal('some more even')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02002829
2830 unlet g:Extend
2831 unlet g:Read
2832enddef
Bram Moolenaarbf67ea12020-05-02 17:52:42 +02002833
Bram Moolenaar62aec932022-01-29 21:45:34 +00002834def s:MakeArgRefs(theArg: string)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002835 var local = 'loc_val'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002836 g:UseArg = (s) => theArg .. '/' .. local .. '/' .. s
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02002837enddef
2838
Bram Moolenaar62aec932022-01-29 21:45:34 +00002839def s:MakeArgRefsVarargs(theArg: string, ...rest: list<string>)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002840 var local = 'the_loc'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002841 g:UseVararg = (s) => theArg .. '/' .. local .. '/' .. s .. '/' .. join(rest)
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02002842enddef
2843
2844def Test_closure_using_argument()
2845 MakeArgRefs('arg_val')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002846 g:UseArg('call_val')->assert_equal('arg_val/loc_val/call_val')
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02002847
2848 MakeArgRefsVarargs('arg_val', 'one', 'two')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002849 g:UseVararg('call_val')->assert_equal('arg_val/the_loc/call_val/one two')
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02002850
2851 unlet g:UseArg
2852 unlet g:UseVararg
Bram Moolenaar44ec21c2021-02-12 21:50:57 +01002853
2854 var lines =<< trim END
2855 vim9script
2856 def Test(Fun: func(number): number): list<number>
2857 return map([1, 2, 3], (_, i) => Fun(i))
2858 enddef
2859 def Inc(nr: number): number
2860 return nr + 2
2861 enddef
2862 assert_equal([3, 4, 5], Test(Inc))
2863 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002864 v9.CheckScriptSuccess(lines)
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02002865enddef
2866
Bram Moolenaar62aec932022-01-29 21:45:34 +00002867def s:MakeGetAndAppendRefs()
Bram Moolenaar85d5e2b2020-10-10 14:13:01 +02002868 var local = 'a'
2869
2870 def Append(arg: string)
2871 local ..= arg
2872 enddef
2873 g:Append = Append
2874
2875 def Get(): string
2876 return local
2877 enddef
2878 g:Get = Get
2879enddef
2880
2881def Test_closure_append_get()
2882 MakeGetAndAppendRefs()
2883 g:Get()->assert_equal('a')
2884 g:Append('-b')
2885 g:Get()->assert_equal('a-b')
2886 g:Append('-c')
2887 g:Get()->assert_equal('a-b-c')
2888
2889 unlet g:Append
2890 unlet g:Get
2891enddef
Bram Moolenaarb68b3462020-05-06 21:06:30 +02002892
Bram Moolenaar04b12692020-05-04 23:24:44 +02002893def Test_nested_closure()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002894 var local = 'text'
Bram Moolenaar04b12692020-05-04 23:24:44 +02002895 def Closure(arg: string): string
2896 return local .. arg
2897 enddef
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002898 Closure('!!!')->assert_equal('text!!!')
Bram Moolenaar04b12692020-05-04 23:24:44 +02002899enddef
2900
Bram Moolenaar62aec932022-01-29 21:45:34 +00002901func s:GetResult(Ref)
Bram Moolenaar6f5b6df2020-05-16 21:20:12 +02002902 return a:Ref('some')
2903endfunc
2904
2905def Test_call_closure_not_compiled()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002906 var text = 'text'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002907 g:Ref = (s) => s .. text
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002908 GetResult(g:Ref)->assert_equal('sometext')
Bram Moolenaar6f5b6df2020-05-16 21:20:12 +02002909enddef
2910
Bram Moolenaar7cbfaa52020-09-18 21:25:32 +02002911def Test_double_closure_fails()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002912 var lines =<< trim END
Bram Moolenaar7cbfaa52020-09-18 21:25:32 +02002913 vim9script
2914 def Func()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002915 var name = 0
2916 for i in range(2)
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002917 timer_start(0, () => name)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002918 endfor
Bram Moolenaar7cbfaa52020-09-18 21:25:32 +02002919 enddef
2920 Func()
2921 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002922 v9.CheckScriptSuccess(lines)
Bram Moolenaar7cbfaa52020-09-18 21:25:32 +02002923enddef
2924
Bram Moolenaar85d5e2b2020-10-10 14:13:01 +02002925def Test_nested_closure_used()
2926 var lines =<< trim END
2927 vim9script
2928 def Func()
2929 var x = 'hello'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002930 var Closure = () => x
2931 g:Myclosure = () => Closure()
Bram Moolenaar85d5e2b2020-10-10 14:13:01 +02002932 enddef
2933 Func()
2934 assert_equal('hello', g:Myclosure())
2935 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002936 v9.CheckScriptSuccess(lines)
Bram Moolenaar85d5e2b2020-10-10 14:13:01 +02002937enddef
Bram Moolenaar0876c782020-10-07 19:08:04 +02002938
Bram Moolenaarc70bdab2020-09-26 19:59:38 +02002939def Test_nested_closure_fails()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02002940 var lines =<< trim END
Bram Moolenaarc70bdab2020-09-26 19:59:38 +02002941 vim9script
2942 def FuncA()
2943 FuncB(0)
2944 enddef
2945 def FuncB(n: number): list<string>
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002946 return map([0], (_, v) => n)
Bram Moolenaarc70bdab2020-09-26 19:59:38 +02002947 enddef
2948 FuncA()
2949 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002950 v9.CheckScriptFailure(lines, 'E1012:')
Bram Moolenaarc70bdab2020-09-26 19:59:38 +02002951enddef
2952
Bram Moolenaar6de22962022-09-09 21:35:36 +01002953def Run_Test_closure_in_for_loop_fails()
2954 var lines =<< trim END
2955 vim9script
Bram Moolenaar766ae5b2022-09-14 00:30:51 +01002956 redraw
Bram Moolenaar6de22962022-09-09 21:35:36 +01002957 for n in [0]
Bram Moolenaar766ae5b2022-09-14 00:30:51 +01002958 # time should be enough for startup to finish
2959 timer_start(200, (_) => {
Bram Moolenaar6de22962022-09-09 21:35:36 +01002960 echo n
2961 })
2962 endfor
2963 END
2964 writefile(lines, 'XTest_closure_fails', 'D')
2965
2966 # Check that an error shows
Bram Moolenaarc069ede2022-09-11 12:01:04 +01002967 var buf = g:RunVimInTerminal('-S XTest_closure_fails', {rows: 6, wait_for_ruler: 0})
Bram Moolenaar766ae5b2022-09-14 00:30:51 +01002968 g:VerifyScreenDump(buf, 'Test_vim9_closure_fails', {wait: 3000})
Bram Moolenaar6de22962022-09-09 21:35:36 +01002969
2970 # clean up
2971 g:StopVimInTerminal(buf)
2972enddef
2973
2974func Test_closure_in_for_loop_fails()
2975 CheckScreendump
2976 call Run_Test_closure_in_for_loop_fails()
2977endfunc
2978
Bram Moolenaarf112f302020-12-20 17:47:52 +01002979def Test_global_closure()
2980 var lines =<< trim END
2981 vim9script
2982 def ReverseEveryNLines(n: number, line1: number, line2: number)
2983 var mods = 'sil keepj keepp lockm '
2984 var range = ':' .. line1 .. ',' .. line2
2985 def g:Offset(): number
2986 var offset = (line('.') - line1 + 1) % n
2987 return offset != 0 ? offset : n
2988 enddef
2989 exe mods .. range .. 'g/^/exe "m .-" .. g:Offset()'
2990 enddef
2991
2992 new
2993 repeat(['aaa', 'bbb', 'ccc'], 3)->setline(1)
2994 ReverseEveryNLines(3, 1, 9)
2995 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002996 v9.CheckScriptSuccess(lines)
Bram Moolenaarf112f302020-12-20 17:47:52 +01002997 var expected = repeat(['ccc', 'bbb', 'aaa'], 3)
2998 assert_equal(expected, getline(1, 9))
2999 bwipe!
3000enddef
3001
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01003002def Test_global_closure_called_directly()
3003 var lines =<< trim END
3004 vim9script
3005 def Outer()
3006 var x = 1
3007 def g:Inner()
3008 var y = x
3009 x += 1
3010 assert_equal(1, y)
3011 enddef
3012 g:Inner()
3013 assert_equal(2, x)
3014 enddef
3015 Outer()
3016 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003017 v9.CheckScriptSuccess(lines)
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01003018 delfunc g:Inner
3019enddef
3020
Bram Moolenaar69c76172021-12-02 16:38:52 +00003021def Test_closure_called_from_legacy()
3022 var lines =<< trim END
3023 vim9script
3024 def Func()
3025 var outer = 'foo'
3026 var F = () => {
3027 outer = 'bar'
3028 }
3029 execute printf('call %s()', string(F))
3030 enddef
3031 Func()
3032 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003033 v9.CheckScriptFailure(lines, 'E1248')
Bram Moolenaar69c76172021-12-02 16:38:52 +00003034enddef
3035
Bram Moolenaar34c54eb2020-11-25 19:15:19 +01003036def Test_failure_in_called_function()
3037 # this was using the frame index as the return value
3038 var lines =<< trim END
3039 vim9script
3040 au TerminalWinOpen * eval [][0]
3041 def PopupTerm(a: any)
3042 # make sure typvals on stack are string
3043 ['a', 'b', 'c', 'd', 'e', 'f', 'g']->join()
3044 FireEvent()
3045 enddef
3046 def FireEvent()
3047 do TerminalWinOpen
3048 enddef
3049 # use try/catch to make eval fail
3050 try
3051 call PopupTerm(0)
3052 catch
3053 endtry
3054 au! TerminalWinOpen
3055 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003056 v9.CheckScriptSuccess(lines)
Bram Moolenaar34c54eb2020-11-25 19:15:19 +01003057enddef
3058
Bram Moolenaar5366e1a2020-10-01 13:01:34 +02003059def Test_nested_lambda()
3060 var lines =<< trim END
3061 vim9script
3062 def Func()
3063 var x = 4
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01003064 var Lambda1 = () => 7
3065 var Lambda2 = () => [Lambda1(), x]
Bram Moolenaar5366e1a2020-10-01 13:01:34 +02003066 var res = Lambda2()
3067 assert_equal([7, 4], res)
3068 enddef
3069 Func()
3070 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003071 v9.CheckScriptSuccess(lines)
Bram Moolenaar5366e1a2020-10-01 13:01:34 +02003072enddef
3073
Bram Moolenaarc04f2a42021-06-09 19:30:03 +02003074def Test_double_nested_lambda()
3075 var lines =<< trim END
3076 vim9script
3077 def F(head: string): func(string): func(string): string
3078 return (sep: string): func(string): string => ((tail: string): string => {
3079 return head .. sep .. tail
3080 })
3081 enddef
3082 assert_equal('hello-there', F('hello')('-')('there'))
3083 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003084 v9.CheckScriptSuccess(lines)
Bram Moolenaarc04f2a42021-06-09 19:30:03 +02003085enddef
3086
Bram Moolenaar074f84c2021-05-18 11:47:44 +02003087def Test_nested_inline_lambda()
Bram Moolenaar074f84c2021-05-18 11:47:44 +02003088 var lines =<< trim END
3089 vim9script
3090 def F(text: string): func(string): func(string): string
3091 return (arg: string): func(string): string => ((sep: string): string => {
Bram Moolenaar23e2e112021-08-03 21:16:18 +02003092 return sep .. arg .. text
Bram Moolenaar074f84c2021-05-18 11:47:44 +02003093 })
3094 enddef
Bram Moolenaar23e2e112021-08-03 21:16:18 +02003095 assert_equal('--there++', F('++')('there')('--'))
Bram Moolenaar074f84c2021-05-18 11:47:44 +02003096 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003097 v9.CheckScriptSuccess(lines)
Bram Moolenaar5245beb2021-07-15 22:03:50 +02003098
3099 lines =<< trim END
3100 vim9script
3101 echo range(4)->mapnew((_, v) => {
3102 return range(v) ->mapnew((_, s) => {
3103 return string(s)
3104 })
3105 })
3106 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003107 v9.CheckScriptSuccess(lines)
Bram Moolenaarc6ba2f92021-07-18 13:42:29 +02003108
3109 lines =<< trim END
3110 vim9script
3111
Bram Moolenaara749a422022-02-12 19:52:25 +00003112 def Func()
Bram Moolenaarc6ba2f92021-07-18 13:42:29 +02003113 range(10)
3114 ->mapnew((_, _) => ({
3115 key: range(10)->mapnew((_, _) => {
3116 return ' '
3117 }),
3118 }))
3119 enddef
3120
3121 defcomp
3122 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003123 v9.CheckScriptSuccess(lines)
Bram Moolenaar074f84c2021-05-18 11:47:44 +02003124enddef
3125
Bram Moolenaar52bf81c2020-11-17 18:50:44 +01003126def Shadowed(): list<number>
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01003127 var FuncList: list<func: number> = [() => 42]
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01003128 return FuncList->mapnew((_, Shadowed) => Shadowed())
Bram Moolenaar52bf81c2020-11-17 18:50:44 +01003129enddef
3130
3131def Test_lambda_arg_shadows_func()
Bram Moolenaar62aec932022-01-29 21:45:34 +00003132 assert_equal([42], g:Shadowed())
Bram Moolenaar52bf81c2020-11-17 18:50:44 +01003133enddef
3134
Bram Moolenaar21dc8f12022-03-16 17:54:17 +00003135def Test_compiling_referenced_func_no_shadow()
3136 var lines =<< trim END
3137 vim9script
3138
3139 def InitializeReply(lspserver: dict<any>)
3140 enddef
3141
3142 def ProcessReply(lspserver: dict<any>)
3143 var lsp_reply_handlers: dict<func> =
3144 { 'initialize': InitializeReply }
3145 lsp_reply_handlers['initialize'](lspserver)
3146 enddef
3147
3148 call ProcessReply({})
3149 END
3150 v9.CheckScriptSuccess(lines)
3151enddef
3152
Bram Moolenaar62aec932022-01-29 21:45:34 +00003153def s:Line_continuation_in_def(dir: string = ''): string
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02003154 var path: string = empty(dir)
3155 \ ? 'empty'
3156 \ : 'full'
3157 return path
Bram Moolenaaracd4c5e2020-06-22 19:39:03 +02003158enddef
3159
3160def Test_line_continuation_in_def()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02003161 Line_continuation_in_def('.')->assert_equal('full')
Bram Moolenaaracd4c5e2020-06-22 19:39:03 +02003162enddef
3163
Bram Moolenaar2ea95b62020-11-19 21:47:56 +01003164def Test_script_var_in_lambda()
3165 var lines =<< trim END
3166 vim9script
3167 var script = 'test'
Bram Moolenaarbb8a7ce2021-04-10 20:10:26 +02003168 assert_equal(['test'], map(['one'], (_, _) => script))
Bram Moolenaar2ea95b62020-11-19 21:47:56 +01003169 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003170 v9.CheckScriptSuccess(lines)
Bram Moolenaar2ea95b62020-11-19 21:47:56 +01003171enddef
3172
Bram Moolenaar62aec932022-01-29 21:45:34 +00003173def s:Line_continuation_in_lambda(): list<string>
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02003174 var x = range(97, 100)
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01003175 ->mapnew((_, v) => nr2char(v)
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01003176 ->toupper())
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02003177 ->reverse()
3178 return x
3179enddef
3180
3181def Test_line_continuation_in_lambda()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02003182 Line_continuation_in_lambda()->assert_equal(['D', 'C', 'B', 'A'])
Bram Moolenaarf898f7c2021-01-16 18:09:52 +01003183
3184 var lines =<< trim END
3185 vim9script
3186 var res = [{n: 1, m: 2, s: 'xxx'}]
3187 ->mapnew((_, v: dict<any>): string => printf('%d:%d:%s',
3188 v.n,
3189 v.m,
3190 substitute(v.s, '.*', 'yyy', '')
3191 ))
3192 assert_equal(['1:2:yyy'], res)
3193 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003194 v9.CheckScriptSuccess(lines)
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02003195enddef
3196
Bram Moolenaarb6571982021-01-08 22:24:19 +01003197def Test_list_lambda()
3198 timer_start(1000, (_) => 0)
3199 var body = execute(timer_info()[0].callback
3200 ->string()
3201 ->substitute("('", ' ', '')
3202 ->substitute("')", '', '')
3203 ->substitute('function\zs', ' ', ''))
Bram Moolenaar767034c2021-04-09 17:24:52 +02003204 assert_match('def <lambda>\d\+(_: any): number\n1 return 0\n enddef', body)
Bram Moolenaarb6571982021-01-08 22:24:19 +01003205enddef
3206
Bram Moolenaar3c77b6a2021-07-25 18:07:00 +02003207def Test_lambda_block_variable()
Bram Moolenaar88421d62021-07-24 14:14:52 +02003208 var lines =<< trim END
3209 vim9script
3210 var flist: list<func>
3211 for i in range(10)
3212 var inloop = i
3213 flist[i] = () => inloop
3214 endfor
3215 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003216 v9.CheckScriptSuccess(lines)
Bram Moolenaar88421d62021-07-24 14:14:52 +02003217
3218 lines =<< trim END
3219 vim9script
3220 if true
3221 var outloop = 5
3222 var flist: list<func>
3223 for i in range(10)
3224 flist[i] = () => outloop
3225 endfor
3226 endif
3227 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003228 v9.CheckScriptSuccess(lines)
Bram Moolenaar88421d62021-07-24 14:14:52 +02003229
3230 lines =<< trim END
3231 vim9script
3232 if true
3233 var outloop = 5
3234 endif
3235 var flist: list<func>
3236 for i in range(10)
3237 flist[i] = () => outloop
3238 endfor
3239 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003240 v9.CheckScriptFailure(lines, 'E1001: Variable not found: outloop', 1)
Bram Moolenaar3c77b6a2021-07-25 18:07:00 +02003241
3242 lines =<< trim END
3243 vim9script
3244 for i in range(10)
3245 var Ref = () => 0
3246 endfor
3247 assert_equal(0, ((i) => 0)(0))
3248 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003249 v9.CheckScriptSuccess(lines)
Bram Moolenaar88421d62021-07-24 14:14:52 +02003250enddef
3251
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02003252def Test_legacy_lambda()
3253 legacy echo {x -> 'hello ' .. x}('foo')
Bram Moolenaardc4c2302021-04-25 13:54:42 +02003254
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02003255 var lines =<< trim END
3256 echo {x -> 'hello ' .. x}('foo')
3257 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003258 v9.CheckDefAndScriptFailure(lines, 'E720:')
Bram Moolenaardc4c2302021-04-25 13:54:42 +02003259
3260 lines =<< trim END
3261 vim9script
3262 def Func()
3263 echo (() => 'no error')()
3264 enddef
3265 legacy call s:Func()
3266 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003267 v9.CheckScriptSuccess(lines)
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02003268enddef
3269
Bram Moolenaarce024c32021-06-26 13:00:49 +02003270def Test_legacy()
3271 var lines =<< trim END
3272 vim9script
3273 func g:LegacyFunction()
3274 let g:legacyvar = 1
3275 endfunc
3276 def Testit()
3277 legacy call g:LegacyFunction()
3278 enddef
3279 Testit()
3280 assert_equal(1, g:legacyvar)
3281 unlet g:legacyvar
3282 delfunc g:LegacyFunction
3283 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003284 v9.CheckScriptSuccess(lines)
Bram Moolenaarce024c32021-06-26 13:00:49 +02003285enddef
3286
Bram Moolenaarc3cb1c92021-06-02 16:47:53 +02003287def Test_legacy_errors()
3288 for cmd in ['if', 'elseif', 'else', 'endif',
3289 'for', 'endfor', 'continue', 'break',
3290 'while', 'endwhile',
3291 'try', 'catch', 'finally', 'endtry']
Bram Moolenaar62aec932022-01-29 21:45:34 +00003292 v9.CheckDefFailure(['legacy ' .. cmd .. ' expr'], 'E1189:')
Bram Moolenaarc3cb1c92021-06-02 16:47:53 +02003293 endfor
3294enddef
3295
Bram Moolenaarb1b6f4d2021-09-13 18:25:54 +02003296def Test_call_legacy_with_dict()
3297 var lines =<< trim END
3298 vim9script
3299 func Legacy() dict
3300 let g:result = self.value
3301 endfunc
3302 def TestDirect()
3303 var d = {value: 'yes', func: Legacy}
3304 d.func()
3305 enddef
3306 TestDirect()
3307 assert_equal('yes', g:result)
3308 unlet g:result
3309
3310 def TestIndirect()
3311 var d = {value: 'foo', func: Legacy}
3312 var Fi = d.func
3313 Fi()
3314 enddef
3315 TestIndirect()
3316 assert_equal('foo', g:result)
3317 unlet g:result
3318
3319 var d = {value: 'bar', func: Legacy}
3320 d.func()
3321 assert_equal('bar', g:result)
3322 unlet g:result
3323 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003324 v9.CheckScriptSuccess(lines)
Bram Moolenaarb1b6f4d2021-09-13 18:25:54 +02003325enddef
3326
Bram Moolenaar62aec932022-01-29 21:45:34 +00003327def s:DoFilterThis(a: string): list<string>
Bram Moolenaarab360522021-01-10 14:02:28 +01003328 # closure nested inside another closure using argument
3329 var Filter = (l) => filter(l, (_, v) => stridx(v, a) == 0)
3330 return ['x', 'y', 'a', 'x2', 'c']->Filter()
3331enddef
3332
3333def Test_nested_closure_using_argument()
3334 assert_equal(['x', 'x2'], DoFilterThis('x'))
3335enddef
3336
Bram Moolenaar0186e582021-01-10 18:33:11 +01003337def Test_triple_nested_closure()
3338 var what = 'x'
3339 var Match = (val: string, cmp: string): bool => stridx(val, cmp) == 0
3340 var Filter = (l) => filter(l, (_, v) => Match(v, what))
3341 assert_equal(['x', 'x2'], ['x', 'y', 'a', 'x2', 'c']->Filter())
3342enddef
3343
Bram Moolenaar8f510af2020-07-05 18:48:23 +02003344func Test_silent_echo()
Bram Moolenaar47e7d702020-07-05 18:18:42 +02003345 CheckScreendump
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003346 call Run_Test_silent_echo()
3347endfunc
Bram Moolenaar47e7d702020-07-05 18:18:42 +02003348
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003349def Run_Test_silent_echo()
3350 var lines =<< trim END
Bram Moolenaar47e7d702020-07-05 18:18:42 +02003351 vim9script
3352 def EchoNothing()
3353 silent echo ''
3354 enddef
3355 defcompile
3356 END
Bram Moolenaar6de22962022-09-09 21:35:36 +01003357 writefile(lines, 'XTest_silent_echo', 'D')
Bram Moolenaar47e7d702020-07-05 18:18:42 +02003358
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003359 # Check that the balloon shows up after a mouse move
Bram Moolenaar62aec932022-01-29 21:45:34 +00003360 var buf = g:RunVimInTerminal('-S XTest_silent_echo', {'rows': 6})
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003361 term_sendkeys(buf, ":abc")
Bram Moolenaar62aec932022-01-29 21:45:34 +00003362 g:VerifyScreenDump(buf, 'Test_vim9_silent_echo', {})
Bram Moolenaar47e7d702020-07-05 18:18:42 +02003363
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003364 # clean up
Bram Moolenaar62aec932022-01-29 21:45:34 +00003365 g:StopVimInTerminal(buf)
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003366enddef
Bram Moolenaar47e7d702020-07-05 18:18:42 +02003367
Bram Moolenaar171fb922020-10-28 16:54:47 +01003368def SilentlyError()
3369 execute('silent! invalid')
3370 g:did_it = 'yes'
3371enddef
3372
Bram Moolenaar62aec932022-01-29 21:45:34 +00003373func s:UserError()
Bram Moolenaar28ee8922020-10-28 20:20:00 +01003374 silent! invalid
3375endfunc
3376
3377def SilentlyUserError()
3378 UserError()
3379 g:did_it = 'yes'
3380enddef
Bram Moolenaar171fb922020-10-28 16:54:47 +01003381
3382" This can't be a :def function, because the assert would not be reached.
Bram Moolenaar171fb922020-10-28 16:54:47 +01003383func Test_ignore_silent_error()
3384 let g:did_it = 'no'
3385 call SilentlyError()
3386 call assert_equal('yes', g:did_it)
3387
Bram Moolenaar28ee8922020-10-28 20:20:00 +01003388 let g:did_it = 'no'
3389 call SilentlyUserError()
3390 call assert_equal('yes', g:did_it)
Bram Moolenaar171fb922020-10-28 16:54:47 +01003391
3392 unlet g:did_it
3393endfunc
3394
Bram Moolenaarcd030c42020-10-30 21:49:40 +01003395def Test_ignore_silent_error_in_filter()
3396 var lines =<< trim END
3397 vim9script
3398 def Filter(winid: number, key: string): bool
3399 if key == 'o'
3400 silent! eval [][0]
3401 return true
3402 endif
3403 return popup_filter_menu(winid, key)
3404 enddef
3405
Bram Moolenaare0de1712020-12-02 17:36:54 +01003406 popup_create('popup', {filter: Filter})
Bram Moolenaarcd030c42020-10-30 21:49:40 +01003407 feedkeys("o\r", 'xnt')
3408 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003409 v9.CheckScriptSuccess(lines)
Bram Moolenaarcd030c42020-10-30 21:49:40 +01003410enddef
3411
Bram Moolenaar62aec932022-01-29 21:45:34 +00003412def s:Fibonacci(n: number): number
Bram Moolenaar4b9bd692020-09-05 21:57:53 +02003413 if n < 2
3414 return n
3415 else
3416 return Fibonacci(n - 1) + Fibonacci(n - 2)
3417 endif
3418enddef
3419
Bram Moolenaar985116a2020-07-12 17:31:09 +02003420def Test_recursive_call()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02003421 Fibonacci(20)->assert_equal(6765)
Bram Moolenaar985116a2020-07-12 17:31:09 +02003422enddef
3423
Bram Moolenaar62aec932022-01-29 21:45:34 +00003424def s:TreeWalk(dir: string): list<any>
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01003425 return readdir(dir)->mapnew((_, val) =>
Bram Moolenaar08f7a412020-07-13 20:41:08 +02003426 fnamemodify(dir .. '/' .. val, ':p')->isdirectory()
Bram Moolenaar2bede172020-11-19 18:53:18 +01003427 ? {[val]: TreeWalk(dir .. '/' .. val)}
Bram Moolenaar08f7a412020-07-13 20:41:08 +02003428 : val
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01003429 )
Bram Moolenaar08f7a412020-07-13 20:41:08 +02003430enddef
3431
3432def Test_closure_in_map()
Bram Moolenaarf5fec052022-09-11 11:49:22 +01003433 mkdir('XclosureDir/tdir', 'pR')
Bram Moolenaar08f7a412020-07-13 20:41:08 +02003434 writefile(['111'], 'XclosureDir/file1')
3435 writefile(['222'], 'XclosureDir/file2')
3436 writefile(['333'], 'XclosureDir/tdir/file3')
3437
Bram Moolenaare0de1712020-12-02 17:36:54 +01003438 TreeWalk('XclosureDir')->assert_equal(['file1', 'file2', {tdir: ['file3']}])
Bram Moolenaar08f7a412020-07-13 20:41:08 +02003439enddef
3440
Bram Moolenaar7b5d5442020-10-04 13:42:34 +02003441def Test_invalid_function_name()
3442 var lines =<< trim END
3443 vim9script
3444 def s: list<string>
3445 END
Bram Moolenaara749a422022-02-12 19:52:25 +00003446 v9.CheckScriptFailure(lines, 'E1268:')
Bram Moolenaar7b5d5442020-10-04 13:42:34 +02003447
3448 lines =<< trim END
3449 vim9script
3450 def g: list<string>
3451 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003452 v9.CheckScriptFailure(lines, 'E129:')
Bram Moolenaar7b5d5442020-10-04 13:42:34 +02003453
3454 lines =<< trim END
3455 vim9script
3456 def <SID>: list<string>
3457 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003458 v9.CheckScriptFailure(lines, 'E884:')
Bram Moolenaar7b5d5442020-10-04 13:42:34 +02003459
3460 lines =<< trim END
3461 vim9script
3462 def F list<string>
3463 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003464 v9.CheckScriptFailure(lines, 'E488:')
Bram Moolenaar7b5d5442020-10-04 13:42:34 +02003465enddef
3466
Bram Moolenaara90afb92020-07-15 22:38:56 +02003467def Test_partial_call()
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02003468 var lines =<< trim END
3469 var Xsetlist: func
3470 Xsetlist = function('setloclist', [0])
3471 Xsetlist([], ' ', {title: 'test'})
3472 getloclist(0, {title: 1})->assert_equal({title: 'test'})
Bram Moolenaara90afb92020-07-15 22:38:56 +02003473
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02003474 Xsetlist = function('setloclist', [0, [], ' '])
3475 Xsetlist({title: 'test'})
3476 getloclist(0, {title: 1})->assert_equal({title: 'test'})
Bram Moolenaara90afb92020-07-15 22:38:56 +02003477
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02003478 Xsetlist = function('setqflist')
3479 Xsetlist([], ' ', {title: 'test'})
3480 getqflist({title: 1})->assert_equal({title: 'test'})
Bram Moolenaara90afb92020-07-15 22:38:56 +02003481
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02003482 Xsetlist = function('setqflist', [[], ' '])
3483 Xsetlist({title: 'test'})
3484 getqflist({title: 1})->assert_equal({title: 'test'})
Bram Moolenaar6abd3dc2020-10-04 14:17:32 +02003485
Bram Moolenaarf78da4f2021-08-01 15:40:31 +02003486 var Len: func: number = function('len', ['word'])
3487 assert_equal(4, Len())
3488
3489 var RepeatFunc = function('repeat', ['o'])
3490 assert_equal('ooooo', RepeatFunc(5))
3491 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003492 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarc66f6452021-08-19 21:08:30 +02003493
3494 lines =<< trim END
3495 vim9script
3496 def Foo(Parser: any)
3497 enddef
3498 var Expr: func(dict<any>): dict<any>
3499 const Call = Foo(Expr)
3500 END
Bram Moolenaar8acb9cc2022-03-08 13:18:55 +00003501 v9.CheckScriptFailure(lines, 'E1031:')
Bram Moolenaara90afb92020-07-15 22:38:56 +02003502enddef
3503
Bram Moolenaarcd1cda22022-02-16 21:48:25 +00003504def Test_partial_double_nested()
3505 var idx = 123
3506 var Get = () => idx
3507 var Ref = function(Get, [])
3508 var RefRef = function(Ref, [])
3509 assert_equal(123, RefRef())
3510enddef
3511
Bram Moolenaar673bcb12022-03-08 16:52:24 +00003512def Test_partial_null_function()
3513 var lines =<< trim END
3514 var d: dict<func> = {f: null_function}
3515 var Ref = d.f
Bram Moolenaared0c62e2022-03-08 19:43:55 +00003516 assert_equal('func(...): unknown', typename(Ref))
Bram Moolenaar673bcb12022-03-08 16:52:24 +00003517 END
3518 v9.CheckDefAndScriptSuccess(lines)
3519enddef
3520
Bram Moolenaarfe1bfc92022-02-06 13:55:03 +00003521" Using "idx" from a legacy global function does not work.
3522" This caused a crash when called from legacy context.
3523func Test_partial_call_fails()
3524 let lines =<< trim END
3525 vim9script
3526
3527 var l = ['a', 'b', 'c']
3528 def Iter(container: any): any
3529 var idx = -1
3530 var obj = {state: container}
Bram Moolenaarf681cfb2022-02-07 20:30:57 +00003531 def g:NextItem__(self: dict<any>): any
Bram Moolenaarfe1bfc92022-02-06 13:55:03 +00003532 ++idx
3533 return self.state[idx]
3534 enddef
Bram Moolenaarf681cfb2022-02-07 20:30:57 +00003535 obj.__next__ = function('g:NextItem__', [obj])
Bram Moolenaarfe1bfc92022-02-06 13:55:03 +00003536 return obj
3537 enddef
3538
3539 var it = Iter(l)
3540 echo it.__next__()
3541 END
Bram Moolenaarf5fec052022-09-11 11:49:22 +01003542 call writefile(lines, 'XpartialCall', 'D')
Bram Moolenaarfe1bfc92022-02-06 13:55:03 +00003543 try
3544 source XpartialCall
3545 catch /E1248:/
3546 endtry
Bram Moolenaarfe1bfc92022-02-06 13:55:03 +00003547endfunc
3548
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02003549def Test_cmd_modifier()
3550 tab echo '0'
Bram Moolenaar62aec932022-01-29 21:45:34 +00003551 v9.CheckDefFailure(['5tab echo 3'], 'E16:')
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02003552enddef
3553
3554def Test_restore_modifiers()
3555 # check that when compiling a :def function command modifiers are not messed
3556 # up.
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02003557 var lines =<< trim END
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02003558 vim9script
3559 set eventignore=
3560 autocmd QuickFixCmdPost * copen
3561 def AutocmdsDisabled()
Bram Moolenaarc3235272021-07-10 19:42:03 +02003562 eval 1 + 2
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02003563 enddef
3564 func Func()
3565 noautocmd call s:AutocmdsDisabled()
3566 let g:ei_after = &eventignore
3567 endfunc
3568 Func()
3569 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003570 v9.CheckScriptSuccess(lines)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02003571 g:ei_after->assert_equal('')
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02003572enddef
3573
Bram Moolenaardfa3d552020-09-10 22:05:08 +02003574def StackTop()
Bram Moolenaarc3235272021-07-10 19:42:03 +02003575 eval 1 + 2
3576 eval 2 + 3
Bram Moolenaardfa3d552020-09-10 22:05:08 +02003577 # call not on fourth line
Bram Moolenaar62aec932022-01-29 21:45:34 +00003578 g:StackBot()
Bram Moolenaardfa3d552020-09-10 22:05:08 +02003579enddef
3580
3581def StackBot()
3582 # throw an error
3583 eval [][0]
3584enddef
3585
3586def Test_callstack_def()
3587 try
Bram Moolenaar62aec932022-01-29 21:45:34 +00003588 g:StackTop()
Bram Moolenaardfa3d552020-09-10 22:05:08 +02003589 catch
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02003590 v:throwpoint->assert_match('Test_callstack_def\[2\]..StackTop\[4\]..StackBot, line 2')
Bram Moolenaardfa3d552020-09-10 22:05:08 +02003591 endtry
3592enddef
3593
Bram Moolenaare8211a32020-10-09 22:04:29 +02003594" Re-using spot for variable used in block
3595def Test_block_scoped_var()
3596 var lines =<< trim END
3597 vim9script
3598 def Func()
3599 var x = ['a', 'b', 'c']
3600 if 1
3601 var y = 'x'
Bram Moolenaarbb8a7ce2021-04-10 20:10:26 +02003602 map(x, (_, _) => y)
Bram Moolenaare8211a32020-10-09 22:04:29 +02003603 endif
3604 var z = x
3605 assert_equal(['x', 'x', 'x'], z)
3606 enddef
3607 Func()
3608 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003609 v9.CheckScriptSuccess(lines)
Bram Moolenaare8211a32020-10-09 22:04:29 +02003610enddef
3611
Bram Moolenaareeece9e2020-11-20 19:26:48 +01003612def Test_reset_did_emsg()
3613 var lines =<< trim END
3614 @s = 'blah'
3615 au BufWinLeave * #
3616 def Func()
3617 var winid = popup_create('popup', {})
3618 exe '*s'
3619 popup_close(winid)
3620 enddef
3621 Func()
3622 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003623 v9.CheckScriptFailure(lines, 'E492:', 8)
Bram Moolenaar2d870f82020-12-05 13:41:01 +01003624 delfunc! g:Func
Bram Moolenaareeece9e2020-11-20 19:26:48 +01003625enddef
3626
Bram Moolenaar57f799e2020-12-12 20:42:19 +01003627def Test_did_emsg_reset()
3628 # executing an autocommand resets did_emsg, this should not result in a
3629 # builtin function considered failing
3630 var lines =<< trim END
3631 vim9script
3632 au BufWinLeave * #
3633 def Func()
Bram Moolenaar767034c2021-04-09 17:24:52 +02003634 popup_menu('', {callback: (a, b) => popup_create('', {})->popup_close()})
Bram Moolenaar57f799e2020-12-12 20:42:19 +01003635 eval [][0]
3636 enddef
3637 nno <F3> <cmd>call <sid>Func()<cr>
3638 feedkeys("\<F3>\e", 'xt')
3639 END
Bram Moolenaarf5fec052022-09-11 11:49:22 +01003640 writefile(lines, 'XemsgReset', 'D')
Bram Moolenaar57f799e2020-12-12 20:42:19 +01003641 assert_fails('so XemsgReset', ['E684:', 'E684:'], lines, 2)
Bram Moolenaarf5fec052022-09-11 11:49:22 +01003642
Bram Moolenaar57f799e2020-12-12 20:42:19 +01003643 nunmap <F3>
3644 au! BufWinLeave
3645enddef
3646
Bram Moolenaar56602ba2020-12-05 21:22:08 +01003647def Test_abort_with_silent_call()
3648 var lines =<< trim END
3649 vim9script
3650 g:result = 'none'
3651 def Func()
3652 g:result += 3
3653 g:result = 'yes'
3654 enddef
3655 # error is silenced, but function aborts on error
3656 silent! Func()
3657 assert_equal('none', g:result)
3658 unlet g:result
3659 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003660 v9.CheckScriptSuccess(lines)
Bram Moolenaar56602ba2020-12-05 21:22:08 +01003661enddef
3662
Bram Moolenaarf665e972020-12-05 19:17:16 +01003663def Test_continues_with_silent_error()
3664 var lines =<< trim END
3665 vim9script
3666 g:result = 'none'
3667 def Func()
3668 silent! g:result += 3
3669 g:result = 'yes'
3670 enddef
3671 # error is silenced, function does not abort
3672 Func()
3673 assert_equal('yes', g:result)
3674 unlet g:result
3675 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003676 v9.CheckScriptSuccess(lines)
Bram Moolenaarf665e972020-12-05 19:17:16 +01003677enddef
3678
Bram Moolenaaraf0df472020-12-02 20:51:22 +01003679def Test_abort_even_with_silent()
3680 var lines =<< trim END
3681 vim9script
3682 g:result = 'none'
3683 def Func()
3684 eval {-> ''}() .. '' .. {}['X']
3685 g:result = 'yes'
3686 enddef
Bram Moolenaarf665e972020-12-05 19:17:16 +01003687 silent! Func()
Bram Moolenaaraf0df472020-12-02 20:51:22 +01003688 assert_equal('none', g:result)
Bram Moolenaar4029cab2020-12-05 18:13:27 +01003689 unlet g:result
3690 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003691 v9.CheckScriptSuccess(lines)
Bram Moolenaar4029cab2020-12-05 18:13:27 +01003692enddef
3693
Bram Moolenaarf665e972020-12-05 19:17:16 +01003694def Test_cmdmod_silent_restored()
3695 var lines =<< trim END
3696 vim9script
3697 def Func()
3698 g:result = 'none'
3699 silent! g:result += 3
3700 g:result = 'none'
3701 g:result += 3
3702 enddef
3703 Func()
3704 END
3705 # can't use CheckScriptFailure, it ignores the :silent!
3706 var fname = 'Xdefsilent'
Bram Moolenaarf5fec052022-09-11 11:49:22 +01003707 writefile(lines, fname, 'D')
Bram Moolenaarf665e972020-12-05 19:17:16 +01003708 var caught = 'no'
3709 try
3710 exe 'source ' .. fname
3711 catch /E1030:/
3712 caught = 'yes'
3713 assert_match('Func, line 4', v:throwpoint)
3714 endtry
3715 assert_equal('yes', caught)
Bram Moolenaarf665e972020-12-05 19:17:16 +01003716enddef
3717
Bram Moolenaar2fecb532021-03-24 22:00:56 +01003718def Test_cmdmod_silent_nested()
3719 var lines =<< trim END
3720 vim9script
3721 var result = ''
3722
3723 def Error()
3724 result ..= 'Eb'
3725 eval [][0]
3726 result ..= 'Ea'
3727 enddef
3728
3729 def Crash()
3730 result ..= 'Cb'
3731 sil! Error()
3732 result ..= 'Ca'
3733 enddef
3734
3735 Crash()
3736 assert_equal('CbEbEaCa', result)
3737 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003738 v9.CheckScriptSuccess(lines)
Bram Moolenaar2fecb532021-03-24 22:00:56 +01003739enddef
3740
Bram Moolenaar4029cab2020-12-05 18:13:27 +01003741def Test_dict_member_with_silent()
3742 var lines =<< trim END
3743 vim9script
3744 g:result = 'none'
3745 var d: dict<any>
3746 def Func()
3747 try
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01003748 g:result = map([], (_, v) => ({}[v]))->join() .. d['']
Bram Moolenaar4029cab2020-12-05 18:13:27 +01003749 catch
3750 endtry
3751 enddef
3752 silent! Func()
3753 assert_equal('0', g:result)
3754 unlet g:result
Bram Moolenaaraf0df472020-12-02 20:51:22 +01003755 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003756 v9.CheckScriptSuccess(lines)
Bram Moolenaaraf0df472020-12-02 20:51:22 +01003757enddef
3758
Bram Moolenaarf9041332021-01-21 19:41:16 +01003759def Test_skip_cmds_with_silent()
3760 var lines =<< trim END
3761 vim9script
3762
3763 def Func(b: bool)
3764 Crash()
3765 enddef
3766
3767 def Crash()
3768 sil! :/not found/d _
3769 sil! :/not found/put _
3770 enddef
3771
3772 Func(true)
3773 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003774 v9.CheckScriptSuccess(lines)
Bram Moolenaarf9041332021-01-21 19:41:16 +01003775enddef
3776
Bram Moolenaar5b3d1bb2020-12-22 12:20:08 +01003777def Test_opfunc()
Bram Moolenaar848fadd2022-01-30 15:28:30 +00003778 nnoremap <F3> <cmd>set opfunc=g:Opfunc<cr>g@
Bram Moolenaar5b3d1bb2020-12-22 12:20:08 +01003779 def g:Opfunc(_: any): string
3780 setline(1, 'ASDF')
3781 return ''
3782 enddef
3783 new
3784 setline(1, 'asdf')
3785 feedkeys("\<F3>$", 'x')
3786 assert_equal('ASDF', getline(1))
3787
3788 bwipe!
3789 nunmap <F3>
3790enddef
3791
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003792func Test_opfunc_error()
3793 CheckScreendump
3794 call Run_Test_opfunc_error()
3795endfunc
3796
3797def Run_Test_opfunc_error()
3798 # test that the error from Opfunc() is displayed right away
3799 var lines =<< trim END
3800 vim9script
3801
3802 def Opfunc(type: string)
3803 try
3804 eval [][0]
3805 catch /nothing/ # error not caught
3806 endtry
3807 enddef
3808 &operatorfunc = Opfunc
3809 nnoremap <expr> l <SID>L()
3810 def L(): string
3811 return 'l'
3812 enddef
3813 'x'->repeat(10)->setline(1)
3814 feedkeys('g@l', 'n')
3815 feedkeys('llll')
3816 END
Bram Moolenaarf5fec052022-09-11 11:49:22 +01003817 call writefile(lines, 'XTest_opfunc_error', 'D')
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003818
Bram Moolenaar62aec932022-01-29 21:45:34 +00003819 var buf = g:RunVimInTerminal('-S XTest_opfunc_error', {rows: 6, wait_for_ruler: 0})
3820 g:WaitForAssert(() => assert_match('Press ENTER', term_getline(buf, 6)))
Bram Moolenaarec892232022-05-06 17:53:06 +01003821 g:WaitForAssert(() => assert_match('E684: List index out of range: 0', term_getline(buf, 5)))
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003822
3823 # clean up
Bram Moolenaar62aec932022-01-29 21:45:34 +00003824 g:StopVimInTerminal(buf)
Bram Moolenaar3b309f12021-12-13 18:19:55 +00003825enddef
3826
Bram Moolenaar077a4232020-12-22 18:33:27 +01003827" this was crashing on exit
3828def Test_nested_lambda_in_closure()
3829 var lines =<< trim END
3830 vim9script
Bram Moolenaar227c58a2021-04-28 20:40:44 +02003831 command WriteDone writefile(['Done'], 'XnestedDone')
Bram Moolenaar077a4232020-12-22 18:33:27 +01003832 def Outer()
3833 def g:Inner()
3834 echo map([1, 2, 3], {_, v -> v + 1})
3835 enddef
3836 g:Inner()
3837 enddef
3838 defcompile
Bram Moolenaar227c58a2021-04-28 20:40:44 +02003839 # not reached
Bram Moolenaar077a4232020-12-22 18:33:27 +01003840 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003841 if !g:RunVim([], lines, '--clean -c WriteDone -c quit')
Bram Moolenaar077a4232020-12-22 18:33:27 +01003842 return
3843 endif
3844 assert_equal(['Done'], readfile('XnestedDone'))
3845 delete('XnestedDone')
3846enddef
3847
Bram Moolenaar92368aa2022-02-07 17:50:39 +00003848def Test_nested_closure_funcref()
3849 var lines =<< trim END
3850 vim9script
3851 def Func()
3852 var n: number
3853 def Nested()
3854 ++n
3855 enddef
3856 Nested()
3857 g:result_one = n
3858 var Ref = function(Nested)
3859 Ref()
3860 g:result_two = n
3861 enddef
3862 Func()
3863 END
3864 v9.CheckScriptSuccess(lines)
3865 assert_equal(1, g:result_one)
3866 assert_equal(2, g:result_two)
3867 unlet g:result_one g:result_two
3868enddef
3869
Bram Moolenaar7aca5ca2022-02-07 19:56:43 +00003870def Test_nested_closure_in_dict()
3871 var lines =<< trim END
3872 vim9script
3873 def Func(): dict<any>
3874 var n: number
3875 def Inc(): number
3876 ++n
3877 return n
3878 enddef
3879 return {inc: function(Inc)}
3880 enddef
3881 disas Func
3882 var d = Func()
3883 assert_equal(1, d.inc())
3884 assert_equal(2, d.inc())
3885 END
3886 v9.CheckScriptSuccess(lines)
3887enddef
3888
Bram Moolenaarfb43cfc2022-03-11 18:54:17 +00003889def Test_script_local_other_script()
3890 var lines =<< trim END
3891 function LegacyJob()
3892 let FuncRef = function('s:close_cb')
3893 endfunction
3894 function s:close_cb(...)
3895 endfunction
3896 END
Bram Moolenaarf5fec052022-09-11 11:49:22 +01003897 lines->writefile('Xlegacy.vim', 'D')
Bram Moolenaarfb43cfc2022-03-11 18:54:17 +00003898 source Xlegacy.vim
3899 g:LegacyJob()
3900 g:LegacyJob()
3901 g:LegacyJob()
3902
3903 delfunc g:LegacyJob
Bram Moolenaarfb43cfc2022-03-11 18:54:17 +00003904enddef
3905
Bram Moolenaar04947cc2021-03-06 19:26:46 +01003906def Test_check_func_arg_types()
3907 var lines =<< trim END
3908 vim9script
3909 def F1(x: string): string
3910 return x
3911 enddef
3912
3913 def F2(x: number): number
3914 return x + 1
3915 enddef
3916
Bram Moolenaar1d9cef72022-03-17 16:30:03 +00003917 def G(Fg: func): dict<func>
3918 return {f: Fg}
Bram Moolenaar04947cc2021-03-06 19:26:46 +01003919 enddef
3920
3921 def H(d: dict<func>): string
3922 return d.f('a')
3923 enddef
3924 END
3925
Bram Moolenaar62aec932022-01-29 21:45:34 +00003926 v9.CheckScriptSuccess(lines + ['echo H(G(F1))'])
3927 v9.CheckScriptFailure(lines + ['echo H(G(F2))'], 'E1013:')
Bram Moolenaar1d9cef72022-03-17 16:30:03 +00003928
3929 v9.CheckScriptFailure(lines + ['def SomeFunc(ff: func)', 'enddef'], 'E704:')
Bram Moolenaar04947cc2021-03-06 19:26:46 +01003930enddef
3931
Bram Moolenaarbadf04f2022-03-12 21:28:22 +00003932def Test_call_func_with_null()
3933 var lines =<< trim END
3934 def Fstring(v: string)
3935 assert_equal(null_string, v)
3936 enddef
3937 Fstring(null_string)
3938 def Fblob(v: blob)
3939 assert_equal(null_blob, v)
3940 enddef
3941 Fblob(null_blob)
3942 def Flist(v: list<number>)
3943 assert_equal(null_list, v)
3944 enddef
3945 Flist(null_list)
3946 def Fdict(v: dict<number>)
3947 assert_equal(null_dict, v)
3948 enddef
3949 Fdict(null_dict)
3950 def Ffunc(Fv: func(number): number)
3951 assert_equal(null_function, Fv)
3952 enddef
3953 Ffunc(null_function)
3954 if has('channel')
3955 def Fchannel(v: channel)
3956 assert_equal(null_channel, v)
3957 enddef
3958 Fchannel(null_channel)
3959 def Fjob(v: job)
3960 assert_equal(null_job, v)
3961 enddef
3962 Fjob(null_job)
3963 endif
3964 END
3965 v9.CheckDefAndScriptSuccess(lines)
3966enddef
3967
3968def Test_null_default_argument()
3969 var lines =<< trim END
3970 def Fstring(v: string = null_string)
3971 assert_equal(null_string, v)
3972 enddef
3973 Fstring()
3974 def Fblob(v: blob = null_blob)
3975 assert_equal(null_blob, v)
3976 enddef
3977 Fblob()
3978 def Flist(v: list<number> = null_list)
3979 assert_equal(null_list, v)
3980 enddef
3981 Flist()
3982 def Fdict(v: dict<number> = null_dict)
3983 assert_equal(null_dict, v)
3984 enddef
3985 Fdict()
3986 def Ffunc(Fv: func(number): number = null_function)
3987 assert_equal(null_function, Fv)
3988 enddef
3989 Ffunc()
3990 if has('channel')
3991 def Fchannel(v: channel = null_channel)
3992 assert_equal(null_channel, v)
3993 enddef
3994 Fchannel()
3995 def Fjob(v: job = null_job)
3996 assert_equal(null_job, v)
3997 enddef
3998 Fjob()
3999 endif
4000 END
4001 v9.CheckDefAndScriptSuccess(lines)
4002enddef
4003
4004def Test_null_return()
4005 var lines =<< trim END
4006 def Fstring(): string
4007 return null_string
4008 enddef
4009 assert_equal(null_string, Fstring())
4010 def Fblob(): blob
4011 return null_blob
4012 enddef
4013 assert_equal(null_blob, Fblob())
4014 def Flist(): list<number>
4015 return null_list
4016 enddef
4017 assert_equal(null_list, Flist())
4018 def Fdict(): dict<number>
4019 return null_dict
4020 enddef
4021 assert_equal(null_dict, Fdict())
4022 def Ffunc(): func(number): number
4023 return null_function
4024 enddef
4025 assert_equal(null_function, Ffunc())
4026 if has('channel')
4027 def Fchannel(): channel
4028 return null_channel
4029 enddef
4030 assert_equal(null_channel, Fchannel())
4031 def Fjob(): job
4032 return null_job
4033 enddef
4034 assert_equal(null_job, Fjob())
4035 endif
4036 END
4037 v9.CheckDefAndScriptSuccess(lines)
4038enddef
4039
Bram Moolenaar6e48b842021-08-10 22:52:02 +02004040def Test_list_any_type_checked()
4041 var lines =<< trim END
4042 vim9script
4043 def Foo()
4044 --decl--
4045 Bar(l)
4046 enddef
4047 def Bar(ll: list<dict<any>>)
4048 enddef
4049 Foo()
4050 END
Bram Moolenaar2d3ac2e2022-02-03 12:34:05 +00004051 # "any" could be "dict<any>", thus OK
Bram Moolenaar6e48b842021-08-10 22:52:02 +02004052 lines[2] = 'var l: list<any>'
Bram Moolenaar2d3ac2e2022-02-03 12:34:05 +00004053 v9.CheckScriptSuccess(lines)
Bram Moolenaar6e48b842021-08-10 22:52:02 +02004054 lines[2] = 'var l: list<any> = []'
Bram Moolenaar2d3ac2e2022-02-03 12:34:05 +00004055 v9.CheckScriptSuccess(lines)
Bram Moolenaar6e48b842021-08-10 22:52:02 +02004056
4057 lines[2] = 'var l: list<any> = [11]'
Bram Moolenaar62aec932022-01-29 21:45:34 +00004058 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected list<dict<any>> but got list<number>', 2)
Bram Moolenaar6e48b842021-08-10 22:52:02 +02004059enddef
4060
Bram Moolenaar701cc6c2021-04-10 13:33:48 +02004061def Test_compile_error()
4062 var lines =<< trim END
4063 def g:Broken()
4064 echo 'a' + {}
4065 enddef
4066 call g:Broken()
4067 END
4068 # First call: compilation error
Bram Moolenaar62aec932022-01-29 21:45:34 +00004069 v9.CheckScriptFailure(lines, 'E1051: Wrong argument type for +')
Bram Moolenaar701cc6c2021-04-10 13:33:48 +02004070
4071 # Second call won't try compiling again
4072 assert_fails('call g:Broken()', 'E1091: Function is not compiled: Broken')
Bram Moolenaar599410c2021-04-10 14:03:43 +02004073 delfunc g:Broken
4074
4075 # No error when compiling with :silent!
4076 lines =<< trim END
4077 def g:Broken()
4078 echo 'a' + []
4079 enddef
4080 silent! defcompile
4081 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004082 v9.CheckScriptSuccess(lines)
Bram Moolenaar599410c2021-04-10 14:03:43 +02004083
4084 # Calling the function won't try compiling again
4085 assert_fails('call g:Broken()', 'E1091: Function is not compiled: Broken')
4086 delfunc g:Broken
Bram Moolenaar701cc6c2021-04-10 13:33:48 +02004087enddef
4088
Bram Moolenaar962c43b2021-04-10 17:18:09 +02004089def Test_ignored_argument()
4090 var lines =<< trim END
4091 vim9script
4092 def Ignore(_, _): string
4093 return 'yes'
4094 enddef
4095 assert_equal('yes', Ignore(1, 2))
4096
4097 func Ok(_)
4098 return a:_
4099 endfunc
4100 assert_equal('ok', Ok('ok'))
4101
4102 func Oktoo()
4103 let _ = 'too'
4104 return _
4105 endfunc
4106 assert_equal('too', Oktoo())
Bram Moolenaarda479c72021-04-10 21:01:38 +02004107
4108 assert_equal([[1], [2], [3]], range(3)->mapnew((_, v) => [v]->map((_, w) => w + 1)))
Bram Moolenaar962c43b2021-04-10 17:18:09 +02004109 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004110 v9.CheckScriptSuccess(lines)
Bram Moolenaar962c43b2021-04-10 17:18:09 +02004111
4112 lines =<< trim END
4113 def Ignore(_: string): string
4114 return _
4115 enddef
4116 defcompile
4117 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004118 v9.CheckScriptFailure(lines, 'E1181:', 1)
Bram Moolenaar962c43b2021-04-10 17:18:09 +02004119
4120 lines =<< trim END
4121 var _ = 1
4122 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004123 v9.CheckDefAndScriptFailure(lines, 'E1181:', 1)
Yegappan Lakshmanan34fcb692021-05-25 20:14:00 +02004124
4125 lines =<< trim END
4126 var x = _
4127 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004128 v9.CheckDefAndScriptFailure(lines, 'E1181:', 1)
Bram Moolenaar962c43b2021-04-10 17:18:09 +02004129enddef
4130
Bram Moolenaarbb8a7ce2021-04-10 20:10:26 +02004131def Test_too_many_arguments()
4132 var lines =<< trim END
4133 echo [0, 1, 2]->map(() => 123)
4134 END
Bram Moolenaareddd4fc2022-02-20 15:52:28 +00004135 v9.CheckDefAndScriptFailure(lines, ['E176:', 'E1106: 2 arguments too many'], 1)
Bram Moolenaarbb8a7ce2021-04-10 20:10:26 +02004136
4137 lines =<< trim END
4138 echo [0, 1, 2]->map((_) => 123)
4139 END
Bram Moolenaareddd4fc2022-02-20 15:52:28 +00004140 v9.CheckDefAndScriptFailure(lines, ['E176', 'E1106: One argument too many'], 1)
Bram Moolenaar31d99482022-05-26 22:24:43 +01004141
4142 lines =<< trim END
4143 vim9script
4144 def OneArgument(arg: string)
4145 echo arg
4146 enddef
4147 var Ref = OneArgument
4148 Ref('a', 'b')
4149 END
4150 v9.CheckScriptFailure(lines, 'E118:')
4151enddef
4152
4153def Test_funcref_with_base()
4154 var lines =<< trim END
4155 vim9script
4156 def TwoArguments(str: string, nr: number)
4157 echo str nr
4158 enddef
4159 var Ref = TwoArguments
4160 Ref('a', 12)
4161 'b'->Ref(34)
4162 END
4163 v9.CheckScriptSuccess(lines)
4164
4165 lines =<< trim END
4166 vim9script
4167 def TwoArguments(str: string, nr: number)
4168 echo str nr
4169 enddef
4170 var Ref = TwoArguments
4171 'a'->Ref('b')
4172 END
4173 v9.CheckScriptFailure(lines, 'E1013: Argument 2: type mismatch, expected number but got string', 6)
4174
4175 lines =<< trim END
4176 vim9script
4177 def TwoArguments(str: string, nr: number)
4178 echo str nr
4179 enddef
4180 var Ref = TwoArguments
4181 123->Ref(456)
4182 END
4183 v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected string but got number')
4184
4185 lines =<< trim END
4186 vim9script
4187 def TwoArguments(nr: number, str: string)
4188 echo str nr
4189 enddef
4190 var Ref = TwoArguments
4191 123->Ref('b')
4192 def AndNowCompiled()
4193 456->Ref('x')
4194 enddef
4195 AndNowCompiled()
4196 END
4197 v9.CheckScriptSuccess(lines)
Bram Moolenaarbb8a7ce2021-04-10 20:10:26 +02004198enddef
Bram Moolenaar077a4232020-12-22 18:33:27 +01004199
Bram Moolenaara6aa1642021-04-23 19:32:23 +02004200def Test_closing_brace_at_start_of_line()
4201 var lines =<< trim END
4202 def Func()
4203 enddef
4204 Func(
4205 )
4206 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004207 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaara6aa1642021-04-23 19:32:23 +02004208enddef
4209
Bram Moolenaar62aec932022-01-29 21:45:34 +00004210func s:CreateMydict()
Bram Moolenaarb033ee22021-08-15 16:08:36 +02004211 let g:mydict = {}
4212 func g:mydict.afunc()
4213 let g:result = self.key
4214 endfunc
4215endfunc
4216
4217def Test_numbered_function_reference()
4218 CreateMydict()
4219 var output = execute('legacy func g:mydict.afunc')
4220 var funcName = 'g:' .. substitute(output, '.*function \(\d\+\).*', '\1', '')
4221 execute 'function(' .. funcName .. ', [], {key: 42})()'
4222 # check that the function still exists
4223 assert_equal(output, execute('legacy func g:mydict.afunc'))
4224 unlet g:mydict
4225enddef
4226
Bram Moolenaard3a11782022-01-05 16:50:40 +00004227def Test_go_beyond_end_of_cmd()
4228 # this was reading the byte after the end of the line
4229 var lines =<< trim END
4230 def F()
4231 cal
4232 enddef
4233 defcompile
4234 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004235 v9.CheckScriptFailure(lines, 'E476:')
Bram Moolenaard3a11782022-01-05 16:50:40 +00004236enddef
4237
Yegappan Lakshmanan7c7e19c2022-04-09 11:09:07 +01004238" Test for memory allocation failure when defining a new lambda
4239func Test_lambda_allocation_failure()
4240 new
4241 let lines =<< trim END
4242 vim9script
4243 g:Xlambda = (x): number => {
4244 return x + 1
4245 }
4246 END
4247 call setline(1, lines)
4248 call test_alloc_fail(GetAllocId('get_func'), 0, 0)
4249 call assert_fails('source', 'E342:')
4250 call assert_false(exists('g:Xlambda'))
4251 bw!
4252endfunc
4253
Bram Moolenaarbce69d62022-05-22 13:45:52 +01004254def Test_multiple_funcref()
4255 # This was using a NULL pointer
4256 var lines =<< trim END
4257 vim9script
4258 def A(F: func, ...args: list<any>): func
4259 return funcref(F, args)
4260 enddef
4261
4262 def B(F: func): func
4263 return funcref(A, [F])
4264 enddef
4265
4266 def Test(n: number)
4267 enddef
4268
4269 const X = B(Test)
4270 X(1)
4271 END
4272 v9.CheckScriptSuccess(lines)
4273
4274 # slightly different case
4275 lines =<< trim END
4276 vim9script
4277
4278 def A(F: func, ...args: list<any>): any
4279 return call(F, args)
4280 enddef
4281
4282 def B(F: func): func
4283 return funcref(A, [F])
4284 enddef
4285
4286 def Test(n: number)
4287 enddef
4288
4289 const X = B(Test)
4290 X(1)
4291 END
4292 v9.CheckScriptSuccess(lines)
4293enddef
4294
Bram Moolenaarbd683e32022-07-18 17:49:03 +01004295def Test_cexpr_errmsg_line_number()
4296 var lines =<< trim END
4297 vim9script
4298 def Func()
4299 var qfl = {}
4300 cexpr qfl
4301 enddef
4302 Func()
4303 END
4304 v9.CheckScriptFailure(lines, 'E777', 2)
4305enddef
4306
Bram Moolenaar1d84f762022-09-03 21:35:53 +01004307def AddDefer(s: string)
4308 g:deferred->extend([s])
4309enddef
4310
4311def DeferTwo()
4312 g:deferred->extend(['in Two'])
4313 for n in range(3)
4314 defer g:AddDefer('two' .. n)
4315 endfor
4316 g:deferred->extend(['end Two'])
4317enddef
4318
4319def DeferOne()
4320 g:deferred->extend(['in One'])
4321 defer g:AddDefer('one')
4322 g:DeferTwo()
4323 g:deferred->extend(['end One'])
4324
4325 writefile(['text'], 'XdeferFile')
4326 defer delete('XdeferFile')
4327enddef
4328
4329def Test_defer()
4330 g:deferred = []
4331 g:DeferOne()
4332 assert_equal(['in One', 'in Two', 'end Two', 'two2', 'two1', 'two0', 'end One', 'one'], g:deferred)
4333 unlet g:deferred
4334 assert_equal('', glob('XdeferFile'))
4335enddef
4336
Bram Moolenaar8b716f52022-02-15 21:17:56 +00004337" The following messes up syntax highlight, keep near the end.
Bram Moolenaar20677332021-06-06 17:02:53 +02004338if has('python3')
Bram Moolenaar8b716f52022-02-15 21:17:56 +00004339 def Test_python3_command()
4340 py3 import vim
Bram Moolenaarf5288c52022-02-15 21:33:29 +00004341 py3 vim.command("g:done = 'yes'")
Bram Moolenaar8b716f52022-02-15 21:17:56 +00004342 assert_equal('yes', g:done)
4343 unlet g:done
4344 enddef
4345
Bram Moolenaar20677332021-06-06 17:02:53 +02004346 def Test_python3_heredoc()
4347 py3 << trim EOF
4348 import vim
4349 vim.vars['didit'] = 'yes'
4350 EOF
4351 assert_equal('yes', g:didit)
4352
4353 python3 << trim EOF
4354 import vim
4355 vim.vars['didit'] = 'again'
4356 EOF
4357 assert_equal('again', g:didit)
4358 enddef
4359endif
4360
Bram Moolenaar20677332021-06-06 17:02:53 +02004361if has('lua')
4362 def Test_lua_heredoc()
4363 g:d = {}
4364 lua << trim EOF
4365 x = vim.eval('g:d')
4366 x['key'] = 'val'
4367 EOF
4368 assert_equal('val', g:d.key)
4369 enddef
Bram Moolenaarefd73ae2022-03-20 18:51:00 +00004370
4371 def Test_lua_heredoc_fails()
4372 var lines = [
4373 'vim9script',
4374 'def ExeLua()',
4375 'lua << trim EOLUA',
4376 "x = vim.eval('g:nodict')",
4377 'EOLUA',
4378 'enddef',
4379 'ExeLua()',
4380 ]
4381 v9.CheckScriptFailure(lines, 'E121: Undefined variable: g:nodict')
4382 enddef
Bram Moolenaar20677332021-06-06 17:02:53 +02004383endif
4384
Bram Moolenaard881d152022-05-13 13:50:36 +01004385if has('perl')
4386 def Test_perl_heredoc_nested()
4387 var lines =<< trim END
4388 vim9script
4389 def F(): string
4390 def G(): string
4391 perl << EOF
4392 EOF
4393 return 'done'
4394 enddef
4395 return G()
4396 enddef
4397 assert_equal('done', F())
4398 END
4399 v9.CheckScriptSuccess(lines)
4400 enddef
4401endif
4402
Bram Moolenaarf7779c62020-05-03 15:38:16 +02004403
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02004404" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker