blob: 371b9efbcbec99b6cc807b0e648c402076e891a6 [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
16def ReturnString(): string
17 return 'string'
18enddef
19
20def ReturnNumber(): number
21 return 123
22enddef
23
24let g:notNumber = 'string'
25
26def ReturnGlobal(): number
27 return g:notNumber
28enddef
29
30def Test_return_something()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +020031 ReturnString()->assert_equal('string')
32 ReturnNumber()->assert_equal(123)
Bram Moolenaar5e654232020-09-16 15:22:00 +020033 assert_fails('ReturnGlobal()', 'E1012: Type mismatch; expected number but got string', '', 1, 'ReturnGlobal')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +020034enddef
35
Bram Moolenaarefd88552020-06-18 20:50:10 +020036def Test_missing_return()
37 CheckDefFailure(['def Missing(): number',
38 ' if g:cond',
39 ' echo "no return"',
40 ' else',
41 ' return 0',
42 ' endif'
43 'enddef'], 'E1027:')
44 CheckDefFailure(['def Missing(): number',
45 ' if g:cond',
46 ' return 1',
47 ' else',
48 ' echo "no return"',
49 ' endif'
50 'enddef'], 'E1027:')
51 CheckDefFailure(['def Missing(): number',
52 ' if g:cond',
53 ' return 1',
54 ' else',
55 ' return 2',
56 ' endif'
57 ' return 3'
58 'enddef'], 'E1095:')
59enddef
60
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +020061let s:nothing = 0
62def ReturnNothing()
63 s:nothing = 1
64 if true
65 return
66 endif
67 s:nothing = 2
68enddef
69
70def Test_return_nothing()
71 ReturnNothing()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +020072 s:nothing->assert_equal(1)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +020073enddef
74
75func Increment()
76 let g:counter += 1
77endfunc
78
79def Test_call_ufunc_count()
80 g:counter = 1
81 Increment()
82 Increment()
83 Increment()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +020084 # works with and without :call
Bram Moolenaarc0c71e92020-09-11 19:09:48 +020085 g:counter->assert_equal(4)
86 eval g:counter->assert_equal(4)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +020087 unlet g:counter
88enddef
89
90def MyVarargs(arg: string, ...rest: list<string>): string
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +020091 var res = arg
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +020092 for s in rest
93 res ..= ',' .. s
94 endfor
95 return res
96enddef
97
98def Test_call_varargs()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +020099 MyVarargs('one')->assert_equal('one')
100 MyVarargs('one', 'two')->assert_equal('one,two')
101 MyVarargs('one', 'two', 'three')->assert_equal('one,two,three')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200102enddef
103
104def MyDefaultArgs(name = 'string'): string
105 return name
106enddef
107
Bram Moolenaare30f64b2020-07-15 19:48:20 +0200108def MyDefaultSecond(name: string, second: bool = true): string
109 return second ? name : 'none'
110enddef
111
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200112def Test_call_default_args()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200113 MyDefaultArgs()->assert_equal('string')
114 MyDefaultArgs('one')->assert_equal('one')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +0200115 assert_fails('MyDefaultArgs("one", "two")', 'E118:', '', 3, 'Test_call_default_args')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200116
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200117 MyDefaultSecond('test')->assert_equal('test')
118 MyDefaultSecond('test', true)->assert_equal('test')
119 MyDefaultSecond('test', false)->assert_equal('none')
Bram Moolenaare30f64b2020-07-15 19:48:20 +0200120
Bram Moolenaar822ba242020-05-24 23:00:18 +0200121 CheckScriptFailure(['def Func(arg: number = asdf)', 'enddef', 'defcompile'], 'E1001:')
Bram Moolenaar77072282020-09-16 17:55:40 +0200122 CheckScriptFailure(['def Func(arg: number = "text")', 'enddef', 'defcompile'], 'E1013: Argument 1: type mismatch, expected number but got string')
Bram Moolenaar04b12692020-05-04 23:24:44 +0200123enddef
124
125def Test_nested_function()
126 def Nested(arg: string): string
127 return 'nested ' .. arg
128 enddef
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200129 Nested('function')->assert_equal('nested function')
Bram Moolenaar04b12692020-05-04 23:24:44 +0200130
Bram Moolenaar0e65d3d2020-05-05 17:53:16 +0200131 CheckDefFailure(['def Nested()', 'enddef', 'Nested(66)'], 'E118:')
132 CheckDefFailure(['def Nested(arg: string)', 'enddef', 'Nested()'], 'E119:')
133
Bram Moolenaar04b12692020-05-04 23:24:44 +0200134 CheckDefFailure(['func Nested()', 'endfunc'], 'E1086:')
Bram Moolenaarbcbf4132020-08-01 22:35:13 +0200135 CheckDefFailure(['def s:Nested()', 'enddef'], 'E1075:')
136 CheckDefFailure(['def b:Nested()', 'enddef'], 'E1075:')
Bram Moolenaar8b848ca2020-09-10 22:28:01 +0200137
138 CheckDefFailure([
139 'def Outer()',
140 ' def Inner()',
141 ' # comment',
142 ' enddef',
143 ' def Inner()',
144 ' enddef',
145 'enddef'], 'E1073:')
146 CheckDefFailure([
147 'def Outer()',
148 ' def Inner()',
149 ' # comment',
150 ' enddef',
151 ' def! Inner()',
152 ' enddef',
153 'enddef'], 'E1117:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200154enddef
155
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200156func Test_call_default_args_from_func()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200157 call MyDefaultArgs()->assert_equal('string')
158 call MyDefaultArgs('one')->assert_equal('one')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +0200159 call assert_fails('call MyDefaultArgs("one", "two")', 'E118:', '', 3, 'Test_call_default_args_from_func')
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200160endfunc
161
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200162def Test_nested_global_function()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200163 var lines =<< trim END
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200164 vim9script
165 def Outer()
166 def g:Inner(): string
167 return 'inner'
168 enddef
169 enddef
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200170 defcompile
171 Outer()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200172 g:Inner()->assert_equal('inner')
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200173 delfunc g:Inner
174 Outer()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200175 g:Inner()->assert_equal('inner')
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200176 delfunc g:Inner
177 Outer()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200178 g:Inner()->assert_equal('inner')
Bram Moolenaaraf8edbb2020-08-01 00:03:09 +0200179 delfunc g:Inner
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200180 END
181 CheckScriptSuccess(lines)
Bram Moolenaar2c79e9d2020-08-01 18:57:52 +0200182
183 lines =<< trim END
184 vim9script
185 def Outer()
186 def g:Inner(): string
187 return 'inner'
188 enddef
189 enddef
190 defcompile
191 Outer()
192 Outer()
193 END
194 CheckScriptFailure(lines, "E122:")
Bram Moolenaarad486a02020-08-01 23:22:18 +0200195
196 lines =<< trim END
197 vim9script
198 def Func()
199 echo 'script'
200 enddef
201 def Outer()
202 def Func()
203 echo 'inner'
204 enddef
205 enddef
206 defcompile
207 END
208 CheckScriptFailure(lines, "E1073:")
Bram Moolenaar38ddf332020-07-31 22:05:04 +0200209enddef
210
Bram Moolenaar333894b2020-08-01 18:53:07 +0200211def Test_global_local_function()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200212 var lines =<< trim END
Bram Moolenaar333894b2020-08-01 18:53:07 +0200213 vim9script
214 def g:Func(): string
215 return 'global'
216 enddef
217 def Func(): string
218 return 'local'
219 enddef
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200220 g:Func()->assert_equal('global')
221 Func()->assert_equal('local')
Bram Moolenaar333894b2020-08-01 18:53:07 +0200222 END
223 CheckScriptSuccess(lines)
Bram Moolenaar035d6e92020-08-11 22:30:42 +0200224
225 lines =<< trim END
226 vim9script
227 def g:Funcy()
228 echo 'funcy'
229 enddef
230 s:Funcy()
231 END
232 CheckScriptFailure(lines, 'E117:')
Bram Moolenaar333894b2020-08-01 18:53:07 +0200233enddef
234
Bram Moolenaar0f769812020-09-12 18:32:34 +0200235def Test_local_function_shadows_global()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200236 var lines =<< trim END
Bram Moolenaar0f769812020-09-12 18:32:34 +0200237 vim9script
238 def g:Gfunc(): string
239 return 'global'
240 enddef
241 def AnotherFunc(): number
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200242 var Gfunc = function('len')
Bram Moolenaar0f769812020-09-12 18:32:34 +0200243 return Gfunc('testing')
244 enddef
245 g:Gfunc()->assert_equal('global')
246 AnotherFunc()->assert_equal(7)
247 delfunc g:Gfunc
248 END
249 CheckScriptSuccess(lines)
250
251 lines =<< trim END
252 vim9script
253 def g:Func(): string
254 return 'global'
255 enddef
256 def AnotherFunc()
257 g:Func = function('len')
258 enddef
259 AnotherFunc()
260 END
261 CheckScriptFailure(lines, 'E705:')
262 delfunc g:Func
263enddef
264
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200265func TakesOneArg(arg)
266 echo a:arg
267endfunc
268
269def Test_call_wrong_args()
Bram Moolenaard2c61702020-09-06 15:58:36 +0200270 CheckDefFailure(['TakesOneArg()'], 'E119:')
271 CheckDefFailure(['TakesOneArg(11, 22)'], 'E118:')
272 CheckDefFailure(['bufnr(xxx)'], 'E1001:')
273 CheckScriptFailure(['def Func(Ref: func(s: string))'], 'E475:')
Bram Moolenaaree8580e2020-08-28 17:19:07 +0200274
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200275 var lines =<< trim END
Bram Moolenaaree8580e2020-08-28 17:19:07 +0200276 vim9script
277 def Func(s: string)
278 echo s
279 enddef
280 Func([])
281 END
Bram Moolenaar77072282020-09-16 17:55:40 +0200282 CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected string but got list<unknown>', 5)
Bram Moolenaarb185a402020-09-18 22:42:00 +0200283
284 lines =<< trim END
285 vim9script
286 def FuncOne(nr: number)
287 echo nr
288 enddef
289 def FuncTwo()
290 FuncOne()
291 enddef
292 defcompile
293 END
294 writefile(lines, 'Xscript')
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200295 var didCatch = false
Bram Moolenaarb185a402020-09-18 22:42:00 +0200296 try
297 source Xscript
298 catch
299 assert_match('E119: Not enough arguments for function: <SNR>\d\+_FuncOne', v:exception)
300 assert_match('Xscript\[8\]..function <SNR>\d\+_FuncTwo, line 1', v:throwpoint)
301 didCatch = true
302 endtry
303 assert_true(didCatch)
304
305 lines =<< trim END
306 vim9script
307 def FuncOne(nr: number)
308 echo nr
309 enddef
310 def FuncTwo()
311 FuncOne(1, 2)
312 enddef
313 defcompile
314 END
315 writefile(lines, 'Xscript')
316 didCatch = false
317 try
318 source Xscript
319 catch
320 assert_match('E118: Too many arguments for function: <SNR>\d\+_FuncOne', v:exception)
321 assert_match('Xscript\[8\]..function <SNR>\d\+_FuncTwo, line 1', v:throwpoint)
322 didCatch = true
323 endtry
324 assert_true(didCatch)
325
326 delete('Xscript')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200327enddef
328
329" Default arg and varargs
330def MyDefVarargs(one: string, two = 'foo', ...rest: list<string>): string
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200331 var res = one .. ',' .. two
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200332 for s in rest
333 res ..= ',' .. s
334 endfor
335 return res
336enddef
337
338def Test_call_def_varargs()
Bram Moolenaar9bd5d872020-09-06 21:47:48 +0200339 assert_fails('MyDefVarargs()', 'E119:', '', 1, 'Test_call_def_varargs')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200340 MyDefVarargs('one')->assert_equal('one,foo')
341 MyDefVarargs('one', 'two')->assert_equal('one,two')
342 MyDefVarargs('one', 'two', 'three')->assert_equal('one,two,three')
Bram Moolenaar24aa48b2020-07-25 16:33:02 +0200343 CheckDefFailure(['MyDefVarargs("one", 22)'],
Bram Moolenaar77072282020-09-16 17:55:40 +0200344 'E1013: Argument 2: type mismatch, expected string but got number')
Bram Moolenaar24aa48b2020-07-25 16:33:02 +0200345 CheckDefFailure(['MyDefVarargs("one", "two", 123)'],
Bram Moolenaar77072282020-09-16 17:55:40 +0200346 'E1013: Argument 3: type mismatch, expected string but got number')
Bram Moolenaar24aa48b2020-07-25 16:33:02 +0200347
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200348 var lines =<< trim END
Bram Moolenaar24aa48b2020-07-25 16:33:02 +0200349 vim9script
350 def Func(...l: list<string>)
351 echo l
352 enddef
353 Func('a', 'b', 'c')
354 END
355 CheckScriptSuccess(lines)
356
357 lines =<< trim END
358 vim9script
359 def Func(...l: list<string>)
360 echo l
361 enddef
362 Func()
363 END
364 CheckScriptSuccess(lines)
365
366 lines =<< trim END
367 vim9script
Bram Moolenaar2f8cbc42020-09-16 17:22:59 +0200368 def Func(...l: any)
369 echo l
370 enddef
371 Func(0)
372 END
373 CheckScriptSuccess(lines)
374
375 lines =<< trim END
376 vim9script
Bram Moolenaar28022722020-09-21 22:02:49 +0200377 def Func(..._l: list<string>)
378 echo _l
379 enddef
380 Func('a', 'b', 'c')
381 END
382 CheckScriptSuccess(lines)
383
384 lines =<< trim END
385 vim9script
Bram Moolenaar24aa48b2020-07-25 16:33:02 +0200386 def Func(...l: list<string>)
387 echo l
388 enddef
389 Func(1, 2, 3)
390 END
Bram Moolenaar77072282020-09-16 17:55:40 +0200391 CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch')
Bram Moolenaar24aa48b2020-07-25 16:33:02 +0200392
393 lines =<< trim END
394 vim9script
395 def Func(...l: list<string>)
396 echo l
397 enddef
398 Func('a', 9)
399 END
Bram Moolenaar77072282020-09-16 17:55:40 +0200400 CheckScriptFailure(lines, 'E1013: Argument 2: type mismatch')
Bram Moolenaar24aa48b2020-07-25 16:33:02 +0200401
402 lines =<< trim END
403 vim9script
404 def Func(...l: list<string>)
405 echo l
406 enddef
407 Func(1, 'a')
408 END
Bram Moolenaar77072282020-09-16 17:55:40 +0200409 CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200410enddef
411
Bram Moolenaar575f24b2020-08-12 14:21:11 +0200412def Test_call_call()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200413 var l = [3, 2, 1]
Bram Moolenaar575f24b2020-08-12 14:21:11 +0200414 call('reverse', [l])
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200415 l->assert_equal([1, 2, 3])
Bram Moolenaar575f24b2020-08-12 14:21:11 +0200416enddef
417
Bram Moolenaar1378fbc2020-04-11 20:50:33 +0200418let s:value = ''
419
420def FuncOneDefArg(opt = 'text')
421 s:value = opt
422enddef
423
424def FuncTwoDefArg(nr = 123, opt = 'text'): string
425 return nr .. opt
426enddef
427
428def FuncVarargs(...arg: list<string>): string
429 return join(arg, ',')
430enddef
431
432def Test_func_type_varargs()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200433 var RefDefArg: func(?string)
Bram Moolenaar1378fbc2020-04-11 20:50:33 +0200434 RefDefArg = FuncOneDefArg
435 RefDefArg()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200436 s:value->assert_equal('text')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +0200437 RefDefArg('some')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200438 s:value->assert_equal('some')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +0200439
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200440 var RefDef2Arg: func(?number, ?string): string
Bram Moolenaar1378fbc2020-04-11 20:50:33 +0200441 RefDef2Arg = FuncTwoDefArg
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200442 RefDef2Arg()->assert_equal('123text')
443 RefDef2Arg(99)->assert_equal('99text')
444 RefDef2Arg(77, 'some')->assert_equal('77some')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +0200445
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200446 CheckDefFailure(['var RefWrong: func(string?)'], 'E1010:')
447 CheckDefFailure(['var RefWrong: func(?string, string)'], 'E1007:')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +0200448
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200449 var RefVarargs: func(...list<string>): string
Bram Moolenaar1378fbc2020-04-11 20:50:33 +0200450 RefVarargs = FuncVarargs
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200451 RefVarargs()->assert_equal('')
452 RefVarargs('one')->assert_equal('one')
453 RefVarargs('one', 'two')->assert_equal('one,two')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +0200454
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200455 CheckDefFailure(['var RefWrong: func(...list<string>, string)'], 'E110:')
456 CheckDefFailure(['var RefWrong: func(...list<string>, ?string)'], 'E110:')
Bram Moolenaar1378fbc2020-04-11 20:50:33 +0200457enddef
458
Bram Moolenaar0b76b422020-04-07 22:05:08 +0200459" Only varargs
460def MyVarargsOnly(...args: list<string>): string
461 return join(args, ',')
462enddef
463
464def Test_call_varargs_only()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200465 MyVarargsOnly()->assert_equal('')
466 MyVarargsOnly('one')->assert_equal('one')
467 MyVarargsOnly('one', 'two')->assert_equal('one,two')
Bram Moolenaar77072282020-09-16 17:55:40 +0200468 CheckDefFailure(['MyVarargsOnly(1)'], 'E1013: Argument 1: type mismatch, expected string but got number')
469 CheckDefFailure(['MyVarargsOnly("one", 2)'], 'E1013: Argument 2: type mismatch, expected string but got number')
Bram Moolenaar0b76b422020-04-07 22:05:08 +0200470enddef
471
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200472def Test_using_var_as_arg()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200473 writefile(['def Func(x: number)', 'var x = 234', 'enddef', 'defcompile'], 'Xdef')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +0200474 assert_fails('so Xdef', 'E1006:', '', 1, 'Func')
Bram Moolenaard2c61702020-09-06 15:58:36 +0200475 delete('Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200476enddef
477
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +0200478def DictArg(arg: dict<string>)
479 arg['key'] = 'value'
480enddef
481
482def ListArg(arg: list<string>)
483 arg[0] = 'value'
484enddef
485
486def Test_assign_to_argument()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200487 # works for dict and list
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200488 var d: dict<string> = {}
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +0200489 DictArg(d)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200490 d['key']->assert_equal('value')
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200491 var l: list<string> = []
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +0200492 ListArg(l)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200493 l[0]->assert_equal('value')
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +0200494
Bram Moolenaard2c61702020-09-06 15:58:36 +0200495 CheckScriptFailure(['def Func(arg: number)', 'arg = 3', 'enddef', 'defcompile'], 'E1090:')
Bram Moolenaarcb2bdb12020-05-10 22:53:56 +0200496enddef
497
Bram Moolenaarb816dae2020-09-20 22:04:00 +0200498" These argument names are reserved in legacy functions.
499def WithReservedNames(firstline: string, lastline: string): string
500 return firstline .. lastline
501enddef
502
503def Test_argument_names()
504 assert_equal('OK', WithReservedNames('O', 'K'))
505enddef
506
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200507def Test_call_func_defined_later()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200508 g:DefinedLater('one')->assert_equal('one')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +0200509 assert_fails('NotDefined("one")', 'E117:', '', 2, 'Test_call_func_defined_later')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200510enddef
511
Bram Moolenaar1df8b3f2020-04-23 18:13:23 +0200512func DefinedLater(arg)
513 return a:arg
514endfunc
515
516def Test_call_funcref()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200517 g:SomeFunc('abc')->assert_equal(3)
Bram Moolenaar9bd5d872020-09-06 21:47:48 +0200518 assert_fails('NotAFunc()', 'E117:', '', 2, 'Test_call_funcref') # comment after call
519 assert_fails('g:NotAFunc()', 'E117:', '', 3, 'Test_call_funcref')
Bram Moolenaar2f1980f2020-07-22 19:30:06 +0200520
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200521 var lines =<< trim END
Bram Moolenaar2f1980f2020-07-22 19:30:06 +0200522 vim9script
523 def RetNumber(): number
524 return 123
525 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200526 var Funcref: func: number = function('RetNumber')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200527 Funcref()->assert_equal(123)
Bram Moolenaar2f1980f2020-07-22 19:30:06 +0200528 END
529 CheckScriptSuccess(lines)
Bram Moolenaar0f60e802020-07-22 20:16:11 +0200530
531 lines =<< trim END
532 vim9script
533 def RetNumber(): number
534 return 123
535 enddef
536 def Bar(F: func: number): number
537 return F()
538 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200539 var Funcref = function('RetNumber')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200540 Bar(Funcref)->assert_equal(123)
Bram Moolenaar0f60e802020-07-22 20:16:11 +0200541 END
542 CheckScriptSuccess(lines)
Bram Moolenaarbfba8652020-07-23 20:09:10 +0200543
544 lines =<< trim END
545 vim9script
546 def UseNumber(nr: number)
547 echo nr
548 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200549 var Funcref: func(number) = function('UseNumber')
Bram Moolenaarbfba8652020-07-23 20:09:10 +0200550 Funcref(123)
551 END
552 CheckScriptSuccess(lines)
Bram Moolenaarb8070e32020-07-23 20:56:04 +0200553
554 lines =<< trim END
555 vim9script
556 def UseNumber(nr: number)
557 echo nr
558 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200559 var Funcref: func(string) = function('UseNumber')
Bram Moolenaarb8070e32020-07-23 20:56:04 +0200560 END
Bram Moolenaar5e654232020-09-16 15:22:00 +0200561 CheckScriptFailure(lines, 'E1012: Type mismatch; expected func(string) but got func(number)')
Bram Moolenaar4fc224c2020-07-26 17:56:25 +0200562
563 lines =<< trim END
564 vim9script
565 def EchoNr(nr = 34)
566 g:echo = nr
567 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200568 var Funcref: func(?number) = function('EchoNr')
Bram Moolenaar4fc224c2020-07-26 17:56:25 +0200569 Funcref()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200570 g:echo->assert_equal(34)
Bram Moolenaar4fc224c2020-07-26 17:56:25 +0200571 Funcref(123)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200572 g:echo->assert_equal(123)
Bram Moolenaar4fc224c2020-07-26 17:56:25 +0200573 END
574 CheckScriptSuccess(lines)
Bram Moolenaarace61322020-07-26 18:16:58 +0200575
576 lines =<< trim END
577 vim9script
578 def EchoList(...l: list<number>)
579 g:echo = l
580 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200581 var Funcref: func(...list<number>) = function('EchoList')
Bram Moolenaarace61322020-07-26 18:16:58 +0200582 Funcref()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200583 g:echo->assert_equal([])
Bram Moolenaarace61322020-07-26 18:16:58 +0200584 Funcref(1, 2, 3)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200585 g:echo->assert_equal([1, 2, 3])
Bram Moolenaarace61322020-07-26 18:16:58 +0200586 END
587 CheckScriptSuccess(lines)
Bram Moolenaar01865ad2020-07-26 18:33:09 +0200588
589 lines =<< trim END
590 vim9script
591 def OptAndVar(nr: number, opt = 12, ...l: list<number>): number
592 g:optarg = opt
593 g:listarg = l
594 return nr
595 enddef
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200596 var Funcref: func(number, ?number, ...list<number>): number = function('OptAndVar')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200597 Funcref(10)->assert_equal(10)
598 g:optarg->assert_equal(12)
599 g:listarg->assert_equal([])
Bram Moolenaar01865ad2020-07-26 18:33:09 +0200600
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200601 Funcref(11, 22)->assert_equal(11)
602 g:optarg->assert_equal(22)
603 g:listarg->assert_equal([])
Bram Moolenaar01865ad2020-07-26 18:33:09 +0200604
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200605 Funcref(17, 18, 1, 2, 3)->assert_equal(17)
606 g:optarg->assert_equal(18)
607 g:listarg->assert_equal([1, 2, 3])
Bram Moolenaar01865ad2020-07-26 18:33:09 +0200608 END
609 CheckScriptSuccess(lines)
Bram Moolenaar1df8b3f2020-04-23 18:13:23 +0200610enddef
611
612let SomeFunc = function('len')
613let NotAFunc = 'text'
614
Bram Moolenaar99aaf0c2020-04-12 14:39:53 +0200615def CombineFuncrefTypes()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200616 # same arguments, different return type
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200617 var Ref1: func(bool): string
618 var Ref2: func(bool): number
619 var Ref3: func(bool): any
Bram Moolenaar99aaf0c2020-04-12 14:39:53 +0200620 Ref3 = g:cond ? Ref1 : Ref2
621
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200622 # different number of arguments
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200623 var Refa1: func(bool): number
624 var Refa2: func(bool, number): number
625 var Refa3: func: number
Bram Moolenaar99aaf0c2020-04-12 14:39:53 +0200626 Refa3 = g:cond ? Refa1 : Refa2
627
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200628 # different argument types
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200629 var Refb1: func(bool, string): number
630 var Refb2: func(string, number): number
631 var Refb3: func(any, any): number
Bram Moolenaar99aaf0c2020-04-12 14:39:53 +0200632 Refb3 = g:cond ? Refb1 : Refb2
633enddef
634
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200635def FuncWithForwardCall()
Bram Moolenaar1df8b3f2020-04-23 18:13:23 +0200636 return g:DefinedEvenLater("yes")
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200637enddef
638
639def DefinedEvenLater(arg: string): string
640 return arg
641enddef
642
643def Test_error_in_nested_function()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200644 # Error in called function requires unwinding the call stack.
Bram Moolenaar44d66522020-09-06 22:26:57 +0200645 assert_fails('FuncWithForwardCall()', 'E1096:', '', 1, 'FuncWithForwardCall')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200646enddef
647
648def Test_return_type_wrong()
Bram Moolenaar5a849da2020-08-08 16:47:30 +0200649 CheckScriptFailure([
650 'def Func(): number',
651 'return "a"',
652 'enddef',
653 'defcompile'], 'expected number but got string')
654 CheckScriptFailure([
655 'def Func(): string',
656 'return 1',
657 'enddef',
658 'defcompile'], 'expected string but got number')
659 CheckScriptFailure([
660 'def Func(): void',
661 'return "a"',
662 'enddef',
663 'defcompile'],
664 'E1096: Returning a value in a function without a return type')
665 CheckScriptFailure([
666 'def Func()',
667 'return "a"',
668 'enddef',
669 'defcompile'],
670 'E1096: Returning a value in a function without a return type')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200671
Bram Moolenaar5a849da2020-08-08 16:47:30 +0200672 CheckScriptFailure([
673 'def Func(): number',
674 'return',
675 'enddef',
676 'defcompile'], 'E1003:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200677
678 CheckScriptFailure(['def Func(): list', 'return []', 'enddef'], 'E1008:')
679 CheckScriptFailure(['def Func(): dict', 'return {}', 'enddef'], 'E1008:')
Bram Moolenaaree4e0c12020-04-06 21:35:05 +0200680 CheckScriptFailure(['def Func()', 'return 1'], 'E1057:')
Bram Moolenaar5a849da2020-08-08 16:47:30 +0200681
682 CheckScriptFailure([
683 'vim9script',
684 'def FuncB()',
685 ' return 123',
686 'enddef',
687 'def FuncA()',
688 ' FuncB()',
689 'enddef',
690 'defcompile'], 'E1096:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200691enddef
692
693def Test_arg_type_wrong()
694 CheckScriptFailure(['def Func3(items: list)', 'echo "a"', 'enddef'], 'E1008: Missing <type>')
Bram Moolenaaree4e0c12020-04-06 21:35:05 +0200695 CheckScriptFailure(['def Func4(...)', 'echo "a"', 'enddef'], 'E1055: Missing name after ...')
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +0200696 CheckScriptFailure(['def Func5(items:string)', 'echo "a"'], 'E1069:')
Bram Moolenaar6e949782020-04-13 17:21:00 +0200697 CheckScriptFailure(['def Func5(items)', 'echo "a"'], 'E1077:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200698enddef
699
700def Test_vim9script_call()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200701 var lines =<< trim END
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200702 vim9script
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200703 var name = ''
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200704 def MyFunc(arg: string)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200705 name = arg
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200706 enddef
707 MyFunc('foobar')
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200708 name->assert_equal('foobar')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200709
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200710 var str = 'barfoo'
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200711 str->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200712 name->assert_equal('barfoo')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200713
Bram Moolenaar67979662020-06-20 22:50:47 +0200714 g:value = 'value'
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200715 g:value->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200716 name->assert_equal('value')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200717
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200718 var listvar = []
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200719 def ListFunc(arg: list<number>)
720 listvar = arg
721 enddef
722 [1, 2, 3]->ListFunc()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200723 listvar->assert_equal([1, 2, 3])
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200724
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200725 var dictvar = {}
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200726 def DictFunc(arg: dict<number>)
727 dictvar = arg
728 enddef
729 {'a': 1, 'b': 2}->DictFunc()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200730 dictvar->assert_equal(#{a: 1, b: 2})
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200731 def CompiledDict()
732 {'a': 3, 'b': 4}->DictFunc()
733 enddef
734 CompiledDict()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200735 dictvar->assert_equal(#{a: 3, b: 4})
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200736
737 #{a: 3, b: 4}->DictFunc()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200738 dictvar->assert_equal(#{a: 3, b: 4})
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200739
740 ('text')->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200741 name->assert_equal('text')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200742 ("some")->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200743 name->assert_equal('some')
Bram Moolenaare6b53242020-07-01 17:28:33 +0200744
Bram Moolenaar13e12b82020-07-24 18:47:22 +0200745 # line starting with single quote is not a mark
Bram Moolenaar10409562020-07-29 20:00:38 +0200746 # line starting with double quote can be a method call
Bram Moolenaar3d48e252020-07-15 14:15:52 +0200747 'asdfasdf'->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200748 name->assert_equal('asdfasdf')
Bram Moolenaar10409562020-07-29 20:00:38 +0200749 "xyz"->MyFunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200750 name->assert_equal('xyz')
Bram Moolenaar3d48e252020-07-15 14:15:52 +0200751
752 def UseString()
753 'xyork'->MyFunc()
754 enddef
755 UseString()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200756 name->assert_equal('xyork')
Bram Moolenaar3d48e252020-07-15 14:15:52 +0200757
Bram Moolenaar10409562020-07-29 20:00:38 +0200758 def UseString2()
759 "knife"->MyFunc()
760 enddef
761 UseString2()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200762 name->assert_equal('knife')
Bram Moolenaar10409562020-07-29 20:00:38 +0200763
Bram Moolenaar13e12b82020-07-24 18:47:22 +0200764 # prepending a colon makes it a mark
765 new
766 setline(1, ['aaa', 'bbb', 'ccc'])
767 normal! 3Gmt1G
768 :'t
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200769 getcurpos()[1]->assert_equal(3)
Bram Moolenaar13e12b82020-07-24 18:47:22 +0200770 bwipe!
771
Bram Moolenaare6b53242020-07-01 17:28:33 +0200772 MyFunc(
773 'continued'
774 )
775 assert_equal('continued',
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200776 name
Bram Moolenaare6b53242020-07-01 17:28:33 +0200777 )
778
779 call MyFunc(
780 'more'
781 ..
782 'lines'
783 )
784 assert_equal(
785 'morelines',
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200786 name)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200787 END
788 writefile(lines, 'Xcall.vim')
789 source Xcall.vim
790 delete('Xcall.vim')
791enddef
792
793def Test_vim9script_call_fail_decl()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200794 var lines =<< trim END
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200795 vim9script
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200796 var name = ''
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200797 def MyFunc(arg: string)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200798 var name = 123
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200799 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +0200800 defcompile
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200801 END
Bram Moolenaar6c4bfe42020-07-23 18:26:30 +0200802 CheckScriptFailure(lines, 'E1054:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200803enddef
804
Bram Moolenaar65b95452020-07-19 14:03:09 +0200805def Test_vim9script_call_fail_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200806 var lines =<< trim END
Bram Moolenaar65b95452020-07-19 14:03:09 +0200807 vim9script
808 def MyFunc(arg: string)
809 echo arg
810 enddef
811 MyFunc(1234)
812 END
Bram Moolenaar77072282020-09-16 17:55:40 +0200813 CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected string but got number')
Bram Moolenaar65b95452020-07-19 14:03:09 +0200814enddef
815
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200816def Test_vim9script_call_fail_const()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200817 var lines =<< trim END
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200818 vim9script
819 const var = ''
820 def MyFunc(arg: string)
821 var = 'asdf'
822 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +0200823 defcompile
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200824 END
825 writefile(lines, 'Xcall_const.vim')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +0200826 assert_fails('source Xcall_const.vim', 'E46:', '', 1, 'MyFunc')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200827 delete('Xcall_const.vim')
828enddef
829
830" Test that inside :function a Python function can be defined, :def is not
831" recognized.
832func Test_function_python()
833 CheckFeature python3
Bram Moolenaar727345e2020-09-27 23:33:59 +0200834 let py = 'python3'
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200835 execute py "<< EOF"
836def do_something():
837 return 1
838EOF
839endfunc
840
841def Test_delfunc()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200842 var lines =<< trim END
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200843 vim9script
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200844 def g:GoneSoon()
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200845 echo 'hello'
846 enddef
847
848 def CallGoneSoon()
849 GoneSoon()
850 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +0200851 defcompile
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200852
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200853 delfunc g:GoneSoon
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200854 CallGoneSoon()
855 END
856 writefile(lines, 'XToDelFunc')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +0200857 assert_fails('so XToDelFunc', 'E933:', '', 1, 'CallGoneSoon')
858 assert_fails('so XToDelFunc', 'E933:', '', 1, 'CallGoneSoon')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200859
860 delete('XToDelFunc')
861enddef
862
863def Test_redef_failure()
Bram Moolenaard2c61702020-09-06 15:58:36 +0200864 writefile(['def Func0(): string', 'return "Func0"', 'enddef'], 'Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200865 so Xdef
Bram Moolenaard2c61702020-09-06 15:58:36 +0200866 writefile(['def Func1(): string', 'return "Func1"', 'enddef'], 'Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200867 so Xdef
Bram Moolenaard2c61702020-09-06 15:58:36 +0200868 writefile(['def! Func0(): string', 'enddef', 'defcompile'], 'Xdef')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +0200869 assert_fails('so Xdef', 'E1027:', '', 1, 'Func0')
Bram Moolenaard2c61702020-09-06 15:58:36 +0200870 writefile(['def Func2(): string', 'return "Func2"', 'enddef'], 'Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200871 so Xdef
Bram Moolenaard2c61702020-09-06 15:58:36 +0200872 delete('Xdef')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200873
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200874 g:Func0()->assert_equal(0)
875 g:Func1()->assert_equal('Func1')
876 g:Func2()->assert_equal('Func2')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200877
878 delfunc! Func0
879 delfunc! Func1
880 delfunc! Func2
881enddef
882
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +0200883def Test_vim9script_func()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200884 var lines =<< trim END
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +0200885 vim9script
886 func Func(arg)
887 echo a:arg
888 endfunc
889 Func('text')
890 END
891 writefile(lines, 'XVim9Func')
892 so XVim9Func
893
894 delete('XVim9Func')
895enddef
896
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200897" Test for internal functions returning different types
898func Test_InternalFuncRetType()
899 let lines =<< trim END
900 def RetFloat(): float
901 return ceil(1.456)
902 enddef
903
904 def RetListAny(): list<any>
Bram Moolenaar17a836c2020-08-12 17:35:58 +0200905 return items({'k': 'v'})
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200906 enddef
907
908 def RetListString(): list<string>
909 return split('a:b:c', ':')
910 enddef
911
912 def RetListDictAny(): list<dict<any>>
913 return getbufinfo()
914 enddef
915
916 def RetDictNumber(): dict<number>
917 return wordcount()
918 enddef
919
920 def RetDictString(): dict<string>
921 return environ()
922 enddef
923 END
924 call writefile(lines, 'Xscript')
925 source Xscript
926
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200927 call RetFloat()->assert_equal(2.0)
928 call RetListAny()->assert_equal([['k', 'v']])
929 call RetListString()->assert_equal(['a', 'b', 'c'])
930 call RetListDictAny()->assert_notequal([])
931 call RetDictNumber()->assert_notequal({})
932 call RetDictString()->assert_notequal({})
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200933 call delete('Xscript')
934endfunc
935
936" Test for passing too many or too few arguments to internal functions
937func Test_internalfunc_arg_error()
938 let l =<< trim END
939 def! FArgErr(): float
940 return ceil(1.1, 2)
941 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +0200942 defcompile
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200943 END
944 call writefile(l, 'Xinvalidarg')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +0200945 call assert_fails('so Xinvalidarg', 'E118:', '', 1, 'FArgErr')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200946 let l =<< trim END
947 def! FArgErr(): float
948 return ceil()
949 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +0200950 defcompile
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200951 END
952 call writefile(l, 'Xinvalidarg')
Bram Moolenaar9bd5d872020-09-06 21:47:48 +0200953 call assert_fails('so Xinvalidarg', 'E119:', '', 1, 'FArgErr')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200954 call delete('Xinvalidarg')
955endfunc
956
957let s:funcResult = 0
958
959def FuncNoArgNoRet()
Bram Moolenaar53900992020-08-22 19:02:02 +0200960 s:funcResult = 11
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200961enddef
962
963def FuncNoArgRetNumber(): number
Bram Moolenaar53900992020-08-22 19:02:02 +0200964 s:funcResult = 22
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200965 return 1234
966enddef
967
Bram Moolenaarec5929d2020-04-07 20:53:39 +0200968def FuncNoArgRetString(): string
Bram Moolenaar53900992020-08-22 19:02:02 +0200969 s:funcResult = 45
Bram Moolenaarec5929d2020-04-07 20:53:39 +0200970 return 'text'
971enddef
972
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200973def FuncOneArgNoRet(arg: number)
Bram Moolenaar53900992020-08-22 19:02:02 +0200974 s:funcResult = arg
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200975enddef
976
977def FuncOneArgRetNumber(arg: number): number
Bram Moolenaar53900992020-08-22 19:02:02 +0200978 s:funcResult = arg
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200979 return arg
980enddef
981
Bram Moolenaar08938ee2020-04-11 23:17:17 +0200982def FuncTwoArgNoRet(one: bool, two: number)
Bram Moolenaar53900992020-08-22 19:02:02 +0200983 s:funcResult = two
Bram Moolenaar08938ee2020-04-11 23:17:17 +0200984enddef
985
Bram Moolenaarec5929d2020-04-07 20:53:39 +0200986def FuncOneArgRetString(arg: string): string
987 return arg
988enddef
989
Bram Moolenaar89228602020-04-05 22:14:54 +0200990def FuncOneArgRetAny(arg: any): any
991 return arg
992enddef
993
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200994def Test_func_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +0200995 var Ref1: func()
Bram Moolenaar53900992020-08-22 19:02:02 +0200996 s:funcResult = 0
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200997 Ref1 = FuncNoArgNoRet
998 Ref1()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +0200999 s:funcResult->assert_equal(11)
Bram Moolenaar4c683752020-04-05 21:38:23 +02001000
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001001 var Ref2: func
Bram Moolenaar53900992020-08-22 19:02:02 +02001002 s:funcResult = 0
Bram Moolenaar4c683752020-04-05 21:38:23 +02001003 Ref2 = FuncNoArgNoRet
1004 Ref2()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001005 s:funcResult->assert_equal(11)
Bram Moolenaar4c683752020-04-05 21:38:23 +02001006
Bram Moolenaar53900992020-08-22 19:02:02 +02001007 s:funcResult = 0
Bram Moolenaar4c683752020-04-05 21:38:23 +02001008 Ref2 = FuncOneArgNoRet
1009 Ref2(12)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001010 s:funcResult->assert_equal(12)
Bram Moolenaar4c683752020-04-05 21:38:23 +02001011
Bram Moolenaar53900992020-08-22 19:02:02 +02001012 s:funcResult = 0
Bram Moolenaar4c683752020-04-05 21:38:23 +02001013 Ref2 = FuncNoArgRetNumber
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001014 Ref2()->assert_equal(1234)
1015 s:funcResult->assert_equal(22)
Bram Moolenaar4c683752020-04-05 21:38:23 +02001016
Bram Moolenaar53900992020-08-22 19:02:02 +02001017 s:funcResult = 0
Bram Moolenaar4c683752020-04-05 21:38:23 +02001018 Ref2 = FuncOneArgRetNumber
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001019 Ref2(13)->assert_equal(13)
1020 s:funcResult->assert_equal(13)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001021enddef
1022
Bram Moolenaar9978d472020-07-05 16:01:56 +02001023def Test_repeat_return_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001024 var res = 0
Bram Moolenaar9978d472020-07-05 16:01:56 +02001025 for n in repeat([1], 3)
1026 res += n
1027 endfor
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001028 res->assert_equal(3)
Bram Moolenaarfce82b32020-07-05 16:07:21 +02001029
1030 res = 0
1031 for n in add([1, 2], 3)
1032 res += n
1033 endfor
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001034 res->assert_equal(6)
Bram Moolenaar9978d472020-07-05 16:01:56 +02001035enddef
1036
Bram Moolenaar846178a2020-07-05 17:04:13 +02001037def Test_argv_return_type()
1038 next fileone filetwo
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001039 var res = ''
Bram Moolenaar846178a2020-07-05 17:04:13 +02001040 for name in argv()
1041 res ..= name
1042 endfor
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001043 res->assert_equal('fileonefiletwo')
Bram Moolenaar846178a2020-07-05 17:04:13 +02001044enddef
1045
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001046def Test_func_type_part()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001047 var RefVoid: func: void
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001048 RefVoid = FuncNoArgNoRet
1049 RefVoid = FuncOneArgNoRet
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001050 CheckDefFailure(['var RefVoid: func: void', 'RefVoid = FuncNoArgRetNumber'], 'E1012: Type mismatch; expected func(...) but got func(): number')
1051 CheckDefFailure(['var RefVoid: func: void', 'RefVoid = FuncNoArgRetString'], 'E1012: Type mismatch; expected func(...) but got func(): string')
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001052
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001053 var RefAny: func(): any
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001054 RefAny = FuncNoArgRetNumber
1055 RefAny = FuncNoArgRetString
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001056 CheckDefFailure(['var RefAny: func(): any', 'RefAny = FuncNoArgNoRet'], 'E1012: Type mismatch; expected func(): any but got func()')
1057 CheckDefFailure(['var RefAny: func(): any', 'RefAny = FuncOneArgNoRet'], 'E1012: Type mismatch; expected func(): any but got func(number)')
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001058
Bram Moolenaar6abd3dc2020-10-04 14:17:32 +02001059 var RefAnyNoArgs: func: any = RefAny
1060
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001061 var RefNr: func: number
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001062 RefNr = FuncNoArgRetNumber
1063 RefNr = FuncOneArgRetNumber
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001064 CheckDefFailure(['var RefNr: func: number', 'RefNr = FuncNoArgNoRet'], 'E1012: Type mismatch; expected func(...): number but got func()')
1065 CheckDefFailure(['var RefNr: func: number', 'RefNr = FuncNoArgRetString'], 'E1012: Type mismatch; expected func(...): number but got func(): string')
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001066
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001067 var RefStr: func: string
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001068 RefStr = FuncNoArgRetString
1069 RefStr = FuncOneArgRetString
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001070 CheckDefFailure(['var RefStr: func: string', 'RefStr = FuncNoArgNoRet'], 'E1012: Type mismatch; expected func(...): string but got func()')
1071 CheckDefFailure(['var RefStr: func: string', 'RefStr = FuncNoArgRetNumber'], 'E1012: Type mismatch; expected func(...): string but got func(): number')
Bram Moolenaarec5929d2020-04-07 20:53:39 +02001072enddef
1073
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001074def Test_func_type_fails()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001075 CheckDefFailure(['var ref1: func()'], 'E704:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001076
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001077 CheckDefFailure(['var Ref1: func()', 'Ref1 = FuncNoArgRetNumber'], 'E1012: Type mismatch; expected func() but got func(): number')
1078 CheckDefFailure(['var Ref1: func()', 'Ref1 = FuncOneArgNoRet'], 'E1012: Type mismatch; expected func() but got func(number)')
1079 CheckDefFailure(['var Ref1: func()', 'Ref1 = FuncOneArgRetNumber'], 'E1012: Type mismatch; expected func() but got func(number): number')
1080 CheckDefFailure(['var Ref1: func(bool)', 'Ref1 = FuncTwoArgNoRet'], 'E1012: Type mismatch; expected func(bool) but got func(bool, number)')
1081 CheckDefFailure(['var Ref1: func(?bool)', 'Ref1 = FuncTwoArgNoRet'], 'E1012: Type mismatch; expected func(?bool) but got func(bool, number)')
1082 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 +02001083
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001084 CheckDefFailure(['var RefWrong: func(string ,number)'], 'E1068:')
1085 CheckDefFailure(['var RefWrong: func(string,number)'], 'E1069:')
1086 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:')
1087 CheckDefFailure(['var RefWrong: func(bool):string'], 'E1069:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001088enddef
1089
Bram Moolenaar89228602020-04-05 22:14:54 +02001090def Test_func_return_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001091 var nr: number
Bram Moolenaar89228602020-04-05 22:14:54 +02001092 nr = FuncNoArgRetNumber()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001093 nr->assert_equal(1234)
Bram Moolenaar89228602020-04-05 22:14:54 +02001094
1095 nr = FuncOneArgRetAny(122)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001096 nr->assert_equal(122)
Bram Moolenaar89228602020-04-05 22:14:54 +02001097
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001098 var str: string
Bram Moolenaar89228602020-04-05 22:14:54 +02001099 str = FuncOneArgRetAny('yes')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001100 str->assert_equal('yes')
Bram Moolenaar89228602020-04-05 22:14:54 +02001101
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001102 CheckDefFailure(['var str: string', 'str = FuncNoArgRetNumber()'], 'E1012: Type mismatch; expected string but got number')
Bram Moolenaar89228602020-04-05 22:14:54 +02001103enddef
1104
Bram Moolenaar6abd3dc2020-10-04 14:17:32 +02001105def Test_func_common_type()
1106 def FuncOne(n: number): number
1107 return n
1108 enddef
1109 def FuncTwo(s: string): number
1110 return len(s)
1111 enddef
1112 def FuncThree(n: number, s: string): number
1113 return n + len(s)
1114 enddef
1115 var list = [FuncOne, FuncTwo, FuncThree]
1116 assert_equal(8, list[0](8))
1117 assert_equal(4, list[1]('word'))
1118 assert_equal(7, list[2](3, 'word'))
1119enddef
1120
Bram Moolenaar5e774c72020-04-12 21:53:00 +02001121def MultiLine(
1122 arg1: string,
1123 arg2 = 1234,
1124 ...rest: list<string>
1125 ): string
1126 return arg1 .. arg2 .. join(rest, '-')
1127enddef
1128
Bram Moolenaar2c330432020-04-13 14:41:35 +02001129def MultiLineComment(
1130 arg1: string, # comment
1131 arg2 = 1234, # comment
1132 ...rest: list<string> # comment
1133 ): string # comment
1134 return arg1 .. arg2 .. join(rest, '-')
1135enddef
1136
Bram Moolenaar5e774c72020-04-12 21:53:00 +02001137def Test_multiline()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001138 MultiLine('text')->assert_equal('text1234')
1139 MultiLine('text', 777)->assert_equal('text777')
1140 MultiLine('text', 777, 'one')->assert_equal('text777one')
1141 MultiLine('text', 777, 'one', 'two')->assert_equal('text777one-two')
Bram Moolenaar5e774c72020-04-12 21:53:00 +02001142enddef
1143
Bram Moolenaar23e03252020-04-12 22:22:31 +02001144func Test_multiline_not_vim9()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001145 call MultiLine('text')->assert_equal('text1234')
1146 call MultiLine('text', 777)->assert_equal('text777')
1147 call MultiLine('text', 777, 'one')->assert_equal('text777one')
1148 call MultiLine('text', 777, 'one', 'two')->assert_equal('text777one-two')
Bram Moolenaar23e03252020-04-12 22:22:31 +02001149endfunc
1150
Bram Moolenaar5e774c72020-04-12 21:53:00 +02001151
Bram Moolenaaree4e0c12020-04-06 21:35:05 +02001152" When using CheckScriptFailure() for the below test, E1010 is generated instead
1153" of E1056.
1154func Test_E1056_1059()
1155 let caught_1056 = 0
1156 try
1157 def F():
1158 return 1
1159 enddef
1160 catch /E1056:/
1161 let caught_1056 = 1
1162 endtry
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001163 eval caught_1056->assert_equal(1)
Bram Moolenaaree4e0c12020-04-06 21:35:05 +02001164
1165 let caught_1059 = 0
1166 try
1167 def F5(items : list)
1168 echo 'a'
1169 enddef
1170 catch /E1059:/
1171 let caught_1059 = 1
1172 endtry
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001173 eval caught_1059->assert_equal(1)
Bram Moolenaaree4e0c12020-04-06 21:35:05 +02001174endfunc
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02001175
Bram Moolenaar015f4262020-05-05 21:25:22 +02001176func DelMe()
1177 echo 'DelMe'
1178endfunc
1179
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001180def Test_error_reporting()
1181 # comment lines at the start of the function
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001182 var lines =<< trim END
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001183 " comment
1184 def Func()
1185 # comment
1186 # comment
1187 invalid
1188 enddef
1189 defcompile
1190 END
Bram Moolenaar08052222020-09-14 17:04:31 +02001191 writefile(lines, 'Xdef')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001192 try
1193 source Xdef
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02001194 assert_report('should have failed')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001195 catch /E476:/
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001196 v:exception->assert_match('Invalid command: invalid')
1197 v:throwpoint->assert_match(', line 3$')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001198 endtry
1199
1200 # comment lines after the start of the function
1201 lines =<< trim END
1202 " comment
1203 def Func()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001204 var x = 1234
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001205 # comment
1206 # comment
1207 invalid
1208 enddef
1209 defcompile
1210 END
Bram Moolenaar08052222020-09-14 17:04:31 +02001211 writefile(lines, 'Xdef')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001212 try
1213 source Xdef
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02001214 assert_report('should have failed')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001215 catch /E476:/
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001216 v:exception->assert_match('Invalid command: invalid')
1217 v:throwpoint->assert_match(', line 4$')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001218 endtry
1219
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02001220 lines =<< trim END
1221 vim9script
1222 def Func()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001223 var db = #{foo: 1, bar: 2}
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02001224 # comment
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001225 var x = db.asdf
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02001226 enddef
1227 defcompile
1228 Func()
1229 END
Bram Moolenaar08052222020-09-14 17:04:31 +02001230 writefile(lines, 'Xdef')
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02001231 try
1232 source Xdef
1233 assert_report('should have failed')
1234 catch /E716:/
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001235 v:throwpoint->assert_match('_Func, line 3$')
Bram Moolenaar7517ffd2020-08-14 18:35:07 +02001236 endtry
1237
Bram Moolenaar08052222020-09-14 17:04:31 +02001238 delete('Xdef')
Bram Moolenaarbf8feb52020-08-08 14:26:31 +02001239enddef
1240
Bram Moolenaar015f4262020-05-05 21:25:22 +02001241def Test_deleted_function()
1242 CheckDefExecFailure([
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001243 'var RefMe: func = function("g:DelMe")',
Bram Moolenaar015f4262020-05-05 21:25:22 +02001244 'delfunc g:DelMe',
1245 'echo RefMe()'], 'E117:')
1246enddef
1247
1248def Test_unknown_function()
1249 CheckDefExecFailure([
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001250 'var Ref: func = function("NotExist")',
Bram Moolenaar9b7bf9e2020-07-11 22:14:59 +02001251 'delfunc g:NotExist'], 'E700:')
Bram Moolenaar015f4262020-05-05 21:25:22 +02001252enddef
1253
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02001254def RefFunc(Ref: func(string): string): string
1255 return Ref('more')
1256enddef
1257
1258def Test_closure_simple()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001259 var local = 'some '
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001260 RefFunc({s -> local .. s})->assert_equal('some more')
Bram Moolenaarc8cd2b32020-05-01 19:29:08 +02001261enddef
1262
Bram Moolenaarbf67ea12020-05-02 17:52:42 +02001263def MakeRef()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001264 var local = 'some '
Bram Moolenaarbf67ea12020-05-02 17:52:42 +02001265 g:Ref = {s -> local .. s}
1266enddef
1267
1268def Test_closure_ref_after_return()
1269 MakeRef()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001270 g:Ref('thing')->assert_equal('some thing')
Bram Moolenaarbf67ea12020-05-02 17:52:42 +02001271 unlet g:Ref
1272enddef
1273
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02001274def MakeTwoRefs()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001275 var local = ['some']
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02001276 g:Extend = {s -> local->add(s)}
1277 g:Read = {-> local}
1278enddef
1279
1280def Test_closure_two_refs()
1281 MakeTwoRefs()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001282 join(g:Read(), ' ')->assert_equal('some')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02001283 g:Extend('more')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001284 join(g:Read(), ' ')->assert_equal('some more')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02001285 g:Extend('even')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001286 join(g:Read(), ' ')->assert_equal('some more even')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02001287
1288 unlet g:Extend
1289 unlet g:Read
1290enddef
1291
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02001292def ReadRef(Ref: func(): list<string>): string
1293 return join(Ref(), ' ')
1294enddef
1295
Bram Moolenaar5e654232020-09-16 15:22:00 +02001296def ExtendRef(Ref: func(string): list<string>, add: string)
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02001297 Ref(add)
1298enddef
1299
1300def Test_closure_two_indirect_refs()
Bram Moolenaarf7779c62020-05-03 15:38:16 +02001301 MakeTwoRefs()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001302 ReadRef(g:Read)->assert_equal('some')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02001303 ExtendRef(g:Extend, 'more')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001304 ReadRef(g:Read)->assert_equal('some more')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02001305 ExtendRef(g:Extend, 'even')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001306 ReadRef(g:Read)->assert_equal('some more even')
Bram Moolenaar5adc55c2020-05-02 23:12:58 +02001307
1308 unlet g:Extend
1309 unlet g:Read
1310enddef
Bram Moolenaarbf67ea12020-05-02 17:52:42 +02001311
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02001312def MakeArgRefs(theArg: string)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001313 var local = 'loc_val'
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02001314 g:UseArg = {s -> theArg .. '/' .. local .. '/' .. s}
1315enddef
1316
1317def MakeArgRefsVarargs(theArg: string, ...rest: list<string>)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001318 var local = 'the_loc'
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02001319 g:UseVararg = {s -> theArg .. '/' .. local .. '/' .. s .. '/' .. join(rest)}
1320enddef
1321
1322def Test_closure_using_argument()
1323 MakeArgRefs('arg_val')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001324 g:UseArg('call_val')->assert_equal('arg_val/loc_val/call_val')
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02001325
1326 MakeArgRefsVarargs('arg_val', 'one', 'two')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001327 g:UseVararg('call_val')->assert_equal('arg_val/the_loc/call_val/one two')
Bram Moolenaar2fd4cd72020-05-03 22:30:49 +02001328
1329 unlet g:UseArg
1330 unlet g:UseVararg
1331enddef
1332
Bram Moolenaar85d5e2b2020-10-10 14:13:01 +02001333def MakeGetAndAppendRefs()
1334 var local = 'a'
1335
1336 def Append(arg: string)
1337 local ..= arg
1338 enddef
1339 g:Append = Append
1340
1341 def Get(): string
1342 return local
1343 enddef
1344 g:Get = Get
1345enddef
1346
1347def Test_closure_append_get()
1348 MakeGetAndAppendRefs()
1349 g:Get()->assert_equal('a')
1350 g:Append('-b')
1351 g:Get()->assert_equal('a-b')
1352 g:Append('-c')
1353 g:Get()->assert_equal('a-b-c')
1354
1355 unlet g:Append
1356 unlet g:Get
1357enddef
Bram Moolenaarb68b3462020-05-06 21:06:30 +02001358
Bram Moolenaar04b12692020-05-04 23:24:44 +02001359def Test_nested_closure()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001360 var local = 'text'
Bram Moolenaar04b12692020-05-04 23:24:44 +02001361 def Closure(arg: string): string
1362 return local .. arg
1363 enddef
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001364 Closure('!!!')->assert_equal('text!!!')
Bram Moolenaar04b12692020-05-04 23:24:44 +02001365enddef
1366
Bram Moolenaar6f5b6df2020-05-16 21:20:12 +02001367func GetResult(Ref)
1368 return a:Ref('some')
1369endfunc
1370
1371def Test_call_closure_not_compiled()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001372 var text = 'text'
Bram Moolenaar6f5b6df2020-05-16 21:20:12 +02001373 g:Ref = {s -> s .. text}
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001374 GetResult(g:Ref)->assert_equal('sometext')
Bram Moolenaar6f5b6df2020-05-16 21:20:12 +02001375enddef
1376
Bram Moolenaar7cbfaa52020-09-18 21:25:32 +02001377def Test_double_closure_fails()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001378 var lines =<< trim END
Bram Moolenaar7cbfaa52020-09-18 21:25:32 +02001379 vim9script
1380 def Func()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001381 var name = 0
1382 for i in range(2)
1383 timer_start(0, {-> name})
1384 endfor
Bram Moolenaar7cbfaa52020-09-18 21:25:32 +02001385 enddef
1386 Func()
1387 END
Bram Moolenaar148ce7a2020-09-23 21:57:23 +02001388 CheckScriptSuccess(lines)
Bram Moolenaar7cbfaa52020-09-18 21:25:32 +02001389enddef
1390
Bram Moolenaar85d5e2b2020-10-10 14:13:01 +02001391def Test_nested_closure_used()
1392 var lines =<< trim END
1393 vim9script
1394 def Func()
1395 var x = 'hello'
1396 var Closure = {-> x}
1397 g:Myclosure = {-> Closure()}
1398 enddef
1399 Func()
1400 assert_equal('hello', g:Myclosure())
1401 END
1402 CheckScriptSuccess(lines)
1403enddef
Bram Moolenaar0876c782020-10-07 19:08:04 +02001404
Bram Moolenaarc70bdab2020-09-26 19:59:38 +02001405def Test_nested_closure_fails()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001406 var lines =<< trim END
Bram Moolenaarc70bdab2020-09-26 19:59:38 +02001407 vim9script
1408 def FuncA()
1409 FuncB(0)
1410 enddef
1411 def FuncB(n: number): list<string>
1412 return map([0], {_, v -> n})
1413 enddef
1414 FuncA()
1415 END
1416 CheckScriptFailure(lines, 'E1012:')
1417enddef
1418
Bram Moolenaar5366e1a2020-10-01 13:01:34 +02001419def Test_nested_lambda()
1420 var lines =<< trim END
1421 vim9script
1422 def Func()
1423 var x = 4
1424 var Lambda1 = {-> 7}
1425 var Lambda2 = {-> [Lambda1(), x]}
1426 var res = Lambda2()
1427 assert_equal([7, 4], res)
1428 enddef
1429 Func()
1430 END
1431 CheckScriptSuccess(lines)
1432enddef
1433
Bram Moolenaar865af6b2020-06-18 18:45:49 +02001434def Test_sort_return_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001435 var res: list<number>
Bram Moolenaar865af6b2020-06-18 18:45:49 +02001436 res = [1, 2, 3]->sort()
1437enddef
1438
Bram Moolenaar08e51f42020-09-16 23:23:36 +02001439def Test_sort_argument()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001440 var res = ['b', 'a', 'c']->sort('i')
Bram Moolenaar08e51f42020-09-16 23:23:36 +02001441 res->assert_equal(['a', 'b', 'c'])
1442enddef
1443
Bram Moolenaarf151ad12020-06-30 13:38:01 +02001444def Test_getqflist_return_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001445 var l = getqflist()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001446 l->assert_equal([])
Bram Moolenaarf151ad12020-06-30 13:38:01 +02001447
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001448 var d = getqflist(#{items: 0})
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001449 d->assert_equal(#{items: []})
Bram Moolenaarf151ad12020-06-30 13:38:01 +02001450enddef
1451
1452def Test_getloclist_return_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001453 var l = getloclist(1)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001454 l->assert_equal([])
Bram Moolenaarf151ad12020-06-30 13:38:01 +02001455
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001456 var d = getloclist(1, #{items: 0})
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001457 d->assert_equal(#{items: []})
Bram Moolenaarf151ad12020-06-30 13:38:01 +02001458enddef
1459
Bram Moolenaara66ba012020-07-05 18:41:08 +02001460def Test_copy_return_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001461 var l = copy([1, 2, 3])
1462 var res = 0
Bram Moolenaara66ba012020-07-05 18:41:08 +02001463 for n in l
1464 res += n
1465 endfor
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001466 res->assert_equal(6)
Bram Moolenaara66ba012020-07-05 18:41:08 +02001467
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001468 var dl = deepcopy([1, 2, 3])
Bram Moolenaara66ba012020-07-05 18:41:08 +02001469 res = 0
1470 for n in dl
1471 res += n
1472 endfor
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001473 res->assert_equal(6)
Bram Moolenaar44b4a242020-09-05 17:18:28 +02001474
1475 dl = deepcopy([1, 2, 3], true)
Bram Moolenaara66ba012020-07-05 18:41:08 +02001476enddef
1477
Bram Moolenaarb3c019c2020-07-05 20:08:39 +02001478def Test_extend_return_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001479 var l = extend([1, 2], [3])
1480 var res = 0
Bram Moolenaarb3c019c2020-07-05 20:08:39 +02001481 for n in l
1482 res += n
1483 endfor
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001484 res->assert_equal(6)
Bram Moolenaarb3c019c2020-07-05 20:08:39 +02001485enddef
1486
Bram Moolenaar2df47312020-09-05 17:30:44 +02001487def Test_garbagecollect()
1488 garbagecollect(true)
1489enddef
1490
Bram Moolenaar252e88a2020-07-05 20:47:18 +02001491def Test_insert_return_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001492 var l = insert([2, 1], 3)
1493 var res = 0
Bram Moolenaar252e88a2020-07-05 20:47:18 +02001494 for n in l
1495 res += n
1496 endfor
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001497 res->assert_equal(6)
Bram Moolenaar252e88a2020-07-05 20:47:18 +02001498enddef
1499
Bram Moolenaar32f335f2020-08-14 18:56:45 +02001500def Test_keys_return_type()
1501 const var: list<string> = #{a: 1, b: 2}->keys()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001502 var->assert_equal(['a', 'b'])
Bram Moolenaar32f335f2020-08-14 18:56:45 +02001503enddef
1504
Bram Moolenaar67627352020-07-05 21:10:24 +02001505def Test_reverse_return_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001506 var l = reverse([1, 2, 3])
1507 var res = 0
Bram Moolenaar67627352020-07-05 21:10:24 +02001508 for n in l
1509 res += n
1510 endfor
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001511 res->assert_equal(6)
Bram Moolenaar67627352020-07-05 21:10:24 +02001512enddef
1513
Bram Moolenaarad7c2492020-07-05 20:55:29 +02001514def Test_remove_return_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001515 var l = remove(#{one: [1, 2], two: [3, 4]}, 'one')
1516 var res = 0
Bram Moolenaarad7c2492020-07-05 20:55:29 +02001517 for n in l
1518 res += n
1519 endfor
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001520 res->assert_equal(3)
Bram Moolenaarad7c2492020-07-05 20:55:29 +02001521enddef
1522
Bram Moolenaar0d94ad62020-07-05 20:16:41 +02001523def Test_filter_return_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001524 var l = filter([1, 2, 3], {-> 1})
1525 var res = 0
Bram Moolenaar0d94ad62020-07-05 20:16:41 +02001526 for n in l
1527 res += n
1528 endfor
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001529 res->assert_equal(6)
Bram Moolenaar0d94ad62020-07-05 20:16:41 +02001530enddef
1531
Bram Moolenaarf39397e2020-08-17 22:21:36 +02001532def Test_bufnr()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001533 var buf = bufnr()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001534 bufnr('%')->assert_equal(buf)
Bram Moolenaarfe136c92020-09-04 18:35:26 +02001535
1536 buf = bufnr('Xdummy', true)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001537 buf->assert_notequal(-1)
Bram Moolenaarfe136c92020-09-04 18:35:26 +02001538 exe 'bwipe! ' .. buf
Bram Moolenaarf39397e2020-08-17 22:21:36 +02001539enddef
1540
Bram Moolenaarec65d772020-08-20 22:29:12 +02001541def Test_col()
1542 new
1543 setline(1, 'asdf')
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001544 col([1, '$'])->assert_equal(5)
Bram Moolenaarec65d772020-08-20 22:29:12 +02001545enddef
1546
Bram Moolenaar24f77502020-09-04 19:50:57 +02001547def Test_char2nr()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001548 char2nr('あ', true)->assert_equal(12354)
Bram Moolenaar24f77502020-09-04 19:50:57 +02001549enddef
1550
Bram Moolenaar3d945cc2020-08-06 21:26:59 +02001551def Test_getreg_return_type()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001552 var s1: string = getreg('"')
1553 var s2: string = getreg('"', 1)
1554 var s3: list<string> = getreg('"', 1, 1)
Bram Moolenaar3d945cc2020-08-06 21:26:59 +02001555enddef
1556
Bram Moolenaarf1a23682020-07-13 18:55:48 +02001557def Wrong_dict_key_type(items: list<number>): list<number>
1558 return filter(items, {_, val -> get({val: 1}, 'x')})
1559enddef
1560
1561def Test_wrong_dict_key_type()
Bram Moolenaar5e654232020-09-16 15:22:00 +02001562 assert_fails('Wrong_dict_key_type([1, 2, 3])', 'E1012:')
Bram Moolenaarf1a23682020-07-13 18:55:48 +02001563enddef
1564
Bram Moolenaaracd4c5e2020-06-22 19:39:03 +02001565def Line_continuation_in_def(dir: string = ''): string
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001566 var path: string = empty(dir)
1567 \ ? 'empty'
1568 \ : 'full'
1569 return path
Bram Moolenaaracd4c5e2020-06-22 19:39:03 +02001570enddef
1571
1572def Test_line_continuation_in_def()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001573 Line_continuation_in_def('.')->assert_equal('full')
Bram Moolenaaracd4c5e2020-06-22 19:39:03 +02001574enddef
1575
Bram Moolenaar5e654232020-09-16 15:22:00 +02001576def Line_continuation_in_lambda(): list<string>
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001577 var x = range(97, 100)
Bram Moolenaar914e7ea2020-07-11 15:20:48 +02001578 ->map({_, v -> nr2char(v)
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02001579 ->toupper()})
1580 ->reverse()
1581 return x
1582enddef
1583
1584def Test_line_continuation_in_lambda()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001585 Line_continuation_in_lambda()->assert_equal(['D', 'C', 'B', 'A'])
Bram Moolenaar7a4b8982020-07-08 17:36:21 +02001586enddef
1587
Bram Moolenaar8f510af2020-07-05 18:48:23 +02001588func Test_silent_echo()
Bram Moolenaar47e7d702020-07-05 18:18:42 +02001589 CheckScreendump
1590
1591 let lines =<< trim END
1592 vim9script
1593 def EchoNothing()
1594 silent echo ''
1595 enddef
1596 defcompile
1597 END
Bram Moolenaar8f510af2020-07-05 18:48:23 +02001598 call writefile(lines, 'XTest_silent_echo')
Bram Moolenaar47e7d702020-07-05 18:18:42 +02001599
1600 " Check that the balloon shows up after a mouse move
1601 let buf = RunVimInTerminal('-S XTest_silent_echo', {'rows': 6})
Bram Moolenaar8f510af2020-07-05 18:48:23 +02001602 call term_sendkeys(buf, ":abc")
Bram Moolenaar47e7d702020-07-05 18:18:42 +02001603 call VerifyScreenDump(buf, 'Test_vim9_silent_echo', {})
1604
1605 " clean up
1606 call StopVimInTerminal(buf)
1607 call delete('XTest_silent_echo')
Bram Moolenaar8f510af2020-07-05 18:48:23 +02001608endfunc
Bram Moolenaar47e7d702020-07-05 18:18:42 +02001609
Bram Moolenaar4b9bd692020-09-05 21:57:53 +02001610""""""" builtin functions that behave differently in Vim9
Bram Moolenaare15eebd2020-08-18 19:11:38 +02001611
Bram Moolenaar4b9bd692020-09-05 21:57:53 +02001612def Test_bufname()
1613 split SomeFile
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001614 bufname('%')->assert_equal('SomeFile')
Bram Moolenaar4b9bd692020-09-05 21:57:53 +02001615 edit OtherFile
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001616 bufname('#')->assert_equal('SomeFile')
Bram Moolenaar4b9bd692020-09-05 21:57:53 +02001617 close
Bram Moolenaar191929b2020-08-19 21:20:49 +02001618enddef
1619
Bram Moolenaara5d38412020-09-02 21:02:35 +02001620def Test_bufwinid()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001621 var origwin = win_getid()
Bram Moolenaara5d38412020-09-02 21:02:35 +02001622 below split SomeFile
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001623 var SomeFileID = win_getid()
Bram Moolenaara5d38412020-09-02 21:02:35 +02001624 below split OtherFile
1625 below split SomeFile
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001626 bufwinid('SomeFile')->assert_equal(SomeFileID)
Bram Moolenaara5d38412020-09-02 21:02:35 +02001627
1628 win_gotoid(origwin)
1629 only
1630 bwipe SomeFile
1631 bwipe OtherFile
1632enddef
1633
Bram Moolenaar4b9bd692020-09-05 21:57:53 +02001634def Test_count()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001635 count('ABC ABC ABC', 'b', true)->assert_equal(3)
1636 count('ABC ABC ABC', 'b', false)->assert_equal(0)
Bram Moolenaar4b9bd692020-09-05 21:57:53 +02001637enddef
1638
1639def Test_expand()
1640 split SomeFile
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001641 expand('%', true, true)->assert_equal(['SomeFile'])
Bram Moolenaar4b9bd692020-09-05 21:57:53 +02001642 close
1643enddef
1644
1645def Test_getbufinfo()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001646 var bufinfo = getbufinfo(bufnr())
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001647 getbufinfo('%')->assert_equal(bufinfo)
Bram Moolenaar4b9bd692020-09-05 21:57:53 +02001648
1649 edit Xtestfile1
1650 hide edit Xtestfile2
1651 hide enew
1652 getbufinfo(#{bufloaded: true, buflisted: true, bufmodified: false})
1653 ->len()->assert_equal(3)
1654 bwipe Xtestfile1 Xtestfile2
1655enddef
1656
Bram Moolenaara5d38412020-09-02 21:02:35 +02001657def Test_getbufline()
1658 e SomeFile
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001659 var buf = bufnr()
Bram Moolenaara5d38412020-09-02 21:02:35 +02001660 e #
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001661 var lines = ['aaa', 'bbb', 'ccc']
Bram Moolenaara5d38412020-09-02 21:02:35 +02001662 setbufline(buf, 1, lines)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001663 getbufline('#', 1, '$')->assert_equal(lines)
Bram Moolenaara5d38412020-09-02 21:02:35 +02001664
1665 bwipe!
1666enddef
1667
1668def Test_getchangelist()
1669 new
1670 setline(1, 'some text')
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001671 var changelist = bufnr()->getchangelist()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001672 getchangelist('%')->assert_equal(changelist)
Bram Moolenaara5d38412020-09-02 21:02:35 +02001673 bwipe!
1674enddef
1675
Bram Moolenaarc08cc722020-09-05 17:51:23 +02001676def Test_getchar()
Bram Moolenaar636c5d52020-09-05 18:48:57 +02001677 while getchar(0)
1678 endwhile
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001679 getchar(true)->assert_equal(0)
Bram Moolenaarc08cc722020-09-05 17:51:23 +02001680enddef
1681
Bram Moolenaard217a872020-09-05 18:31:33 +02001682def Test_getcompletion()
1683 set wildignore=*.vim,*~
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001684 var l = getcompletion('run', 'file', true)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001685 l->assert_equal([])
Bram Moolenaard217a872020-09-05 18:31:33 +02001686 set wildignore&
1687enddef
1688
Bram Moolenaar67ff97d2020-09-02 21:45:54 +02001689def Test_getreg()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001690 var lines = ['aaa', 'bbb', 'ccc']
Bram Moolenaar67ff97d2020-09-02 21:45:54 +02001691 setreg('a', lines)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001692 getreg('a', true, true)->assert_equal(lines)
Bram Moolenaar67ff97d2020-09-02 21:45:54 +02001693enddef
1694
Bram Moolenaar5892ea12020-09-02 21:53:11 +02001695def Test_glob()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001696 glob('runtest.vim', true, true, true)->assert_equal(['runtest.vim'])
Bram Moolenaar5892ea12020-09-02 21:53:11 +02001697enddef
1698
Bram Moolenaarf966ce52020-09-02 21:57:07 +02001699def Test_globpath()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001700 globpath('.', 'runtest.vim', true, true, true)->assert_equal(['./runtest.vim'])
Bram Moolenaarf966ce52020-09-02 21:57:07 +02001701enddef
1702
Bram Moolenaar4b9bd692020-09-05 21:57:53 +02001703def Test_has()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001704 has('eval', true)->assert_equal(1)
Bram Moolenaar4b9bd692020-09-05 21:57:53 +02001705enddef
1706
Bram Moolenaar04d594b2020-09-02 22:25:35 +02001707def Test_hasmapto()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001708 hasmapto('foobar', 'i', true)->assert_equal(0)
Bram Moolenaar04d594b2020-09-02 22:25:35 +02001709 iabbrev foo foobar
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001710 hasmapto('foobar', 'i', true)->assert_equal(1)
Bram Moolenaar04d594b2020-09-02 22:25:35 +02001711 iunabbrev foo
1712enddef
1713
Bram Moolenaar4b9bd692020-09-05 21:57:53 +02001714def Test_index()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001715 index(['a', 'b', 'a', 'B'], 'b', 2, true)->assert_equal(3)
Bram Moolenaar4b9bd692020-09-05 21:57:53 +02001716enddef
1717
1718def Test_list2str_str2list_utf8()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001719 var s = "\u3042\u3044"
1720 var l = [0x3042, 0x3044]
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001721 str2list(s, true)->assert_equal(l)
1722 list2str(l, true)->assert_equal(s)
Bram Moolenaar4b9bd692020-09-05 21:57:53 +02001723enddef
1724
Bram Moolenaar04d594b2020-09-02 22:25:35 +02001725def SID(): number
1726 return expand('<SID>')
1727 ->matchstr('<SNR>\zs\d\+\ze_$')
1728 ->str2nr()
1729enddef
1730
1731def Test_maparg()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001732 var lnum = str2nr(expand('<sflnum>'))
Bram Moolenaar04d594b2020-09-02 22:25:35 +02001733 map foo bar
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001734 maparg('foo', '', false, true)->assert_equal(#{
Bram Moolenaar04d594b2020-09-02 22:25:35 +02001735 lnum: lnum + 1,
1736 script: 0,
1737 mode: ' ',
1738 silent: 0,
1739 noremap: 0,
1740 lhs: 'foo',
1741 lhsraw: 'foo',
1742 nowait: 0,
1743 expr: 0,
1744 sid: SID(),
1745 rhs: 'bar',
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001746 buffer: 0})
Bram Moolenaar04d594b2020-09-02 22:25:35 +02001747 unmap foo
1748enddef
1749
1750def Test_mapcheck()
1751 iabbrev foo foobar
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001752 mapcheck('foo', 'i', true)->assert_equal('foobar')
Bram Moolenaar04d594b2020-09-02 22:25:35 +02001753 iunabbrev foo
1754enddef
1755
Bram Moolenaar74273e62020-10-01 21:37:21 +02001756def Test_maparg_mapset()
1757 nnoremap <F3> :echo "hit F3"<CR>
1758 var mapsave = maparg('<F3>', 'n', false, true)
1759 mapset('n', false, mapsave)
1760
1761 nunmap <F3>
1762enddef
1763
Bram Moolenaar4b9bd692020-09-05 21:57:53 +02001764def Test_nr2char()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001765 nr2char(97, true)->assert_equal('a')
Bram Moolenaar4b9bd692020-09-05 21:57:53 +02001766enddef
1767
1768def Test_readdir()
1769 eval expand('sautest')->readdir({e -> e[0] !=# '.'})
1770 eval expand('sautest')->readdirex({e -> e.name[0] !=# '.'})
1771enddef
1772
1773def Test_search()
1774 new
1775 setline(1, ['foo', 'bar'])
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001776 var val = 0
Bram Moolenaar4b9bd692020-09-05 21:57:53 +02001777 # skip expr returns boolean
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001778 search('bar', 'W', 0, 0, {-> val == 1})->assert_equal(2)
Bram Moolenaar4b9bd692020-09-05 21:57:53 +02001779 :1
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001780 search('bar', 'W', 0, 0, {-> val == 0})->assert_equal(0)
Bram Moolenaar4b9bd692020-09-05 21:57:53 +02001781 # skip expr returns number, only 0 and 1 are accepted
1782 :1
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001783 search('bar', 'W', 0, 0, {-> 0})->assert_equal(2)
Bram Moolenaar4b9bd692020-09-05 21:57:53 +02001784 :1
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001785 search('bar', 'W', 0, 0, {-> 1})->assert_equal(0)
Bram Moolenaar4b9bd692020-09-05 21:57:53 +02001786 assert_fails("search('bar', '', 0, 0, {-> -1})", 'E1023:')
1787 assert_fails("search('bar', '', 0, 0, {-> -1})", 'E1023:')
1788enddef
1789
1790def Test_searchcount()
1791 new
1792 setline(1, "foo bar")
1793 :/foo
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001794 searchcount(#{recompute: true})
1795 ->assert_equal(#{
1796 exact_match: 1,
1797 current: 1,
1798 total: 1,
1799 maxcount: 99,
1800 incomplete: 0})
Bram Moolenaar4b9bd692020-09-05 21:57:53 +02001801 bwipe!
1802enddef
1803
1804def Test_searchdecl()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001805 searchdecl('blah', true, true)->assert_equal(1)
Bram Moolenaar4b9bd692020-09-05 21:57:53 +02001806enddef
1807
1808def Test_setbufvar()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001809 setbufvar(bufnr('%'), '&syntax', 'vim')
1810 &syntax->assert_equal('vim')
1811 setbufvar(bufnr('%'), '&ts', 16)
1812 &ts->assert_equal(16)
1813 settabwinvar(1, 1, '&syntax', 'vam')
1814 &syntax->assert_equal('vam')
1815 settabwinvar(1, 1, '&ts', 15)
1816 &ts->assert_equal(15)
1817 setlocal ts=8
Bram Moolenaar4b9bd692020-09-05 21:57:53 +02001818
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001819 setbufvar('%', 'myvar', 123)
1820 getbufvar('%', 'myvar')->assert_equal(123)
Bram Moolenaar4b9bd692020-09-05 21:57:53 +02001821enddef
1822
Bram Moolenaar401f0c02020-09-05 22:37:39 +02001823def Test_setloclist()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001824 var items = [#{filename: '/tmp/file', lnum: 1, valid: true}]
1825 var what = #{items: items}
Bram Moolenaar401f0c02020-09-05 22:37:39 +02001826 setqflist([], ' ', what)
1827 setloclist(0, [], ' ', what)
1828enddef
1829
Bram Moolenaar4b9bd692020-09-05 21:57:53 +02001830def Test_setreg()
1831 setreg('a', ['aaa', 'bbb', 'ccc'])
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001832 var reginfo = getreginfo('a')
Bram Moolenaar4b9bd692020-09-05 21:57:53 +02001833 setreg('a', reginfo)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001834 getreginfo('a')->assert_equal(reginfo)
Bram Moolenaar4b9bd692020-09-05 21:57:53 +02001835enddef
1836
Bram Moolenaar7c27f332020-09-05 22:45:55 +02001837def Test_spellsuggest()
1838 if !has('spell')
1839 MissingFeature 'spell'
1840 else
1841 spellsuggest('marrch', 1, true)->assert_equal(['March'])
1842 endif
1843enddef
1844
Bram Moolenaar3986b942020-09-06 16:09:04 +02001845def Test_split()
1846 split(' aa bb ', '\W\+', true)->assert_equal(['', 'aa', 'bb', ''])
1847enddef
1848
1849def Test_str2nr()
1850 str2nr("1'000'000", 10, true)->assert_equal(1000000)
1851enddef
1852
1853def Test_strchars()
1854 strchars("A\u20dd", true)->assert_equal(1)
1855enddef
1856
Bram Moolenaarad304702020-09-06 18:22:53 +02001857def Test_submatch()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001858 var pat = 'A\(.\)\(.\)\(.\)\(.\)\(.\)\(.\)\(.\)\(.\)\(.\)'
1859 var Rep = {-> range(10)->map({_, v -> submatch(v, true)})->string()}
1860 var actual = substitute('A123456789', pat, Rep, '')
1861 var expected = "[['A123456789'], ['1'], ['2'], ['3'], ['4'], ['5'], ['6'], ['7'], ['8'], ['9']]"
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001862 actual->assert_equal(expected)
Bram Moolenaarad304702020-09-06 18:22:53 +02001863enddef
1864
Bram Moolenaar4b9bd692020-09-05 21:57:53 +02001865def Test_synID()
1866 new
1867 setline(1, "text")
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001868 synID(1, 1, true)->assert_equal(0)
Bram Moolenaar4b9bd692020-09-05 21:57:53 +02001869 bwipe!
1870enddef
1871
Bram Moolenaarad304702020-09-06 18:22:53 +02001872def Test_term_gettty()
Bram Moolenaar63969ef2020-09-06 20:06:59 +02001873 if !has('terminal')
1874 MissingFeature 'terminal'
1875 else
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001876 var buf = Run_shell_in_terminal({})
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001877 term_gettty(buf, true)->assert_notequal('')
Bram Moolenaar63969ef2020-09-06 20:06:59 +02001878 StopShellInTerminal(buf)
1879 endif
Bram Moolenaarad304702020-09-06 18:22:53 +02001880enddef
1881
1882def Test_term_start()
Bram Moolenaar63969ef2020-09-06 20:06:59 +02001883 if !has('terminal')
1884 MissingFeature 'terminal'
1885 else
1886 botright new
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001887 var winnr = winnr()
Bram Moolenaar63969ef2020-09-06 20:06:59 +02001888 term_start(&shell, #{curwin: true})
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001889 winnr()->assert_equal(winnr)
Bram Moolenaar63969ef2020-09-06 20:06:59 +02001890 bwipe!
1891 endif
Bram Moolenaarad304702020-09-06 18:22:53 +02001892enddef
1893
Bram Moolenaar418155d2020-09-06 18:39:38 +02001894def Test_timer_paused()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001895 var id = timer_start(50, {-> 0})
Bram Moolenaar418155d2020-09-06 18:39:38 +02001896 timer_pause(id, true)
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001897 var info = timer_info(id)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001898 info[0]['paused']->assert_equal(1)
Bram Moolenaar418155d2020-09-06 18:39:38 +02001899 timer_stop(id)
1900enddef
1901
Bram Moolenaar4b9bd692020-09-05 21:57:53 +02001902def Test_win_splitmove()
1903 split
1904 win_splitmove(1, 2, #{vertical: true, rightbelow: true})
1905 close
1906enddef
1907
1908""""""" end of builtin functions
1909
1910def Fibonacci(n: number): number
1911 if n < 2
1912 return n
1913 else
1914 return Fibonacci(n - 1) + Fibonacci(n - 2)
1915 endif
1916enddef
1917
Bram Moolenaar985116a2020-07-12 17:31:09 +02001918def Test_recursive_call()
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001919 Fibonacci(20)->assert_equal(6765)
Bram Moolenaar985116a2020-07-12 17:31:09 +02001920enddef
1921
Bram Moolenaar08f7a412020-07-13 20:41:08 +02001922def TreeWalk(dir: string): list<any>
1923 return readdir(dir)->map({_, val ->
1924 fnamemodify(dir .. '/' .. val, ':p')->isdirectory()
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001925 ? {val: TreeWalk(dir .. '/' .. val)}
Bram Moolenaar08f7a412020-07-13 20:41:08 +02001926 : val
1927 })
1928enddef
1929
1930def Test_closure_in_map()
1931 mkdir('XclosureDir/tdir', 'p')
1932 writefile(['111'], 'XclosureDir/file1')
1933 writefile(['222'], 'XclosureDir/file2')
1934 writefile(['333'], 'XclosureDir/tdir/file3')
1935
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001936 TreeWalk('XclosureDir')->assert_equal(['file1', 'file2', {'tdir': ['file3']}])
Bram Moolenaar08f7a412020-07-13 20:41:08 +02001937
1938 delete('XclosureDir', 'rf')
1939enddef
1940
Bram Moolenaar7b5d5442020-10-04 13:42:34 +02001941def Test_invalid_function_name()
1942 var lines =<< trim END
1943 vim9script
1944 def s: list<string>
1945 END
1946 CheckScriptFailure(lines, 'E129:')
1947
1948 lines =<< trim END
1949 vim9script
1950 def g: list<string>
1951 END
1952 CheckScriptFailure(lines, 'E129:')
1953
1954 lines =<< trim END
1955 vim9script
1956 def <SID>: list<string>
1957 END
1958 CheckScriptFailure(lines, 'E884:')
1959
1960 lines =<< trim END
1961 vim9script
1962 def F list<string>
1963 END
1964 CheckScriptFailure(lines, 'E488:')
1965enddef
1966
Bram Moolenaara90afb92020-07-15 22:38:56 +02001967def Test_partial_call()
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001968 var Xsetlist = function('setloclist', [0])
Bram Moolenaara90afb92020-07-15 22:38:56 +02001969 Xsetlist([], ' ', {'title': 'test'})
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001970 getloclist(0, {'title': 1})->assert_equal({'title': 'test'})
Bram Moolenaara90afb92020-07-15 22:38:56 +02001971
1972 Xsetlist = function('setloclist', [0, [], ' '])
1973 Xsetlist({'title': 'test'})
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001974 getloclist(0, {'title': 1})->assert_equal({'title': 'test'})
Bram Moolenaara90afb92020-07-15 22:38:56 +02001975
1976 Xsetlist = function('setqflist')
1977 Xsetlist([], ' ', {'title': 'test'})
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001978 getqflist({'title': 1})->assert_equal({'title': 'test'})
Bram Moolenaara90afb92020-07-15 22:38:56 +02001979
1980 Xsetlist = function('setqflist', [[], ' '])
1981 Xsetlist({'title': 'test'})
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02001982 getqflist({'title': 1})->assert_equal({'title': 'test'})
Bram Moolenaar6abd3dc2020-10-04 14:17:32 +02001983
1984 var Len: func: number = function('len', ['word'])
1985 assert_equal(4, Len())
Bram Moolenaara90afb92020-07-15 22:38:56 +02001986enddef
1987
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02001988def Test_cmd_modifier()
1989 tab echo '0'
Bram Moolenaard2c61702020-09-06 15:58:36 +02001990 CheckDefFailure(['5tab echo 3'], 'E16:')
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02001991enddef
1992
1993def Test_restore_modifiers()
1994 # check that when compiling a :def function command modifiers are not messed
1995 # up.
Bram Moolenaar7a9cbca2020-09-27 22:47:05 +02001996 var lines =<< trim END
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02001997 vim9script
1998 set eventignore=
1999 autocmd QuickFixCmdPost * copen
2000 def AutocmdsDisabled()
2001 eval 0
2002 enddef
2003 func Func()
2004 noautocmd call s:AutocmdsDisabled()
2005 let g:ei_after = &eventignore
2006 endfunc
2007 Func()
2008 END
2009 CheckScriptSuccess(lines)
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002010 g:ei_after->assert_equal('')
Bram Moolenaar2dd0a2c2020-08-08 15:10:27 +02002011enddef
2012
Bram Moolenaardfa3d552020-09-10 22:05:08 +02002013def StackTop()
2014 eval 1
2015 eval 2
2016 # call not on fourth line
2017 StackBot()
2018enddef
2019
2020def StackBot()
2021 # throw an error
2022 eval [][0]
2023enddef
2024
2025def Test_callstack_def()
2026 try
2027 StackTop()
2028 catch
Bram Moolenaarc0c71e92020-09-11 19:09:48 +02002029 v:throwpoint->assert_match('Test_callstack_def\[2\]..StackTop\[4\]..StackBot, line 2')
Bram Moolenaardfa3d552020-09-10 22:05:08 +02002030 endtry
2031enddef
2032
Bram Moolenaare8211a32020-10-09 22:04:29 +02002033" Re-using spot for variable used in block
2034def Test_block_scoped_var()
2035 var lines =<< trim END
2036 vim9script
2037 def Func()
2038 var x = ['a', 'b', 'c']
2039 if 1
2040 var y = 'x'
2041 map(x, {-> y})
2042 endif
2043 var z = x
2044 assert_equal(['x', 'x', 'x'], z)
2045 enddef
2046 Func()
2047 END
2048 CheckScriptSuccess(lines)
2049enddef
2050
Bram Moolenaarf7779c62020-05-03 15:38:16 +02002051
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +02002052" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker