blob: 223b2fbda7703a1d50345847c1632218df413184 [file] [log] [blame]
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001" Test various aspects of the Vim9 script language.
2
3source check.vim
Bram Moolenaarad304702020-09-06 18:22:53 +02004source term_util.vim
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02005source view_util.vim
Bram Moolenaar04b12692020-05-04 23:24:44 +02006source vim9.vim
Bram Moolenaar47e7d702020-07-05 18:18:42 +02007source screendump.vim
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02008
9func Test_def_basic()
10 def SomeFunc(): string
11 return 'yes'
12 enddef
Bram Moolenaarc0c71e92020-09-11 19:09:48 +020013 call SomeFunc()->assert_equal('yes')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +020014endfunc
15
Bram Moolenaar2b9b17e2020-10-13 18:38:11 +020016func Test_compiling_error()
17 " use a terminal to see the whole error message
Bram Moolenaarf4e8cdd2020-10-12 22:07:13 +020018 CheckRunVimInTerminal
19
Bram Moolenaar2b9b17e2020-10-13 18:38:11 +020020 call TestCompilingError()
21endfunc
22
23def TestCompilingError()
Bram Moolenaarf4e8cdd2020-10-12 22:07:13 +020024 var lines =<< trim END
25 vim9script
26 def Fails()
27 echo nothing
28 enddef
29 defcompile
30 END
31 call writefile(lines, 'XTest_compile_error')
32 var buf = RunVimInTerminal('-S XTest_compile_error',
Bram Moolenaare0de1712020-12-02 17:36:54 +010033 {rows: 10, wait_for_ruler: 0})
Bram Moolenaarf4e8cdd2020-10-12 22:07:13 +020034 var text = ''
35 for loop in range(100)
36 text = ''
37 for i in range(1, 9)
38 text ..= term_getline(buf, i)
39 endfor
Bram Moolenaar18dc3552020-11-22 14:24:00 +010040 if text =~ 'Variable not found: nothing'
Bram Moolenaarf4e8cdd2020-10-12 22:07:13 +020041 break
42 endif
43 sleep 20m
44 endfor
45 assert_match('Error detected while compiling command line.*Fails.*Variable not found: nothing', text)
46
47 # clean up
48 call StopVimInTerminal(buf)
49 call delete('XTest_compile_error')
50enddef
51
Bram Moolenaar0ba48e82020-11-17 18:23:19 +010052def CallRecursive(n: number): number
53 return CallRecursive(n + 1)
54enddef
55
56def CallMapRecursive(l: list<number>): number
Bram Moolenaar2949cfd2020-12-31 21:28:47 +010057 return map(l, (_, v) => CallMapRecursive([v]))[0]
Bram Moolenaar0ba48e82020-11-17 18:23:19 +010058enddef
59
60def Test_funcdepth_error()
61 set maxfuncdepth=10
62
63 var caught = false
64 try
65 CallRecursive(1)
66 catch /E132:/
67 caught = true
68 endtry
69 assert_true(caught)
70
71 caught = false
72 try
73 CallMapRecursive([1])
74 catch /E132:/
75 caught = true
76 endtry
77 assert_true(caught)
78
79 set maxfuncdepth&
80enddef
81
Bram Moolenaar5178b1b2021-01-01 18:43:51 +010082def Test_endfunc_enddef()
83 var lines =<< trim END
84 def Test()
85 echo 'test'
86 endfunc
87 enddef
88 END
89 CheckScriptFailure(lines, 'E1151:', 3)
90
91 lines =<< trim END
92 def Test()
93 func Nested()
94 echo 'test'
95 enddef
96 enddef
97 END
98 CheckScriptFailure(lines, 'E1152:', 4)
99enddef
100
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200101def ReturnString(): string
102 return 'string'
103enddef
104
105def ReturnNumber(): number
106 return 123
107enddef
108
109let g:notNumber = 'string'
110
111def ReturnGlobal(): number
112 return g:notNumber
113enddef
114
115def Test_return_something()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200116 ReturnString()->assert_equal('string')
117 ReturnNumber()->assert_equal(123)
Bram Moolenaar5e654232020-09-16 15:22:00 +0200118 assert_fails('ReturnGlobal()', 'E1012: Type mismatch; expected number but got string', '', 1, 'ReturnGlobal')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200119enddef
120
Bram Moolenaarefd88552020-06-18 20:50:10 +0200121def Test_missing_return()
122 CheckDefFailure(['def Missing(): number',
123 ' if g:cond',
124 ' echo "no return"',
125 ' else',
126 ' return 0',
127 ' endif'
128 'enddef'], 'E1027:')
129 CheckDefFailure(['def Missing(): number',
130 ' if g:cond',
131 ' return 1',
132 ' else',
133 ' echo "no return"',
134 ' endif'
135 'enddef'], 'E1027:')
136 CheckDefFailure(['def Missing(): number',
137 ' if g:cond',
138 ' return 1',
139 ' else',
140 ' return 2',
141 ' endif'
142 ' return 3'
143 'enddef'], 'E1095:')
144enddef
145
Bram Moolenaar403dc312020-10-17 19:29:51 +0200146def Test_return_bool()
147 var lines =<< trim END
148 vim9script
149 def MenuFilter(id: number, key: string): bool
150 return popup_filter_menu(id, key)
151 enddef
152 def YesnoFilter(id: number, key: string): bool
153 return popup_filter_yesno(id, key)
154 enddef
155 defcompile
156 END
157 CheckScriptSuccess(lines)
158enddef
159
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200160let s:nothing = 0
161def ReturnNothing()
162 s:nothing = 1
163 if true
164 return
165 endif
166 s:nothing = 2
167enddef
168
169def Test_return_nothing()
170 ReturnNothing()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200171 s:nothing->assert_equal(1)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200172enddef
173
174func Increment()
175 let g:counter += 1
176endfunc
177
178def Test_call_ufunc_count()
179 g:counter = 1
180 Increment()
181 Increment()
182 Increment()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200183 # works with and without :call
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200184 g:counter->assert_equal(4)
185 eval g:counter->assert_equal(4)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200186 unlet g:counter
187enddef
188
189def MyVarargs(arg: string, ...rest: list<string>): string
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200190 var res = arg
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200191 for s in rest
192 res ..= ',' .. s
193 endfor
194 return res
195enddef
196
197def Test_call_varargs()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200198 MyVarargs('one')->assert_equal('one')
199 MyVarargs('one', 'two')->assert_equal('one,two')
200 MyVarargs('one', 'two', 'three')->assert_equal('one,two,three')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200201enddef
202
203def MyDefaultArgs(name = 'string'): string
204 return name
205enddef
206
Bram Moolenaare30f64b2020-07-15 19:48:20 +0200207def MyDefaultSecond(name: string, second: bool = true): string
208 return second ? name : 'none'
209enddef
210
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200211def Test_call_default_args()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200212 MyDefaultArgs()->assert_equal('string')
213 MyDefaultArgs('one')->assert_equal('one')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +0200214 assert_fails('MyDefaultArgs("one", "two")', 'E118:', '', 3, 'Test_call_default_args')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200215
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200216 MyDefaultSecond('test')->assert_equal('test')
217 MyDefaultSecond('test', true)->assert_equal('test')
218 MyDefaultSecond('test', false)->assert_equal('none')
Bram Moolenaare30f64b2020-07-15 19:48:20 +0200219
Bram Moolenaar822ba242020-05-24 23:00:18 +0200220 CheckScriptFailure(['def Func(arg: number = asdf)', 'enddef', 'defcompile'], 'E1001:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +0100221 delfunc g:Func
Bram Moolenaar77072282020-09-16 17:55:40 +0200222 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 +0100223 delfunc g:Func
Bram Moolenaar04b12692020-05-04 23:24:44 +0200224enddef
225
226def Test_nested_function()
227 def Nested(arg: string): string
228 return 'nested ' .. arg
229 enddef
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200230 Nested('function')->assert_equal('nested function')
Bram Moolenaar04b12692020-05-04 23:24:44 +0200231
Bram Moolenaar0e65d3d2020-05-05 17:53:16 +0200232 CheckDefFailure(['def Nested()', 'enddef', 'Nested(66)'], 'E118:')
233 CheckDefFailure(['def Nested(arg: string)', 'enddef', 'Nested()'], 'E119:')
234
Bram Moolenaar04b12692020-05-04 23:24:44 +0200235 CheckDefFailure(['func Nested()', 'endfunc'], 'E1086:')
Bram Moolenaarbcbf4132020-08-01 22:35:13 +0200236 CheckDefFailure(['def s:Nested()', 'enddef'], 'E1075:')
237 CheckDefFailure(['def b:Nested()', 'enddef'], 'E1075:')
Bram Moolenaar8b848ca2020-09-10 22:28:01 +0200238
Bram Moolenaar54021752020-12-06 18:50:36 +0100239 var lines =<< trim END
240 def Outer()
241 def Inner()
242 # comment
243 enddef
244 def Inner()
245 enddef
246 enddef
247 END
248 CheckDefFailure(lines, 'E1073:')
249
250 lines =<< trim END
251 def Outer()
252 def Inner()
253 # comment
254 enddef
255 def! Inner()
256 enddef
257 enddef
258 END
259 CheckDefFailure(lines, 'E1117:')
260
261 # nested function inside conditional
262 # TODO: should it work when "thecount" is inside the "if"?
263 lines =<< trim END
264 vim9script
265 var thecount = 0
266 if true
267 def Test(): number
268 def TheFunc(): number
269 thecount += 1
270 return thecount
271 enddef
272 return TheFunc()
273 enddef
274 endif
275 defcompile
276 assert_equal(1, Test())
277 assert_equal(2, Test())
278 END
279 CheckScriptSuccess(lines)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200280enddef
281
Bram Moolenaaradc8e442020-12-31 18:28:18 +0100282def Test_not_nested_function()
283 echo printf('%d',
284 function('len')('xxx'))
285enddef
286
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200287func Test_call_default_args_from_func()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200288 call MyDefaultArgs()->assert_equal('string')
289 call MyDefaultArgs('one')->assert_equal('one')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +0200290 call assert_fails('call MyDefaultArgs("one", "two")', 'E118:', '', 3, 'Test_call_default_args_from_func')
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200291endfunc
292
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200293def Test_nested_global_function()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200294 var lines =<< trim END
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200295 vim9script
296 def Outer()
297 def g:Inner(): string
298 return 'inner'
299 enddef
300 enddef
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200301 defcompile
302 Outer()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200303 g:Inner()->assert_equal('inner')
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200304 delfunc g:Inner
305 Outer()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200306 g:Inner()->assert_equal('inner')
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200307 delfunc g:Inner
308 Outer()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200309 g:Inner()->assert_equal('inner')
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200310 delfunc g:Inner
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200311 END
312 CheckScriptSuccess(lines)
Bram Moolenaar2c79e9d2020-08-01 18:57:52 +0200313
314 lines =<< trim END
315 vim9script
316 def Outer()
317 def g:Inner(): string
318 return 'inner'
319 enddef
320 enddef
321 defcompile
322 Outer()
323 Outer()
324 END
325 CheckScriptFailure(lines, "E122:")
Bram Moolenaarcd45ed02020-12-22 17:35:54 +0100326 delfunc g:Inner
Bram Moolenaarad486a02020-08-01 23:22:18 +0200327
328 lines =<< trim END
329 vim9script
Bram Moolenaar58a52f22020-12-22 18:56:55 +0100330 def Outer()
331 def g:Inner()
Bram Moolenaar2949cfd2020-12-31 21:28:47 +0100332 echo map([1, 2, 3], (_, v) => v + 1)
Bram Moolenaar58a52f22020-12-22 18:56:55 +0100333 enddef
334 g:Inner()
335 enddef
336 Outer()
337 END
338 CheckScriptSuccess(lines)
339 delfunc g:Inner
340
341 lines =<< trim END
342 vim9script
Bram Moolenaarad486a02020-08-01 23:22:18 +0200343 def Func()
344 echo 'script'
345 enddef
346 def Outer()
347 def Func()
348 echo 'inner'
349 enddef
350 enddef
351 defcompile
352 END
353 CheckScriptFailure(lines, "E1073:")
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200354enddef
355
Bram Moolenaar6abdcf82020-11-22 18:15:44 +0100356def DefListAll()
357 def
358enddef
359
360def DefListOne()
361 def DefListOne
362enddef
363
364def DefListMatches()
365 def /DefList
366enddef
367
368def Test_nested_def_list()
369 var funcs = split(execute('call DefListAll()'), "\n")
370 assert_true(len(funcs) > 10)
371 assert_true(funcs->index('def DefListAll()') >= 0)
372
373 funcs = split(execute('call DefListOne()'), "\n")
374 assert_equal([' def DefListOne()', '1 def DefListOne', ' enddef'], funcs)
375
376 funcs = split(execute('call DefListMatches()'), "\n")
377 assert_true(len(funcs) >= 3)
378 assert_true(funcs->index('def DefListAll()') >= 0)
379 assert_true(funcs->index('def DefListOne()') >= 0)
380 assert_true(funcs->index('def DefListMatches()') >= 0)
Bram Moolenaar54021752020-12-06 18:50:36 +0100381
382 var lines =<< trim END
383 vim9script
384 def Func()
385 def +Func+
386 enddef
387 defcompile
388 END
389 CheckScriptFailure(lines, 'E476:', 1)
Bram Moolenaar6abdcf82020-11-22 18:15:44 +0100390enddef
391
Bram Moolenaar333894b2020-08-01 18:53:07 +0200392def Test_global_local_function()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200393 var lines =<< trim END
Bram Moolenaar333894b2020-08-01 18:53:07 +0200394 vim9script
395 def g:Func(): string
396 return 'global'
397 enddef
398 def Func(): string
399 return 'local'
400 enddef
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200401 g:Func()->assert_equal('global')
402 Func()->assert_equal('local')
Bram Moolenaar2d870f82020-12-05 13:41:01 +0100403 delfunc g:Func
Bram Moolenaar333894b2020-08-01 18:53:07 +0200404 END
405 CheckScriptSuccess(lines)
Bram Moolenaar035d6e92020-08-11 22:30:42 +0200406
407 lines =<< trim END
408 vim9script
409 def g:Funcy()
410 echo 'funcy'
411 enddef
412 s:Funcy()
413 END
414 CheckScriptFailure(lines, 'E117:')
Bram Moolenaar333894b2020-08-01 18:53:07 +0200415enddef
416
Bram Moolenaar0f769812020-09-12 18:32:34 +0200417def Test_local_function_shadows_global()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200418 var lines =<< trim END
Bram Moolenaar0f769812020-09-12 18:32:34 +0200419 vim9script
420 def g:Gfunc(): string
421 return 'global'
422 enddef
423 def AnotherFunc(): number
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200424 var Gfunc = function('len')
Bram Moolenaar0f769812020-09-12 18:32:34 +0200425 return Gfunc('testing')
426 enddef
427 g:Gfunc()->assert_equal('global')
428 AnotherFunc()->assert_equal(7)
429 delfunc g:Gfunc
430 END
431 CheckScriptSuccess(lines)
432
433 lines =<< trim END
434 vim9script
435 def g:Func(): string
436 return 'global'
437 enddef
438 def AnotherFunc()
439 g:Func = function('len')
440 enddef
441 AnotherFunc()
442 END
443 CheckScriptFailure(lines, 'E705:')
444 delfunc g:Func
445enddef
446
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200447func TakesOneArg(arg)
448 echo a:arg
449endfunc
450
451def Test_call_wrong_args()
Bram Moolenaard2c61702020-09-06 15:58:36 +0200452 CheckDefFailure(['TakesOneArg()'], 'E119:')
453 CheckDefFailure(['TakesOneArg(11, 22)'], 'E118:')
454 CheckDefFailure(['bufnr(xxx)'], 'E1001:')
455 CheckScriptFailure(['def Func(Ref: func(s: string))'], 'E475:')
Bram Moolenaaree8580e2020-08-28 17:19:07 +0200456
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200457 var lines =<< trim END
Bram Moolenaaree8580e2020-08-28 17:19:07 +0200458 vim9script
459 def Func(s: string)
460 echo s
461 enddef
462 Func([])
463 END
Bram Moolenaar77072282020-09-16 17:55:40 +0200464 CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected string but got list<unknown>', 5)
Bram Moolenaarb185a402020-09-18 22:42:00 +0200465
466 lines =<< trim END
467 vim9script
468 def FuncOne(nr: number)
469 echo nr
470 enddef
471 def FuncTwo()
472 FuncOne()
473 enddef
474 defcompile
475 END
476 writefile(lines, 'Xscript')
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200477 var didCatch = false
Bram Moolenaarb185a402020-09-18 22:42:00 +0200478 try
479 source Xscript
480 catch
481 assert_match('E119: Not enough arguments for function: <SNR>\d\+_FuncOne', v:exception)
482 assert_match('Xscript\[8\]..function <SNR>\d\+_FuncTwo, line 1', v:throwpoint)
483 didCatch = true
484 endtry
485 assert_true(didCatch)
486
487 lines =<< trim END
488 vim9script
489 def FuncOne(nr: number)
490 echo nr
491 enddef
492 def FuncTwo()
493 FuncOne(1, 2)
494 enddef
495 defcompile
496 END
497 writefile(lines, 'Xscript')
498 didCatch = false
499 try
500 source Xscript
501 catch
502 assert_match('E118: Too many arguments for function: <SNR>\d\+_FuncOne', v:exception)
503 assert_match('Xscript\[8\]..function <SNR>\d\+_FuncTwo, line 1', v:throwpoint)
504 didCatch = true
505 endtry
506 assert_true(didCatch)
507
508 delete('Xscript')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200509enddef
510
Bram Moolenaar50824712020-12-20 21:10:17 +0100511def Test_call_funcref_wrong_args()
512 var head =<< trim END
513 vim9script
514 def Func3(a1: string, a2: number, a3: list<number>)
515 echo a1 .. a2 .. a3[0]
516 enddef
517 def Testme()
518 var funcMap: dict<func> = {func: Func3}
519 END
520 var tail =<< trim END
521 enddef
522 Testme()
523 END
524 CheckScriptSuccess(head + ["funcMap['func']('str', 123, [1, 2, 3])"] + tail)
525
526 CheckScriptFailure(head + ["funcMap['func']('str', 123)"] + tail, 'E119:')
527 CheckScriptFailure(head + ["funcMap['func']('str', 123, [1], 4)"] + tail, 'E118:')
528enddef
529
Bram Moolenaarb4d16cb2020-11-05 18:45:46 +0100530def Test_call_lambda_args()
Bram Moolenaar2949cfd2020-12-31 21:28:47 +0100531 CheckDefFailure(['echo ((i) => 0)()'],
532 'E119: Not enough arguments for function: ((i) => 0)()')
Bram Moolenaarb4d16cb2020-11-05 18:45:46 +0100533
534 var lines =<< trim END
Bram Moolenaar2949cfd2020-12-31 21:28:47 +0100535 var Ref = (x: number, y: number) => x + y
Bram Moolenaarb4d16cb2020-11-05 18:45:46 +0100536 echo Ref(1, 'x')
537 END
538 CheckDefFailure(lines, 'E1013: Argument 2: type mismatch, expected number but got string')
539enddef
540
Bram Moolenaar709664c2020-12-12 14:33:41 +0100541def Test_lambda_uses_assigned_var()
542 CheckDefSuccess([
543 'var x: any = "aaa"'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +0100544 'x = filter(["bbb"], (_, v) => v =~ x)'])
Bram Moolenaar709664c2020-12-12 14:33:41 +0100545enddef
546
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200547" Default arg and varargs
548def MyDefVarargs(one: string, two = 'foo', ...rest: list<string>): string
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200549 var res = one .. ',' .. two
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200550 for s in rest
551 res ..= ',' .. s
552 endfor
553 return res
554enddef
555
556def Test_call_def_varargs()
Bram Moolenaar9bd5d872020-09-06 21:47:48 +0200557 assert_fails('MyDefVarargs()', 'E119:', '', 1, 'Test_call_def_varargs')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200558 MyDefVarargs('one')->assert_equal('one,foo')
559 MyDefVarargs('one', 'two')->assert_equal('one,two')
560 MyDefVarargs('one', 'two', 'three')->assert_equal('one,two,three')
Bram Moolenaar24aa48b2020-07-25 16:33:02 +0200561 CheckDefFailure(['MyDefVarargs("one", 22)'],
Bram Moolenaar77072282020-09-16 17:55:40 +0200562 'E1013: Argument 2: type mismatch, expected string but got number')
Bram Moolenaar24aa48b2020-07-25 16:33:02 +0200563 CheckDefFailure(['MyDefVarargs("one", "two", 123)'],
Bram Moolenaar77072282020-09-16 17:55:40 +0200564 'E1013: Argument 3: type mismatch, expected string but got number')
Bram Moolenaar24aa48b2020-07-25 16:33:02 +0200565
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200566 var lines =<< trim END
Bram Moolenaar24aa48b2020-07-25 16:33:02 +0200567 vim9script
568 def Func(...l: list<string>)
569 echo l
570 enddef
571 Func('a', 'b', 'c')
572 END
573 CheckScriptSuccess(lines)
574
575 lines =<< trim END
576 vim9script
577 def Func(...l: list<string>)
578 echo l
579 enddef
580 Func()
581 END
582 CheckScriptSuccess(lines)
583
584 lines =<< trim END
585 vim9script
Bram Moolenaar2f8cbc42020-09-16 17:22:59 +0200586 def Func(...l: any)
587 echo l
588 enddef
589 Func(0)
590 END
591 CheckScriptSuccess(lines)
592
593 lines =<< trim END
594 vim9script
Bram Moolenaar28022722020-09-21 22:02:49 +0200595 def Func(..._l: list<string>)
596 echo _l
597 enddef
598 Func('a', 'b', 'c')
599 END
600 CheckScriptSuccess(lines)
601
602 lines =<< trim END
603 vim9script
Bram Moolenaar24aa48b2020-07-25 16:33:02 +0200604 def Func(...l: list<string>)
605 echo l
606 enddef
607 Func(1, 2, 3)
608 END
Bram Moolenaar77072282020-09-16 17:55:40 +0200609 CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch')
Bram Moolenaar24aa48b2020-07-25 16:33:02 +0200610
611 lines =<< trim END
612 vim9script
613 def Func(...l: list<string>)
614 echo l
615 enddef
616 Func('a', 9)
617 END
Bram Moolenaar77072282020-09-16 17:55:40 +0200618 CheckScriptFailure(lines, 'E1013: Argument 2: type mismatch')
Bram Moolenaar24aa48b2020-07-25 16:33:02 +0200619
620 lines =<< trim END
621 vim9script
622 def Func(...l: list<string>)
623 echo l
624 enddef
625 Func(1, 'a')
626 END
Bram Moolenaar77072282020-09-16 17:55:40 +0200627 CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200628enddef
629
Bram Moolenaar1378fbc2020-04-11 20:50:33 +0200630let s:value = ''
631
632def FuncOneDefArg(opt = 'text')
633 s:value = opt
634enddef
635
636def FuncTwoDefArg(nr = 123, opt = 'text'): string
637 return nr .. opt
638enddef
639
640def FuncVarargs(...arg: list<string>): string
641 return join(arg, ',')
642enddef
643
644def Test_func_type_varargs()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200645 var RefDefArg: func(?string)
Bram Moolenaar1378fbc2020-04-11 20:50:33 +0200646 RefDefArg = FuncOneDefArg
647 RefDefArg()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200648 s:value->assert_equal('text')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +0200649 RefDefArg('some')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200650 s:value->assert_equal('some')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +0200651
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200652 var RefDef2Arg: func(?number, ?string): string
Bram Moolenaar1378fbc2020-04-11 20:50:33 +0200653 RefDef2Arg = FuncTwoDefArg
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200654 RefDef2Arg()->assert_equal('123text')
655 RefDef2Arg(99)->assert_equal('99text')
656 RefDef2Arg(77, 'some')->assert_equal('77some')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +0200657
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200658 CheckDefFailure(['var RefWrong: func(string?)'], 'E1010:')
659 CheckDefFailure(['var RefWrong: func(?string, string)'], 'E1007:')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +0200660
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200661 var RefVarargs: func(...list<string>): string
Bram Moolenaar1378fbc2020-04-11 20:50:33 +0200662 RefVarargs = FuncVarargs
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200663 RefVarargs()->assert_equal('')
664 RefVarargs('one')->assert_equal('one')
665 RefVarargs('one', 'two')->assert_equal('one,two')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +0200666
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200667 CheckDefFailure(['var RefWrong: func(...list<string>, string)'], 'E110:')
668 CheckDefFailure(['var RefWrong: func(...list<string>, ?string)'], 'E110:')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +0200669enddef
670
Bram Moolenaar0b76b422020-04-07 22:05:08 +0200671" Only varargs
672def MyVarargsOnly(...args: list<string>): string
673 return join(args, ',')
674enddef
675
676def Test_call_varargs_only()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200677 MyVarargsOnly()->assert_equal('')
678 MyVarargsOnly('one')->assert_equal('one')
679 MyVarargsOnly('one', 'two')->assert_equal('one,two')
Bram Moolenaar77072282020-09-16 17:55:40 +0200680 CheckDefFailure(['MyVarargsOnly(1)'], 'E1013: Argument 1: type mismatch, expected string but got number')
681 CheckDefFailure(['MyVarargsOnly("one", 2)'], 'E1013: Argument 2: type mismatch, expected string but got number')
Bram Moolenaar0b76b422020-04-07 22:05:08 +0200682enddef
683
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200684def Test_using_var_as_arg()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200685 writefile(['def Func(x: number)', 'var x = 234', 'enddef', 'defcompile'], 'Xdef')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +0200686 assert_fails('so Xdef', 'E1006:', '', 1, 'Func')
Bram Moolenaard2c61702020-09-06 15:58:36 +0200687 delete('Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200688enddef
689
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +0200690def DictArg(arg: dict<string>)
691 arg['key'] = 'value'
692enddef
693
694def ListArg(arg: list<string>)
695 arg[0] = 'value'
696enddef
697
698def Test_assign_to_argument()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200699 # works for dict and list
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200700 var d: dict<string> = {}
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +0200701 DictArg(d)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200702 d['key']->assert_equal('value')
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200703 var l: list<string> = []
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +0200704 ListArg(l)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200705 l[0]->assert_equal('value')
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +0200706
Bram Moolenaard2c61702020-09-06 15:58:36 +0200707 CheckScriptFailure(['def Func(arg: number)', 'arg = 3', 'enddef', 'defcompile'], 'E1090:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +0100708 delfunc! g:Func
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +0200709enddef
710
Bram Moolenaarb816dae2020-09-20 22:04:00 +0200711" These argument names are reserved in legacy functions.
712def WithReservedNames(firstline: string, lastline: string): string
713 return firstline .. lastline
714enddef
715
716def Test_argument_names()
717 assert_equal('OK', WithReservedNames('O', 'K'))
718enddef
719
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200720def Test_call_func_defined_later()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200721 g:DefinedLater('one')->assert_equal('one')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +0200722 assert_fails('NotDefined("one")', 'E117:', '', 2, 'Test_call_func_defined_later')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200723enddef
724
Bram Moolenaar1df8b3f2020-04-23 18:13:23 +0200725func DefinedLater(arg)
726 return a:arg
727endfunc
728
729def Test_call_funcref()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200730 g:SomeFunc('abc')->assert_equal(3)
Bram Moolenaar9bd5d872020-09-06 21:47:48 +0200731 assert_fails('NotAFunc()', 'E117:', '', 2, 'Test_call_funcref') # comment after call
732 assert_fails('g:NotAFunc()', 'E117:', '', 3, 'Test_call_funcref')
Bram Moolenaar2f1980f2020-07-22 19:30:06 +0200733
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200734 var lines =<< trim END
Bram Moolenaar2f1980f2020-07-22 19:30:06 +0200735 vim9script
736 def RetNumber(): number
737 return 123
738 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200739 var Funcref: func: number = function('RetNumber')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200740 Funcref()->assert_equal(123)
Bram Moolenaar2f1980f2020-07-22 19:30:06 +0200741 END
742 CheckScriptSuccess(lines)
Bram Moolenaar0f60e802020-07-22 20:16:11 +0200743
744 lines =<< trim END
745 vim9script
746 def RetNumber(): number
747 return 123
748 enddef
749 def Bar(F: func: number): number
750 return F()
751 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200752 var Funcref = function('RetNumber')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200753 Bar(Funcref)->assert_equal(123)
Bram Moolenaar0f60e802020-07-22 20:16:11 +0200754 END
755 CheckScriptSuccess(lines)
Bram Moolenaarbfba8652020-07-23 20:09:10 +0200756
757 lines =<< trim END
758 vim9script
759 def UseNumber(nr: number)
760 echo nr
761 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200762 var Funcref: func(number) = function('UseNumber')
Bram Moolenaarbfba8652020-07-23 20:09:10 +0200763 Funcref(123)
764 END
765 CheckScriptSuccess(lines)
Bram Moolenaarb8070e32020-07-23 20:56:04 +0200766
767 lines =<< trim END
768 vim9script
769 def UseNumber(nr: number)
770 echo nr
771 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200772 var Funcref: func(string) = function('UseNumber')
Bram Moolenaarb8070e32020-07-23 20:56:04 +0200773 END
Bram Moolenaar5e654232020-09-16 15:22:00 +0200774 CheckScriptFailure(lines, 'E1012: Type mismatch; expected func(string) but got func(number)')
Bram Moolenaar4fc224c2020-07-26 17:56:25 +0200775
776 lines =<< trim END
777 vim9script
778 def EchoNr(nr = 34)
779 g:echo = nr
780 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200781 var Funcref: func(?number) = function('EchoNr')
Bram Moolenaar4fc224c2020-07-26 17:56:25 +0200782 Funcref()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200783 g:echo->assert_equal(34)
Bram Moolenaar4fc224c2020-07-26 17:56:25 +0200784 Funcref(123)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200785 g:echo->assert_equal(123)
Bram Moolenaar4fc224c2020-07-26 17:56:25 +0200786 END
787 CheckScriptSuccess(lines)
Bram Moolenaarace61322020-07-26 18:16:58 +0200788
789 lines =<< trim END
790 vim9script
791 def EchoList(...l: list<number>)
792 g:echo = l
793 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200794 var Funcref: func(...list<number>) = function('EchoList')
Bram Moolenaarace61322020-07-26 18:16:58 +0200795 Funcref()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200796 g:echo->assert_equal([])
Bram Moolenaarace61322020-07-26 18:16:58 +0200797 Funcref(1, 2, 3)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200798 g:echo->assert_equal([1, 2, 3])
Bram Moolenaarace61322020-07-26 18:16:58 +0200799 END
800 CheckScriptSuccess(lines)
Bram Moolenaar01865ad2020-07-26 18:33:09 +0200801
802 lines =<< trim END
803 vim9script
804 def OptAndVar(nr: number, opt = 12, ...l: list<number>): number
805 g:optarg = opt
806 g:listarg = l
807 return nr
808 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200809 var Funcref: func(number, ?number, ...list<number>): number = function('OptAndVar')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200810 Funcref(10)->assert_equal(10)
811 g:optarg->assert_equal(12)
812 g:listarg->assert_equal([])
Bram Moolenaar01865ad2020-07-26 18:33:09 +0200813
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200814 Funcref(11, 22)->assert_equal(11)
815 g:optarg->assert_equal(22)
816 g:listarg->assert_equal([])
Bram Moolenaar01865ad2020-07-26 18:33:09 +0200817
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200818 Funcref(17, 18, 1, 2, 3)->assert_equal(17)
819 g:optarg->assert_equal(18)
820 g:listarg->assert_equal([1, 2, 3])
Bram Moolenaar01865ad2020-07-26 18:33:09 +0200821 END
822 CheckScriptSuccess(lines)
Bram Moolenaar1df8b3f2020-04-23 18:13:23 +0200823enddef
824
825let SomeFunc = function('len')
826let NotAFunc = 'text'
827
Bram Moolenaar99aaf0c2020-04-12 14:39:53 +0200828def CombineFuncrefTypes()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200829 # same arguments, different return type
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200830 var Ref1: func(bool): string
831 var Ref2: func(bool): number
832 var Ref3: func(bool): any
Bram Moolenaar99aaf0c2020-04-12 14:39:53 +0200833 Ref3 = g:cond ? Ref1 : Ref2
834
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200835 # different number of arguments
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200836 var Refa1: func(bool): number
837 var Refa2: func(bool, number): number
838 var Refa3: func: number
Bram Moolenaar99aaf0c2020-04-12 14:39:53 +0200839 Refa3 = g:cond ? Refa1 : Refa2
840
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200841 # different argument types
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200842 var Refb1: func(bool, string): number
843 var Refb2: func(string, number): number
844 var Refb3: func(any, any): number
Bram Moolenaar99aaf0c2020-04-12 14:39:53 +0200845 Refb3 = g:cond ? Refb1 : Refb2
846enddef
847
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200848def FuncWithForwardCall()
Bram Moolenaar1df8b3f2020-04-23 18:13:23 +0200849 return g:DefinedEvenLater("yes")
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200850enddef
851
852def DefinedEvenLater(arg: string): string
853 return arg
854enddef
855
856def Test_error_in_nested_function()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200857 # Error in called function requires unwinding the call stack.
Bram Moolenaar44d66522020-09-06 22:26:57 +0200858 assert_fails('FuncWithForwardCall()', 'E1096:', '', 1, 'FuncWithForwardCall')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200859enddef
860
861def Test_return_type_wrong()
Bram Moolenaar5a849da2020-08-08 16:47:30 +0200862 CheckScriptFailure([
863 'def Func(): number',
864 'return "a"',
865 'enddef',
866 'defcompile'], 'expected number but got string')
Bram Moolenaar2d870f82020-12-05 13:41:01 +0100867 delfunc! g:Func
Bram Moolenaar5a849da2020-08-08 16:47:30 +0200868 CheckScriptFailure([
869 'def Func(): string',
870 'return 1',
871 'enddef',
872 'defcompile'], 'expected string but got number')
Bram Moolenaar2d870f82020-12-05 13:41:01 +0100873 delfunc! g:Func
Bram Moolenaar5a849da2020-08-08 16:47:30 +0200874 CheckScriptFailure([
875 'def Func(): void',
876 'return "a"',
877 'enddef',
878 'defcompile'],
879 'E1096: Returning a value in a function without a return type')
Bram Moolenaar2d870f82020-12-05 13:41:01 +0100880 delfunc! g:Func
Bram Moolenaar5a849da2020-08-08 16:47:30 +0200881 CheckScriptFailure([
882 'def Func()',
883 'return "a"',
884 'enddef',
885 'defcompile'],
886 'E1096: Returning a value in a function without a return type')
Bram Moolenaar2d870f82020-12-05 13:41:01 +0100887 delfunc! g:Func
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200888
Bram Moolenaar5a849da2020-08-08 16:47:30 +0200889 CheckScriptFailure([
890 'def Func(): number',
891 'return',
892 'enddef',
893 'defcompile'], 'E1003:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +0100894 delfunc! g:Func
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200895
896 CheckScriptFailure(['def Func(): list', 'return []', 'enddef'], 'E1008:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +0100897 delfunc! g:Func
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200898 CheckScriptFailure(['def Func(): dict', 'return {}', 'enddef'], 'E1008:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +0100899 delfunc! g:Func
Bram Moolenaaree4e0c12020-04-06 21:35:05 +0200900 CheckScriptFailure(['def Func()', 'return 1'], 'E1057:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +0100901 delfunc! g:Func
Bram Moolenaar5a849da2020-08-08 16:47:30 +0200902
903 CheckScriptFailure([
904 'vim9script',
905 'def FuncB()',
906 ' return 123',
907 'enddef',
908 'def FuncA()',
909 ' FuncB()',
910 'enddef',
911 'defcompile'], 'E1096:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200912enddef
913
914def Test_arg_type_wrong()
915 CheckScriptFailure(['def Func3(items: list)', 'echo "a"', 'enddef'], 'E1008: Missing <type>')
Bram Moolenaaree4e0c12020-04-06 21:35:05 +0200916 CheckScriptFailure(['def Func4(...)', 'echo "a"', 'enddef'], 'E1055: Missing name after ...')
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +0200917 CheckScriptFailure(['def Func5(items:string)', 'echo "a"'], 'E1069:')
Bram Moolenaar6e949782020-04-13 17:21:00 +0200918 CheckScriptFailure(['def Func5(items)', 'echo "a"'], 'E1077:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200919enddef
920
921def Test_vim9script_call()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200922 var lines =<< trim END
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200923 vim9script
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200924 var name = ''
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200925 def MyFunc(arg: string)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200926 name = arg
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200927 enddef
928 MyFunc('foobar')
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200929 name->assert_equal('foobar')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200930
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200931 var str = 'barfoo'
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200932 str->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200933 name->assert_equal('barfoo')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200934
Bram Moolenaar67979662020-06-20 22:50:47 +0200935 g:value = 'value'
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200936 g:value->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200937 name->assert_equal('value')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200938
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200939 var listvar = []
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200940 def ListFunc(arg: list<number>)
941 listvar = arg
942 enddef
943 [1, 2, 3]->ListFunc()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200944 listvar->assert_equal([1, 2, 3])
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200945
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200946 var dictvar = {}
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200947 def DictFunc(arg: dict<number>)
948 dictvar = arg
949 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +0100950 {a: 1, b: 2}->DictFunc()
951 dictvar->assert_equal({a: 1, b: 2})
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200952 def CompiledDict()
Bram Moolenaare0de1712020-12-02 17:36:54 +0100953 {a: 3, b: 4}->DictFunc()
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200954 enddef
955 CompiledDict()
Bram Moolenaare0de1712020-12-02 17:36:54 +0100956 dictvar->assert_equal({a: 3, b: 4})
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200957
Bram Moolenaare0de1712020-12-02 17:36:54 +0100958 {a: 3, b: 4}->DictFunc()
959 dictvar->assert_equal({a: 3, b: 4})
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200960
961 ('text')->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200962 name->assert_equal('text')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200963 ("some")->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200964 name->assert_equal('some')
Bram Moolenaare6b53242020-07-01 17:28:33 +0200965
Bram Moolenaar13e12b82020-07-24 18:47:22 +0200966 # line starting with single quote is not a mark
Bram Moolenaar10409562020-07-29 20:00:38 +0200967 # line starting with double quote can be a method call
Bram Moolenaar3d48e252020-07-15 14:15:52 +0200968 'asdfasdf'->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200969 name->assert_equal('asdfasdf')
Bram Moolenaar10409562020-07-29 20:00:38 +0200970 "xyz"->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200971 name->assert_equal('xyz')
Bram Moolenaar3d48e252020-07-15 14:15:52 +0200972
973 def UseString()
974 'xyork'->MyFunc()
975 enddef
976 UseString()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200977 name->assert_equal('xyork')
Bram Moolenaar3d48e252020-07-15 14:15:52 +0200978
Bram Moolenaar10409562020-07-29 20:00:38 +0200979 def UseString2()
980 "knife"->MyFunc()
981 enddef
982 UseString2()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200983 name->assert_equal('knife')
Bram Moolenaar10409562020-07-29 20:00:38 +0200984
Bram Moolenaar13e12b82020-07-24 18:47:22 +0200985 # prepending a colon makes it a mark
986 new
987 setline(1, ['aaa', 'bbb', 'ccc'])
988 normal! 3Gmt1G
989 :'t
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200990 getcurpos()[1]->assert_equal(3)
Bram Moolenaar13e12b82020-07-24 18:47:22 +0200991 bwipe!
992
Bram Moolenaare6b53242020-07-01 17:28:33 +0200993 MyFunc(
994 'continued'
995 )
996 assert_equal('continued',
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200997 name
Bram Moolenaare6b53242020-07-01 17:28:33 +0200998 )
999
1000 call MyFunc(
1001 'more'
1002 ..
1003 'lines'
1004 )
1005 assert_equal(
1006 'morelines',
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001007 name)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001008 END
1009 writefile(lines, 'Xcall.vim')
1010 source Xcall.vim
1011 delete('Xcall.vim')
1012enddef
1013
1014def Test_vim9script_call_fail_decl()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001015 var lines =<< trim END
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001016 vim9script
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001017 var name = ''
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001018 def MyFunc(arg: string)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001019 var name = 123
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001020 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +02001021 defcompile
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001022 END
Bram Moolenaar6c4bfe42020-07-23 18:26:30 +02001023 CheckScriptFailure(lines, 'E1054:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001024enddef
1025
Bram Moolenaar65b95452020-07-19 14:03:09 +02001026def Test_vim9script_call_fail_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001027 var lines =<< trim END
Bram Moolenaar65b95452020-07-19 14:03:09 +02001028 vim9script
1029 def MyFunc(arg: string)
1030 echo arg
1031 enddef
1032 MyFunc(1234)
1033 END
Bram Moolenaar77072282020-09-16 17:55:40 +02001034 CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected string but got number')
Bram Moolenaar65b95452020-07-19 14:03:09 +02001035enddef
1036
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001037def Test_vim9script_call_fail_const()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001038 var lines =<< trim END
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001039 vim9script
1040 const var = ''
1041 def MyFunc(arg: string)
1042 var = 'asdf'
1043 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +02001044 defcompile
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001045 END
1046 writefile(lines, 'Xcall_const.vim')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +02001047 assert_fails('source Xcall_const.vim', 'E46:', '', 1, 'MyFunc')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001048 delete('Xcall_const.vim')
Bram Moolenaar3bdc90b2020-12-22 20:35:40 +01001049
1050 lines =<< trim END
1051 const g:Aconst = 77
1052 def Change()
1053 # comment
1054 g:Aconst = 99
1055 enddef
1056 call Change()
1057 unlet g:Aconst
1058 END
Bram Moolenaar1dcf55d2020-12-22 22:07:30 +01001059 CheckScriptFailure(lines, 'E741: Value is locked: Aconst', 2)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001060enddef
1061
1062" Test that inside :function a Python function can be defined, :def is not
1063" recognized.
1064func Test_function_python()
1065 CheckFeature python3
Bram Moolenaar727345e2020-09-27 23:33:59 +02001066 let py = 'python3'
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001067 execute py "<< EOF"
1068def do_something():
1069 return 1
1070EOF
1071endfunc
1072
1073def Test_delfunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001074 var lines =<< trim END
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001075 vim9script
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001076 def g:GoneSoon()
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001077 echo 'hello'
1078 enddef
1079
1080 def CallGoneSoon()
1081 GoneSoon()
1082 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +02001083 defcompile
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001084
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001085 delfunc g:GoneSoon
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001086 CallGoneSoon()
1087 END
1088 writefile(lines, 'XToDelFunc')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +02001089 assert_fails('so XToDelFunc', 'E933:', '', 1, 'CallGoneSoon')
1090 assert_fails('so XToDelFunc', 'E933:', '', 1, 'CallGoneSoon')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001091
1092 delete('XToDelFunc')
1093enddef
1094
1095def Test_redef_failure()
Bram Moolenaard2c61702020-09-06 15:58:36 +02001096 writefile(['def Func0(): string', 'return "Func0"', 'enddef'], 'Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001097 so Xdef
Bram Moolenaard2c61702020-09-06 15:58:36 +02001098 writefile(['def Func1(): string', 'return "Func1"', 'enddef'], 'Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001099 so Xdef
Bram Moolenaard2c61702020-09-06 15:58:36 +02001100 writefile(['def! Func0(): string', 'enddef', 'defcompile'], 'Xdef')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +02001101 assert_fails('so Xdef', 'E1027:', '', 1, 'Func0')
Bram Moolenaard2c61702020-09-06 15:58:36 +02001102 writefile(['def Func2(): string', 'return "Func2"', 'enddef'], 'Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001103 so Xdef
Bram Moolenaard2c61702020-09-06 15:58:36 +02001104 delete('Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001105
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001106 g:Func0()->assert_equal(0)
1107 g:Func1()->assert_equal('Func1')
1108 g:Func2()->assert_equal('Func2')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001109
1110 delfunc! Func0
1111 delfunc! Func1
1112 delfunc! Func2
1113enddef
1114
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001115def Test_vim9script_func()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001116 var lines =<< trim END
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001117 vim9script
1118 func Func(arg)
1119 echo a:arg
1120 endfunc
1121 Func('text')
1122 END
1123 writefile(lines, 'XVim9Func')
1124 so XVim9Func
1125
1126 delete('XVim9Func')
1127enddef
1128
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001129let s:funcResult = 0
1130
1131def FuncNoArgNoRet()
Bram Moolenaar53900992020-08-22 19:02:02 +02001132 s:funcResult = 11
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001133enddef
1134
1135def FuncNoArgRetNumber(): number
Bram Moolenaar53900992020-08-22 19:02:02 +02001136 s:funcResult = 22
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001137 return 1234
1138enddef
1139
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001140def FuncNoArgRetString(): string
Bram Moolenaar53900992020-08-22 19:02:02 +02001141 s:funcResult = 45
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001142 return 'text'
1143enddef
1144
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001145def FuncOneArgNoRet(arg: number)
Bram Moolenaar53900992020-08-22 19:02:02 +02001146 s:funcResult = arg
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001147enddef
1148
1149def FuncOneArgRetNumber(arg: number): number
Bram Moolenaar53900992020-08-22 19:02:02 +02001150 s:funcResult = arg
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001151 return arg
1152enddef
1153
Bram Moolenaar08938ee2020-04-11 23:17:17 +02001154def FuncTwoArgNoRet(one: bool, two: number)
Bram Moolenaar53900992020-08-22 19:02:02 +02001155 s:funcResult = two
Bram Moolenaar08938ee2020-04-11 23:17:17 +02001156enddef
1157
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001158def FuncOneArgRetString(arg: string): string
1159 return arg
1160enddef
1161
Bram Moolenaar89228602020-04-05 22:14:54 +02001162def FuncOneArgRetAny(arg: any): any
1163 return arg
1164enddef
1165
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001166def Test_func_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001167 var Ref1: func()
Bram Moolenaar53900992020-08-22 19:02:02 +02001168 s:funcResult = 0
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001169 Ref1 = FuncNoArgNoRet
1170 Ref1()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001171 s:funcResult->assert_equal(11)
Bram Moolenaar4c683752020-04-05 21:38:23 +02001172
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001173 var Ref2: func
Bram Moolenaar53900992020-08-22 19:02:02 +02001174 s:funcResult = 0
Bram Moolenaar4c683752020-04-05 21:38:23 +02001175 Ref2 = FuncNoArgNoRet
1176 Ref2()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001177 s:funcResult->assert_equal(11)
Bram Moolenaar4c683752020-04-05 21:38:23 +02001178
Bram Moolenaar53900992020-08-22 19:02:02 +02001179 s:funcResult = 0
Bram Moolenaar4c683752020-04-05 21:38:23 +02001180 Ref2 = FuncOneArgNoRet
1181 Ref2(12)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001182 s:funcResult->assert_equal(12)
Bram Moolenaar4c683752020-04-05 21:38:23 +02001183
Bram Moolenaar53900992020-08-22 19:02:02 +02001184 s:funcResult = 0
Bram Moolenaar4c683752020-04-05 21:38:23 +02001185 Ref2 = FuncNoArgRetNumber
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001186 Ref2()->assert_equal(1234)
1187 s:funcResult->assert_equal(22)
Bram Moolenaar4c683752020-04-05 21:38:23 +02001188
Bram Moolenaar53900992020-08-22 19:02:02 +02001189 s:funcResult = 0
Bram Moolenaar4c683752020-04-05 21:38:23 +02001190 Ref2 = FuncOneArgRetNumber
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001191 Ref2(13)->assert_equal(13)
1192 s:funcResult->assert_equal(13)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001193enddef
1194
Bram Moolenaar9978d472020-07-05 16:01:56 +02001195def Test_repeat_return_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001196 var res = 0
Bram Moolenaar9978d472020-07-05 16:01:56 +02001197 for n in repeat([1], 3)
1198 res += n
1199 endfor
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001200 res->assert_equal(3)
Bram Moolenaarfce82b32020-07-05 16:07:21 +02001201
1202 res = 0
1203 for n in add([1, 2], 3)
1204 res += n
1205 endfor
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001206 res->assert_equal(6)
Bram Moolenaar9978d472020-07-05 16:01:56 +02001207enddef
1208
Bram Moolenaar846178a2020-07-05 17:04:13 +02001209def Test_argv_return_type()
1210 next fileone filetwo
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001211 var res = ''
Bram Moolenaar846178a2020-07-05 17:04:13 +02001212 for name in argv()
1213 res ..= name
1214 endfor
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001215 res->assert_equal('fileonefiletwo')
Bram Moolenaar846178a2020-07-05 17:04:13 +02001216enddef
1217
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001218def Test_func_type_part()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001219 var RefVoid: func: void
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001220 RefVoid = FuncNoArgNoRet
1221 RefVoid = FuncOneArgNoRet
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001222 CheckDefFailure(['var RefVoid: func: void', 'RefVoid = FuncNoArgRetNumber'], 'E1012: Type mismatch; expected func(...) but got func(): number')
1223 CheckDefFailure(['var RefVoid: func: void', 'RefVoid = FuncNoArgRetString'], 'E1012: Type mismatch; expected func(...) but got func(): string')
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001224
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001225 var RefAny: func(): any
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001226 RefAny = FuncNoArgRetNumber
1227 RefAny = FuncNoArgRetString
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001228 CheckDefFailure(['var RefAny: func(): any', 'RefAny = FuncNoArgNoRet'], 'E1012: Type mismatch; expected func(): any but got func()')
1229 CheckDefFailure(['var RefAny: func(): any', 'RefAny = FuncOneArgNoRet'], 'E1012: Type mismatch; expected func(): any but got func(number)')
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001230
Bram Moolenaar6abd3dc2020-10-04 14:17:32 +02001231 var RefAnyNoArgs: func: any = RefAny
1232
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001233 var RefNr: func: number
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001234 RefNr = FuncNoArgRetNumber
1235 RefNr = FuncOneArgRetNumber
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001236 CheckDefFailure(['var RefNr: func: number', 'RefNr = FuncNoArgNoRet'], 'E1012: Type mismatch; expected func(...): number but got func()')
1237 CheckDefFailure(['var RefNr: func: number', 'RefNr = FuncNoArgRetString'], 'E1012: Type mismatch; expected func(...): number but got func(): string')
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001238
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001239 var RefStr: func: string
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001240 RefStr = FuncNoArgRetString
1241 RefStr = FuncOneArgRetString
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001242 CheckDefFailure(['var RefStr: func: string', 'RefStr = FuncNoArgNoRet'], 'E1012: Type mismatch; expected func(...): string but got func()')
1243 CheckDefFailure(['var RefStr: func: string', 'RefStr = FuncNoArgRetNumber'], 'E1012: Type mismatch; expected func(...): string but got func(): number')
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001244enddef
1245
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001246def Test_func_type_fails()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001247 CheckDefFailure(['var ref1: func()'], 'E704:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001248
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001249 CheckDefFailure(['var Ref1: func()', 'Ref1 = FuncNoArgRetNumber'], 'E1012: Type mismatch; expected func() but got func(): number')
1250 CheckDefFailure(['var Ref1: func()', 'Ref1 = FuncOneArgNoRet'], 'E1012: Type mismatch; expected func() but got func(number)')
1251 CheckDefFailure(['var Ref1: func()', 'Ref1 = FuncOneArgRetNumber'], 'E1012: Type mismatch; expected func() but got func(number): number')
1252 CheckDefFailure(['var Ref1: func(bool)', 'Ref1 = FuncTwoArgNoRet'], 'E1012: Type mismatch; expected func(bool) but got func(bool, number)')
1253 CheckDefFailure(['var Ref1: func(?bool)', 'Ref1 = FuncTwoArgNoRet'], 'E1012: Type mismatch; expected func(?bool) but got func(bool, number)')
1254 CheckDefFailure(['var Ref1: func(...bool)', 'Ref1 = FuncTwoArgNoRet'], 'E1012: Type mismatch; expected func(...bool) but got func(bool, number)')
Bram Moolenaar08938ee2020-04-11 23:17:17 +02001255
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001256 CheckDefFailure(['var RefWrong: func(string ,number)'], 'E1068:')
1257 CheckDefFailure(['var RefWrong: func(string,number)'], 'E1069:')
1258 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:')
1259 CheckDefFailure(['var RefWrong: func(bool):string'], 'E1069:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001260enddef
1261
Bram Moolenaar89228602020-04-05 22:14:54 +02001262def Test_func_return_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001263 var nr: number
Bram Moolenaar89228602020-04-05 22:14:54 +02001264 nr = FuncNoArgRetNumber()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001265 nr->assert_equal(1234)
Bram Moolenaar89228602020-04-05 22:14:54 +02001266
1267 nr = FuncOneArgRetAny(122)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001268 nr->assert_equal(122)
Bram Moolenaar89228602020-04-05 22:14:54 +02001269
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001270 var str: string
Bram Moolenaar89228602020-04-05 22:14:54 +02001271 str = FuncOneArgRetAny('yes')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001272 str->assert_equal('yes')
Bram Moolenaar89228602020-04-05 22:14:54 +02001273
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001274 CheckDefFailure(['var str: string', 'str = FuncNoArgRetNumber()'], 'E1012: Type mismatch; expected string but got number')
Bram Moolenaar89228602020-04-05 22:14:54 +02001275enddef
1276
Bram Moolenaar6abd3dc2020-10-04 14:17:32 +02001277def Test_func_common_type()
1278 def FuncOne(n: number): number
1279 return n
1280 enddef
1281 def FuncTwo(s: string): number
1282 return len(s)
1283 enddef
1284 def FuncThree(n: number, s: string): number
1285 return n + len(s)
1286 enddef
1287 var list = [FuncOne, FuncTwo, FuncThree]
1288 assert_equal(8, list[0](8))
1289 assert_equal(4, list[1]('word'))
1290 assert_equal(7, list[2](3, 'word'))
1291enddef
1292
Bram Moolenaar5e774c72020-04-12 21:53:00 +02001293def MultiLine(
1294 arg1: string,
1295 arg2 = 1234,
1296 ...rest: list<string>
1297 ): string
1298 return arg1 .. arg2 .. join(rest, '-')
1299enddef
1300
Bram Moolenaar2c330432020-04-13 14:41:35 +02001301def MultiLineComment(
1302 arg1: string, # comment
1303 arg2 = 1234, # comment
1304 ...rest: list<string> # comment
1305 ): string # comment
1306 return arg1 .. arg2 .. join(rest, '-')
1307enddef
1308
Bram Moolenaar5e774c72020-04-12 21:53:00 +02001309def Test_multiline()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001310 MultiLine('text')->assert_equal('text1234')
1311 MultiLine('text', 777)->assert_equal('text777')
1312 MultiLine('text', 777, 'one')->assert_equal('text777one')
1313 MultiLine('text', 777, 'one', 'two')->assert_equal('text777one-two')
Bram Moolenaar5e774c72020-04-12 21:53:00 +02001314enddef
1315
Bram Moolenaar23e03252020-04-12 22:22:31 +02001316func Test_multiline_not_vim9()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001317 call MultiLine('text')->assert_equal('text1234')
1318 call MultiLine('text', 777)->assert_equal('text777')
1319 call MultiLine('text', 777, 'one')->assert_equal('text777one')
1320 call MultiLine('text', 777, 'one', 'two')->assert_equal('text777one-two')
Bram Moolenaar23e03252020-04-12 22:22:31 +02001321endfunc
1322
Bram Moolenaar5e774c72020-04-12 21:53:00 +02001323
Bram Moolenaaree4e0c12020-04-06 21:35:05 +02001324" When using CheckScriptFailure() for the below test, E1010 is generated instead
1325" of E1056.
1326func Test_E1056_1059()
1327 let caught_1056 = 0
1328 try
1329 def F():
1330 return 1
1331 enddef
1332 catch /E1056:/
1333 let caught_1056 = 1
1334 endtry
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001335 eval caught_1056->assert_equal(1)
Bram Moolenaaree4e0c12020-04-06 21:35:05 +02001336
1337 let caught_1059 = 0
1338 try
1339 def F5(items : list)
1340 echo 'a'
1341 enddef
1342 catch /E1059:/
1343 let caught_1059 = 1
1344 endtry
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001345 eval caught_1059->assert_equal(1)
Bram Moolenaaree4e0c12020-04-06 21:35:05 +02001346endfunc
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001347
Bram Moolenaar015f4262020-05-05 21:25:22 +02001348func DelMe()
1349 echo 'DelMe'
1350endfunc
1351
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001352def Test_error_reporting()
1353 # comment lines at the start of the function
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001354 var lines =<< trim END
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001355 " comment
1356 def Func()
1357 # comment
1358 # comment
1359 invalid
1360 enddef
1361 defcompile
1362 END
Bram Moolenaar08052222020-09-14 17:04:31 +02001363 writefile(lines, 'Xdef')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001364 try
1365 source Xdef
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02001366 assert_report('should have failed')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001367 catch /E476:/
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001368 v:exception->assert_match('Invalid command: invalid')
1369 v:throwpoint->assert_match(', line 3$')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001370 endtry
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001371 delfunc! g:Func
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001372
1373 # comment lines after the start of the function
1374 lines =<< trim END
1375 " comment
1376 def Func()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001377 var x = 1234
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001378 # comment
1379 # comment
1380 invalid
1381 enddef
1382 defcompile
1383 END
Bram Moolenaar08052222020-09-14 17:04:31 +02001384 writefile(lines, 'Xdef')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001385 try
1386 source Xdef
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02001387 assert_report('should have failed')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001388 catch /E476:/
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001389 v:exception->assert_match('Invalid command: invalid')
1390 v:throwpoint->assert_match(', line 4$')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001391 endtry
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001392 delfunc! g:Func
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001393
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02001394 lines =<< trim END
1395 vim9script
1396 def Func()
Bram Moolenaare0de1712020-12-02 17:36:54 +01001397 var db = {foo: 1, bar: 2}
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02001398 # comment
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001399 var x = db.asdf
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02001400 enddef
1401 defcompile
1402 Func()
1403 END
Bram Moolenaar08052222020-09-14 17:04:31 +02001404 writefile(lines, 'Xdef')
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02001405 try
1406 source Xdef
1407 assert_report('should have failed')
1408 catch /E716:/
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001409 v:throwpoint->assert_match('_Func, line 3$')
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02001410 endtry
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001411 delfunc! g:Func
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02001412
Bram Moolenaar08052222020-09-14 17:04:31 +02001413 delete('Xdef')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001414enddef
1415
Bram Moolenaar015f4262020-05-05 21:25:22 +02001416def Test_deleted_function()
1417 CheckDefExecFailure([
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001418 'var RefMe: func = function("g:DelMe")',
Bram Moolenaar015f4262020-05-05 21:25:22 +02001419 'delfunc g:DelMe',
1420 'echo RefMe()'], 'E117:')
1421enddef
1422
1423def Test_unknown_function()
1424 CheckDefExecFailure([
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001425 'var Ref: func = function("NotExist")',
Bram Moolenaar9b7bf9e2020-07-11 22:14:59 +02001426 'delfunc g:NotExist'], 'E700:')
Bram Moolenaar015f4262020-05-05 21:25:22 +02001427enddef
1428
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02001429def RefFunc(Ref: func(string): string): string
1430 return Ref('more')
1431enddef
1432
1433def Test_closure_simple()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001434 var local = 'some '
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001435 RefFunc((s) => local .. s)->assert_equal('some more')
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02001436enddef
1437
Bram Moolenaarbf67ea12020-05-02 17:52:42 +02001438def MakeRef()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001439 var local = 'some '
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001440 g:Ref = (s) => local .. s
Bram Moolenaarbf67ea12020-05-02 17:52:42 +02001441enddef
1442
1443def Test_closure_ref_after_return()
1444 MakeRef()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001445 g:Ref('thing')->assert_equal('some thing')
Bram Moolenaarbf67ea12020-05-02 17:52:42 +02001446 unlet g:Ref
1447enddef
1448
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02001449def MakeTwoRefs()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001450 var local = ['some']
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001451 g:Extend = (s) => local->add(s)
1452 g:Read = () => local
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02001453enddef
1454
1455def Test_closure_two_refs()
1456 MakeTwoRefs()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001457 join(g:Read(), ' ')->assert_equal('some')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02001458 g:Extend('more')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001459 join(g:Read(), ' ')->assert_equal('some more')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02001460 g:Extend('even')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001461 join(g:Read(), ' ')->assert_equal('some more even')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02001462
1463 unlet g:Extend
1464 unlet g:Read
1465enddef
1466
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02001467def ReadRef(Ref: func(): list<string>): string
1468 return join(Ref(), ' ')
1469enddef
1470
Bram Moolenaar5e654232020-09-16 15:22:00 +02001471def ExtendRef(Ref: func(string): list<string>, add: string)
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02001472 Ref(add)
1473enddef
1474
1475def Test_closure_two_indirect_refs()
Bram Moolenaarf7779c62020-05-03 15:38:16 +02001476 MakeTwoRefs()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001477 ReadRef(g:Read)->assert_equal('some')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02001478 ExtendRef(g:Extend, 'more')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001479 ReadRef(g:Read)->assert_equal('some more')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02001480 ExtendRef(g:Extend, 'even')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001481 ReadRef(g:Read)->assert_equal('some more even')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02001482
1483 unlet g:Extend
1484 unlet g:Read
1485enddef
Bram Moolenaarbf67ea12020-05-02 17:52:42 +02001486
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02001487def MakeArgRefs(theArg: string)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001488 var local = 'loc_val'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001489 g:UseArg = (s) => theArg .. '/' .. local .. '/' .. s
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02001490enddef
1491
1492def MakeArgRefsVarargs(theArg: string, ...rest: list<string>)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001493 var local = 'the_loc'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001494 g:UseVararg = (s) => theArg .. '/' .. local .. '/' .. s .. '/' .. join(rest)
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02001495enddef
1496
1497def Test_closure_using_argument()
1498 MakeArgRefs('arg_val')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001499 g:UseArg('call_val')->assert_equal('arg_val/loc_val/call_val')
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02001500
1501 MakeArgRefsVarargs('arg_val', 'one', 'two')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001502 g:UseVararg('call_val')->assert_equal('arg_val/the_loc/call_val/one two')
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02001503
1504 unlet g:UseArg
1505 unlet g:UseVararg
1506enddef
1507
Bram Moolenaar85d5e2b2020-10-10 14:13:01 +02001508def MakeGetAndAppendRefs()
1509 var local = 'a'
1510
1511 def Append(arg: string)
1512 local ..= arg
1513 enddef
1514 g:Append = Append
1515
1516 def Get(): string
1517 return local
1518 enddef
1519 g:Get = Get
1520enddef
1521
1522def Test_closure_append_get()
1523 MakeGetAndAppendRefs()
1524 g:Get()->assert_equal('a')
1525 g:Append('-b')
1526 g:Get()->assert_equal('a-b')
1527 g:Append('-c')
1528 g:Get()->assert_equal('a-b-c')
1529
1530 unlet g:Append
1531 unlet g:Get
1532enddef
Bram Moolenaarb68b3462020-05-06 21:06:30 +02001533
Bram Moolenaar04b12692020-05-04 23:24:44 +02001534def Test_nested_closure()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001535 var local = 'text'
Bram Moolenaar04b12692020-05-04 23:24:44 +02001536 def Closure(arg: string): string
1537 return local .. arg
1538 enddef
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001539 Closure('!!!')->assert_equal('text!!!')
Bram Moolenaar04b12692020-05-04 23:24:44 +02001540enddef
1541
Bram Moolenaar6f5b6df2020-05-16 21:20:12 +02001542func GetResult(Ref)
1543 return a:Ref('some')
1544endfunc
1545
1546def Test_call_closure_not_compiled()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001547 var text = 'text'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001548 g:Ref = (s) => s .. text
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001549 GetResult(g:Ref)->assert_equal('sometext')
Bram Moolenaar6f5b6df2020-05-16 21:20:12 +02001550enddef
1551
Bram Moolenaar7cbfaa52020-09-18 21:25:32 +02001552def Test_double_closure_fails()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001553 var lines =<< trim END
Bram Moolenaar7cbfaa52020-09-18 21:25:32 +02001554 vim9script
1555 def Func()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001556 var name = 0
1557 for i in range(2)
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001558 timer_start(0, () => name)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001559 endfor
Bram Moolenaar7cbfaa52020-09-18 21:25:32 +02001560 enddef
1561 Func()
1562 END
Bram Moolenaar148ce7a2020-09-23 21:57:23 +02001563 CheckScriptSuccess(lines)
Bram Moolenaar7cbfaa52020-09-18 21:25:32 +02001564enddef
1565
Bram Moolenaar85d5e2b2020-10-10 14:13:01 +02001566def Test_nested_closure_used()
1567 var lines =<< trim END
1568 vim9script
1569 def Func()
1570 var x = 'hello'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001571 var Closure = () => x
1572 g:Myclosure = () => Closure()
Bram Moolenaar85d5e2b2020-10-10 14:13:01 +02001573 enddef
1574 Func()
1575 assert_equal('hello', g:Myclosure())
1576 END
1577 CheckScriptSuccess(lines)
1578enddef
Bram Moolenaar0876c782020-10-07 19:08:04 +02001579
Bram Moolenaarc70bdab2020-09-26 19:59:38 +02001580def Test_nested_closure_fails()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001581 var lines =<< trim END
Bram Moolenaarc70bdab2020-09-26 19:59:38 +02001582 vim9script
1583 def FuncA()
1584 FuncB(0)
1585 enddef
1586 def FuncB(n: number): list<string>
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001587 return map([0], (_, v) => n)
Bram Moolenaarc70bdab2020-09-26 19:59:38 +02001588 enddef
1589 FuncA()
1590 END
1591 CheckScriptFailure(lines, 'E1012:')
1592enddef
1593
Bram Moolenaarf112f302020-12-20 17:47:52 +01001594def Test_global_closure()
1595 var lines =<< trim END
1596 vim9script
1597 def ReverseEveryNLines(n: number, line1: number, line2: number)
1598 var mods = 'sil keepj keepp lockm '
1599 var range = ':' .. line1 .. ',' .. line2
1600 def g:Offset(): number
1601 var offset = (line('.') - line1 + 1) % n
1602 return offset != 0 ? offset : n
1603 enddef
1604 exe mods .. range .. 'g/^/exe "m .-" .. g:Offset()'
1605 enddef
1606
1607 new
1608 repeat(['aaa', 'bbb', 'ccc'], 3)->setline(1)
1609 ReverseEveryNLines(3, 1, 9)
1610 END
1611 CheckScriptSuccess(lines)
1612 var expected = repeat(['ccc', 'bbb', 'aaa'], 3)
1613 assert_equal(expected, getline(1, 9))
1614 bwipe!
1615enddef
1616
Bram Moolenaarcd45ed02020-12-22 17:35:54 +01001617def Test_global_closure_called_directly()
1618 var lines =<< trim END
1619 vim9script
1620 def Outer()
1621 var x = 1
1622 def g:Inner()
1623 var y = x
1624 x += 1
1625 assert_equal(1, y)
1626 enddef
1627 g:Inner()
1628 assert_equal(2, x)
1629 enddef
1630 Outer()
1631 END
1632 CheckScriptSuccess(lines)
1633 delfunc g:Inner
1634enddef
1635
Bram Moolenaar34c54eb2020-11-25 19:15:19 +01001636def Test_failure_in_called_function()
1637 # this was using the frame index as the return value
1638 var lines =<< trim END
1639 vim9script
1640 au TerminalWinOpen * eval [][0]
1641 def PopupTerm(a: any)
1642 # make sure typvals on stack are string
1643 ['a', 'b', 'c', 'd', 'e', 'f', 'g']->join()
1644 FireEvent()
1645 enddef
1646 def FireEvent()
1647 do TerminalWinOpen
1648 enddef
1649 # use try/catch to make eval fail
1650 try
1651 call PopupTerm(0)
1652 catch
1653 endtry
1654 au! TerminalWinOpen
1655 END
1656 CheckScriptSuccess(lines)
1657enddef
1658
Bram Moolenaar5366e1a2020-10-01 13:01:34 +02001659def Test_nested_lambda()
1660 var lines =<< trim END
1661 vim9script
1662 def Func()
1663 var x = 4
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001664 var Lambda1 = () => 7
1665 var Lambda2 = () => [Lambda1(), x]
Bram Moolenaar5366e1a2020-10-01 13:01:34 +02001666 var res = Lambda2()
1667 assert_equal([7, 4], res)
1668 enddef
1669 Func()
1670 END
1671 CheckScriptSuccess(lines)
1672enddef
1673
Bram Moolenaar52bf81c2020-11-17 18:50:44 +01001674def Shadowed(): list<number>
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001675 var FuncList: list<func: number> = [() => 42]
1676 return FuncList->map((_, Shadowed) => Shadowed())
Bram Moolenaar52bf81c2020-11-17 18:50:44 +01001677enddef
1678
1679def Test_lambda_arg_shadows_func()
1680 assert_equal([42], Shadowed())
1681enddef
1682
Bram Moolenaaracd4c5e2020-06-22 19:39:03 +02001683def Line_continuation_in_def(dir: string = ''): string
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001684 var path: string = empty(dir)
1685 \ ? 'empty'
1686 \ : 'full'
1687 return path
Bram Moolenaaracd4c5e2020-06-22 19:39:03 +02001688enddef
1689
1690def Test_line_continuation_in_def()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001691 Line_continuation_in_def('.')->assert_equal('full')
Bram Moolenaaracd4c5e2020-06-22 19:39:03 +02001692enddef
1693
Bram Moolenaar2ea95b62020-11-19 21:47:56 +01001694def Test_script_var_in_lambda()
1695 var lines =<< trim END
1696 vim9script
1697 var script = 'test'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001698 assert_equal(['test'], map(['one'], () => script))
Bram Moolenaar2ea95b62020-11-19 21:47:56 +01001699 END
1700 CheckScriptSuccess(lines)
1701enddef
1702
Bram Moolenaar5e654232020-09-16 15:22:00 +02001703def Line_continuation_in_lambda(): list<string>
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001704 var x = range(97, 100)
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001705 ->map((_, v) => nr2char(v)
1706 ->toupper())
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02001707 ->reverse()
1708 return x
1709enddef
1710
1711def Test_line_continuation_in_lambda()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001712 Line_continuation_in_lambda()->assert_equal(['D', 'C', 'B', 'A'])
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02001713enddef
1714
Bram Moolenaar8f510af2020-07-05 18:48:23 +02001715func Test_silent_echo()
Bram Moolenaar47e7d702020-07-05 18:18:42 +02001716 CheckScreendump
1717
1718 let lines =<< trim END
1719 vim9script
1720 def EchoNothing()
1721 silent echo ''
1722 enddef
1723 defcompile
1724 END
Bram Moolenaar8f510af2020-07-05 18:48:23 +02001725 call writefile(lines, 'XTest_silent_echo')
Bram Moolenaar47e7d702020-07-05 18:18:42 +02001726
1727 " Check that the balloon shows up after a mouse move
1728 let buf = RunVimInTerminal('-S XTest_silent_echo', {'rows': 6})
Bram Moolenaar8f510af2020-07-05 18:48:23 +02001729 call term_sendkeys(buf, ":abc")
Bram Moolenaar47e7d702020-07-05 18:18:42 +02001730 call VerifyScreenDump(buf, 'Test_vim9_silent_echo', {})
1731
1732 " clean up
1733 call StopVimInTerminal(buf)
1734 call delete('XTest_silent_echo')
Bram Moolenaar8f510af2020-07-05 18:48:23 +02001735endfunc
Bram Moolenaar47e7d702020-07-05 18:18:42 +02001736
Bram Moolenaar171fb922020-10-28 16:54:47 +01001737def SilentlyError()
1738 execute('silent! invalid')
1739 g:did_it = 'yes'
1740enddef
1741
Bram Moolenaar28ee8922020-10-28 20:20:00 +01001742func UserError()
1743 silent! invalid
1744endfunc
1745
1746def SilentlyUserError()
1747 UserError()
1748 g:did_it = 'yes'
1749enddef
Bram Moolenaar171fb922020-10-28 16:54:47 +01001750
1751" This can't be a :def function, because the assert would not be reached.
Bram Moolenaar171fb922020-10-28 16:54:47 +01001752func Test_ignore_silent_error()
1753 let g:did_it = 'no'
1754 call SilentlyError()
1755 call assert_equal('yes', g:did_it)
1756
Bram Moolenaar28ee8922020-10-28 20:20:00 +01001757 let g:did_it = 'no'
1758 call SilentlyUserError()
1759 call assert_equal('yes', g:did_it)
Bram Moolenaar171fb922020-10-28 16:54:47 +01001760
1761 unlet g:did_it
1762endfunc
1763
Bram Moolenaarcd030c42020-10-30 21:49:40 +01001764def Test_ignore_silent_error_in_filter()
1765 var lines =<< trim END
1766 vim9script
1767 def Filter(winid: number, key: string): bool
1768 if key == 'o'
1769 silent! eval [][0]
1770 return true
1771 endif
1772 return popup_filter_menu(winid, key)
1773 enddef
1774
Bram Moolenaare0de1712020-12-02 17:36:54 +01001775 popup_create('popup', {filter: Filter})
Bram Moolenaarcd030c42020-10-30 21:49:40 +01001776 feedkeys("o\r", 'xnt')
1777 END
1778 CheckScriptSuccess(lines)
1779enddef
1780
Bram Moolenaar4b9bd692020-09-05 21:57:53 +02001781def Fibonacci(n: number): number
1782 if n < 2
1783 return n
1784 else
1785 return Fibonacci(n - 1) + Fibonacci(n - 2)
1786 endif
1787enddef
1788
Bram Moolenaar985116a2020-07-12 17:31:09 +02001789def Test_recursive_call()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001790 Fibonacci(20)->assert_equal(6765)
Bram Moolenaar985116a2020-07-12 17:31:09 +02001791enddef
1792
Bram Moolenaar08f7a412020-07-13 20:41:08 +02001793def TreeWalk(dir: string): list<any>
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001794 return readdir(dir)->map((_, val) =>
Bram Moolenaar08f7a412020-07-13 20:41:08 +02001795 fnamemodify(dir .. '/' .. val, ':p')->isdirectory()
Bram Moolenaar2bede172020-11-19 18:53:18 +01001796 ? {[val]: TreeWalk(dir .. '/' .. val)}
Bram Moolenaar08f7a412020-07-13 20:41:08 +02001797 : val
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001798 )
Bram Moolenaar08f7a412020-07-13 20:41:08 +02001799enddef
1800
1801def Test_closure_in_map()
1802 mkdir('XclosureDir/tdir', 'p')
1803 writefile(['111'], 'XclosureDir/file1')
1804 writefile(['222'], 'XclosureDir/file2')
1805 writefile(['333'], 'XclosureDir/tdir/file3')
1806
Bram Moolenaare0de1712020-12-02 17:36:54 +01001807 TreeWalk('XclosureDir')->assert_equal(['file1', 'file2', {tdir: ['file3']}])
Bram Moolenaar08f7a412020-07-13 20:41:08 +02001808
1809 delete('XclosureDir', 'rf')
1810enddef
1811
Bram Moolenaar7b5d5442020-10-04 13:42:34 +02001812def Test_invalid_function_name()
1813 var lines =<< trim END
1814 vim9script
1815 def s: list<string>
1816 END
1817 CheckScriptFailure(lines, 'E129:')
1818
1819 lines =<< trim END
1820 vim9script
1821 def g: list<string>
1822 END
1823 CheckScriptFailure(lines, 'E129:')
1824
1825 lines =<< trim END
1826 vim9script
1827 def <SID>: list<string>
1828 END
1829 CheckScriptFailure(lines, 'E884:')
1830
1831 lines =<< trim END
1832 vim9script
1833 def F list<string>
1834 END
1835 CheckScriptFailure(lines, 'E488:')
1836enddef
1837
Bram Moolenaara90afb92020-07-15 22:38:56 +02001838def Test_partial_call()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001839 var Xsetlist = function('setloclist', [0])
Bram Moolenaare0de1712020-12-02 17:36:54 +01001840 Xsetlist([], ' ', {title: 'test'})
1841 getloclist(0, {title: 1})->assert_equal({title: 'test'})
Bram Moolenaara90afb92020-07-15 22:38:56 +02001842
1843 Xsetlist = function('setloclist', [0, [], ' '])
Bram Moolenaare0de1712020-12-02 17:36:54 +01001844 Xsetlist({title: 'test'})
1845 getloclist(0, {title: 1})->assert_equal({title: 'test'})
Bram Moolenaara90afb92020-07-15 22:38:56 +02001846
1847 Xsetlist = function('setqflist')
Bram Moolenaare0de1712020-12-02 17:36:54 +01001848 Xsetlist([], ' ', {title: 'test'})
1849 getqflist({title: 1})->assert_equal({title: 'test'})
Bram Moolenaara90afb92020-07-15 22:38:56 +02001850
1851 Xsetlist = function('setqflist', [[], ' '])
Bram Moolenaare0de1712020-12-02 17:36:54 +01001852 Xsetlist({title: 'test'})
1853 getqflist({title: 1})->assert_equal({title: 'test'})
Bram Moolenaar6abd3dc2020-10-04 14:17:32 +02001854
1855 var Len: func: number = function('len', ['word'])
1856 assert_equal(4, Len())
Bram Moolenaara90afb92020-07-15 22:38:56 +02001857enddef
1858
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02001859def Test_cmd_modifier()
1860 tab echo '0'
Bram Moolenaard2c61702020-09-06 15:58:36 +02001861 CheckDefFailure(['5tab echo 3'], 'E16:')
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02001862enddef
1863
1864def Test_restore_modifiers()
1865 # check that when compiling a :def function command modifiers are not messed
1866 # up.
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001867 var lines =<< trim END
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02001868 vim9script
1869 set eventignore=
1870 autocmd QuickFixCmdPost * copen
1871 def AutocmdsDisabled()
Bram Moolenaar6cf7e3b2020-10-28 14:31:16 +01001872 eval 0
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02001873 enddef
1874 func Func()
1875 noautocmd call s:AutocmdsDisabled()
1876 let g:ei_after = &eventignore
1877 endfunc
1878 Func()
1879 END
1880 CheckScriptSuccess(lines)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001881 g:ei_after->assert_equal('')
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02001882enddef
1883
Bram Moolenaardfa3d552020-09-10 22:05:08 +02001884def StackTop()
1885 eval 1
1886 eval 2
1887 # call not on fourth line
1888 StackBot()
1889enddef
1890
1891def StackBot()
1892 # throw an error
1893 eval [][0]
1894enddef
1895
1896def Test_callstack_def()
1897 try
1898 StackTop()
1899 catch
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001900 v:throwpoint->assert_match('Test_callstack_def\[2\]..StackTop\[4\]..StackBot, line 2')
Bram Moolenaardfa3d552020-09-10 22:05:08 +02001901 endtry
1902enddef
1903
Bram Moolenaare8211a32020-10-09 22:04:29 +02001904" Re-using spot for variable used in block
1905def Test_block_scoped_var()
1906 var lines =<< trim END
1907 vim9script
1908 def Func()
1909 var x = ['a', 'b', 'c']
1910 if 1
1911 var y = 'x'
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001912 map(x, () => y)
Bram Moolenaare8211a32020-10-09 22:04:29 +02001913 endif
1914 var z = x
1915 assert_equal(['x', 'x', 'x'], z)
1916 enddef
1917 Func()
1918 END
1919 CheckScriptSuccess(lines)
1920enddef
1921
Bram Moolenaareeece9e2020-11-20 19:26:48 +01001922def Test_reset_did_emsg()
1923 var lines =<< trim END
1924 @s = 'blah'
1925 au BufWinLeave * #
1926 def Func()
1927 var winid = popup_create('popup', {})
1928 exe '*s'
1929 popup_close(winid)
1930 enddef
1931 Func()
1932 END
1933 CheckScriptFailure(lines, 'E492:', 8)
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001934 delfunc! g:Func
Bram Moolenaareeece9e2020-11-20 19:26:48 +01001935enddef
1936
Bram Moolenaar57f799e2020-12-12 20:42:19 +01001937def Test_did_emsg_reset()
1938 # executing an autocommand resets did_emsg, this should not result in a
1939 # builtin function considered failing
1940 var lines =<< trim END
1941 vim9script
1942 au BufWinLeave * #
1943 def Func()
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001944 popup_menu('', {callback: () => popup_create('', {})->popup_close()})
Bram Moolenaar57f799e2020-12-12 20:42:19 +01001945 eval [][0]
1946 enddef
1947 nno <F3> <cmd>call <sid>Func()<cr>
1948 feedkeys("\<F3>\e", 'xt')
1949 END
1950 writefile(lines, 'XemsgReset')
1951 assert_fails('so XemsgReset', ['E684:', 'E684:'], lines, 2)
1952 delete('XemsgReset')
1953 nunmap <F3>
1954 au! BufWinLeave
1955enddef
1956
Bram Moolenaar56602ba2020-12-05 21:22:08 +01001957def Test_abort_with_silent_call()
1958 var lines =<< trim END
1959 vim9script
1960 g:result = 'none'
1961 def Func()
1962 g:result += 3
1963 g:result = 'yes'
1964 enddef
1965 # error is silenced, but function aborts on error
1966 silent! Func()
1967 assert_equal('none', g:result)
1968 unlet g:result
1969 END
1970 CheckScriptSuccess(lines)
1971enddef
1972
Bram Moolenaarf665e972020-12-05 19:17:16 +01001973def Test_continues_with_silent_error()
1974 var lines =<< trim END
1975 vim9script
1976 g:result = 'none'
1977 def Func()
1978 silent! g:result += 3
1979 g:result = 'yes'
1980 enddef
1981 # error is silenced, function does not abort
1982 Func()
1983 assert_equal('yes', g:result)
1984 unlet g:result
1985 END
1986 CheckScriptSuccess(lines)
1987enddef
1988
Bram Moolenaaraf0df472020-12-02 20:51:22 +01001989def Test_abort_even_with_silent()
1990 var lines =<< trim END
1991 vim9script
1992 g:result = 'none'
1993 def Func()
1994 eval {-> ''}() .. '' .. {}['X']
1995 g:result = 'yes'
1996 enddef
Bram Moolenaarf665e972020-12-05 19:17:16 +01001997 silent! Func()
Bram Moolenaaraf0df472020-12-02 20:51:22 +01001998 assert_equal('none', g:result)
Bram Moolenaar4029cab2020-12-05 18:13:27 +01001999 unlet g:result
2000 END
2001 CheckScriptSuccess(lines)
2002enddef
2003
Bram Moolenaarf665e972020-12-05 19:17:16 +01002004def Test_cmdmod_silent_restored()
2005 var lines =<< trim END
2006 vim9script
2007 def Func()
2008 g:result = 'none'
2009 silent! g:result += 3
2010 g:result = 'none'
2011 g:result += 3
2012 enddef
2013 Func()
2014 END
2015 # can't use CheckScriptFailure, it ignores the :silent!
2016 var fname = 'Xdefsilent'
2017 writefile(lines, fname)
2018 var caught = 'no'
2019 try
2020 exe 'source ' .. fname
2021 catch /E1030:/
2022 caught = 'yes'
2023 assert_match('Func, line 4', v:throwpoint)
2024 endtry
2025 assert_equal('yes', caught)
2026 delete(fname)
2027enddef
2028
Bram Moolenaar4029cab2020-12-05 18:13:27 +01002029def Test_dict_member_with_silent()
2030 var lines =<< trim END
2031 vim9script
2032 g:result = 'none'
2033 var d: dict<any>
2034 def Func()
2035 try
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002036 g:result = map([], (_, v) => ({}[v]))->join() .. d['']
Bram Moolenaar4029cab2020-12-05 18:13:27 +01002037 catch
2038 endtry
2039 enddef
2040 silent! Func()
2041 assert_equal('0', g:result)
2042 unlet g:result
Bram Moolenaaraf0df472020-12-02 20:51:22 +01002043 END
2044 CheckScriptSuccess(lines)
2045enddef
2046
Bram Moolenaar5b3d1bb2020-12-22 12:20:08 +01002047def Test_opfunc()
2048 nnoremap <F3> <cmd>set opfunc=Opfunc<cr>g@
2049 def g:Opfunc(_: any): string
2050 setline(1, 'ASDF')
2051 return ''
2052 enddef
2053 new
2054 setline(1, 'asdf')
2055 feedkeys("\<F3>$", 'x')
2056 assert_equal('ASDF', getline(1))
2057
2058 bwipe!
2059 nunmap <F3>
2060enddef
2061
Bram Moolenaar077a4232020-12-22 18:33:27 +01002062" this was crashing on exit
2063def Test_nested_lambda_in_closure()
2064 var lines =<< trim END
2065 vim9script
2066 def Outer()
2067 def g:Inner()
2068 echo map([1, 2, 3], {_, v -> v + 1})
2069 enddef
2070 g:Inner()
2071 enddef
2072 defcompile
2073 writefile(['Done'], 'XnestedDone')
2074 quit
2075 END
2076 if !RunVim([], lines, '--clean')
2077 return
2078 endif
2079 assert_equal(['Done'], readfile('XnestedDone'))
2080 delete('XnestedDone')
2081enddef
2082
2083
Bram Moolenaarf7779c62020-05-03 15:38:16 +02002084
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002085" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker