blob: 87924c62946865e9d664720209f090fe41c0c3df [file] [log] [blame]
Bram Moolenaar971caf52020-09-21 22:21:42 +02001" Test Vim9 assignments
2
3source check.vim
4source vim9.vim
5
6let s:appendToMe = 'xxx'
7let s:addToMe = 111
8let g:existing = 'yes'
9let g:inc_counter = 1
10let $SOME_ENV_VAR = 'some'
11let g:alist = [7]
Bram Moolenaar5b5ae292021-02-20 17:04:02 +010012let g:adict = #{a: 1}
Bram Moolenaar971caf52020-09-21 22:21:42 +020013let g:astring = 'text'
14
15def Test_assignment_bool()
Bram Moolenaar30fd8202020-09-26 15:09:30 +020016 var bool1: bool = true
Bram Moolenaar971caf52020-09-21 22:21:42 +020017 assert_equal(v:true, bool1)
Bram Moolenaar30fd8202020-09-26 15:09:30 +020018 var bool2: bool = false
Bram Moolenaar971caf52020-09-21 22:21:42 +020019 assert_equal(v:false, bool2)
20
Bram Moolenaar30fd8202020-09-26 15:09:30 +020021 var bool3: bool = 0
Bram Moolenaar971caf52020-09-21 22:21:42 +020022 assert_equal(false, bool3)
Bram Moolenaar30fd8202020-09-26 15:09:30 +020023 var bool4: bool = 1
Bram Moolenaar971caf52020-09-21 22:21:42 +020024 assert_equal(true, bool4)
25
Bram Moolenaar2bb26582020-10-03 22:52:39 +020026 var bool5: bool = 1 && true
Bram Moolenaar971caf52020-09-21 22:21:42 +020027 assert_equal(true, bool5)
Bram Moolenaar2bb26582020-10-03 22:52:39 +020028 var bool6: bool = 0 && 1
Bram Moolenaar971caf52020-09-21 22:21:42 +020029 assert_equal(false, bool6)
Bram Moolenaar2bb26582020-10-03 22:52:39 +020030 var bool7: bool = 0 || 1 && true
Bram Moolenaar971caf52020-09-21 22:21:42 +020031 assert_equal(true, bool7)
32
Bram Moolenaar30fd8202020-09-26 15:09:30 +020033 var lines =<< trim END
Bram Moolenaar971caf52020-09-21 22:21:42 +020034 vim9script
35 def GetFlag(): bool
Bram Moolenaar30fd8202020-09-26 15:09:30 +020036 var flag: bool = 1
Bram Moolenaar971caf52020-09-21 22:21:42 +020037 return flag
38 enddef
Bram Moolenaar30fd8202020-09-26 15:09:30 +020039 var flag: bool = GetFlag()
Bram Moolenaar971caf52020-09-21 22:21:42 +020040 assert_equal(true, flag)
41 flag = 0
42 assert_equal(false, flag)
43 flag = 1
44 assert_equal(true, flag)
Bram Moolenaar2bb26582020-10-03 22:52:39 +020045 flag = 1 || true
Bram Moolenaar971caf52020-09-21 22:21:42 +020046 assert_equal(true, flag)
Bram Moolenaar2bb26582020-10-03 22:52:39 +020047 flag = 1 && false
Bram Moolenaar971caf52020-09-21 22:21:42 +020048 assert_equal(false, flag)
Bram Moolenaardd1f4262020-12-31 17:41:01 +010049
50 var cp: bool = &cp
51 var fen: bool = &l:fen
Bram Moolenaar971caf52020-09-21 22:21:42 +020052 END
53 CheckScriptSuccess(lines)
Bram Moolenaar30fd8202020-09-26 15:09:30 +020054 CheckDefAndScriptFailure(['var x: bool = 2'], 'E1012:')
55 CheckDefAndScriptFailure(['var x: bool = -1'], 'E1012:')
56 CheckDefAndScriptFailure(['var x: bool = [1]'], 'E1012:')
57 CheckDefAndScriptFailure(['var x: bool = {}'], 'E1012:')
58 CheckDefAndScriptFailure(['var x: bool = "x"'], 'E1012:')
Bram Moolenaar9a562c12021-01-23 13:39:14 +010059
60 CheckDefAndScriptFailure(['var x: bool = "x"', '', 'eval 0'], 'E1012:', 1)
Bram Moolenaar971caf52020-09-21 22:21:42 +020061enddef
62
63def Test_syntax()
Bram Moolenaar98309382020-09-27 21:58:45 +020064 var name = 234
Bram Moolenaar30fd8202020-09-26 15:09:30 +020065 var other: list<string> = ['asdf']
Bram Moolenaar971caf52020-09-21 22:21:42 +020066enddef
67
68def Test_assignment()
Bram Moolenaar30fd8202020-09-26 15:09:30 +020069 CheckDefFailure(['var x:string'], 'E1069:')
70 CheckDefFailure(['var x:string = "x"'], 'E1069:')
71 CheckDefFailure(['var a:string = "x"'], 'E1069:')
Bram Moolenaar2949cfd2020-12-31 21:28:47 +010072 CheckDefFailure(['var lambda = () => "lambda"'], 'E704:')
Bram Moolenaar30fd8202020-09-26 15:09:30 +020073 CheckScriptFailure(['var x = "x"'], 'E1124:')
Bram Moolenaar971caf52020-09-21 22:21:42 +020074
Bram Moolenaar3f327882021-03-17 20:56:38 +010075 # lower case name is OK for a list
76 var lambdaLines =<< trim END
77 var lambdaList: list<func> = [Test_syntax]
78 lambdaList[0] = () => "lambda"
79 END
80 CheckDefAndScriptSuccess(lambdaLines)
81
Bram Moolenaar30fd8202020-09-26 15:09:30 +020082 var nr: number = 1234
83 CheckDefFailure(['var nr: number = "asdf"'], 'E1012:')
Bram Moolenaar971caf52020-09-21 22:21:42 +020084
Bram Moolenaar30fd8202020-09-26 15:09:30 +020085 var a: number = 6 #comment
Bram Moolenaar971caf52020-09-21 22:21:42 +020086 assert_equal(6, a)
87
88 if has('channel')
Bram Moolenaar30fd8202020-09-26 15:09:30 +020089 var chan1: channel
Bram Moolenaar218450a2020-10-17 18:51:52 +020090 assert_equal('fail', ch_status(chan1))
91
Bram Moolenaar30fd8202020-09-26 15:09:30 +020092 var job1: job
Bram Moolenaar218450a2020-10-17 18:51:52 +020093 assert_equal('fail', job_status(job1))
94
Bram Moolenaarfc8aa6d2020-10-12 20:31:26 +020095 # calling job_start() is in test_vim9_fails.vim, it causes leak reports
Bram Moolenaar971caf52020-09-21 22:21:42 +020096 endif
97 if has('float')
Bram Moolenaar30fd8202020-09-26 15:09:30 +020098 var float1: float = 3.4
Bram Moolenaar971caf52020-09-21 22:21:42 +020099 endif
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200100 var Funky1: func
101 var Funky2: func = function('len')
102 var Party2: func = funcref('g:Test_syntax')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200103
104 g:newvar = 'new' #comment
105 assert_equal('new', g:newvar)
106
107 assert_equal('yes', g:existing)
108 g:existing = 'no'
109 assert_equal('no', g:existing)
110
111 v:char = 'abc'
112 assert_equal('abc', v:char)
113
114 $ENVVAR = 'foobar'
115 assert_equal('foobar', $ENVVAR)
116 $ENVVAR = ''
117
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200118 var lines =<< trim END
Bram Moolenaar971caf52020-09-21 22:21:42 +0200119 vim9script
120 $ENVVAR = 'barfoo'
121 assert_equal('barfoo', $ENVVAR)
122 $ENVVAR = ''
123 END
124 CheckScriptSuccess(lines)
125
126 s:appendToMe ..= 'yyy'
127 assert_equal('xxxyyy', s:appendToMe)
128 s:addToMe += 222
129 assert_equal(333, s:addToMe)
130 s:newVar = 'new'
131 assert_equal('new', s:newVar)
132
133 set ts=7
Bram Moolenaardd1f4262020-12-31 17:41:01 +0100134 var ts: number = &ts
135 assert_equal(7, ts)
Bram Moolenaar971caf52020-09-21 22:21:42 +0200136 &ts += 1
137 assert_equal(8, &ts)
138 &ts -= 3
139 assert_equal(5, &ts)
140 &ts *= 2
141 assert_equal(10, &ts)
142 &ts /= 3
143 assert_equal(3, &ts)
144 set ts=10
145 &ts %= 4
146 assert_equal(2, &ts)
147
148 if has('float')
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200149 var f100: float = 100.0
Bram Moolenaar971caf52020-09-21 22:21:42 +0200150 f100 /= 5
151 assert_equal(20.0, f100)
152
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200153 var f200: float = 200.0
Bram Moolenaar971caf52020-09-21 22:21:42 +0200154 f200 /= 5.0
155 assert_equal(40.0, f200)
156
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200157 CheckDefFailure(['var nr: number = 200', 'nr /= 5.0'], 'E1012:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200158 endif
159
160 lines =<< trim END
161 &ts = 6
162 &ts += 3
163 assert_equal(9, &ts)
164
165 &l:ts = 6
166 assert_equal(6, &ts)
167 &l:ts += 2
168 assert_equal(8, &ts)
169
170 &g:ts = 6
171 assert_equal(6, &g:ts)
172 &g:ts += 2
173 assert_equal(8, &g:ts)
Bram Moolenaar0ea04402021-01-04 13:37:54 +0100174
175 &number = true
176 assert_equal(true, &number)
177 &number = 0
178 assert_equal(false, &number)
179 &number = 1
180 assert_equal(true, &number)
181 &number = false
182 assert_equal(false, &number)
Bram Moolenaar971caf52020-09-21 22:21:42 +0200183 END
184 CheckDefAndScriptSuccess(lines)
185
186 CheckDefFailure(['&notex += 3'], 'E113:')
187 CheckDefFailure(['&ts ..= "xxx"'], 'E1019:')
188 CheckDefFailure(['&ts = [7]'], 'E1012:')
189 CheckDefExecFailure(['&ts = g:alist'], 'E1012: Type mismatch; expected number but got list<number>')
190 CheckDefFailure(['&ts = "xx"'], 'E1012:')
191 CheckDefExecFailure(['&ts = g:astring'], 'E1012: Type mismatch; expected number but got string')
192 CheckDefFailure(['&path += 3'], 'E1012:')
193 CheckDefExecFailure(['&bs = "asdf"'], 'E474:')
194 # test freeing ISN_STOREOPT
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200195 CheckDefFailure(['&ts = 3', 'var asdf'], 'E1022:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200196 &ts = 8
197
198 lines =<< trim END
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200199 var save_TI = &t_TI
Bram Moolenaar971caf52020-09-21 22:21:42 +0200200 &t_TI = ''
201 assert_equal('', &t_TI)
202 &t_TI = 'xxx'
203 assert_equal('xxx', &t_TI)
204 &t_TI = save_TI
205 END
206 CheckDefAndScriptSuccess(lines)
207
208 CheckDefFailure(['&t_TI = 123'], 'E1012:')
209 CheckScriptFailure(['vim9script', '&t_TI = 123'], 'E928:')
210
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200211 CheckDefFailure(['var s:var = 123'], 'E1101:')
212 CheckDefFailure(['var s:var: number'], 'E1101:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200213
214 lines =<< trim END
215 vim9script
216 def SomeFunc()
217 s:var = 123
218 enddef
219 defcompile
220 END
221 CheckScriptFailure(lines, 'E1089:')
222
223 g:inc_counter += 1
224 assert_equal(2, g:inc_counter)
225
Bram Moolenaar7bf9a072021-08-02 21:55:15 +0200226 if has('float')
227 var f: float
228 f += 1
229 assert_equal(1.0, f)
230 endif
231
Bram Moolenaar971caf52020-09-21 22:21:42 +0200232 $SOME_ENV_VAR ..= 'more'
233 assert_equal('somemore', $SOME_ENV_VAR)
234 CheckDefFailure(['$SOME_ENV_VAR += "more"'], 'E1051:')
235 CheckDefFailure(['$SOME_ENV_VAR += 123'], 'E1012:')
236
Bram Moolenaar971caf52020-09-21 22:21:42 +0200237 v:errmsg = 'none'
238 v:errmsg ..= 'again'
239 assert_equal('noneagain', v:errmsg)
240 CheckDefFailure(['v:errmsg += "more"'], 'E1051:')
241 CheckDefFailure(['v:errmsg += 123'], 'E1012:')
242
Bram Moolenaarfc8aa6d2020-10-12 20:31:26 +0200243 var text =<< trim END
244 some text
245 END
Bram Moolenaar971caf52020-09-21 22:21:42 +0200246enddef
247
Bram Moolenaaraf647e72021-08-05 19:01:17 +0200248def Test_float_and_number()
249 if !has('float')
250 MissingFeature float
251 else
252 var lines =<< trim END
253 var f: float
254 f += 2
255 f -= 1
256 assert_equal(1.0, f)
257 ++f
258 --f
259 assert_equal(1.0, f)
260 END
261 CheckDefAndScriptSuccess(lines)
262 endif
263enddef
264
Bram Moolenaarf5d52c92021-07-31 22:51:10 +0200265let g:someNumber = 43
266
267def Test_assign_concat()
268 var lines =<< trim END
269 var s = '-'
270 s ..= 99
271 s ..= true
272 s ..= '-'
273 s ..= v:null
274 s ..= g:someNumber
275 assert_equal('-99true-null43', s)
276 END
277 CheckDefAndScriptSuccess(lines)
278
279 lines =<< trim END
280 var s = '-'
281 s ..= [1, 2]
282 END
283 CheckDefAndScriptFailure2(lines, 'E1105: Cannot convert list to string', 'E734: Wrong variable type for .=', 2)
284 lines =<< trim END
285 var s = '-'
286 s ..= {a: 2}
287 END
288 CheckDefAndScriptFailure2(lines, 'E1105: Cannot convert dict to string', 'E734: Wrong variable type for .=', 2)
289enddef
290
Bram Moolenaar13e45d12021-06-26 13:28:35 +0200291def Test_assign_register()
292 var lines =<< trim END
293 @c = 'areg'
294 @c ..= 'add'
295 assert_equal('aregadd', @c)
296
297 @@ = 'some text'
298 assert_equal('some text', getreg('"'))
299 END
300 CheckDefAndScriptSuccess(lines)
301
302 CheckDefFailure(['@a += "more"'], 'E1051:')
303 CheckDefFailure(['@a += 123'], 'E1012:')
304enddef
305
Bram Moolenaard0edaf92021-05-28 21:06:08 +0200306def Test_reserved_name()
307 for name in ['true', 'false', 'null']
308 CheckDefExecAndScriptFailure(['var ' .. name .. ' = 0'], 'E1034:')
309 CheckDefExecAndScriptFailure(['var ' .. name .. ': bool'], 'E1034:')
310 endfor
311enddef
312
Bram Moolenaaraa1959b2021-04-15 22:13:39 +0200313def Test_skipped_assignment()
314 var lines =<< trim END
315 for x in []
316 var i: number = 1
317 while false
318 i += 1
319 endwhile
320 endfor
321 END
322 CheckDefAndScriptSuccess(lines)
323enddef
324
Bram Moolenaar7824fc82021-11-26 17:36:51 +0000325def Test_assign_keep_type()
326 var lines =<< trim END
327 vim9script
328 var l: list<number> = [123]
329 l = [123]
330 l->add('string')
331 END
332 CheckScriptFailure(lines, 'E1012:', 4)
333enddef
334
Bram Moolenaar8ff16e02020-12-07 21:49:52 +0100335def Test_assign_unpack()
336 var lines =<< trim END
337 var v1: number
338 var v2: number
339 [v1, v2] = [1, 2]
340 assert_equal(1, v1)
341 assert_equal(2, v2)
Bram Moolenaarf93bbd02021-04-10 22:35:43 +0200342
343 [v1, _, v2, _] = [1, 99, 2, 77]
344 assert_equal(1, v1)
345 assert_equal(2, v2)
346
347 [v1, v2; _] = [1, 2, 3, 4, 5]
348 assert_equal(1, v1)
349 assert_equal(2, v2)
Bram Moolenaar035bd1c2021-06-21 19:44:11 +0200350
Bram Moolenaar4d5dfe22021-06-26 13:59:29 +0200351 var reslist = []
352 for text in ['aaa {bbb} ccc', 'ddd {eee} fff']
353 var before: string
354 var middle: string
355 var after: string
356 [_, before, middle, after; _] = text->matchlist('\(.\{-\}\){\(.\{-\}\)}\(.*\)')
357 reslist->add(before)->add(middle)->add(after)
358 endfor
359 assert_equal(['aaa ', 'bbb', ' ccc', 'ddd ', 'eee', ' fff'], reslist)
360
Bram Moolenaar035bd1c2021-06-21 19:44:11 +0200361 var a = 1
362 var b = 3
363 [a, b] += [2, 4]
364 assert_equal(3, a)
365 assert_equal(7, b)
366
367 [a, b] -= [1, 2]
368 assert_equal(2, a)
369 assert_equal(5, b)
370
371 [a, b] *= [3, 2]
372 assert_equal(6, a)
373 assert_equal(10, b)
374
375 [a, b] /= [2, 4]
376 assert_equal(3, a)
377 assert_equal(2, b)
378
379 [a, b] = [17, 15]
380 [a, b] %= [5, 3]
381 assert_equal(2, a)
382 assert_equal(0, b)
Bram Moolenaar8ff16e02020-12-07 21:49:52 +0100383 END
384 CheckDefAndScriptSuccess(lines)
385
386 lines =<< trim END
387 var v1: number
388 var v2: number
389 [v1, v2] =
390 END
391 CheckDefFailure(lines, 'E1097:', 5)
392
393 lines =<< trim END
394 var v1: number
395 var v2: number
396 [v1, v2] = xxx
397 END
398 CheckDefFailure(lines, 'E1001:', 3)
399
400 lines =<< trim END
401 var v1: number
402 var v2: number
403 [v1, v2] = popup_clear()
404 END
405 CheckDefFailure(lines, 'E1031:', 3)
406
407 lines =<< trim END
Bram Moolenaar3862ea32021-01-01 21:05:55 +0100408 [v1, v2] = [1, 2]
409 END
410 CheckDefFailure(lines, 'E1089', 1)
411 CheckScriptFailure(['vim9script'] + lines, 'E1089', 2)
412
413 lines =<< trim END
Bram Moolenaar8ff16e02020-12-07 21:49:52 +0100414 var v1: number
415 var v2: number
416 [v1, v2] = ''
417 END
418 CheckDefFailure(lines, 'E1012: Type mismatch; expected list<any> but got string', 3)
Bram Moolenaarf785aa12021-02-11 21:19:34 +0100419
420 lines =<< trim END
421 g:values = [false, 0]
422 var x: bool
423 var y: string
424 [x, y] = g:values
425 END
426 CheckDefExecAndScriptFailure(lines, 'E1163: Variable 2: type mismatch, expected string but got number')
Bram Moolenaar4270d8b2021-08-07 16:30:42 +0200427
428 lines =<< trim END
429 var x: number
430 var y: number
431 var z: string
432 [x, y, z] = [1, 2, 3]
433 END
434 CheckDefAndScriptFailure(lines, 'E1163: Variable 3: type mismatch, expected string but got number')
435
436 lines =<< trim END
437 var x: number
438 var y: string
439 var z: string
440 [x, y, z] = [1, '2', 3]
441 END
442 CheckDefExecAndScriptFailure(lines, 'E1163: Variable 3: type mismatch, expected string but got number')
Bram Moolenaar8ff16e02020-12-07 21:49:52 +0100443enddef
444
Bram Moolenaar7f764942020-12-02 15:11:18 +0100445def Test_assign_linebreak()
446 var nr: number
447 nr =
448 123
449 assert_equal(123, nr)
450
451 var n2: number
452 [nr, n2] =
453 [12, 34]
454 assert_equal(12, nr)
455 assert_equal(34, n2)
456
Bram Moolenaar8ff16e02020-12-07 21:49:52 +0100457 CheckDefFailure(["var x = #"], 'E1097:', 3)
Bram Moolenaar77709b12021-04-03 21:01:01 +0200458
459 var lines =<< trim END
460 var x: list<string> = ['a']
461 var y: list<number> = x
462 ->copy()
463 ->copy()
464 END
465 CheckDefFailure(lines, 'E1012:', 2)
Bram Moolenaar6977dba2021-07-04 22:48:12 +0200466
467 lines =<< trim END
468 var x: any
469 x.key = 1
470 + 2
471 + 3
472 + 4
473 + 5
474 END
475 CheckDefExecAndScriptFailure2(lines, 'E1148:', 'E1203:', 2)
Bram Moolenaar7f764942020-12-02 15:11:18 +0100476enddef
477
Bram Moolenaardc234ca2020-11-28 18:52:33 +0100478def Test_assign_index()
479 # list of list
480 var l1: list<number>
481 l1[0] = 123
482 assert_equal([123], l1)
483
484 var l2: list<list<number>>
485 l2[0] = []
486 l2[0][0] = 123
487 assert_equal([[123]], l2)
488
489 var l3: list<list<list<number>>>
490 l3[0] = []
491 l3[0][0] = []
492 l3[0][0][0] = 123
493 assert_equal([[[123]]], l3)
494
495 var lines =<< trim END
496 var l3: list<list<number>>
497 l3[0] = []
498 l3[0][0] = []
499 END
500 CheckDefFailure(lines, 'E1012: Type mismatch; expected number but got list<unknown>', 3)
501
502 # dict of dict
503 var d1: dict<number>
504 d1.one = 1
505 assert_equal({one: 1}, d1)
506
507 var d2: dict<dict<number>>
508 d2.one = {}
509 d2.one.two = 123
510 assert_equal({one: {two: 123}}, d2)
511
512 var d3: dict<dict<dict<number>>>
513 d3.one = {}
514 d3.one.two = {}
515 d3.one.two.three = 123
516 assert_equal({one: {two: {three: 123}}}, d3)
517
Bram Moolenaare97976b2021-08-01 13:17:17 +0200518 # should not read the next line when generating "a.b"
519 var a = {}
520 a.b = {}
521 a.b.c = {}
522 ->copy()
523
Bram Moolenaardc234ca2020-11-28 18:52:33 +0100524 lines =<< trim END
525 var d3: dict<dict<number>>
526 d3.one = {}
527 d3.one.two = {}
528 END
529 CheckDefFailure(lines, 'E1012: Type mismatch; expected number but got dict<unknown>', 3)
530
Bram Moolenaaracbae182020-12-13 18:44:43 +0100531 lines =<< trim END
532 var lines: list<string>
533 lines['a'] = 'asdf'
534 END
Bram Moolenaarf30a14d2021-01-17 21:51:24 +0100535 CheckDefFailure(lines, 'E1012:', 2)
Bram Moolenaaracbae182020-12-13 18:44:43 +0100536
537 lines =<< trim END
538 var lines: string
539 lines[9] = 'asdf'
540 END
541 CheckDefFailure(lines, 'E1141:', 2)
542
Bram Moolenaardc234ca2020-11-28 18:52:33 +0100543 # list of dict
544 var ld: list<dict<number>>
545 ld[0] = {}
546 ld[0].one = 123
547 assert_equal([{one: 123}], ld)
548
549 lines =<< trim END
550 var ld: list<dict<number>>
551 ld[0] = []
552 END
553 CheckDefFailure(lines, 'E1012: Type mismatch; expected dict<number> but got list<unknown>', 2)
554
555 # dict of list
556 var dl: dict<list<number>>
557 dl.one = []
558 dl.one[0] = 123
559 assert_equal({one: [123]}, dl)
560
561 lines =<< trim END
562 var dl: dict<list<number>>
563 dl.one = {}
564 END
565 CheckDefFailure(lines, 'E1012: Type mismatch; expected list<number> but got dict<unknown>', 2)
566enddef
567
Bram Moolenaar81ed4962020-09-23 15:56:50 +0200568def Test_extend_list()
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200569 var lines =<< trim END
Bram Moolenaar07802042021-09-09 23:01:14 +0200570 var l1: list<number>
571 var l2 = l1
572 assert_true(l1 is l2)
573 l1 += [123]
574 assert_equal([123], l1)
575 assert_true(l1 is l2)
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100576 END
Bram Moolenaar07802042021-09-09 23:01:14 +0200577 CheckDefAndScriptSuccess(lines)
Bram Moolenaar81ed4962020-09-23 15:56:50 +0200578
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100579 lines =<< trim END
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100580 var list: list<string>
581 extend(list, ['x'])
582 assert_equal(['x'], list)
Bram Moolenaar81ed4962020-09-23 15:56:50 +0200583 END
Bram Moolenaar07802042021-09-09 23:01:14 +0200584 CheckDefAndScriptSuccess(lines)
Bram Moolenaar1a739232020-10-10 15:37:58 +0200585
586 # appending to NULL list from a function
587 lines =<< trim END
588 vim9script
589 var list: list<string>
590 def Func()
591 list += ['a', 'b']
592 enddef
593 Func()
594 assert_equal(['a', 'b'], list)
595 END
596 CheckScriptSuccess(lines)
Bram Moolenaar3beaf9c2020-12-18 17:23:14 +0100597 lines =<< trim END
598 vim9script
599 var list: list<string>
600 def Func()
601 extend(list, ['x', 'b'])
602 enddef
603 Func()
604 assert_equal(['x', 'b'], list)
605 END
606 CheckScriptSuccess(lines)
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100607
608 lines =<< trim END
609 vim9script
610 var l: list<string> = test_null_list()
611 extend(l, ['x'])
612 assert_equal(['x'], l)
613 END
614 CheckScriptSuccess(lines)
615
616 lines =<< trim END
617 vim9script
618 extend(test_null_list(), ['x'])
619 END
620 CheckScriptFailure(lines, 'E1134:', 2)
621enddef
622
623def Test_extend_dict()
624 var lines =<< trim END
625 vim9script
626 var d: dict<number>
Bram Moolenaare0de1712020-12-02 17:36:54 +0100627 extend(d, {a: 1})
628 assert_equal({a: 1}, d)
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100629
630 var d2: dict<number>
631 d2['one'] = 1
Bram Moolenaare0de1712020-12-02 17:36:54 +0100632 assert_equal({one: 1}, d2)
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100633 END
634 CheckScriptSuccess(lines)
635
636 lines =<< trim END
637 vim9script
638 var d: dict<string> = test_null_dict()
Bram Moolenaare0de1712020-12-02 17:36:54 +0100639 extend(d, {a: 'x'})
640 assert_equal({a: 'x'}, d)
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100641 END
642 CheckScriptSuccess(lines)
643
644 lines =<< trim END
645 vim9script
Bram Moolenaare0de1712020-12-02 17:36:54 +0100646 extend(test_null_dict(), {a: 'x'})
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100647 END
648 CheckScriptFailure(lines, 'E1133:', 2)
Bram Moolenaar81ed4962020-09-23 15:56:50 +0200649enddef
650
Bram Moolenaar971caf52020-09-21 22:21:42 +0200651def Test_single_letter_vars()
652 # single letter variables
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200653 var a: number = 123
Bram Moolenaar971caf52020-09-21 22:21:42 +0200654 a = 123
655 assert_equal(123, a)
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200656 var b: number
Bram Moolenaar971caf52020-09-21 22:21:42 +0200657 b = 123
658 assert_equal(123, b)
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200659 var g: number
Bram Moolenaar971caf52020-09-21 22:21:42 +0200660 g = 123
661 assert_equal(123, g)
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200662 var s: number
Bram Moolenaar971caf52020-09-21 22:21:42 +0200663 s = 123
664 assert_equal(123, s)
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200665 var t: number
Bram Moolenaar971caf52020-09-21 22:21:42 +0200666 t = 123
667 assert_equal(123, t)
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200668 var v: number
Bram Moolenaar971caf52020-09-21 22:21:42 +0200669 v = 123
670 assert_equal(123, v)
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200671 var w: number
Bram Moolenaar971caf52020-09-21 22:21:42 +0200672 w = 123
673 assert_equal(123, w)
674enddef
675
676def Test_vim9_single_char_vars()
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200677 var lines =<< trim END
Bram Moolenaar971caf52020-09-21 22:21:42 +0200678 vim9script
679
680 # single character variable declarations work
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200681 var a: string
682 var b: number
683 var l: list<any>
684 var s: string
685 var t: number
686 var v: number
687 var w: number
Bram Moolenaar971caf52020-09-21 22:21:42 +0200688
689 # script-local variables can be used without s: prefix
690 a = 'script-a'
691 b = 111
692 l = [1, 2, 3]
693 s = 'script-s'
694 t = 222
695 v = 333
696 w = 444
697
698 assert_equal('script-a', a)
699 assert_equal(111, b)
700 assert_equal([1, 2, 3], l)
701 assert_equal('script-s', s)
702 assert_equal(222, t)
703 assert_equal(333, v)
704 assert_equal(444, w)
705 END
706 writefile(lines, 'Xsinglechar')
707 source Xsinglechar
708 delete('Xsinglechar')
709enddef
710
711def Test_assignment_list()
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200712 var list1: list<bool> = [false, true, false]
713 var list2: list<number> = [1, 2, 3]
714 var list3: list<string> = ['sdf', 'asdf']
715 var list4: list<any> = ['yes', true, 1234]
716 var list5: list<blob> = [0z01, 0z02]
Bram Moolenaar971caf52020-09-21 22:21:42 +0200717
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200718 var listS: list<string> = []
719 var listN: list<number> = []
Bram Moolenaar971caf52020-09-21 22:21:42 +0200720
721 assert_equal([1, 2, 3], list2)
722 list2[-1] = 99
723 assert_equal([1, 2, 99], list2)
724 list2[-2] = 88
725 assert_equal([1, 88, 99], list2)
726 list2[-3] = 77
727 assert_equal([77, 88, 99], list2)
728 list2 += [100]
729 assert_equal([77, 88, 99, 100], list2)
730
731 list3 += ['end']
732 assert_equal(['sdf', 'asdf', 'end'], list3)
733
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200734 CheckDefExecFailure(['var ll = [1, 2, 3]', 'll[-4] = 6'], 'E684:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200735
736 # type becomes list<any>
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200737 var somelist = rand() > 0 ? [1, 2, 3] : ['a', 'b', 'c']
Bram Moolenaar4f5e3972020-12-21 17:30:50 +0100738
739 var lines =<< trim END
740 var d = {dd: test_null_list()}
741 d.dd[0] = 0
742 END
743 CheckDefExecFailure(lines, 'E1147:', 2)
Bram Moolenaar7a40ff02021-07-04 15:54:08 +0200744
745 lines =<< trim END
746 def OneArg(x: bool)
747 enddef
748 def TwoArgs(x: bool, y: bool)
749 enddef
750 var fl: list<func(bool, bool, bool)> = [OneArg, TwoArgs]
751 END
752 CheckDefExecAndScriptFailure(lines, 'E1012:', 5)
Bram Moolenaar971caf52020-09-21 22:21:42 +0200753enddef
754
Bram Moolenaarab36e6a2021-11-30 16:14:49 +0000755def Test_list_declaration()
756 var [v1, v2] = [1, 2]
757 v1 += 3
758 assert_equal(4, v1)
759 v2 *= 3
760 assert_equal(6, v2)
761
762 var lines =<< trim END
763 var [v1, v2] = [1]
764 END
765 CheckDefExecAndScriptFailure2(lines, 'E1093: Expected 2 items but got 1', 'E688:')
766 lines =<< trim END
767 var testlist = [1]
768 var [v1, v2] = testlist
769 END
770 CheckDefExecAndScriptFailure2(lines, 'E1093: Expected 2 items but got 1', 'E688:')
771 lines =<< trim END
772 var [v1, v2] = [1, 2, 3]
773 END
774 CheckDefExecAndScriptFailure2(lines, 'E1093: Expected 2 items but got 3', 'E687:')
775 lines =<< trim END
776 var testlist = [1, 2, 3]
777 var [v1, v2] = testlist
778 END
779 CheckDefExecAndScriptFailure2(lines, 'E1093: Expected 2 items but got 3', 'E687:')
780
781 var [vnr, vstr] = [123, 'text']
782 vnr += 3
783 assert_equal(126, vnr)
784 vstr ..= 'end'
785 assert_equal('textend', vstr)
786
787 var [vnr2: number, vstr2: string] = [123, 'text']
788 vnr2 += 3
789 assert_equal(126, vnr2)
790 vstr2 ..= 'end'
791 assert_equal('textend', vstr2)
792
793 var [vnr3: number; vlist: list<string>] = [123, 'foo', 'bar']
794 vnr3 += 5
795 assert_equal(128, vnr3)
796 assert_equal(['foo', 'bar'], vlist)
797
798 lines =<< trim END
799 var [vnr2: number, vstr2: number] = [123, 'text']
800 END
801 CheckDefExecAndScriptFailure2(lines, 'E1163: Variable 2: type mismatch, expected number but got string', 'E1012: Type mismatch; expected number but got string')
802 lines =<< trim END
803 var testlist = [234, 'text']
804 var [vnr2: number, vstr2: number] = testlist
805 END
806 CheckDefExecAndScriptFailure2(lines, 'E1163: Variable 2: type mismatch, expected number but got string', 'E1012: Type mismatch; expected number but got string')
807enddef
808
Bram Moolenaar97f227d2021-07-04 20:20:52 +0200809def PartFuncBool(b: bool): string
Bram Moolenaarb7480cd2021-07-04 18:28:15 +0200810 return 'done'
811enddef
812
813def Test_assignment_partial()
Bram Moolenaar97f227d2021-07-04 20:20:52 +0200814 var lines =<< trim END
815 var Partial: func(): string = function(PartFuncBool, [true])
816 assert_equal('done', Partial())
817 END
818 CheckDefAndScriptSuccess(lines)
Bram Moolenaar22f85d02021-07-04 23:29:30 +0200819
820 lines =<< trim END
821 vim9script
822 def Func(b: bool)
823 enddef
824 var Ref: func = function(Func, [true])
825 assert_equal('func()', typename(Ref))
826 Ref()
827 END
828 CheckScriptSuccess(lines)
Bram Moolenaarb7480cd2021-07-04 18:28:15 +0200829enddef
830
Bram Moolenaarf30a14d2021-01-17 21:51:24 +0100831def Test_assignment_list_any_index()
832 var l: list<number> = [1, 2]
833 for [x, y, _]
834 in [[0, 1, ''], [1, 3, '']]
835 l[x] = l[x] + y
836 endfor
837 assert_equal([2, 5], l)
838enddef
839
Bram Moolenaar971caf52020-09-21 22:21:42 +0200840def Test_assignment_list_vim9script()
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200841 var lines =<< trim END
Bram Moolenaar971caf52020-09-21 22:21:42 +0200842 vim9script
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200843 var v1: number
844 var v2: number
845 var v3: number
Bram Moolenaar971caf52020-09-21 22:21:42 +0200846 [v1, v2, v3] = [1, 2, 3]
847 assert_equal([1, 2, 3], [v1, v2, v3])
848 END
849 CheckScriptSuccess(lines)
850enddef
851
852def Test_assignment_dict()
Bram Moolenaare0de1712020-12-02 17:36:54 +0100853 var dict1: dict<bool> = {one: false, two: true}
854 var dict2: dict<number> = {one: 1, two: 2}
855 var dict3: dict<string> = {key: 'value'}
856 var dict4: dict<any> = {one: 1, two: '2'}
857 var dict5: dict<blob> = {one: 0z01, two: 0z02}
Bram Moolenaar971caf52020-09-21 22:21:42 +0200858
859 # overwrite
860 dict3['key'] = 'another'
Bram Moolenaare0de1712020-12-02 17:36:54 +0100861 assert_equal(dict3, {key: 'another'})
Bram Moolenaarfc74d032020-11-16 22:11:49 +0100862 dict3.key = 'yet another'
Bram Moolenaare0de1712020-12-02 17:36:54 +0100863 assert_equal(dict3, {key: 'yet another'})
Bram Moolenaarfc74d032020-11-16 22:11:49 +0100864
Bram Moolenaard24602f2020-12-20 15:20:56 +0100865 # member "any" can also be a dict and assigned to
866 var anydict: dict<any> = {nest: {}, nr: 0}
867 anydict.nest['this'] = 123
868 anydict.nest.that = 456
869 assert_equal({nest: {this: 123, that: 456}, nr: 0}, anydict)
870
Bram Moolenaarfc74d032020-11-16 22:11:49 +0100871 var lines =<< trim END
Bram Moolenaard88dc4d2020-12-20 14:49:42 +0100872 var dd = {}
873 dd.two = 2
874 assert_equal({two: 2}, dd)
875 END
Bram Moolenaar4f5e3972020-12-21 17:30:50 +0100876 CheckDefAndScriptSuccess(lines)
877
878 lines =<< trim END
879 var d = {dd: {}}
880 d.dd[0] = 2
881 d.dd['x'] = 3
882 d.dd.y = 4
883 assert_equal({dd: {0: 2, x: 3, y: 4}}, d)
884 END
885 CheckDefAndScriptSuccess(lines)
Bram Moolenaard88dc4d2020-12-20 14:49:42 +0100886
887 lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +0100888 var dd = {one: 1}
Bram Moolenaarfc74d032020-11-16 22:11:49 +0100889 dd.one) = 2
890 END
Bram Moolenaard88dc4d2020-12-20 14:49:42 +0100891 CheckDefFailure(lines, 'E488:', 2)
892
893 lines =<< trim END
894 var dd = {one: 1}
895 var dd.one = 2
896 END
897 CheckDefAndScriptFailure(lines, 'E1017:', 2)
Bram Moolenaar971caf52020-09-21 22:21:42 +0200898
899 # empty key can be used
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200900 var dd = {}
Bram Moolenaar971caf52020-09-21 22:21:42 +0200901 dd[""] = 6
Bram Moolenaare0de1712020-12-02 17:36:54 +0100902 assert_equal({['']: 6}, dd)
Bram Moolenaar971caf52020-09-21 22:21:42 +0200903
904 # type becomes dict<any>
Bram Moolenaare0de1712020-12-02 17:36:54 +0100905 var somedict = rand() > 0 ? {a: 1, b: 2} : {a: 'a', b: 'b'}
Bram Moolenaar971caf52020-09-21 22:21:42 +0200906
907 # assignment to script-local dict
Bram Moolenaarfc74d032020-11-16 22:11:49 +0100908 lines =<< trim END
Bram Moolenaar971caf52020-09-21 22:21:42 +0200909 vim9script
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200910 var test: dict<any> = {}
Bram Moolenaar971caf52020-09-21 22:21:42 +0200911 def FillDict(): dict<any>
912 test['a'] = 43
913 return test
914 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +0100915 assert_equal({a: 43}, FillDict())
Bram Moolenaar971caf52020-09-21 22:21:42 +0200916 END
917 CheckScriptSuccess(lines)
918
919 lines =<< trim END
920 vim9script
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200921 var test: dict<any>
Bram Moolenaar971caf52020-09-21 22:21:42 +0200922 def FillDict(): dict<any>
923 test['a'] = 43
924 return test
925 enddef
926 FillDict()
Bram Moolenaar3beaf9c2020-12-18 17:23:14 +0100927 assert_equal({a: 43}, test)
Bram Moolenaar971caf52020-09-21 22:21:42 +0200928 END
Bram Moolenaar3beaf9c2020-12-18 17:23:14 +0100929 CheckScriptSuccess(lines)
Bram Moolenaar971caf52020-09-21 22:21:42 +0200930
931 # assignment to global dict
932 lines =<< trim END
933 vim9script
934 g:test = {}
935 def FillDict(): dict<any>
936 g:test['a'] = 43
937 return g:test
938 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +0100939 assert_equal({a: 43}, FillDict())
Bram Moolenaar971caf52020-09-21 22:21:42 +0200940 END
941 CheckScriptSuccess(lines)
942
943 # assignment to buffer dict
944 lines =<< trim END
945 vim9script
946 b:test = {}
947 def FillDict(): dict<any>
948 b:test['a'] = 43
949 return b:test
950 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +0100951 assert_equal({a: 43}, FillDict())
Bram Moolenaar971caf52020-09-21 22:21:42 +0200952 END
953 CheckScriptSuccess(lines)
Bram Moolenaar4f5e3972020-12-21 17:30:50 +0100954
955 lines =<< trim END
956 var d = {dd: test_null_dict()}
957 d.dd[0] = 0
958 END
959 CheckDefExecFailure(lines, 'E1103:', 2)
960
961 lines =<< trim END
962 var d = {dd: 'string'}
963 d.dd[0] = 0
964 END
965 CheckDefExecFailure(lines, 'E1148:', 2)
Bram Moolenaar3a3b10e2021-06-26 15:00:59 +0200966
967 lines =<< trim END
968 var n: any
969 n.key = 5
970 END
971 CheckDefExecAndScriptFailure2(lines, 'E1148:', 'E1203: Dot can only be used on a dictionary: n.key = 5', 2)
Bram Moolenaar971caf52020-09-21 22:21:42 +0200972enddef
973
974def Test_assignment_local()
975 # Test in a separated file in order not to the current buffer/window/tab is
976 # changed.
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200977 var script_lines: list<string> =<< trim END
Bram Moolenaar971caf52020-09-21 22:21:42 +0200978 let b:existing = 'yes'
979 let w:existing = 'yes'
980 let t:existing = 'yes'
981
982 def Test_assignment_local_internal()
983 b:newvar = 'new'
984 assert_equal('new', b:newvar)
985 assert_equal('yes', b:existing)
986 b:existing = 'no'
987 assert_equal('no', b:existing)
988 b:existing ..= 'NO'
989 assert_equal('noNO', b:existing)
990
991 w:newvar = 'new'
992 assert_equal('new', w:newvar)
993 assert_equal('yes', w:existing)
994 w:existing = 'no'
995 assert_equal('no', w:existing)
996 w:existing ..= 'NO'
997 assert_equal('noNO', w:existing)
998
999 t:newvar = 'new'
1000 assert_equal('new', t:newvar)
1001 assert_equal('yes', t:existing)
1002 t:existing = 'no'
1003 assert_equal('no', t:existing)
1004 t:existing ..= 'NO'
1005 assert_equal('noNO', t:existing)
1006 enddef
1007 call Test_assignment_local_internal()
1008 END
1009 CheckScriptSuccess(script_lines)
1010enddef
1011
1012def Test_assignment_default()
Bram Moolenaar971caf52020-09-21 22:21:42 +02001013 # Test default values.
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001014 var thebool: bool
Bram Moolenaar971caf52020-09-21 22:21:42 +02001015 assert_equal(v:false, thebool)
1016
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001017 var thenumber: number
Bram Moolenaar971caf52020-09-21 22:21:42 +02001018 assert_equal(0, thenumber)
1019
1020 if has('float')
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001021 var thefloat: float
Bram Moolenaar971caf52020-09-21 22:21:42 +02001022 assert_equal(0.0, thefloat)
1023 endif
1024
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001025 var thestring: string
Bram Moolenaar971caf52020-09-21 22:21:42 +02001026 assert_equal('', thestring)
1027
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001028 var theblob: blob
Bram Moolenaar971caf52020-09-21 22:21:42 +02001029 assert_equal(0z, theblob)
1030
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001031 var Thefunc: func
Bram Moolenaar971caf52020-09-21 22:21:42 +02001032 assert_equal(test_null_function(), Thefunc)
1033
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001034 var thelist: list<any>
Bram Moolenaar971caf52020-09-21 22:21:42 +02001035 assert_equal([], thelist)
1036
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001037 var thedict: dict<any>
Bram Moolenaar971caf52020-09-21 22:21:42 +02001038 assert_equal({}, thedict)
1039
1040 if has('channel')
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001041 var thejob: job
Bram Moolenaar971caf52020-09-21 22:21:42 +02001042 assert_equal(test_null_job(), thejob)
1043
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001044 var thechannel: channel
Bram Moolenaar971caf52020-09-21 22:21:42 +02001045 assert_equal(test_null_channel(), thechannel)
1046
1047 if has('unix') && executable('cat')
1048 # check with non-null job and channel, types must match
Bram Moolenaare0de1712020-12-02 17:36:54 +01001049 thejob = job_start("cat ", {})
Bram Moolenaar971caf52020-09-21 22:21:42 +02001050 thechannel = job_getchannel(thejob)
1051 job_stop(thejob, 'kill')
1052 endif
1053 endif
1054
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001055 var nr = 1234 | nr = 5678
Bram Moolenaar971caf52020-09-21 22:21:42 +02001056 assert_equal(5678, nr)
1057enddef
1058
Bram Moolenaar3862ea32021-01-01 21:05:55 +01001059let scriptvar = 'init'
1060
Bram Moolenaar971caf52020-09-21 22:21:42 +02001061def Test_assignment_var_list()
Bram Moolenaarda7c20c2020-11-30 21:12:19 +01001062 var lines =<< trim END
1063 var v1: string
1064 var v2: string
1065 var vrem: list<string>
1066 [v1] = ['aaa']
1067 assert_equal('aaa', v1)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001068
Bram Moolenaarda7c20c2020-11-30 21:12:19 +01001069 [v1, v2] = ['one', 'two']
1070 assert_equal('one', v1)
1071 assert_equal('two', v2)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001072
Bram Moolenaarda7c20c2020-11-30 21:12:19 +01001073 [v1, v2; vrem] = ['one', 'two']
1074 assert_equal('one', v1)
1075 assert_equal('two', v2)
1076 assert_equal([], vrem)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001077
Bram Moolenaarda7c20c2020-11-30 21:12:19 +01001078 [v1, v2; vrem] = ['one', 'two', 'three']
1079 assert_equal('one', v1)
1080 assert_equal('two', v2)
1081 assert_equal(['three'], vrem)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001082
Bram Moolenaarda7c20c2020-11-30 21:12:19 +01001083 [&ts, &sw] = [3, 4]
1084 assert_equal(3, &ts)
1085 assert_equal(4, &sw)
1086 set ts=8 sw=4
Bram Moolenaar004d9b02020-11-30 21:40:03 +01001087
1088 [@a, @z] = ['aa', 'zz']
1089 assert_equal('aa', @a)
1090 assert_equal('zz', @z)
1091
1092 [$SOME_VAR, $OTHER_VAR] = ['some', 'other']
1093 assert_equal('some', $SOME_VAR)
1094 assert_equal('other', $OTHER_VAR)
1095
Bram Moolenaar3862ea32021-01-01 21:05:55 +01001096 [g:globalvar, b:bufvar, w:winvar, t:tabvar, v:errmsg] =
1097 ['global', 'buf', 'win', 'tab', 'error']
Bram Moolenaar004d9b02020-11-30 21:40:03 +01001098 assert_equal('global', g:globalvar)
Bram Moolenaar004d9b02020-11-30 21:40:03 +01001099 assert_equal('buf', b:bufvar)
1100 assert_equal('win', w:winvar)
1101 assert_equal('tab', t:tabvar)
1102 assert_equal('error', v:errmsg)
1103 unlet g:globalvar
Bram Moolenaarda7c20c2020-11-30 21:12:19 +01001104 END
1105 CheckDefAndScriptSuccess(lines)
Bram Moolenaar3862ea32021-01-01 21:05:55 +01001106
1107 [g:globalvar, s:scriptvar, b:bufvar] = ['global', 'script', 'buf']
1108 assert_equal('global', g:globalvar)
1109 assert_equal('script', s:scriptvar)
1110 assert_equal('buf', b:bufvar)
1111
1112 lines =<< trim END
1113 vim9script
1114 var s:scriptvar = 'init'
1115 [g:globalvar, s:scriptvar, w:winvar] = ['global', 'script', 'win']
1116 assert_equal('global', g:globalvar)
1117 assert_equal('script', s:scriptvar)
1118 assert_equal('win', w:winvar)
1119 END
1120 CheckScriptSuccess(lines)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001121enddef
1122
1123def Test_assignment_vim9script()
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001124 var lines =<< trim END
Bram Moolenaar971caf52020-09-21 22:21:42 +02001125 vim9script
1126 def Func(): list<number>
1127 return [1, 2]
1128 enddef
Bram Moolenaar98309382020-09-27 21:58:45 +02001129 var name1: number
1130 var name2: number
1131 [name1, name2] =
Bram Moolenaar971caf52020-09-21 22:21:42 +02001132 Func()
Bram Moolenaar98309382020-09-27 21:58:45 +02001133 assert_equal(1, name1)
1134 assert_equal(2, name2)
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001135 var ll =
Bram Moolenaar971caf52020-09-21 22:21:42 +02001136 Func()
1137 assert_equal([1, 2], ll)
1138
1139 @/ = 'text'
1140 assert_equal('text', @/)
1141 @0 = 'zero'
1142 assert_equal('zero', @0)
1143 @1 = 'one'
1144 assert_equal('one', @1)
1145 @9 = 'nine'
1146 assert_equal('nine', @9)
1147 @- = 'minus'
1148 assert_equal('minus', @-)
1149 if has('clipboard_working')
1150 @* = 'star'
1151 assert_equal('star', @*)
1152 @+ = 'plus'
1153 assert_equal('plus', @+)
1154 endif
1155
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001156 var a: number = 123
Bram Moolenaar971caf52020-09-21 22:21:42 +02001157 assert_equal(123, a)
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001158 var s: string = 'yes'
Bram Moolenaar971caf52020-09-21 22:21:42 +02001159 assert_equal('yes', s)
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001160 var b: number = 42
Bram Moolenaar971caf52020-09-21 22:21:42 +02001161 assert_equal(42, b)
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001162 var w: number = 43
Bram Moolenaar971caf52020-09-21 22:21:42 +02001163 assert_equal(43, w)
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001164 var t: number = 44
Bram Moolenaar971caf52020-09-21 22:21:42 +02001165 assert_equal(44, t)
Bram Moolenaar7a66a172020-10-16 19:56:12 +02001166
1167 var to_var = 0
1168 to_var = 3
1169 assert_equal(3, to_var)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001170 END
1171 CheckScriptSuccess(lines)
Bram Moolenaar06f9c692020-09-27 21:27:40 +02001172
1173 lines =<< trim END
1174 vim9script
1175 var n: number
1176 def Func()
1177 n = 'string'
1178 enddef
1179 defcompile
1180 END
1181 CheckScriptFailure(lines, 'E1012: Type mismatch; expected number but got string')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001182enddef
1183
1184def Mess(): string
1185 v:foldstart = 123
1186 return 'xxx'
1187enddef
1188
1189def Test_assignment_failure()
Bram Moolenaar98309382020-09-27 21:58:45 +02001190 CheckDefFailure(['var name=234'], 'E1004:')
1191 CheckDefFailure(['var name =234'], 'E1004:')
1192 CheckDefFailure(['var name= 234'], 'E1004:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001193
Bram Moolenaar98309382020-09-27 21:58:45 +02001194 CheckScriptFailure(['vim9script', 'var name=234'], 'E1004:')
1195 CheckScriptFailure(['vim9script', 'var name=234'], "before and after '='")
1196 CheckScriptFailure(['vim9script', 'var name =234'], 'E1004:')
1197 CheckScriptFailure(['vim9script', 'var name= 234'], 'E1004:')
1198 CheckScriptFailure(['vim9script', 'var name = 234', 'name+=234'], 'E1004:')
1199 CheckScriptFailure(['vim9script', 'var name = 234', 'name+=234'], "before and after '+='")
1200 CheckScriptFailure(['vim9script', 'var name = "x"', 'name..="y"'], 'E1004:')
1201 CheckScriptFailure(['vim9script', 'var name = "x"', 'name..="y"'], "before and after '..='")
Bram Moolenaar971caf52020-09-21 22:21:42 +02001202
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001203 CheckDefFailure(['var true = 1'], 'E1034:')
1204 CheckDefFailure(['var false = 1'], 'E1034:')
Bram Moolenaar74235772021-06-12 14:53:05 +02001205 CheckDefFailure(['var null = 1'], 'E1034:')
1206 CheckDefFailure(['var this = 1'], 'E1034:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001207
1208 CheckDefFailure(['[a; b; c] = g:list'], 'E452:')
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001209 CheckDefExecFailure(['var a: number',
Bram Moolenaar971caf52020-09-21 22:21:42 +02001210 '[a] = test_null_list()'], 'E1093:')
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001211 CheckDefExecFailure(['var a: number',
Bram Moolenaar971caf52020-09-21 22:21:42 +02001212 '[a] = []'], 'E1093:')
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001213 CheckDefExecFailure(['var x: number',
1214 'var y: number',
Bram Moolenaar971caf52020-09-21 22:21:42 +02001215 '[x, y] = [1]'], 'E1093:')
Bram Moolenaar352134b2020-10-17 22:04:08 +02001216 CheckDefExecFailure(['var x: string',
1217 'var y: string',
1218 '[x, y] = ["x"]'], 'E1093:')
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001219 CheckDefExecFailure(['var x: number',
1220 'var y: number',
1221 'var z: list<number>',
Bram Moolenaar971caf52020-09-21 22:21:42 +02001222 '[x, y; z] = [1]'], 'E1093:')
1223
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001224 CheckDefFailure(['var somevar'], "E1022:")
1225 CheckDefFailure(['var &tabstop = 4'], 'E1052:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001226 CheckDefFailure(['&g:option = 5'], 'E113:')
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001227 CheckScriptFailure(['vim9script', 'var &tabstop = 4'], 'E1052:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001228
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001229 CheckDefFailure(['var $VAR = 5'], 'E1016: Cannot declare an environment variable:')
1230 CheckScriptFailure(['vim9script', 'var $ENV = "xxx"'], 'E1016:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001231
1232 if has('dnd')
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001233 CheckDefFailure(['var @~ = 5'], 'E1066:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001234 else
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001235 CheckDefFailure(['var @~ = 5'], 'E354:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001236 CheckDefFailure(['@~ = 5'], 'E354:')
1237 endif
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001238 CheckDefFailure(['var @a = 5'], 'E1066:')
1239 CheckDefFailure(['var @/ = "x"'], 'E1066:')
1240 CheckScriptFailure(['vim9script', 'var @a = "abc"'], 'E1066:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001241
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001242 CheckDefFailure(['var g:var = 5'], 'E1016: Cannot declare a global variable:')
1243 CheckDefFailure(['var w:var = 5'], 'E1016: Cannot declare a window variable:')
1244 CheckDefFailure(['var b:var = 5'], 'E1016: Cannot declare a buffer variable:')
1245 CheckDefFailure(['var t:var = 5'], 'E1016: Cannot declare a tab variable:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001246
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001247 CheckDefFailure(['var anr = 4', 'anr ..= "text"'], 'E1019:')
1248 CheckDefFailure(['var xnr += 4'], 'E1020:', 1)
1249 CheckScriptFailure(['vim9script', 'var xnr += 4'], 'E1020:')
1250 CheckDefFailure(["var xnr = xnr + 1"], 'E1001:', 1)
1251 CheckScriptFailure(['vim9script', 'var xnr = xnr + 4'], 'E121:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001252
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001253 CheckScriptFailure(['vim9script', 'def Func()', 'var dummy = s:notfound', 'enddef', 'defcompile'], 'E1108:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001254
Bram Moolenaar98309382020-09-27 21:58:45 +02001255 CheckDefFailure(['var name: list<string> = [123]'], 'expected list<string> but got list<number>')
1256 CheckDefFailure(['var name: list<number> = ["xx"]'], 'expected list<number> but got list<string>')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001257
Bram Moolenaare0de1712020-12-02 17:36:54 +01001258 CheckDefFailure(['var name: dict<string> = {key: 123}'], 'expected dict<string> but got dict<number>')
1259 CheckDefFailure(['var name: dict<number> = {key: "xx"}'], 'expected dict<number> but got dict<string>')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001260
Bram Moolenaar98309382020-09-27 21:58:45 +02001261 CheckDefFailure(['var name = feedkeys("0")'], 'E1031:')
1262 CheckDefFailure(['var name: number = feedkeys("0")'], 'expected number but got void')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001263
Bram Moolenaar98309382020-09-27 21:58:45 +02001264 CheckDefFailure(['var name: dict <number>'], 'E1068:')
1265 CheckDefFailure(['var name: dict<number'], 'E1009:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001266
1267 assert_fails('s/^/\=Mess()/n', 'E794:')
Bram Moolenaar98309382020-09-27 21:58:45 +02001268 CheckDefFailure(['var name: dict<number'], 'E1009:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001269
1270 CheckDefFailure(['w:foo: number = 10'],
1271 'E488: Trailing characters: : number = 1')
1272 CheckDefFailure(['t:foo: bool = true'],
1273 'E488: Trailing characters: : bool = true')
1274 CheckDefFailure(['b:foo: string = "x"'],
1275 'E488: Trailing characters: : string = "x"')
1276 CheckDefFailure(['g:foo: number = 123'],
1277 'E488: Trailing characters: : number = 123')
1278enddef
1279
1280def Test_assign_list()
Bram Moolenaare65081d2021-06-27 15:04:05 +02001281 var lines =<< trim END
1282 var l: list<string> = []
1283 l[0] = 'value'
1284 assert_equal('value', l[0])
Bram Moolenaar971caf52020-09-21 22:21:42 +02001285
Bram Moolenaare65081d2021-06-27 15:04:05 +02001286 l[1] = 'asdf'
1287 assert_equal('value', l[0])
1288 assert_equal('asdf', l[1])
1289 assert_equal('asdf', l[-1])
1290 assert_equal('value', l[-2])
Bram Moolenaar971caf52020-09-21 22:21:42 +02001291
Bram Moolenaare65081d2021-06-27 15:04:05 +02001292 var nrl: list<number> = []
1293 for i in range(5)
1294 nrl[i] = i
1295 endfor
1296 assert_equal([0, 1, 2, 3, 4], nrl)
1297
1298 var ul: list<any>
1299 ul[0] = 1
1300 ul[1] = 2
1301 ul[2] = 3
1302 assert_equal([1, 2, 3], ul)
1303 END
1304 CheckDefAndScriptSuccess(lines)
Bram Moolenaar334a8b42020-10-19 16:07:42 +02001305
1306 CheckDefFailure(["var l: list<number> = ['', true]"], 'E1012: Type mismatch; expected list<number> but got list<any>', 1)
1307 CheckDefFailure(["var l: list<list<number>> = [['', true]]"], 'E1012: Type mismatch; expected list<list<number>> but got list<list<any>>', 1)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001308enddef
1309
1310def Test_assign_dict()
Bram Moolenaarc3689572021-01-01 19:40:02 +01001311 var lines =<< trim END
1312 var d: dict<string> = {}
1313 d['key'] = 'value'
1314 assert_equal('value', d['key'])
Bram Moolenaar971caf52020-09-21 22:21:42 +02001315
Bram Moolenaarc3689572021-01-01 19:40:02 +01001316 d[123] = 'qwerty'
1317 assert_equal('qwerty', d[123])
1318 assert_equal('qwerty', d['123'])
Bram Moolenaar971caf52020-09-21 22:21:42 +02001319
Bram Moolenaarc3689572021-01-01 19:40:02 +01001320 var nrd: dict<number> = {}
1321 for i in range(3)
1322 nrd[i] = i
1323 endfor
1324 assert_equal({0: 0, 1: 1, 2: 2}, nrd)
1325
1326 d.somekey = 'someval'
1327 assert_equal({key: 'value', '123': 'qwerty', somekey: 'someval'}, d)
Bram Moolenaar23e2e112021-08-03 21:16:18 +02001328 unlet d.somekey
1329 assert_equal({key: 'value', '123': 'qwerty'}, d)
Bram Moolenaarc3689572021-01-01 19:40:02 +01001330 END
1331 CheckDefAndScriptSuccess(lines)
1332
Bram Moolenaare0de1712020-12-02 17:36:54 +01001333 CheckDefFailure(["var d: dict<number> = {a: '', b: true}"], 'E1012: Type mismatch; expected dict<number> but got dict<any>', 1)
1334 CheckDefFailure(["var d: dict<dict<number>> = {x: {a: '', b: true}}"], 'E1012: Type mismatch; expected dict<dict<number>> but got dict<dict<any>>', 1)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001335enddef
1336
Bram Moolenaar04bdd572020-09-23 13:25:32 +02001337def Test_assign_dict_unknown_type()
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001338 var lines =<< trim END
Bram Moolenaar04bdd572020-09-23 13:25:32 +02001339 vim9script
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001340 var mylist = []
Bram Moolenaare0de1712020-12-02 17:36:54 +01001341 mylist += [{one: 'one'}]
Bram Moolenaar04bdd572020-09-23 13:25:32 +02001342 def Func()
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001343 var dd = mylist[0]
Bram Moolenaar04bdd572020-09-23 13:25:32 +02001344 assert_equal('one', dd.one)
1345 enddef
1346 Func()
1347 END
1348 CheckScriptSuccess(lines)
1349
Bram Moolenaarce2c5442020-11-28 21:21:17 +01001350 lines =<< trim END
1351 vim9script
1352 var mylist = [[]]
Bram Moolenaare0de1712020-12-02 17:36:54 +01001353 mylist[0] += [{one: 'one'}]
Bram Moolenaarce2c5442020-11-28 21:21:17 +01001354 def Func()
1355 var dd = mylist[0][0]
1356 assert_equal('one', dd.one)
1357 enddef
1358 Func()
1359 END
1360 CheckScriptSuccess(lines)
Bram Moolenaar04bdd572020-09-23 13:25:32 +02001361enddef
1362
Bram Moolenaarf76ec1e2021-03-03 17:58:16 +01001363def Test_assign_dict_with_op()
1364 var lines =<< trim END
Bram Moolenaarf76ec1e2021-03-03 17:58:16 +01001365 var ds: dict<string> = {a: 'x'}
1366 ds['a'] ..= 'y'
1367 ds.a ..= 'z'
1368 assert_equal('xyz', ds.a)
1369
1370 var dn: dict<number> = {a: 9}
1371 dn['a'] += 2
1372 assert_equal(11, dn.a)
1373 dn.a += 2
1374 assert_equal(13, dn.a)
1375
1376 dn['a'] -= 3
1377 assert_equal(10, dn.a)
1378 dn.a -= 2
1379 assert_equal(8, dn.a)
1380
1381 dn['a'] *= 2
1382 assert_equal(16, dn.a)
1383 dn.a *= 2
1384 assert_equal(32, dn.a)
1385
1386 dn['a'] /= 3
1387 assert_equal(10, dn.a)
1388 dn.a /= 2
1389 assert_equal(5, dn.a)
1390
1391 dn['a'] %= 3
1392 assert_equal(2, dn.a)
1393 dn.a %= 6
1394 assert_equal(2, dn.a)
Bram Moolenaarb9c0cd82021-04-05 20:51:00 +02001395
1396 var dd: dict<dict<list<any>>>
1397 dd.a = {}
1398 dd.a.b = [0]
1399 dd.a.b += [1]
1400 assert_equal({a: {b: [0, 1]}}, dd)
Bram Moolenaar0d351a02021-04-05 21:05:26 +02001401
1402 var dab = {a: ['b']}
1403 dab.a[0] ..= 'c'
1404 assert_equal({a: ['bc']}, dab)
Bram Moolenaarf76ec1e2021-03-03 17:58:16 +01001405 END
Bram Moolenaare42939a2021-04-05 17:11:17 +02001406 CheckDefAndScriptSuccess(lines)
1407enddef
1408
1409def Test_assign_list_with_op()
1410 var lines =<< trim END
1411 var ls: list<string> = ['x']
1412 ls[0] ..= 'y'
1413 assert_equal('xy', ls[0])
1414
1415 var ln: list<number> = [9]
1416 ln[0] += 2
1417 assert_equal(11, ln[0])
1418
1419 ln[0] -= 3
1420 assert_equal(8, ln[0])
1421
1422 ln[0] *= 2
1423 assert_equal(16, ln[0])
1424
1425 ln[0] /= 3
1426 assert_equal(5, ln[0])
1427
1428 ln[0] %= 3
1429 assert_equal(2, ln[0])
1430 END
1431 CheckDefAndScriptSuccess(lines)
1432enddef
1433
1434def Test_assign_with_op_fails()
1435 var lines =<< trim END
1436 var s = 'abc'
1437 s[1] += 'x'
1438 END
1439 CheckDefAndScriptFailure2(lines, 'E1141:', 'E689:', 2)
1440
1441 lines =<< trim END
1442 var s = 'abc'
1443 s[1] ..= 'x'
1444 END
1445 CheckDefAndScriptFailure2(lines, 'E1141:', 'E689:', 2)
Bram Moolenaarb9c0cd82021-04-05 20:51:00 +02001446
1447 lines =<< trim END
1448 var dd: dict<dict<list<any>>>
1449 dd.a = {}
1450 dd.a.b += [1]
1451 END
1452 CheckDefExecAndScriptFailure(lines, 'E716:', 3)
Bram Moolenaarf76ec1e2021-03-03 17:58:16 +01001453enddef
1454
Bram Moolenaar971caf52020-09-21 22:21:42 +02001455def Test_assign_lambda()
1456 # check if assign a lambda to a variable which type is func or any.
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001457 var lines =<< trim END
Bram Moolenaar971caf52020-09-21 22:21:42 +02001458 vim9script
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001459 var FuncRef = () => 123
Bram Moolenaar971caf52020-09-21 22:21:42 +02001460 assert_equal(123, FuncRef())
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001461 var FuncRef_Func: func = () => 123
Bram Moolenaar971caf52020-09-21 22:21:42 +02001462 assert_equal(123, FuncRef_Func())
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001463 var FuncRef_Any: any = () => 123
Bram Moolenaar971caf52020-09-21 22:21:42 +02001464 assert_equal(123, FuncRef_Any())
Bram Moolenaar06409502021-02-17 17:00:27 +01001465 var FuncRef_Number: func(): number = () => 321
1466 assert_equal(321, FuncRef_Number())
Bram Moolenaar971caf52020-09-21 22:21:42 +02001467 END
1468 CheckScriptSuccess(lines)
Bram Moolenaar328eac22021-01-07 19:23:08 +01001469
1470 lines =<< trim END
1471 var Ref: func(number)
1472 Ref = (j) => !j
1473 END
Bram Moolenaar06409502021-02-17 17:00:27 +01001474 CheckDefAndScriptFailure(lines, 'E1012: Type mismatch; expected func(number) but got func(any): bool')
Bram Moolenaarc7dac852021-02-17 18:49:11 +01001475
1476 lines =<< trim END
1477 echo filter([1, 2, 3], (_, v: string) => v + 1)
1478 END
1479 CheckDefAndScriptFailure(lines, 'E1051:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001480enddef
1481
Bram Moolenaarc0e29012020-09-27 14:22:48 +02001482def Test_heredoc()
1483 var lines =<< trim END # comment
1484 text
1485 END
1486 assert_equal(['text'], lines)
1487
1488 CheckDefFailure(['var lines =<< trim END X', 'END'], 'E488:')
1489 CheckDefFailure(['var lines =<< trim END " comment', 'END'], 'E488:')
Bram Moolenaar2914a202020-09-27 18:24:03 +02001490
1491 lines =<< trim [END]
1492 def Func()
1493 var&lines =<< trim END
1494 x
1495 x
Bram Moolenaarb5b94802020-12-13 17:50:20 +01001496 enddef
1497 defcompile
1498 [END]
1499 CheckScriptFailure(lines, 'E1145: Missing heredoc end marker: END')
1500 delfunc! g:Func
1501
1502 lines =<< trim [END]
1503 def Func()
1504 var lines =<< trim END
1505 x
1506 x
Bram Moolenaar2914a202020-09-27 18:24:03 +02001507 x
1508 x
1509 x
1510 x
1511 x
1512 x
1513 enddef
1514 call Func()
1515 [END]
Bram Moolenaarb5b94802020-12-13 17:50:20 +01001516 CheckScriptFailure(lines, 'E1145: Missing heredoc end marker: END')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001517 delfunc! g:Func
Bram Moolenaar81530e32021-07-28 21:25:49 +02001518
1519 lines =<< trim END
1520 var lines: number =<< trim STOP
1521 aaa
1522 bbb
1523 STOP
1524 END
1525 CheckDefAndScriptFailure(lines, 'E1012: Type mismatch; expected number but got list<string>', 1)
Bram Moolenaarc0e29012020-09-27 14:22:48 +02001526enddef
1527
Bram Moolenaar083966f2020-12-08 11:29:40 +01001528def Test_var_func_call()
Bram Moolenaar55759b52020-09-30 22:59:42 +02001529 var lines =<< trim END
1530 vim9script
1531 func GetValue()
1532 if exists('g:count')
1533 let g:count += 1
1534 else
1535 let g:count = 1
1536 endif
1537 return 'this'
1538 endfunc
1539 var val: string = GetValue()
1540 # env var is always a string
1541 var env = $TERM
1542 END
1543 writefile(lines, 'Xfinished')
1544 source Xfinished
1545 # GetValue() is not called during discovery phase
1546 assert_equal(1, g:count)
1547
1548 unlet g:count
1549 delete('Xfinished')
1550enddef
1551
Bram Moolenaar083966f2020-12-08 11:29:40 +01001552def Test_var_missing_type()
Bram Moolenaar55759b52020-09-30 22:59:42 +02001553 var lines =<< trim END
1554 vim9script
1555 var name = g:unknown
1556 END
1557 CheckScriptFailure(lines, 'E121:')
1558
1559 lines =<< trim END
1560 vim9script
1561 var nr: number = 123
1562 var name = nr
1563 END
1564 CheckScriptSuccess(lines)
1565enddef
1566
Bram Moolenaar083966f2020-12-08 11:29:40 +01001567def Test_var_declaration()
Bram Moolenaar55759b52020-09-30 22:59:42 +02001568 var lines =<< trim END
1569 vim9script
1570 var name: string
1571 g:var_uninit = name
1572 name = 'text'
1573 g:var_test = name
1574 # prefixing s: is optional
1575 s:name = 'prefixed'
1576 g:var_prefixed = s:name
1577
Bram Moolenaar7257af42020-12-08 22:08:51 +01001578 const FOO: number = 123
1579 assert_equal(123, FOO)
Bram Moolenaar89b474d2020-12-22 21:19:39 +01001580 const FOOS = 'foos'
1581 assert_equal('foos', FOOS)
1582 final FLIST = [1]
1583 assert_equal([1], FLIST)
1584 FLIST[0] = 11
1585 assert_equal([11], FLIST)
1586
1587 const g:FOO: number = 321
1588 assert_equal(321, g:FOO)
1589 const g:FOOS = 'gfoos'
1590 assert_equal('gfoos', g:FOOS)
1591 final g:FLIST = [2]
1592 assert_equal([2], g:FLIST)
1593 g:FLIST[0] = 22
1594 assert_equal([22], g:FLIST)
1595
Bram Moolenaard877a572021-04-01 19:42:48 +02001596 def SetGlobalConst()
1597 const g:globConst = 123
1598 enddef
1599 SetGlobalConst()
1600 assert_equal(123, g:globConst)
1601 assert_true(islocked('g:globConst'))
1602
Bram Moolenaar89b474d2020-12-22 21:19:39 +01001603 const w:FOO: number = 46
1604 assert_equal(46, w:FOO)
1605 const w:FOOS = 'wfoos'
1606 assert_equal('wfoos', w:FOOS)
1607 final w:FLIST = [3]
1608 assert_equal([3], w:FLIST)
1609 w:FLIST[0] = 33
1610 assert_equal([33], w:FLIST)
Bram Moolenaar7257af42020-12-08 22:08:51 +01001611
Bram Moolenaar55759b52020-09-30 22:59:42 +02001612 var s:other: number
1613 other = 1234
1614 g:other_var = other
1615
Bram Moolenaarccc25aa2021-03-26 21:27:52 +01001616 var xyz: string # comment
1617
Bram Moolenaar55759b52020-09-30 22:59:42 +02001618 # type is inferred
Bram Moolenaar3862ea32021-01-01 21:05:55 +01001619 var s:dict = {['a']: 222}
Bram Moolenaar55759b52020-09-30 22:59:42 +02001620 def GetDictVal(key: any)
1621 g:dict_val = s:dict[key]
1622 enddef
1623 GetDictVal('a')
Bram Moolenaar08251752021-01-11 21:20:18 +01001624
1625 final adict: dict<string> = {}
1626 def ChangeAdict()
1627 adict.foo = 'foo'
1628 enddef
1629 ChangeAdict()
Bram Moolenaar55759b52020-09-30 22:59:42 +02001630 END
1631 CheckScriptSuccess(lines)
1632 assert_equal('', g:var_uninit)
1633 assert_equal('text', g:var_test)
1634 assert_equal('prefixed', g:var_prefixed)
1635 assert_equal(1234, g:other_var)
1636 assert_equal(222, g:dict_val)
1637
1638 unlet g:var_uninit
1639 unlet g:var_test
1640 unlet g:var_prefixed
1641 unlet g:other_var
Bram Moolenaar6e50ec22021-04-03 19:32:44 +02001642 unlet g:globConst
Bram Moolenaar89b474d2020-12-22 21:19:39 +01001643 unlet g:FOO
1644 unlet g:FOOS
1645 unlet g:FLIST
1646 unlet w:FOO
1647 unlet w:FOOS
1648 unlet w:FLIST
Bram Moolenaar55759b52020-09-30 22:59:42 +02001649enddef
1650
Bram Moolenaar083966f2020-12-08 11:29:40 +01001651def Test_var_declaration_fails()
Bram Moolenaar55759b52020-09-30 22:59:42 +02001652 var lines =<< trim END
1653 vim9script
1654 final var: string
1655 END
1656 CheckScriptFailure(lines, 'E1125:')
1657
1658 lines =<< trim END
1659 vim9script
Bram Moolenaar89b474d2020-12-22 21:19:39 +01001660 const g:constvar = 'string'
1661 g:constvar = 'xx'
1662 END
1663 CheckScriptFailure(lines, 'E741:')
1664 unlet g:constvar
1665
1666 lines =<< trim END
1667 vim9script
Bram Moolenaarf5906aa2021-04-02 14:35:15 +02001668 var name = 'one'
1669 lockvar name
1670 def SetLocked()
1671 name = 'two'
1672 enddef
1673 SetLocked()
1674 END
Bram Moolenaardcf29ac2021-04-02 14:44:02 +02001675 CheckScriptFailure(lines, 'E741: Value is locked: name', 1)
1676
1677 lines =<< trim END
1678 let s:legacy = 'one'
1679 lockvar s:legacy
1680 def SetLocked()
1681 s:legacy = 'two'
1682 enddef
1683 call SetLocked()
1684 END
1685 CheckScriptFailure(lines, 'E741: Value is locked: s:legacy', 1)
Bram Moolenaarf5906aa2021-04-02 14:35:15 +02001686
1687 lines =<< trim END
1688 vim9script
Bram Moolenaard877a572021-04-01 19:42:48 +02001689 def SetGlobalConst()
1690 const g:globConst = 123
1691 enddef
1692 SetGlobalConst()
1693 g:globConst = 234
1694 END
Bram Moolenaar6e50ec22021-04-03 19:32:44 +02001695 CheckScriptFailure(lines, 'E741: Value is locked: g:globConst', 6)
Bram Moolenaard877a572021-04-01 19:42:48 +02001696 unlet g:globConst
1697
1698 lines =<< trim END
1699 vim9script
Bram Moolenaar08251752021-01-11 21:20:18 +01001700 const cdict: dict<string> = {}
1701 def Change()
1702 cdict.foo = 'foo'
1703 enddef
1704 defcompile
1705 END
1706 CheckScriptFailure(lines, 'E46:')
1707
1708 lines =<< trim END
1709 vim9script
Bram Moolenaar89b474d2020-12-22 21:19:39 +01001710 final w:finalvar = [9]
1711 w:finalvar = [8]
1712 END
1713 CheckScriptFailure(lines, 'E1122:')
1714 unlet w:finalvar
1715
1716 lines =<< trim END
1717 vim9script
Bram Moolenaar55759b52020-09-30 22:59:42 +02001718 const var: string
1719 END
1720 CheckScriptFailure(lines, 'E1021:')
1721
1722 lines =<< trim END
1723 vim9script
1724 var 9var: string
1725 END
Bram Moolenaarccc25aa2021-03-26 21:27:52 +01001726 CheckScriptFailure(lines, 'E488:')
Bram Moolenaar7257af42020-12-08 22:08:51 +01001727
1728 CheckDefFailure(['var foo.bar = 2'], 'E1087:')
1729 CheckDefFailure(['var foo[3] = 2'], 'E1087:')
1730 CheckDefFailure(['const foo: number'], 'E1021:')
Bram Moolenaar55759b52020-09-30 22:59:42 +02001731enddef
1732
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02001733def Test_script_local_in_legacy()
1734 # OK to define script-local later when prefixed with s:
1735 var lines =<< trim END
1736 def SetLater()
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02001737 s:legvar = 'two'
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02001738 enddef
1739 defcompile
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02001740 let s:legvar = 'one'
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02001741 call SetLater()
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02001742 call assert_equal('two', s:legvar)
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02001743 END
1744 CheckScriptSuccess(lines)
1745
1746 # OK to leave out s: prefix when script-local already defined
1747 lines =<< trim END
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02001748 let s:legvar = 'one'
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02001749 def SetNoPrefix()
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02001750 legvar = 'two'
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02001751 enddef
1752 call SetNoPrefix()
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02001753 call assert_equal('two', s:legvar)
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02001754 END
1755 CheckScriptSuccess(lines)
1756
1757 # Not OK to leave out s: prefix when script-local defined later
1758 lines =<< trim END
1759 def SetLaterNoPrefix()
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02001760 legvar = 'two'
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02001761 enddef
1762 defcompile
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02001763 let s:legvar = 'one'
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02001764 END
1765 CheckScriptFailure(lines, 'E476:', 1)
Bram Moolenaar47bc9c32021-07-17 21:24:56 +02001766
1767 edit! Xfile
1768 lines =<< trim END
1769 var edit: bool
1770 legacy edit
1771 END
1772 CheckDefAndScriptSuccess(lines)
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02001773enddef
1774
Bram Moolenaar083966f2020-12-08 11:29:40 +01001775def Test_var_type_check()
Bram Moolenaar55759b52020-09-30 22:59:42 +02001776 var lines =<< trim END
1777 vim9script
1778 var name: string
1779 name = 1234
1780 END
1781 CheckScriptFailure(lines, 'E1012:')
1782
1783 lines =<< trim END
1784 vim9script
1785 var name:string
1786 END
1787 CheckScriptFailure(lines, 'E1069:')
1788
Bram Moolenaar60faf862021-08-23 22:22:45 +02001789 CheckDefAndScriptFailure(['var n:number = 42'], 'E1069:')
1790
Bram Moolenaar55759b52020-09-30 22:59:42 +02001791 lines =<< trim END
1792 vim9script
1793 var name: asdf
1794 END
1795 CheckScriptFailure(lines, 'E1010:')
1796
1797 lines =<< trim END
1798 vim9script
1799 var s:l: list<number>
1800 s:l = []
1801 END
1802 CheckScriptSuccess(lines)
1803
1804 lines =<< trim END
1805 vim9script
1806 var s:d: dict<number>
1807 s:d = {}
1808 END
1809 CheckScriptSuccess(lines)
Bram Moolenaar378697a2021-07-15 19:23:18 +02001810
1811 lines =<< trim END
1812 vim9script
1813 var d = {a: 1, b: [2]}
1814 def Func(b: bool)
1815 var l: list<number> = b ? d.b : [3]
1816 enddef
1817 defcompile
1818 END
1819 CheckScriptSuccess(lines)
Bram Moolenaar55759b52020-09-30 22:59:42 +02001820enddef
1821
1822let g:dict_number = #{one: 1, two: 2}
1823
Bram Moolenaar083966f2020-12-08 11:29:40 +01001824def Test_var_list_dict_type()
Bram Moolenaar55759b52020-09-30 22:59:42 +02001825 var ll: list<number>
1826 ll = [1, 2, 2, 3, 3, 3]->uniq()
1827 ll->assert_equal([1, 2, 3])
1828
1829 var dd: dict<number>
1830 dd = g:dict_number
1831 dd->assert_equal(g:dict_number)
1832
1833 var lines =<< trim END
1834 var ll: list<number>
1835 ll = [1, 2, 3]->map('"one"')
1836 END
Bram Moolenaar70250fb2021-01-16 19:01:53 +01001837 CheckDefExecFailure(lines, 'E1012: Type mismatch; expected number but got string')
Bram Moolenaar55759b52020-09-30 22:59:42 +02001838enddef
1839
Bram Moolenaar083966f2020-12-08 11:29:40 +01001840def Test_cannot_use_let()
1841 CheckDefAndScriptFailure(['let a = 34'], 'E1126:', 1)
1842enddef
1843
Bram Moolenaar55759b52020-09-30 22:59:42 +02001844def Test_unlet()
1845 g:somevar = 'yes'
1846 assert_true(exists('g:somevar'))
1847 unlet g:somevar
1848 assert_false(exists('g:somevar'))
1849 unlet! g:somevar
1850
1851 # also works for script-local variable in legacy Vim script
1852 s:somevar = 'legacy'
1853 assert_true(exists('s:somevar'))
1854 unlet s:somevar
1855 assert_false(exists('s:somevar'))
1856 unlet! s:somevar
1857
Bram Moolenaar0acbf5a2021-01-05 20:58:25 +01001858 CheckDefExecFailure([
1859 'var dd = 111',
1860 'unlet dd',
1861 ], 'E1081:', 2)
1862
Bram Moolenaar752fc692021-01-04 21:57:11 +01001863 # dict unlet
1864 var dd = {a: 1, b: 2, c: 3}
1865 unlet dd['a']
1866 unlet dd.c
1867 assert_equal({b: 2}, dd)
1868
1869 # list unlet
1870 var ll = [1, 2, 3, 4]
1871 unlet ll[1]
1872 unlet ll[-1]
1873 assert_equal([1, 3], ll)
1874
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01001875 ll = [1, 2, 3, 4]
1876 unlet ll[0 : 1]
1877 assert_equal([3, 4], ll)
1878
1879 ll = [1, 2, 3, 4]
1880 unlet ll[2 : 8]
1881 assert_equal([1, 2], ll)
1882
1883 ll = [1, 2, 3, 4]
1884 unlet ll[-2 : -1]
1885 assert_equal([1, 2], ll)
1886
1887 CheckDefFailure([
1888 'var ll = [1, 2]',
1889 'll[1 : 2] = 7',
Bram Moolenaar4f0884d2021-08-11 21:49:23 +02001890 ], 'E1012: Type mismatch; expected list<number> but got number', 2)
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01001891 CheckDefFailure([
1892 'var dd = {a: 1}',
1893 'unlet dd["a" : "a"]',
1894 ], 'E1166:', 2)
1895 CheckDefExecFailure([
1896 'unlet g:adict[0 : 1]',
1897 ], 'E1148:', 1)
1898 CheckDefFailure([
1899 'var ll = [1, 2]',
1900 'unlet ll[0:1]',
1901 ], 'E1004:', 2)
1902 CheckDefFailure([
1903 'var ll = [1, 2]',
1904 'unlet ll[0 :1]',
1905 ], 'E1004:', 2)
1906 CheckDefFailure([
1907 'var ll = [1, 2]',
1908 'unlet ll[0: 1]',
1909 ], 'E1004:', 2)
Bram Moolenaar7f2c3412021-11-29 16:01:49 +00001910 # command recognized as assignment when skipping, should not give an error
1911 CheckScriptSuccess([
1912 'vim9script',
1913 'for i in []',
1914 " put =''",
1915 'endfor'])
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01001916
1917 CheckDefFailure([
1918 'var ll = [1, 2]',
1919 'unlet ll["x" : 1]',
1920 ], 'E1012:', 2)
1921 CheckDefFailure([
1922 'var ll = [1, 2]',
1923 'unlet ll[0 : "x"]',
1924 ], 'E1012:', 2)
1925
Bram Moolenaar752fc692021-01-04 21:57:11 +01001926 # list of dict unlet
1927 var dl = [{a: 1, b: 2}, {c: 3}]
1928 unlet dl[0]['b']
1929 assert_equal([{a: 1}, {c: 3}], dl)
1930
1931 CheckDefExecFailure([
Bram Moolenaar0acbf5a2021-01-05 20:58:25 +01001932 'var ll = test_null_list()',
1933 'unlet ll[0]',
1934 ], 'E684:', 2)
Bram Moolenaar752fc692021-01-04 21:57:11 +01001935 CheckDefExecFailure([
Bram Moolenaar0acbf5a2021-01-05 20:58:25 +01001936 'var ll = [1]',
1937 'unlet ll[2]',
1938 ], 'E684:', 2)
Bram Moolenaar752fc692021-01-04 21:57:11 +01001939 CheckDefExecFailure([
Bram Moolenaar0acbf5a2021-01-05 20:58:25 +01001940 'var ll = [1]',
1941 'unlet ll[g:astring]',
Bram Moolenaarf30a14d2021-01-17 21:51:24 +01001942 ], 'E1012:', 2)
Bram Moolenaar752fc692021-01-04 21:57:11 +01001943 CheckDefExecFailure([
Bram Moolenaar0acbf5a2021-01-05 20:58:25 +01001944 'var dd = test_null_dict()',
1945 'unlet dd["a"]',
1946 ], 'E716:', 2)
1947 CheckDefExecFailure([
1948 'var dd = {a: 1}',
1949 'unlet dd["b"]',
1950 ], 'E716:', 2)
1951 CheckDefExecFailure([
1952 'var dd = {a: 1}',
1953 'unlet dd[g:alist]',
1954 ], 'E1105:', 2)
Bram Moolenaar752fc692021-01-04 21:57:11 +01001955
Bram Moolenaar2ef951d2021-01-03 20:55:26 +01001956 # can compile unlet before variable exists
Bram Moolenaar752fc692021-01-04 21:57:11 +01001957 g:someDict = {key: 'val'}
1958 var k = 'key'
1959 unlet g:someDict[k]
1960 assert_equal({}, g:someDict)
1961 unlet g:someDict
1962 assert_false(exists('g:someDict'))
Bram Moolenaar2ef951d2021-01-03 20:55:26 +01001963
Bram Moolenaar55759b52020-09-30 22:59:42 +02001964 CheckScriptFailure([
1965 'vim9script',
1966 'var svar = 123',
1967 'unlet svar',
1968 ], 'E1081:')
1969 CheckScriptFailure([
1970 'vim9script',
1971 'var svar = 123',
1972 'unlet s:svar',
1973 ], 'E1081:')
1974 CheckScriptFailure([
1975 'vim9script',
1976 'var svar = 123',
1977 'def Func()',
1978 ' unlet svar',
1979 'enddef',
1980 'defcompile',
1981 ], 'E1081:')
1982 CheckScriptFailure([
1983 'vim9script',
1984 'var svar = 123',
Bram Moolenaar9aed7292020-12-18 15:38:00 +01001985 'func Func()',
1986 ' unlet s:svar',
1987 'endfunc',
1988 'Func()',
1989 ], 'E1081:')
1990 CheckScriptFailure([
1991 'vim9script',
1992 'var svar = 123',
Bram Moolenaar55759b52020-09-30 22:59:42 +02001993 'def Func()',
1994 ' unlet s:svar',
1995 'enddef',
1996 'defcompile',
1997 ], 'E1081:')
1998
Bram Moolenaar0acbf5a2021-01-05 20:58:25 +01001999 writefile(['vim9script', 'export var svar = 1234'], 'XunletExport.vim')
2000 var lines =<< trim END
2001 vim9script
2002 import svar from './XunletExport.vim'
2003 def UnletSvar()
2004 unlet svar
2005 enddef
2006 defcompile
2007 END
2008 CheckScriptFailure(lines, 'E1081:', 1)
2009 delete('XunletExport.vim')
2010
Bram Moolenaar55759b52020-09-30 22:59:42 +02002011 $ENVVAR = 'foobar'
2012 assert_equal('foobar', $ENVVAR)
2013 unlet $ENVVAR
2014 assert_equal('', $ENVVAR)
2015enddef
2016
Bram Moolenaarc5f59fa2021-01-21 12:34:14 +01002017def Test_expr_error_no_assign()
2018 var lines =<< trim END
2019 vim9script
2020 var x = invalid
2021 echo x
2022 END
2023 CheckScriptFailureList(lines, ['E121:', 'E121:'])
2024
2025 lines =<< trim END
2026 vim9script
2027 var x = 1 / 0
2028 echo x
2029 END
Bram Moolenaar227c58a2021-04-28 20:40:44 +02002030 CheckScriptFailure(lines, 'E1154:')
Bram Moolenaarc5f59fa2021-01-21 12:34:14 +01002031
2032 lines =<< trim END
2033 vim9script
2034 var x = 1 % 0
2035 echo x
2036 END
Bram Moolenaar227c58a2021-04-28 20:40:44 +02002037 CheckScriptFailure(lines, 'E1154:')
Bram Moolenaarccc25aa2021-03-26 21:27:52 +01002038
2039 lines =<< trim END
2040 var x: string 'string'
2041 END
2042 CheckDefAndScriptFailure(lines, 'E488:')
Bram Moolenaarc5f59fa2021-01-21 12:34:14 +01002043enddef
2044
2045
Bram Moolenaar17126b12021-01-07 22:03:02 +01002046def Test_assign_command_modifier()
2047 var lines =<< trim END
Bram Moolenaar9e0f8832021-01-09 12:09:22 +01002048 var verbose = 0
2049 verbose = 1
2050 assert_equal(1, verbose)
2051 silent verbose = 2
2052 assert_equal(2, verbose)
2053 silent verbose += 2
2054 assert_equal(4, verbose)
2055 silent verbose -= 1
2056 assert_equal(3, verbose)
Bram Moolenaar17126b12021-01-07 22:03:02 +01002057
Bram Moolenaar9e0f8832021-01-09 12:09:22 +01002058 var topleft = {one: 1}
2059 sandbox topleft.one = 3
2060 assert_equal({one: 3}, topleft)
2061 leftabove topleft[' '] = 4
2062 assert_equal({one: 3, ' ': 4}, topleft)
2063
2064 var x: number
2065 var y: number
2066 silent [x, y] = [1, 2]
2067 assert_equal(1, x)
2068 assert_equal(2, y)
Bram Moolenaar17126b12021-01-07 22:03:02 +01002069 END
2070 CheckDefAndScriptSuccess(lines)
2071enddef
2072
Bram Moolenaar74f4a962021-06-17 21:03:07 +02002073def Test_assign_alt_buf_register()
2074 var lines =<< trim END
2075 edit 'file_b1'
2076 var b1 = bufnr()
2077 edit 'file_b2'
2078 var b2 = bufnr()
2079 assert_equal(b1, bufnr('#'))
2080 @# = b2
2081 assert_equal(b2, bufnr('#'))
2082 END
2083 CheckDefAndScriptSuccess(lines)
2084enddef
2085
Bram Moolenaar32154662021-03-28 21:14:06 +02002086def Test_script_funcref_case()
2087 var lines =<< trim END
2088 var Len = (s: string): number => len(s) + 1
2089 assert_equal(5, Len('asdf'))
2090 END
2091 CheckDefAndScriptSuccess(lines)
2092
2093 lines =<< trim END
2094 var len = (s: string): number => len(s) + 1
2095 END
2096 CheckDefAndScriptFailure(lines, 'E704:')
2097
2098 lines =<< trim END
2099 vim9script
2100 var s:Len = (s: string): number => len(s) + 2
2101 assert_equal(6, Len('asdf'))
2102 END
2103 CheckScriptSuccess(lines)
2104
2105 lines =<< trim END
2106 vim9script
2107 var s:len = (s: string): number => len(s) + 1
2108 END
2109 CheckScriptFailure(lines, 'E704:')
2110enddef
2111
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02002112def Test_inc_dec()
2113 var lines =<< trim END
2114 var nr = 7
2115 ++nr
Bram Moolenaar730bf302021-04-24 20:43:56 +02002116 assert_equal(8, nr)
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02002117 --nr
Bram Moolenaar730bf302021-04-24 20:43:56 +02002118 assert_equal(7, nr)
Bram Moolenaarf3d30842021-06-25 19:29:30 +02002119 ++nr | ++nr
2120 assert_equal(9, nr)
2121 ++nr # comment
2122 assert_equal(10, nr)
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02002123
2124 var ll = [1, 2]
2125 --ll[0]
2126 ++ll[1]
Bram Moolenaar730bf302021-04-24 20:43:56 +02002127 assert_equal([0, 3], ll)
2128
2129 g:count = 1
2130 ++g:count
2131 --g:count
2132 assert_equal(1, g:count)
2133 unlet g:count
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02002134 END
2135 CheckDefAndScriptSuccess(lines)
Bram Moolenaar22480d12021-06-25 21:31:09 +02002136
2137 lines =<< trim END
2138 var nr = 7
2139 ++ nr
2140 END
2141 CheckDefAndScriptFailure(lines, "E1202: No white space allowed after '++': ++ nr")
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02002142enddef
2143
Bram Moolenaar327d3ee2021-07-28 19:34:14 +02002144def Test_abort_after_error()
2145 # should abort after strpart() fails, not give another type error
2146 var lines =<< trim END
2147 vim9script
2148 var x: string
2149 x = strpart(1, 2)
2150 END
2151 writefile(lines, 'Xtestscript')
2152 var expected = 'E1174: String required for argument 1'
2153 assert_fails('so Xtestscript', [expected, expected], 3)
2154
2155 delete('Xtestscript')
2156enddef
2157
2158
Bram Moolenaar55759b52020-09-30 22:59:42 +02002159
Bram Moolenaar971caf52020-09-21 22:21:42 +02002160" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker