blob: 4a6f1a7e5cb2f06e1b2bb4bd659787c639be88f6 [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]
12let g:astring = 'text'
13
14def Test_assignment_bool()
Bram Moolenaar30fd8202020-09-26 15:09:30 +020015 var bool1: bool = true
Bram Moolenaar971caf52020-09-21 22:21:42 +020016 assert_equal(v:true, bool1)
Bram Moolenaar30fd8202020-09-26 15:09:30 +020017 var bool2: bool = false
Bram Moolenaar971caf52020-09-21 22:21:42 +020018 assert_equal(v:false, bool2)
19
Bram Moolenaar30fd8202020-09-26 15:09:30 +020020 var bool3: bool = 0
Bram Moolenaar971caf52020-09-21 22:21:42 +020021 assert_equal(false, bool3)
Bram Moolenaar30fd8202020-09-26 15:09:30 +020022 var bool4: bool = 1
Bram Moolenaar971caf52020-09-21 22:21:42 +020023 assert_equal(true, bool4)
24
Bram Moolenaar2bb26582020-10-03 22:52:39 +020025 var bool5: bool = 1 && true
Bram Moolenaar971caf52020-09-21 22:21:42 +020026 assert_equal(true, bool5)
Bram Moolenaar2bb26582020-10-03 22:52:39 +020027 var bool6: bool = 0 && 1
Bram Moolenaar971caf52020-09-21 22:21:42 +020028 assert_equal(false, bool6)
Bram Moolenaar2bb26582020-10-03 22:52:39 +020029 var bool7: bool = 0 || 1 && true
Bram Moolenaar971caf52020-09-21 22:21:42 +020030 assert_equal(true, bool7)
31
Bram Moolenaar30fd8202020-09-26 15:09:30 +020032 var lines =<< trim END
Bram Moolenaar971caf52020-09-21 22:21:42 +020033 vim9script
34 def GetFlag(): bool
Bram Moolenaar30fd8202020-09-26 15:09:30 +020035 var flag: bool = 1
Bram Moolenaar971caf52020-09-21 22:21:42 +020036 return flag
37 enddef
Bram Moolenaar30fd8202020-09-26 15:09:30 +020038 var flag: bool = GetFlag()
Bram Moolenaar971caf52020-09-21 22:21:42 +020039 assert_equal(true, flag)
40 flag = 0
41 assert_equal(false, flag)
42 flag = 1
43 assert_equal(true, flag)
Bram Moolenaar2bb26582020-10-03 22:52:39 +020044 flag = 1 || true
Bram Moolenaar971caf52020-09-21 22:21:42 +020045 assert_equal(true, flag)
Bram Moolenaar2bb26582020-10-03 22:52:39 +020046 flag = 1 && false
Bram Moolenaar971caf52020-09-21 22:21:42 +020047 assert_equal(false, flag)
48 END
49 CheckScriptSuccess(lines)
Bram Moolenaar30fd8202020-09-26 15:09:30 +020050 CheckDefAndScriptFailure(['var x: bool = 2'], 'E1012:')
51 CheckDefAndScriptFailure(['var x: bool = -1'], 'E1012:')
52 CheckDefAndScriptFailure(['var x: bool = [1]'], 'E1012:')
53 CheckDefAndScriptFailure(['var x: bool = {}'], 'E1012:')
54 CheckDefAndScriptFailure(['var x: bool = "x"'], 'E1012:')
Bram Moolenaar971caf52020-09-21 22:21:42 +020055enddef
56
57def Test_syntax()
Bram Moolenaar98309382020-09-27 21:58:45 +020058 var name = 234
Bram Moolenaar30fd8202020-09-26 15:09:30 +020059 var other: list<string> = ['asdf']
Bram Moolenaar971caf52020-09-21 22:21:42 +020060enddef
61
62def Test_assignment()
Bram Moolenaar30fd8202020-09-26 15:09:30 +020063 CheckDefFailure(['var x:string'], 'E1069:')
64 CheckDefFailure(['var x:string = "x"'], 'E1069:')
65 CheckDefFailure(['var a:string = "x"'], 'E1069:')
66 CheckDefFailure(['var lambda = {-> "lambda"}'], 'E704:')
67 CheckScriptFailure(['var x = "x"'], 'E1124:')
Bram Moolenaar971caf52020-09-21 22:21:42 +020068
Bram Moolenaar30fd8202020-09-26 15:09:30 +020069 var nr: number = 1234
70 CheckDefFailure(['var nr: number = "asdf"'], 'E1012:')
Bram Moolenaar971caf52020-09-21 22:21:42 +020071
Bram Moolenaar30fd8202020-09-26 15:09:30 +020072 var a: number = 6 #comment
Bram Moolenaar971caf52020-09-21 22:21:42 +020073 assert_equal(6, a)
74
75 if has('channel')
Bram Moolenaar30fd8202020-09-26 15:09:30 +020076 var chan1: channel
Bram Moolenaar218450a2020-10-17 18:51:52 +020077 assert_equal('fail', ch_status(chan1))
78
Bram Moolenaar30fd8202020-09-26 15:09:30 +020079 var job1: job
Bram Moolenaar218450a2020-10-17 18:51:52 +020080 assert_equal('fail', job_status(job1))
81
Bram Moolenaarfc8aa6d2020-10-12 20:31:26 +020082 # calling job_start() is in test_vim9_fails.vim, it causes leak reports
Bram Moolenaar971caf52020-09-21 22:21:42 +020083 endif
84 if has('float')
Bram Moolenaar30fd8202020-09-26 15:09:30 +020085 var float1: float = 3.4
Bram Moolenaar971caf52020-09-21 22:21:42 +020086 endif
Bram Moolenaar30fd8202020-09-26 15:09:30 +020087 var Funky1: func
88 var Funky2: func = function('len')
89 var Party2: func = funcref('g:Test_syntax')
Bram Moolenaar971caf52020-09-21 22:21:42 +020090
91 g:newvar = 'new' #comment
92 assert_equal('new', g:newvar)
93
94 assert_equal('yes', g:existing)
95 g:existing = 'no'
96 assert_equal('no', g:existing)
97
98 v:char = 'abc'
99 assert_equal('abc', v:char)
100
101 $ENVVAR = 'foobar'
102 assert_equal('foobar', $ENVVAR)
103 $ENVVAR = ''
104
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200105 var lines =<< trim END
Bram Moolenaar971caf52020-09-21 22:21:42 +0200106 vim9script
107 $ENVVAR = 'barfoo'
108 assert_equal('barfoo', $ENVVAR)
109 $ENVVAR = ''
110 END
111 CheckScriptSuccess(lines)
112
113 s:appendToMe ..= 'yyy'
114 assert_equal('xxxyyy', s:appendToMe)
115 s:addToMe += 222
116 assert_equal(333, s:addToMe)
117 s:newVar = 'new'
118 assert_equal('new', s:newVar)
119
120 set ts=7
121 &ts += 1
122 assert_equal(8, &ts)
123 &ts -= 3
124 assert_equal(5, &ts)
125 &ts *= 2
126 assert_equal(10, &ts)
127 &ts /= 3
128 assert_equal(3, &ts)
129 set ts=10
130 &ts %= 4
131 assert_equal(2, &ts)
132
133 if has('float')
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200134 var f100: float = 100.0
Bram Moolenaar971caf52020-09-21 22:21:42 +0200135 f100 /= 5
136 assert_equal(20.0, f100)
137
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200138 var f200: float = 200.0
Bram Moolenaar971caf52020-09-21 22:21:42 +0200139 f200 /= 5.0
140 assert_equal(40.0, f200)
141
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200142 CheckDefFailure(['var nr: number = 200', 'nr /= 5.0'], 'E1012:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200143 endif
144
145 lines =<< trim END
146 &ts = 6
147 &ts += 3
148 assert_equal(9, &ts)
149
150 &l:ts = 6
151 assert_equal(6, &ts)
152 &l:ts += 2
153 assert_equal(8, &ts)
154
155 &g:ts = 6
156 assert_equal(6, &g:ts)
157 &g:ts += 2
158 assert_equal(8, &g:ts)
159 END
160 CheckDefAndScriptSuccess(lines)
161
162 CheckDefFailure(['&notex += 3'], 'E113:')
163 CheckDefFailure(['&ts ..= "xxx"'], 'E1019:')
164 CheckDefFailure(['&ts = [7]'], 'E1012:')
165 CheckDefExecFailure(['&ts = g:alist'], 'E1012: Type mismatch; expected number but got list<number>')
166 CheckDefFailure(['&ts = "xx"'], 'E1012:')
167 CheckDefExecFailure(['&ts = g:astring'], 'E1012: Type mismatch; expected number but got string')
168 CheckDefFailure(['&path += 3'], 'E1012:')
169 CheckDefExecFailure(['&bs = "asdf"'], 'E474:')
170 # test freeing ISN_STOREOPT
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200171 CheckDefFailure(['&ts = 3', 'var asdf'], 'E1022:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200172 &ts = 8
173
174 lines =<< trim END
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200175 var save_TI = &t_TI
Bram Moolenaar971caf52020-09-21 22:21:42 +0200176 &t_TI = ''
177 assert_equal('', &t_TI)
178 &t_TI = 'xxx'
179 assert_equal('xxx', &t_TI)
180 &t_TI = save_TI
181 END
182 CheckDefAndScriptSuccess(lines)
183
184 CheckDefFailure(['&t_TI = 123'], 'E1012:')
185 CheckScriptFailure(['vim9script', '&t_TI = 123'], 'E928:')
186
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200187 CheckDefFailure(['var s:var = 123'], 'E1101:')
188 CheckDefFailure(['var s:var: number'], 'E1101:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200189
190 lines =<< trim END
191 vim9script
192 def SomeFunc()
193 s:var = 123
194 enddef
195 defcompile
196 END
197 CheckScriptFailure(lines, 'E1089:')
198
199 g:inc_counter += 1
200 assert_equal(2, g:inc_counter)
201
202 $SOME_ENV_VAR ..= 'more'
203 assert_equal('somemore', $SOME_ENV_VAR)
204 CheckDefFailure(['$SOME_ENV_VAR += "more"'], 'E1051:')
205 CheckDefFailure(['$SOME_ENV_VAR += 123'], 'E1012:')
206
207 lines =<< trim END
208 @c = 'areg'
209 @c ..= 'add'
210 assert_equal('aregadd', @c)
211 END
212 CheckDefAndScriptSuccess(lines)
213
214 CheckDefFailure(['@a += "more"'], 'E1051:')
215 CheckDefFailure(['@a += 123'], 'E1012:')
216
217 v:errmsg = 'none'
218 v:errmsg ..= 'again'
219 assert_equal('noneagain', v:errmsg)
220 CheckDefFailure(['v:errmsg += "more"'], 'E1051:')
221 CheckDefFailure(['v:errmsg += 123'], 'E1012:')
222
Bram Moolenaarfc8aa6d2020-10-12 20:31:26 +0200223 var text =<< trim END
224 some text
225 END
Bram Moolenaar971caf52020-09-21 22:21:42 +0200226enddef
227
Bram Moolenaar8ff16e02020-12-07 21:49:52 +0100228def Test_assign_unpack()
229 var lines =<< trim END
230 var v1: number
231 var v2: number
232 [v1, v2] = [1, 2]
233 assert_equal(1, v1)
234 assert_equal(2, v2)
235 END
236 CheckDefAndScriptSuccess(lines)
237
238 lines =<< trim END
239 var v1: number
240 var v2: number
241 [v1, v2] =
242 END
243 CheckDefFailure(lines, 'E1097:', 5)
244
245 lines =<< trim END
246 var v1: number
247 var v2: number
248 [v1, v2] = xxx
249 END
250 CheckDefFailure(lines, 'E1001:', 3)
251
252 lines =<< trim END
253 var v1: number
254 var v2: number
255 [v1, v2] = popup_clear()
256 END
257 CheckDefFailure(lines, 'E1031:', 3)
258
259 lines =<< trim END
260 var v1: number
261 var v2: number
262 [v1, v2] = ''
263 END
264 CheckDefFailure(lines, 'E1012: Type mismatch; expected list<any> but got string', 3)
265enddef
266
Bram Moolenaar7f764942020-12-02 15:11:18 +0100267def Test_assign_linebreak()
268 var nr: number
269 nr =
270 123
271 assert_equal(123, nr)
272
273 var n2: number
274 [nr, n2] =
275 [12, 34]
276 assert_equal(12, nr)
277 assert_equal(34, n2)
278
Bram Moolenaar8ff16e02020-12-07 21:49:52 +0100279 CheckDefFailure(["var x = #"], 'E1097:', 3)
Bram Moolenaar7f764942020-12-02 15:11:18 +0100280enddef
281
Bram Moolenaardc234ca2020-11-28 18:52:33 +0100282def Test_assign_index()
283 # list of list
284 var l1: list<number>
285 l1[0] = 123
286 assert_equal([123], l1)
287
288 var l2: list<list<number>>
289 l2[0] = []
290 l2[0][0] = 123
291 assert_equal([[123]], l2)
292
293 var l3: list<list<list<number>>>
294 l3[0] = []
295 l3[0][0] = []
296 l3[0][0][0] = 123
297 assert_equal([[[123]]], l3)
298
299 var lines =<< trim END
300 var l3: list<list<number>>
301 l3[0] = []
302 l3[0][0] = []
303 END
304 CheckDefFailure(lines, 'E1012: Type mismatch; expected number but got list<unknown>', 3)
305
306 # dict of dict
307 var d1: dict<number>
308 d1.one = 1
309 assert_equal({one: 1}, d1)
310
311 var d2: dict<dict<number>>
312 d2.one = {}
313 d2.one.two = 123
314 assert_equal({one: {two: 123}}, d2)
315
316 var d3: dict<dict<dict<number>>>
317 d3.one = {}
318 d3.one.two = {}
319 d3.one.two.three = 123
320 assert_equal({one: {two: {three: 123}}}, d3)
321
322 lines =<< trim END
323 var d3: dict<dict<number>>
324 d3.one = {}
325 d3.one.two = {}
326 END
327 CheckDefFailure(lines, 'E1012: Type mismatch; expected number but got dict<unknown>', 3)
328
Bram Moolenaaracbae182020-12-13 18:44:43 +0100329 lines =<< trim END
330 var lines: list<string>
331 lines['a'] = 'asdf'
332 END
333 CheckDefFailure(lines, 'E39:', 2)
334
335 lines =<< trim END
336 var lines: string
337 lines[9] = 'asdf'
338 END
339 CheckDefFailure(lines, 'E1141:', 2)
340
Bram Moolenaardc234ca2020-11-28 18:52:33 +0100341 # list of dict
342 var ld: list<dict<number>>
343 ld[0] = {}
344 ld[0].one = 123
345 assert_equal([{one: 123}], ld)
346
347 lines =<< trim END
348 var ld: list<dict<number>>
349 ld[0] = []
350 END
351 CheckDefFailure(lines, 'E1012: Type mismatch; expected dict<number> but got list<unknown>', 2)
352
353 # dict of list
354 var dl: dict<list<number>>
355 dl.one = []
356 dl.one[0] = 123
357 assert_equal({one: [123]}, dl)
358
359 lines =<< trim END
360 var dl: dict<list<number>>
361 dl.one = {}
362 END
363 CheckDefFailure(lines, 'E1012: Type mismatch; expected list<number> but got dict<unknown>', 2)
364enddef
365
Bram Moolenaar81ed4962020-09-23 15:56:50 +0200366def Test_extend_list()
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200367 var lines =<< trim END
Bram Moolenaar81ed4962020-09-23 15:56:50 +0200368 vim9script
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200369 var l: list<number>
Bram Moolenaar81ed4962020-09-23 15:56:50 +0200370 l += [123]
371 assert_equal([123], l)
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100372 END
373 CheckScriptSuccess(lines)
Bram Moolenaar81ed4962020-09-23 15:56:50 +0200374
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100375 lines =<< trim END
376 vim9script
377 var list: list<string>
378 extend(list, ['x'])
379 assert_equal(['x'], list)
Bram Moolenaar81ed4962020-09-23 15:56:50 +0200380 END
381 CheckScriptSuccess(lines)
Bram Moolenaar1a739232020-10-10 15:37:58 +0200382
383 # appending to NULL list from a function
384 lines =<< trim END
385 vim9script
386 var list: list<string>
387 def Func()
388 list += ['a', 'b']
389 enddef
390 Func()
391 assert_equal(['a', 'b'], list)
392 END
393 CheckScriptSuccess(lines)
Bram Moolenaar3beaf9c2020-12-18 17:23:14 +0100394 lines =<< trim END
395 vim9script
396 var list: list<string>
397 def Func()
398 extend(list, ['x', 'b'])
399 enddef
400 Func()
401 assert_equal(['x', 'b'], list)
402 END
403 CheckScriptSuccess(lines)
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100404
405 lines =<< trim END
406 vim9script
407 var l: list<string> = test_null_list()
408 extend(l, ['x'])
409 assert_equal(['x'], l)
410 END
411 CheckScriptSuccess(lines)
412
413 lines =<< trim END
414 vim9script
415 extend(test_null_list(), ['x'])
416 END
417 CheckScriptFailure(lines, 'E1134:', 2)
418enddef
419
420def Test_extend_dict()
421 var lines =<< trim END
422 vim9script
423 var d: dict<number>
Bram Moolenaare0de1712020-12-02 17:36:54 +0100424 extend(d, {a: 1})
425 assert_equal({a: 1}, d)
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100426
427 var d2: dict<number>
428 d2['one'] = 1
Bram Moolenaare0de1712020-12-02 17:36:54 +0100429 assert_equal({one: 1}, d2)
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100430 END
431 CheckScriptSuccess(lines)
432
433 lines =<< trim END
434 vim9script
435 var d: dict<string> = test_null_dict()
Bram Moolenaare0de1712020-12-02 17:36:54 +0100436 extend(d, {a: 'x'})
437 assert_equal({a: 'x'}, d)
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100438 END
439 CheckScriptSuccess(lines)
440
441 lines =<< trim END
442 vim9script
Bram Moolenaare0de1712020-12-02 17:36:54 +0100443 extend(test_null_dict(), {a: 'x'})
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100444 END
445 CheckScriptFailure(lines, 'E1133:', 2)
Bram Moolenaar81ed4962020-09-23 15:56:50 +0200446enddef
447
Bram Moolenaar971caf52020-09-21 22:21:42 +0200448def Test_single_letter_vars()
449 # single letter variables
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200450 var a: number = 123
Bram Moolenaar971caf52020-09-21 22:21:42 +0200451 a = 123
452 assert_equal(123, a)
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200453 var b: number
Bram Moolenaar971caf52020-09-21 22:21:42 +0200454 b = 123
455 assert_equal(123, b)
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200456 var g: number
Bram Moolenaar971caf52020-09-21 22:21:42 +0200457 g = 123
458 assert_equal(123, g)
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200459 var s: number
Bram Moolenaar971caf52020-09-21 22:21:42 +0200460 s = 123
461 assert_equal(123, s)
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200462 var t: number
Bram Moolenaar971caf52020-09-21 22:21:42 +0200463 t = 123
464 assert_equal(123, t)
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200465 var v: number
Bram Moolenaar971caf52020-09-21 22:21:42 +0200466 v = 123
467 assert_equal(123, v)
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200468 var w: number
Bram Moolenaar971caf52020-09-21 22:21:42 +0200469 w = 123
470 assert_equal(123, w)
471enddef
472
473def Test_vim9_single_char_vars()
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200474 var lines =<< trim END
Bram Moolenaar971caf52020-09-21 22:21:42 +0200475 vim9script
476
477 # single character variable declarations work
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200478 var a: string
479 var b: number
480 var l: list<any>
481 var s: string
482 var t: number
483 var v: number
484 var w: number
Bram Moolenaar971caf52020-09-21 22:21:42 +0200485
486 # script-local variables can be used without s: prefix
487 a = 'script-a'
488 b = 111
489 l = [1, 2, 3]
490 s = 'script-s'
491 t = 222
492 v = 333
493 w = 444
494
495 assert_equal('script-a', a)
496 assert_equal(111, b)
497 assert_equal([1, 2, 3], l)
498 assert_equal('script-s', s)
499 assert_equal(222, t)
500 assert_equal(333, v)
501 assert_equal(444, w)
502 END
503 writefile(lines, 'Xsinglechar')
504 source Xsinglechar
505 delete('Xsinglechar')
506enddef
507
508def Test_assignment_list()
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200509 var list1: list<bool> = [false, true, false]
510 var list2: list<number> = [1, 2, 3]
511 var list3: list<string> = ['sdf', 'asdf']
512 var list4: list<any> = ['yes', true, 1234]
513 var list5: list<blob> = [0z01, 0z02]
Bram Moolenaar971caf52020-09-21 22:21:42 +0200514
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200515 var listS: list<string> = []
516 var listN: list<number> = []
Bram Moolenaar971caf52020-09-21 22:21:42 +0200517
518 assert_equal([1, 2, 3], list2)
519 list2[-1] = 99
520 assert_equal([1, 2, 99], list2)
521 list2[-2] = 88
522 assert_equal([1, 88, 99], list2)
523 list2[-3] = 77
524 assert_equal([77, 88, 99], list2)
525 list2 += [100]
526 assert_equal([77, 88, 99, 100], list2)
527
528 list3 += ['end']
529 assert_equal(['sdf', 'asdf', 'end'], list3)
530
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200531 CheckDefExecFailure(['var ll = [1, 2, 3]', 'll[-4] = 6'], 'E684:')
532 CheckDefExecFailure(['var [v1, v2] = [1, 2]'], 'E1092:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200533
534 # type becomes list<any>
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200535 var somelist = rand() > 0 ? [1, 2, 3] : ['a', 'b', 'c']
Bram Moolenaar971caf52020-09-21 22:21:42 +0200536enddef
537
538def Test_assignment_list_vim9script()
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200539 var lines =<< trim END
Bram Moolenaar971caf52020-09-21 22:21:42 +0200540 vim9script
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200541 var v1: number
542 var v2: number
543 var v3: number
Bram Moolenaar971caf52020-09-21 22:21:42 +0200544 [v1, v2, v3] = [1, 2, 3]
545 assert_equal([1, 2, 3], [v1, v2, v3])
546 END
547 CheckScriptSuccess(lines)
548enddef
549
550def Test_assignment_dict()
Bram Moolenaare0de1712020-12-02 17:36:54 +0100551 var dict1: dict<bool> = {one: false, two: true}
552 var dict2: dict<number> = {one: 1, two: 2}
553 var dict3: dict<string> = {key: 'value'}
554 var dict4: dict<any> = {one: 1, two: '2'}
555 var dict5: dict<blob> = {one: 0z01, two: 0z02}
Bram Moolenaar971caf52020-09-21 22:21:42 +0200556
557 # overwrite
558 dict3['key'] = 'another'
Bram Moolenaare0de1712020-12-02 17:36:54 +0100559 assert_equal(dict3, {key: 'another'})
Bram Moolenaarfc74d032020-11-16 22:11:49 +0100560 dict3.key = 'yet another'
Bram Moolenaare0de1712020-12-02 17:36:54 +0100561 assert_equal(dict3, {key: 'yet another'})
Bram Moolenaarfc74d032020-11-16 22:11:49 +0100562
563 var lines =<< trim END
Bram Moolenaard88dc4d2020-12-20 14:49:42 +0100564 vim9script
565 var dd = {}
566 dd.two = 2
567 assert_equal({two: 2}, dd)
568 END
569 CheckScriptSuccess(lines)
570
571 lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +0100572 var dd = {one: 1}
Bram Moolenaarfc74d032020-11-16 22:11:49 +0100573 dd.one) = 2
574 END
Bram Moolenaard88dc4d2020-12-20 14:49:42 +0100575 CheckDefFailure(lines, 'E488:', 2)
576
577 lines =<< trim END
578 var dd = {one: 1}
579 var dd.one = 2
580 END
581 CheckDefAndScriptFailure(lines, 'E1017:', 2)
Bram Moolenaar971caf52020-09-21 22:21:42 +0200582
583 # empty key can be used
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200584 var dd = {}
Bram Moolenaar971caf52020-09-21 22:21:42 +0200585 dd[""] = 6
Bram Moolenaare0de1712020-12-02 17:36:54 +0100586 assert_equal({['']: 6}, dd)
Bram Moolenaar971caf52020-09-21 22:21:42 +0200587
588 # type becomes dict<any>
Bram Moolenaare0de1712020-12-02 17:36:54 +0100589 var somedict = rand() > 0 ? {a: 1, b: 2} : {a: 'a', b: 'b'}
Bram Moolenaar971caf52020-09-21 22:21:42 +0200590
591 # assignment to script-local dict
Bram Moolenaarfc74d032020-11-16 22:11:49 +0100592 lines =<< trim END
Bram Moolenaar971caf52020-09-21 22:21:42 +0200593 vim9script
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200594 var test: dict<any> = {}
Bram Moolenaar971caf52020-09-21 22:21:42 +0200595 def FillDict(): dict<any>
596 test['a'] = 43
597 return test
598 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +0100599 assert_equal({a: 43}, FillDict())
Bram Moolenaar971caf52020-09-21 22:21:42 +0200600 END
601 CheckScriptSuccess(lines)
602
603 lines =<< trim END
604 vim9script
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200605 var test: dict<any>
Bram Moolenaar971caf52020-09-21 22:21:42 +0200606 def FillDict(): dict<any>
607 test['a'] = 43
608 return test
609 enddef
610 FillDict()
Bram Moolenaar3beaf9c2020-12-18 17:23:14 +0100611 assert_equal({a: 43}, test)
Bram Moolenaar971caf52020-09-21 22:21:42 +0200612 END
Bram Moolenaar3beaf9c2020-12-18 17:23:14 +0100613 CheckScriptSuccess(lines)
Bram Moolenaar971caf52020-09-21 22:21:42 +0200614
615 # assignment to global dict
616 lines =<< trim END
617 vim9script
618 g:test = {}
619 def FillDict(): dict<any>
620 g:test['a'] = 43
621 return g:test
622 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +0100623 assert_equal({a: 43}, FillDict())
Bram Moolenaar971caf52020-09-21 22:21:42 +0200624 END
625 CheckScriptSuccess(lines)
626
627 # assignment to buffer dict
628 lines =<< trim END
629 vim9script
630 b:test = {}
631 def FillDict(): dict<any>
632 b:test['a'] = 43
633 return b:test
634 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +0100635 assert_equal({a: 43}, FillDict())
Bram Moolenaar971caf52020-09-21 22:21:42 +0200636 END
637 CheckScriptSuccess(lines)
638enddef
639
640def Test_assignment_local()
641 # Test in a separated file in order not to the current buffer/window/tab is
642 # changed.
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200643 var script_lines: list<string> =<< trim END
Bram Moolenaar971caf52020-09-21 22:21:42 +0200644 let b:existing = 'yes'
645 let w:existing = 'yes'
646 let t:existing = 'yes'
647
648 def Test_assignment_local_internal()
649 b:newvar = 'new'
650 assert_equal('new', b:newvar)
651 assert_equal('yes', b:existing)
652 b:existing = 'no'
653 assert_equal('no', b:existing)
654 b:existing ..= 'NO'
655 assert_equal('noNO', b:existing)
656
657 w:newvar = 'new'
658 assert_equal('new', w:newvar)
659 assert_equal('yes', w:existing)
660 w:existing = 'no'
661 assert_equal('no', w:existing)
662 w:existing ..= 'NO'
663 assert_equal('noNO', w:existing)
664
665 t:newvar = 'new'
666 assert_equal('new', t:newvar)
667 assert_equal('yes', t:existing)
668 t:existing = 'no'
669 assert_equal('no', t:existing)
670 t:existing ..= 'NO'
671 assert_equal('noNO', t:existing)
672 enddef
673 call Test_assignment_local_internal()
674 END
675 CheckScriptSuccess(script_lines)
676enddef
677
678def Test_assignment_default()
Bram Moolenaar971caf52020-09-21 22:21:42 +0200679 # Test default values.
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200680 var thebool: bool
Bram Moolenaar971caf52020-09-21 22:21:42 +0200681 assert_equal(v:false, thebool)
682
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200683 var thenumber: number
Bram Moolenaar971caf52020-09-21 22:21:42 +0200684 assert_equal(0, thenumber)
685
686 if has('float')
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200687 var thefloat: float
Bram Moolenaar971caf52020-09-21 22:21:42 +0200688 assert_equal(0.0, thefloat)
689 endif
690
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200691 var thestring: string
Bram Moolenaar971caf52020-09-21 22:21:42 +0200692 assert_equal('', thestring)
693
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200694 var theblob: blob
Bram Moolenaar971caf52020-09-21 22:21:42 +0200695 assert_equal(0z, theblob)
696
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200697 var Thefunc: func
Bram Moolenaar971caf52020-09-21 22:21:42 +0200698 assert_equal(test_null_function(), Thefunc)
699
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200700 var thelist: list<any>
Bram Moolenaar971caf52020-09-21 22:21:42 +0200701 assert_equal([], thelist)
702
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200703 var thedict: dict<any>
Bram Moolenaar971caf52020-09-21 22:21:42 +0200704 assert_equal({}, thedict)
705
706 if has('channel')
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200707 var thejob: job
Bram Moolenaar971caf52020-09-21 22:21:42 +0200708 assert_equal(test_null_job(), thejob)
709
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200710 var thechannel: channel
Bram Moolenaar971caf52020-09-21 22:21:42 +0200711 assert_equal(test_null_channel(), thechannel)
712
713 if has('unix') && executable('cat')
714 # check with non-null job and channel, types must match
Bram Moolenaare0de1712020-12-02 17:36:54 +0100715 thejob = job_start("cat ", {})
Bram Moolenaar971caf52020-09-21 22:21:42 +0200716 thechannel = job_getchannel(thejob)
717 job_stop(thejob, 'kill')
718 endif
719 endif
720
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200721 var nr = 1234 | nr = 5678
Bram Moolenaar971caf52020-09-21 22:21:42 +0200722 assert_equal(5678, nr)
723enddef
724
725def Test_assignment_var_list()
Bram Moolenaarda7c20c2020-11-30 21:12:19 +0100726 var lines =<< trim END
727 var v1: string
728 var v2: string
729 var vrem: list<string>
730 [v1] = ['aaa']
731 assert_equal('aaa', v1)
Bram Moolenaar971caf52020-09-21 22:21:42 +0200732
Bram Moolenaarda7c20c2020-11-30 21:12:19 +0100733 [v1, v2] = ['one', 'two']
734 assert_equal('one', v1)
735 assert_equal('two', v2)
Bram Moolenaar971caf52020-09-21 22:21:42 +0200736
Bram Moolenaarda7c20c2020-11-30 21:12:19 +0100737 [v1, v2; vrem] = ['one', 'two']
738 assert_equal('one', v1)
739 assert_equal('two', v2)
740 assert_equal([], vrem)
Bram Moolenaar971caf52020-09-21 22:21:42 +0200741
Bram Moolenaarda7c20c2020-11-30 21:12:19 +0100742 [v1, v2; vrem] = ['one', 'two', 'three']
743 assert_equal('one', v1)
744 assert_equal('two', v2)
745 assert_equal(['three'], vrem)
Bram Moolenaar971caf52020-09-21 22:21:42 +0200746
Bram Moolenaarda7c20c2020-11-30 21:12:19 +0100747 [&ts, &sw] = [3, 4]
748 assert_equal(3, &ts)
749 assert_equal(4, &sw)
750 set ts=8 sw=4
Bram Moolenaar004d9b02020-11-30 21:40:03 +0100751
752 [@a, @z] = ['aa', 'zz']
753 assert_equal('aa', @a)
754 assert_equal('zz', @z)
755
756 [$SOME_VAR, $OTHER_VAR] = ['some', 'other']
757 assert_equal('some', $SOME_VAR)
758 assert_equal('other', $OTHER_VAR)
759
760 [g:globalvar, s:scriptvar, b:bufvar, w:winvar, t:tabvar, v:errmsg] =
761 ['global', 'script', 'buf', 'win', 'tab', 'error']
762 assert_equal('global', g:globalvar)
763 assert_equal('script', s:scriptvar)
764 assert_equal('buf', b:bufvar)
765 assert_equal('win', w:winvar)
766 assert_equal('tab', t:tabvar)
767 assert_equal('error', v:errmsg)
768 unlet g:globalvar
Bram Moolenaarda7c20c2020-11-30 21:12:19 +0100769 END
770 CheckDefAndScriptSuccess(lines)
Bram Moolenaar971caf52020-09-21 22:21:42 +0200771enddef
772
773def Test_assignment_vim9script()
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200774 var lines =<< trim END
Bram Moolenaar971caf52020-09-21 22:21:42 +0200775 vim9script
776 def Func(): list<number>
777 return [1, 2]
778 enddef
Bram Moolenaar98309382020-09-27 21:58:45 +0200779 var name1: number
780 var name2: number
781 [name1, name2] =
Bram Moolenaar971caf52020-09-21 22:21:42 +0200782 Func()
Bram Moolenaar98309382020-09-27 21:58:45 +0200783 assert_equal(1, name1)
784 assert_equal(2, name2)
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200785 var ll =
Bram Moolenaar971caf52020-09-21 22:21:42 +0200786 Func()
787 assert_equal([1, 2], ll)
788
789 @/ = 'text'
790 assert_equal('text', @/)
791 @0 = 'zero'
792 assert_equal('zero', @0)
793 @1 = 'one'
794 assert_equal('one', @1)
795 @9 = 'nine'
796 assert_equal('nine', @9)
797 @- = 'minus'
798 assert_equal('minus', @-)
799 if has('clipboard_working')
800 @* = 'star'
801 assert_equal('star', @*)
802 @+ = 'plus'
803 assert_equal('plus', @+)
804 endif
805
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200806 var a: number = 123
Bram Moolenaar971caf52020-09-21 22:21:42 +0200807 assert_equal(123, a)
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200808 var s: string = 'yes'
Bram Moolenaar971caf52020-09-21 22:21:42 +0200809 assert_equal('yes', s)
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200810 var b: number = 42
Bram Moolenaar971caf52020-09-21 22:21:42 +0200811 assert_equal(42, b)
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200812 var w: number = 43
Bram Moolenaar971caf52020-09-21 22:21:42 +0200813 assert_equal(43, w)
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200814 var t: number = 44
Bram Moolenaar971caf52020-09-21 22:21:42 +0200815 assert_equal(44, t)
Bram Moolenaar7a66a172020-10-16 19:56:12 +0200816
817 var to_var = 0
818 to_var = 3
819 assert_equal(3, to_var)
Bram Moolenaar971caf52020-09-21 22:21:42 +0200820 END
821 CheckScriptSuccess(lines)
Bram Moolenaar06f9c692020-09-27 21:27:40 +0200822
823 lines =<< trim END
824 vim9script
825 var n: number
826 def Func()
827 n = 'string'
828 enddef
829 defcompile
830 END
831 CheckScriptFailure(lines, 'E1012: Type mismatch; expected number but got string')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200832enddef
833
834def Mess(): string
835 v:foldstart = 123
836 return 'xxx'
837enddef
838
839def Test_assignment_failure()
Bram Moolenaar98309382020-09-27 21:58:45 +0200840 CheckDefFailure(['var name=234'], 'E1004:')
841 CheckDefFailure(['var name =234'], 'E1004:')
842 CheckDefFailure(['var name= 234'], 'E1004:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200843
Bram Moolenaar98309382020-09-27 21:58:45 +0200844 CheckScriptFailure(['vim9script', 'var name=234'], 'E1004:')
845 CheckScriptFailure(['vim9script', 'var name=234'], "before and after '='")
846 CheckScriptFailure(['vim9script', 'var name =234'], 'E1004:')
847 CheckScriptFailure(['vim9script', 'var name= 234'], 'E1004:')
848 CheckScriptFailure(['vim9script', 'var name = 234', 'name+=234'], 'E1004:')
849 CheckScriptFailure(['vim9script', 'var name = 234', 'name+=234'], "before and after '+='")
850 CheckScriptFailure(['vim9script', 'var name = "x"', 'name..="y"'], 'E1004:')
851 CheckScriptFailure(['vim9script', 'var name = "x"', 'name..="y"'], "before and after '..='")
Bram Moolenaar971caf52020-09-21 22:21:42 +0200852
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200853 CheckDefFailure(['var true = 1'], 'E1034:')
854 CheckDefFailure(['var false = 1'], 'E1034:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200855
856 CheckDefFailure(['[a; b; c] = g:list'], 'E452:')
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200857 CheckDefExecFailure(['var a: number',
Bram Moolenaar971caf52020-09-21 22:21:42 +0200858 '[a] = test_null_list()'], 'E1093:')
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200859 CheckDefExecFailure(['var a: number',
Bram Moolenaar971caf52020-09-21 22:21:42 +0200860 '[a] = []'], 'E1093:')
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200861 CheckDefExecFailure(['var x: number',
862 'var y: number',
Bram Moolenaar971caf52020-09-21 22:21:42 +0200863 '[x, y] = [1]'], 'E1093:')
Bram Moolenaar352134b2020-10-17 22:04:08 +0200864 CheckDefExecFailure(['var x: string',
865 'var y: string',
866 '[x, y] = ["x"]'], 'E1093:')
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200867 CheckDefExecFailure(['var x: number',
868 'var y: number',
869 'var z: list<number>',
Bram Moolenaar971caf52020-09-21 22:21:42 +0200870 '[x, y; z] = [1]'], 'E1093:')
871
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200872 CheckDefFailure(['var somevar'], "E1022:")
873 CheckDefFailure(['var &tabstop = 4'], 'E1052:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200874 CheckDefFailure(['&g:option = 5'], 'E113:')
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200875 CheckScriptFailure(['vim9script', 'var &tabstop = 4'], 'E1052:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200876
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200877 CheckDefFailure(['var $VAR = 5'], 'E1016: Cannot declare an environment variable:')
878 CheckScriptFailure(['vim9script', 'var $ENV = "xxx"'], 'E1016:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200879
880 if has('dnd')
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200881 CheckDefFailure(['var @~ = 5'], 'E1066:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200882 else
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200883 CheckDefFailure(['var @~ = 5'], 'E354:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200884 CheckDefFailure(['@~ = 5'], 'E354:')
885 endif
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200886 CheckDefFailure(['var @a = 5'], 'E1066:')
887 CheckDefFailure(['var @/ = "x"'], 'E1066:')
888 CheckScriptFailure(['vim9script', 'var @a = "abc"'], 'E1066:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200889
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200890 CheckDefFailure(['var g:var = 5'], 'E1016: Cannot declare a global variable:')
891 CheckDefFailure(['var w:var = 5'], 'E1016: Cannot declare a window variable:')
892 CheckDefFailure(['var b:var = 5'], 'E1016: Cannot declare a buffer variable:')
893 CheckDefFailure(['var t:var = 5'], 'E1016: Cannot declare a tab variable:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200894
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200895 CheckDefFailure(['var anr = 4', 'anr ..= "text"'], 'E1019:')
896 CheckDefFailure(['var xnr += 4'], 'E1020:', 1)
897 CheckScriptFailure(['vim9script', 'var xnr += 4'], 'E1020:')
898 CheckDefFailure(["var xnr = xnr + 1"], 'E1001:', 1)
899 CheckScriptFailure(['vim9script', 'var xnr = xnr + 4'], 'E121:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200900
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200901 CheckScriptFailure(['vim9script', 'def Func()', 'var dummy = s:notfound', 'enddef', 'defcompile'], 'E1108:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200902
Bram Moolenaar98309382020-09-27 21:58:45 +0200903 CheckDefFailure(['var name: list<string> = [123]'], 'expected list<string> but got list<number>')
904 CheckDefFailure(['var name: list<number> = ["xx"]'], 'expected list<number> but got list<string>')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200905
Bram Moolenaare0de1712020-12-02 17:36:54 +0100906 CheckDefFailure(['var name: dict<string> = {key: 123}'], 'expected dict<string> but got dict<number>')
907 CheckDefFailure(['var name: dict<number> = {key: "xx"}'], 'expected dict<number> but got dict<string>')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200908
Bram Moolenaar98309382020-09-27 21:58:45 +0200909 CheckDefFailure(['var name = feedkeys("0")'], 'E1031:')
910 CheckDefFailure(['var name: number = feedkeys("0")'], 'expected number but got void')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200911
Bram Moolenaar98309382020-09-27 21:58:45 +0200912 CheckDefFailure(['var name: dict <number>'], 'E1068:')
913 CheckDefFailure(['var name: dict<number'], 'E1009:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200914
915 assert_fails('s/^/\=Mess()/n', 'E794:')
Bram Moolenaar98309382020-09-27 21:58:45 +0200916 CheckDefFailure(['var name: dict<number'], 'E1009:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200917
918 CheckDefFailure(['w:foo: number = 10'],
919 'E488: Trailing characters: : number = 1')
920 CheckDefFailure(['t:foo: bool = true'],
921 'E488: Trailing characters: : bool = true')
922 CheckDefFailure(['b:foo: string = "x"'],
923 'E488: Trailing characters: : string = "x"')
924 CheckDefFailure(['g:foo: number = 123'],
925 'E488: Trailing characters: : number = 123')
926enddef
927
928def Test_assign_list()
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200929 var l: list<string> = []
Bram Moolenaar971caf52020-09-21 22:21:42 +0200930 l[0] = 'value'
931 assert_equal('value', l[0])
932
933 l[1] = 'asdf'
934 assert_equal('value', l[0])
935 assert_equal('asdf', l[1])
936 assert_equal('asdf', l[-1])
937 assert_equal('value', l[-2])
938
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200939 var nrl: list<number> = []
Bram Moolenaar971caf52020-09-21 22:21:42 +0200940 for i in range(5)
941 nrl[i] = i
942 endfor
943 assert_equal([0, 1, 2, 3, 4], nrl)
Bram Moolenaar334a8b42020-10-19 16:07:42 +0200944
945 CheckDefFailure(["var l: list<number> = ['', true]"], 'E1012: Type mismatch; expected list<number> but got list<any>', 1)
946 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 +0200947enddef
948
949def Test_assign_dict()
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200950 var d: dict<string> = {}
Bram Moolenaar971caf52020-09-21 22:21:42 +0200951 d['key'] = 'value'
952 assert_equal('value', d['key'])
953
954 d[123] = 'qwerty'
955 assert_equal('qwerty', d[123])
956 assert_equal('qwerty', d['123'])
957
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200958 var nrd: dict<number> = {}
Bram Moolenaar971caf52020-09-21 22:21:42 +0200959 for i in range(3)
960 nrd[i] = i
961 endfor
Bram Moolenaare0de1712020-12-02 17:36:54 +0100962 assert_equal({0: 0, 1: 1, 2: 2}, nrd)
Bram Moolenaar334a8b42020-10-19 16:07:42 +0200963
Bram Moolenaare0de1712020-12-02 17:36:54 +0100964 CheckDefFailure(["var d: dict<number> = {a: '', b: true}"], 'E1012: Type mismatch; expected dict<number> but got dict<any>', 1)
965 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 +0200966enddef
967
Bram Moolenaar04bdd572020-09-23 13:25:32 +0200968def Test_assign_dict_unknown_type()
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200969 var lines =<< trim END
Bram Moolenaar04bdd572020-09-23 13:25:32 +0200970 vim9script
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200971 var mylist = []
Bram Moolenaare0de1712020-12-02 17:36:54 +0100972 mylist += [{one: 'one'}]
Bram Moolenaar04bdd572020-09-23 13:25:32 +0200973 def Func()
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200974 var dd = mylist[0]
Bram Moolenaar04bdd572020-09-23 13:25:32 +0200975 assert_equal('one', dd.one)
976 enddef
977 Func()
978 END
979 CheckScriptSuccess(lines)
980
Bram Moolenaarce2c5442020-11-28 21:21:17 +0100981 lines =<< trim END
982 vim9script
983 var mylist = [[]]
Bram Moolenaare0de1712020-12-02 17:36:54 +0100984 mylist[0] += [{one: 'one'}]
Bram Moolenaarce2c5442020-11-28 21:21:17 +0100985 def Func()
986 var dd = mylist[0][0]
987 assert_equal('one', dd.one)
988 enddef
989 Func()
990 END
991 CheckScriptSuccess(lines)
Bram Moolenaar04bdd572020-09-23 13:25:32 +0200992enddef
993
Bram Moolenaar971caf52020-09-21 22:21:42 +0200994def Test_assign_lambda()
995 # check if assign a lambda to a variable which type is func or any.
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200996 var lines =<< trim END
Bram Moolenaar971caf52020-09-21 22:21:42 +0200997 vim9script
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200998 var FuncRef = {->123}
Bram Moolenaar971caf52020-09-21 22:21:42 +0200999 assert_equal(123, FuncRef())
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001000 var FuncRef_Func: func = {->123}
Bram Moolenaar971caf52020-09-21 22:21:42 +02001001 assert_equal(123, FuncRef_Func())
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001002 var FuncRef_Any: any = {->123}
Bram Moolenaar971caf52020-09-21 22:21:42 +02001003 assert_equal(123, FuncRef_Any())
1004 END
1005 CheckScriptSuccess(lines)
1006enddef
1007
Bram Moolenaarc0e29012020-09-27 14:22:48 +02001008def Test_heredoc()
1009 var lines =<< trim END # comment
1010 text
1011 END
1012 assert_equal(['text'], lines)
1013
1014 CheckDefFailure(['var lines =<< trim END X', 'END'], 'E488:')
1015 CheckDefFailure(['var lines =<< trim END " comment', 'END'], 'E488:')
Bram Moolenaar2914a202020-09-27 18:24:03 +02001016
1017 lines =<< trim [END]
1018 def Func()
1019 var&lines =<< trim END
1020 x
1021 x
Bram Moolenaarb5b94802020-12-13 17:50:20 +01001022 enddef
1023 defcompile
1024 [END]
1025 CheckScriptFailure(lines, 'E1145: Missing heredoc end marker: END')
1026 delfunc! g:Func
1027
1028 lines =<< trim [END]
1029 def Func()
1030 var lines =<< trim END
1031 x
1032 x
Bram Moolenaar2914a202020-09-27 18:24:03 +02001033 x
1034 x
1035 x
1036 x
1037 x
1038 x
1039 enddef
1040 call Func()
1041 [END]
Bram Moolenaarb5b94802020-12-13 17:50:20 +01001042 CheckScriptFailure(lines, 'E1145: Missing heredoc end marker: END')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001043 delfunc! g:Func
Bram Moolenaarc0e29012020-09-27 14:22:48 +02001044enddef
1045
Bram Moolenaar083966f2020-12-08 11:29:40 +01001046def Test_var_func_call()
Bram Moolenaar55759b52020-09-30 22:59:42 +02001047 var lines =<< trim END
1048 vim9script
1049 func GetValue()
1050 if exists('g:count')
1051 let g:count += 1
1052 else
1053 let g:count = 1
1054 endif
1055 return 'this'
1056 endfunc
1057 var val: string = GetValue()
1058 # env var is always a string
1059 var env = $TERM
1060 END
1061 writefile(lines, 'Xfinished')
1062 source Xfinished
1063 # GetValue() is not called during discovery phase
1064 assert_equal(1, g:count)
1065
1066 unlet g:count
1067 delete('Xfinished')
1068enddef
1069
Bram Moolenaar083966f2020-12-08 11:29:40 +01001070def Test_var_missing_type()
Bram Moolenaar55759b52020-09-30 22:59:42 +02001071 var lines =<< trim END
1072 vim9script
1073 var name = g:unknown
1074 END
1075 CheckScriptFailure(lines, 'E121:')
1076
1077 lines =<< trim END
1078 vim9script
1079 var nr: number = 123
1080 var name = nr
1081 END
1082 CheckScriptSuccess(lines)
1083enddef
1084
Bram Moolenaar083966f2020-12-08 11:29:40 +01001085def Test_var_declaration()
Bram Moolenaar55759b52020-09-30 22:59:42 +02001086 var lines =<< trim END
1087 vim9script
1088 var name: string
1089 g:var_uninit = name
1090 name = 'text'
1091 g:var_test = name
1092 # prefixing s: is optional
1093 s:name = 'prefixed'
1094 g:var_prefixed = s:name
1095
Bram Moolenaar7257af42020-12-08 22:08:51 +01001096 const FOO: number = 123
1097 assert_equal(123, FOO)
1098
Bram Moolenaar55759b52020-09-30 22:59:42 +02001099 var s:other: number
1100 other = 1234
1101 g:other_var = other
1102
1103 # type is inferred
Bram Moolenaare0de1712020-12-02 17:36:54 +01001104 s:dict = {['a']: 222}
Bram Moolenaar55759b52020-09-30 22:59:42 +02001105 def GetDictVal(key: any)
1106 g:dict_val = s:dict[key]
1107 enddef
1108 GetDictVal('a')
1109 END
1110 CheckScriptSuccess(lines)
1111 assert_equal('', g:var_uninit)
1112 assert_equal('text', g:var_test)
1113 assert_equal('prefixed', g:var_prefixed)
1114 assert_equal(1234, g:other_var)
1115 assert_equal(222, g:dict_val)
1116
1117 unlet g:var_uninit
1118 unlet g:var_test
1119 unlet g:var_prefixed
1120 unlet g:other_var
1121enddef
1122
Bram Moolenaar083966f2020-12-08 11:29:40 +01001123def Test_var_declaration_fails()
Bram Moolenaar55759b52020-09-30 22:59:42 +02001124 var lines =<< trim END
1125 vim9script
1126 final var: string
1127 END
1128 CheckScriptFailure(lines, 'E1125:')
1129
1130 lines =<< trim END
1131 vim9script
1132 const var: string
1133 END
1134 CheckScriptFailure(lines, 'E1021:')
1135
1136 lines =<< trim END
1137 vim9script
1138 var 9var: string
1139 END
1140 CheckScriptFailure(lines, 'E475:')
Bram Moolenaar7257af42020-12-08 22:08:51 +01001141
1142 CheckDefFailure(['var foo.bar = 2'], 'E1087:')
1143 CheckDefFailure(['var foo[3] = 2'], 'E1087:')
1144 CheckDefFailure(['const foo: number'], 'E1021:')
Bram Moolenaar55759b52020-09-30 22:59:42 +02001145enddef
1146
Bram Moolenaar083966f2020-12-08 11:29:40 +01001147def Test_var_type_check()
Bram Moolenaar55759b52020-09-30 22:59:42 +02001148 var lines =<< trim END
1149 vim9script
1150 var name: string
1151 name = 1234
1152 END
1153 CheckScriptFailure(lines, 'E1012:')
1154
1155 lines =<< trim END
1156 vim9script
1157 var name:string
1158 END
1159 CheckScriptFailure(lines, 'E1069:')
1160
1161 lines =<< trim END
1162 vim9script
1163 var name: asdf
1164 END
1165 CheckScriptFailure(lines, 'E1010:')
1166
1167 lines =<< trim END
1168 vim9script
1169 var s:l: list<number>
1170 s:l = []
1171 END
1172 CheckScriptSuccess(lines)
1173
1174 lines =<< trim END
1175 vim9script
1176 var s:d: dict<number>
1177 s:d = {}
1178 END
1179 CheckScriptSuccess(lines)
1180enddef
1181
1182let g:dict_number = #{one: 1, two: 2}
1183
Bram Moolenaar083966f2020-12-08 11:29:40 +01001184def Test_var_list_dict_type()
Bram Moolenaar55759b52020-09-30 22:59:42 +02001185 var ll: list<number>
1186 ll = [1, 2, 2, 3, 3, 3]->uniq()
1187 ll->assert_equal([1, 2, 3])
1188
1189 var dd: dict<number>
1190 dd = g:dict_number
1191 dd->assert_equal(g:dict_number)
1192
1193 var lines =<< trim END
1194 var ll: list<number>
1195 ll = [1, 2, 3]->map('"one"')
1196 END
1197 CheckDefExecFailure(lines, 'E1012: Type mismatch; expected list<number> but got list<string>')
1198enddef
1199
Bram Moolenaar083966f2020-12-08 11:29:40 +01001200def Test_cannot_use_let()
1201 CheckDefAndScriptFailure(['let a = 34'], 'E1126:', 1)
1202enddef
1203
Bram Moolenaar55759b52020-09-30 22:59:42 +02001204def Test_unlet()
1205 g:somevar = 'yes'
1206 assert_true(exists('g:somevar'))
1207 unlet g:somevar
1208 assert_false(exists('g:somevar'))
1209 unlet! g:somevar
1210
1211 # also works for script-local variable in legacy Vim script
1212 s:somevar = 'legacy'
1213 assert_true(exists('s:somevar'))
1214 unlet s:somevar
1215 assert_false(exists('s:somevar'))
1216 unlet! s:somevar
1217
1218 CheckScriptFailure([
1219 'vim9script',
1220 'var svar = 123',
1221 'unlet svar',
1222 ], 'E1081:')
1223 CheckScriptFailure([
1224 'vim9script',
1225 'var svar = 123',
1226 'unlet s:svar',
1227 ], 'E1081:')
1228 CheckScriptFailure([
1229 'vim9script',
1230 'var svar = 123',
1231 'def Func()',
1232 ' unlet svar',
1233 'enddef',
1234 'defcompile',
1235 ], 'E1081:')
1236 CheckScriptFailure([
1237 'vim9script',
1238 'var svar = 123',
Bram Moolenaar9aed7292020-12-18 15:38:00 +01001239 'func Func()',
1240 ' unlet s:svar',
1241 'endfunc',
1242 'Func()',
1243 ], 'E1081:')
1244 CheckScriptFailure([
1245 'vim9script',
1246 'var svar = 123',
Bram Moolenaar55759b52020-09-30 22:59:42 +02001247 'def Func()',
1248 ' unlet s:svar',
1249 'enddef',
1250 'defcompile',
1251 ], 'E1081:')
1252
1253 $ENVVAR = 'foobar'
1254 assert_equal('foobar', $ENVVAR)
1255 unlet $ENVVAR
1256 assert_equal('', $ENVVAR)
1257enddef
1258
1259
Bram Moolenaar971caf52020-09-21 22:21:42 +02001260" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker