blob: 57d205ceef3bddf1b9896b1b54c28c14c0a81e02 [file] [log] [blame]
Bram Moolenaar971caf52020-09-21 22:21:42 +02001" Test Vim9 assignments
2
3source check.vim
Bram Moolenaar62aec932022-01-29 21:45:34 +00004import './vim9.vim' as v9
Bram Moolenaarc653e4a2022-01-05 10:16:30 +00005source term_util.vim
Bram Moolenaar971caf52020-09-21 22:21:42 +02006
7let s:appendToMe = 'xxx'
8let s:addToMe = 111
Bram Moolenaara749a422022-02-12 19:52:25 +00009let s:newVar = ''
Bram Moolenaar971caf52020-09-21 22:21:42 +020010let g:existing = 'yes'
11let g:inc_counter = 1
12let $SOME_ENV_VAR = 'some'
13let g:alist = [7]
Bram Moolenaar5b5ae292021-02-20 17:04:02 +010014let g:adict = #{a: 1}
Bram Moolenaar971caf52020-09-21 22:21:42 +020015let g:astring = 'text'
16
17def Test_assignment_bool()
Bram Moolenaar30fd8202020-09-26 15:09:30 +020018 var bool1: bool = true
Bram Moolenaar971caf52020-09-21 22:21:42 +020019 assert_equal(v:true, bool1)
Bram Moolenaar30fd8202020-09-26 15:09:30 +020020 var bool2: bool = false
Bram Moolenaar971caf52020-09-21 22:21:42 +020021 assert_equal(v:false, bool2)
22
Bram Moolenaar30fd8202020-09-26 15:09:30 +020023 var bool3: bool = 0
Bram Moolenaar971caf52020-09-21 22:21:42 +020024 assert_equal(false, bool3)
Bram Moolenaar30fd8202020-09-26 15:09:30 +020025 var bool4: bool = 1
Bram Moolenaar971caf52020-09-21 22:21:42 +020026 assert_equal(true, bool4)
27
Bram Moolenaar2bb26582020-10-03 22:52:39 +020028 var bool5: bool = 1 && true
Bram Moolenaar971caf52020-09-21 22:21:42 +020029 assert_equal(true, bool5)
Bram Moolenaar2bb26582020-10-03 22:52:39 +020030 var bool6: bool = 0 && 1
Bram Moolenaar971caf52020-09-21 22:21:42 +020031 assert_equal(false, bool6)
Bram Moolenaar2bb26582020-10-03 22:52:39 +020032 var bool7: bool = 0 || 1 && true
Bram Moolenaar971caf52020-09-21 22:21:42 +020033 assert_equal(true, bool7)
34
Bram Moolenaar30fd8202020-09-26 15:09:30 +020035 var lines =<< trim END
Bram Moolenaar971caf52020-09-21 22:21:42 +020036 vim9script
37 def GetFlag(): bool
Bram Moolenaar30fd8202020-09-26 15:09:30 +020038 var flag: bool = 1
Bram Moolenaar971caf52020-09-21 22:21:42 +020039 return flag
40 enddef
Bram Moolenaar30fd8202020-09-26 15:09:30 +020041 var flag: bool = GetFlag()
Bram Moolenaar971caf52020-09-21 22:21:42 +020042 assert_equal(true, flag)
43 flag = 0
44 assert_equal(false, flag)
45 flag = 1
46 assert_equal(true, flag)
Bram Moolenaar2bb26582020-10-03 22:52:39 +020047 flag = 1 || true
Bram Moolenaar971caf52020-09-21 22:21:42 +020048 assert_equal(true, flag)
Bram Moolenaar2bb26582020-10-03 22:52:39 +020049 flag = 1 && false
Bram Moolenaar971caf52020-09-21 22:21:42 +020050 assert_equal(false, flag)
Bram Moolenaardd1f4262020-12-31 17:41:01 +010051
52 var cp: bool = &cp
53 var fen: bool = &l:fen
Bram Moolenaar971caf52020-09-21 22:21:42 +020054 END
Bram Moolenaar62aec932022-01-29 21:45:34 +000055 v9.CheckScriptSuccess(lines)
56 v9.CheckDefAndScriptFailure(['var x: bool = 2'], 'E1012:')
57 v9.CheckDefAndScriptFailure(['var x: bool = -1'], 'E1012:')
58 v9.CheckDefAndScriptFailure(['var x: bool = [1]'], 'E1012:')
59 v9.CheckDefAndScriptFailure(['var x: bool = {}'], 'E1012:')
60 v9.CheckDefAndScriptFailure(['var x: bool = "x"'], 'E1012:')
Bram Moolenaar9a562c12021-01-23 13:39:14 +010061
Bram Moolenaar62aec932022-01-29 21:45:34 +000062 v9.CheckDefAndScriptFailure(['var x: bool = "x"', '', 'eval 0'], 'E1012:', 1)
Bram Moolenaar971caf52020-09-21 22:21:42 +020063enddef
64
65def Test_syntax()
Bram Moolenaar98309382020-09-27 21:58:45 +020066 var name = 234
Bram Moolenaar30fd8202020-09-26 15:09:30 +020067 var other: list<string> = ['asdf']
Bram Moolenaar971caf52020-09-21 22:21:42 +020068enddef
69
70def Test_assignment()
Bram Moolenaar62aec932022-01-29 21:45:34 +000071 v9.CheckDefFailure(['var x:string'], 'E1069:')
72 v9.CheckDefFailure(['var x:string = "x"'], 'E1069:')
73 v9.CheckDefFailure(['var a:string = "x"'], 'E1069:')
74 v9.CheckDefFailure(['var lambda = () => "lambda"'], 'E704:')
75 v9.CheckScriptFailure(['var x = "x"'], 'E1124:')
Bram Moolenaar971caf52020-09-21 22:21:42 +020076
Bram Moolenaar3f327882021-03-17 20:56:38 +010077 # lower case name is OK for a list
78 var lambdaLines =<< trim END
Bram Moolenaar848fadd2022-01-30 15:28:30 +000079 var lambdaList: list<func> = [g:Test_syntax]
Bram Moolenaar3f327882021-03-17 20:56:38 +010080 lambdaList[0] = () => "lambda"
81 END
Bram Moolenaar62aec932022-01-29 21:45:34 +000082 v9.CheckDefAndScriptSuccess(lambdaLines)
Bram Moolenaar3f327882021-03-17 20:56:38 +010083
Bram Moolenaar30fd8202020-09-26 15:09:30 +020084 var nr: number = 1234
Bram Moolenaar62aec932022-01-29 21:45:34 +000085 v9.CheckDefFailure(['var nr: number = "asdf"'], 'E1012:')
Bram Moolenaar971caf52020-09-21 22:21:42 +020086
Bram Moolenaar30fd8202020-09-26 15:09:30 +020087 var a: number = 6 #comment
Bram Moolenaar971caf52020-09-21 22:21:42 +020088 assert_equal(6, a)
89
90 if has('channel')
Bram Moolenaar30fd8202020-09-26 15:09:30 +020091 var chan1: channel
Bram Moolenaar218450a2020-10-17 18:51:52 +020092 assert_equal('fail', ch_status(chan1))
93
Bram Moolenaar30fd8202020-09-26 15:09:30 +020094 var job1: job
Bram Moolenaar218450a2020-10-17 18:51:52 +020095 assert_equal('fail', job_status(job1))
96
Bram Moolenaarfc8aa6d2020-10-12 20:31:26 +020097 # calling job_start() is in test_vim9_fails.vim, it causes leak reports
Bram Moolenaar971caf52020-09-21 22:21:42 +020098 endif
99 if has('float')
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200100 var float1: float = 3.4
Bram Moolenaar971caf52020-09-21 22:21:42 +0200101 endif
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200102 var Funky1: func
103 var Funky2: func = function('len')
104 var Party2: func = funcref('g:Test_syntax')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200105
106 g:newvar = 'new' #comment
107 assert_equal('new', g:newvar)
108
109 assert_equal('yes', g:existing)
110 g:existing = 'no'
111 assert_equal('no', g:existing)
112
113 v:char = 'abc'
114 assert_equal('abc', v:char)
115
116 $ENVVAR = 'foobar'
117 assert_equal('foobar', $ENVVAR)
118 $ENVVAR = ''
119
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200120 var lines =<< trim END
Bram Moolenaar971caf52020-09-21 22:21:42 +0200121 vim9script
122 $ENVVAR = 'barfoo'
123 assert_equal('barfoo', $ENVVAR)
124 $ENVVAR = ''
125 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000126 v9.CheckScriptSuccess(lines)
Bram Moolenaar971caf52020-09-21 22:21:42 +0200127
Bram Moolenaara749a422022-02-12 19:52:25 +0000128 appendToMe ..= 'yyy'
129 assert_equal('xxxyyy', appendToMe)
130 addToMe += 222
131 assert_equal(333, addToMe)
132 newVar = 'new'
133 assert_equal('new', newVar)
Bram Moolenaar971caf52020-09-21 22:21:42 +0200134
135 set ts=7
Bram Moolenaardd1f4262020-12-31 17:41:01 +0100136 var ts: number = &ts
137 assert_equal(7, ts)
Bram Moolenaar971caf52020-09-21 22:21:42 +0200138 &ts += 1
139 assert_equal(8, &ts)
140 &ts -= 3
141 assert_equal(5, &ts)
142 &ts *= 2
143 assert_equal(10, &ts)
144 &ts /= 3
145 assert_equal(3, &ts)
146 set ts=10
147 &ts %= 4
148 assert_equal(2, &ts)
149
150 if has('float')
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200151 var f100: float = 100.0
Bram Moolenaar971caf52020-09-21 22:21:42 +0200152 f100 /= 5
153 assert_equal(20.0, f100)
154
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200155 var f200: float = 200.0
Bram Moolenaar971caf52020-09-21 22:21:42 +0200156 f200 /= 5.0
157 assert_equal(40.0, f200)
158
Bram Moolenaar62aec932022-01-29 21:45:34 +0000159 v9.CheckDefFailure(['var nr: number = 200', 'nr /= 5.0'], 'E1012:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200160 endif
161
162 lines =<< trim END
163 &ts = 6
164 &ts += 3
165 assert_equal(9, &ts)
166
167 &l:ts = 6
168 assert_equal(6, &ts)
169 &l:ts += 2
170 assert_equal(8, &ts)
171
172 &g:ts = 6
173 assert_equal(6, &g:ts)
174 &g:ts += 2
175 assert_equal(8, &g:ts)
Bram Moolenaar0ea04402021-01-04 13:37:54 +0100176
177 &number = true
178 assert_equal(true, &number)
179 &number = 0
180 assert_equal(false, &number)
181 &number = 1
182 assert_equal(true, &number)
183 &number = false
184 assert_equal(false, &number)
Bram Moolenaar971caf52020-09-21 22:21:42 +0200185 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000186 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar971caf52020-09-21 22:21:42 +0200187
Bram Moolenaar62aec932022-01-29 21:45:34 +0000188 v9.CheckDefFailure(['&notex += 3'], 'E113:')
189 v9.CheckDefFailure(['&ts ..= "xxx"'], 'E1019:')
190 v9.CheckDefFailure(['&ts = [7]'], 'E1012:')
191 v9.CheckDefExecFailure(['&ts = g:alist'], 'E1012: Type mismatch; expected number but got list<number>')
192 v9.CheckDefFailure(['&ts = "xx"'], 'E1012:')
193 v9.CheckDefExecFailure(['&ts = g:astring'], 'E1012: Type mismatch; expected number but got string')
194 v9.CheckDefFailure(['&path += 3'], 'E1012:')
195 v9.CheckDefExecFailure(['&bs = "asdf"'], 'E474:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200196 # test freeing ISN_STOREOPT
Bram Moolenaar62aec932022-01-29 21:45:34 +0000197 v9.CheckDefFailure(['&ts = 3', 'var asdf'], 'E1022:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200198 &ts = 8
199
200 lines =<< trim END
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200201 var save_TI = &t_TI
Bram Moolenaar971caf52020-09-21 22:21:42 +0200202 &t_TI = ''
203 assert_equal('', &t_TI)
204 &t_TI = 'xxx'
205 assert_equal('xxx', &t_TI)
206 &t_TI = save_TI
207 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000208 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar971caf52020-09-21 22:21:42 +0200209
Bram Moolenaar62aec932022-01-29 21:45:34 +0000210 v9.CheckDefFailure(['&t_TI = 123'], 'E1012:')
211 v9.CheckScriptFailure(['vim9script', '&t_TI = 123'], 'E928:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200212
Bram Moolenaar62aec932022-01-29 21:45:34 +0000213 v9.CheckDefFailure(['var s:var = 123'], 'E1101:')
214 v9.CheckDefFailure(['var s:var: number'], 'E1101:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200215
216 lines =<< trim END
217 vim9script
218 def SomeFunc()
219 s:var = 123
220 enddef
221 defcompile
222 END
Bram Moolenaarafa048f2022-02-22 20:43:36 +0000223 v9.CheckScriptFailure(lines, 'E1268:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200224
225 g:inc_counter += 1
226 assert_equal(2, g:inc_counter)
227
Bram Moolenaar7bf9a072021-08-02 21:55:15 +0200228 if has('float')
229 var f: float
230 f += 1
231 assert_equal(1.0, f)
232 endif
233
Bram Moolenaar971caf52020-09-21 22:21:42 +0200234 $SOME_ENV_VAR ..= 'more'
235 assert_equal('somemore', $SOME_ENV_VAR)
Bram Moolenaar62aec932022-01-29 21:45:34 +0000236 v9.CheckDefFailure(['$SOME_ENV_VAR += "more"'], 'E1051:')
237 v9.CheckDefFailure(['$SOME_ENV_VAR += 123'], 'E1012:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200238
Bram Moolenaar971caf52020-09-21 22:21:42 +0200239 v:errmsg = 'none'
240 v:errmsg ..= 'again'
241 assert_equal('noneagain', v:errmsg)
Bram Moolenaar62aec932022-01-29 21:45:34 +0000242 v9.CheckDefFailure(['v:errmsg += "more"'], 'E1051:')
243 v9.CheckDefFailure(['v:errmsg += 123'], 'E1012:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200244
Bram Moolenaarfc8aa6d2020-10-12 20:31:26 +0200245 var text =<< trim END
246 some text
247 END
Bram Moolenaar971caf52020-09-21 22:21:42 +0200248enddef
249
Bram Moolenaaraf647e72021-08-05 19:01:17 +0200250def Test_float_and_number()
251 if !has('float')
252 MissingFeature float
253 else
254 var lines =<< trim END
255 var f: float
256 f += 2
257 f -= 1
258 assert_equal(1.0, f)
259 ++f
260 --f
261 assert_equal(1.0, f)
262 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000263 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaaraf647e72021-08-05 19:01:17 +0200264 endif
265enddef
266
Bram Moolenaarf5d52c92021-07-31 22:51:10 +0200267let g:someNumber = 43
268
269def Test_assign_concat()
270 var lines =<< trim END
271 var s = '-'
272 s ..= 99
273 s ..= true
274 s ..= '-'
275 s ..= v:null
276 s ..= g:someNumber
277 assert_equal('-99true-null43', s)
278 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000279 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarf5d52c92021-07-31 22:51:10 +0200280
281 lines =<< trim END
282 var s = '-'
283 s ..= [1, 2]
284 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000285 v9.CheckDefAndScriptFailure(lines, ['E1105: Cannot convert list to string', 'E734: Wrong variable type for .='], 2)
Bram Moolenaarf5d52c92021-07-31 22:51:10 +0200286 lines =<< trim END
287 var s = '-'
288 s ..= {a: 2}
289 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000290 v9.CheckDefAndScriptFailure(lines, ['E1105: Cannot convert dict to string', 'E734: Wrong variable type for .='], 2)
Bram Moolenaar22ebd172022-04-01 15:26:58 +0100291
292 lines =<< trim END
293 var ls: list<string> = []
294 ls[-1] ..= 'foo'
295 END
296 v9.CheckDefExecAndScriptFailure(lines, 'E684: list index out of range: -1', 2)
Bram Moolenaarf5d52c92021-07-31 22:51:10 +0200297enddef
298
Bram Moolenaar13e45d12021-06-26 13:28:35 +0200299def Test_assign_register()
300 var lines =<< trim END
301 @c = 'areg'
302 @c ..= 'add'
303 assert_equal('aregadd', @c)
304
305 @@ = 'some text'
306 assert_equal('some text', getreg('"'))
307 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000308 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar13e45d12021-06-26 13:28:35 +0200309
Bram Moolenaar62aec932022-01-29 21:45:34 +0000310 v9.CheckDefFailure(['@a += "more"'], 'E1051:')
311 v9.CheckDefFailure(['@a += 123'], 'E1012:')
Bram Moolenaar13e45d12021-06-26 13:28:35 +0200312enddef
313
Bram Moolenaard0edaf92021-05-28 21:06:08 +0200314def Test_reserved_name()
Bram Moolenaar8acb9cc2022-03-08 13:18:55 +0000315 var more_names = ['null_job', 'null_channel']
316 if !has('job')
317 more_names = []
318 endif
319
320 for name in ['true',
321 'false',
322 'null',
323 'null_blob',
324 'null_dict',
325 'null_function',
326 'null_list',
327 'null_partial',
328 'null_string',
329 ] + more_names
Bram Moolenaar62aec932022-01-29 21:45:34 +0000330 v9.CheckDefExecAndScriptFailure(['var ' .. name .. ' = 0'], 'E1034:')
331 v9.CheckDefExecAndScriptFailure(['var ' .. name .. ': bool'], 'E1034:')
Bram Moolenaard0edaf92021-05-28 21:06:08 +0200332 endfor
333enddef
334
Bram Moolenaar8acb9cc2022-03-08 13:18:55 +0000335def Test_null_values()
336 var lines =<< trim END
337 var b: blob = null_blob
338 var dn: dict<number> = null_dict
339 var ds: dict<string> = null_dict
340 var ln: list<number> = null_list
341 var ls: list<string> = null_list
342 var Ff: func(string): string = null_function
343 var Fp: func(number): number = null_partial
344 var s: string = null_string
345 if has('job')
346 var j: job = null_job
347 var c: channel = null_channel
348 endif
Bram Moolenaar56b84b12022-03-09 19:46:48 +0000349
350 var d: dict<func> = {a: function('tr'), b: null_function}
Bram Moolenaarbadf04f2022-03-12 21:28:22 +0000351
352 var bl: list<blob> = [0z12, null_blob]
353 var dnl: list<dict<number>> = [{a: 1}, null_dict]
354 var dsl: list<dict<string>> = [{a: 'x'}, null_dict]
355 var lnl: list<list<number>> = [[1], null_list]
356 var lsl: list<list<string>> = [['x'], null_list]
357 def Len(v: string): number
358 return len(v)
359 enddef
360 var Ffl: list<func(string): number> = [Len, null_function]
361 var Fpl: list<func(string): number> = [Len, null_partial]
362 var sl: list<string> = ['x', null_string]
363 if has('job')
364 var jl: list<job> = [null_job]
365 var cl: list<channel> = [null_channel]
366 endif
Bram Moolenaar8acb9cc2022-03-08 13:18:55 +0000367 END
368 v9.CheckDefAndScriptSuccess(lines)
369enddef
370
Bram Moolenaar56b84b12022-03-09 19:46:48 +0000371def Test_keep_type_after_assigning_null()
372 var lines =<< trim END
373 var b: blob
374 b = null_blob
375 b = 'text'
376 END
377 v9.CheckDefExecAndScriptFailure(lines, 'E1012: Type mismatch; expected blob but got string')
378
379 lines =<< trim END
380 var l: list<number>
381 l = null_list
382 l = ['text']
383 END
384 v9.CheckDefExecAndScriptFailure(lines, 'E1012: Type mismatch; expected list<number> but got list<string>')
385
386 lines =<< trim END
387 var d: dict<string>
388 d = null_dict
389 d = {a: 1, b: 2}
390 END
391 v9.CheckDefExecAndScriptFailure(lines, 'E1012: Type mismatch; expected dict<string> but got dict<number>')
392enddef
393
Bram Moolenaaraa1959b2021-04-15 22:13:39 +0200394def Test_skipped_assignment()
395 var lines =<< trim END
396 for x in []
397 var i: number = 1
398 while false
399 i += 1
400 endwhile
401 endfor
402 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000403 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaaraa1959b2021-04-15 22:13:39 +0200404enddef
405
Bram Moolenaar7824fc82021-11-26 17:36:51 +0000406def Test_assign_keep_type()
407 var lines =<< trim END
408 vim9script
409 var l: list<number> = [123]
410 l = [123]
411 l->add('string')
412 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000413 v9.CheckScriptFailure(lines, 'E1012:', 4)
Bram Moolenaar7824fc82021-11-26 17:36:51 +0000414enddef
415
Bram Moolenaar8ff16e02020-12-07 21:49:52 +0100416def Test_assign_unpack()
417 var lines =<< trim END
418 var v1: number
419 var v2: number
420 [v1, v2] = [1, 2]
421 assert_equal(1, v1)
422 assert_equal(2, v2)
Bram Moolenaarf93bbd02021-04-10 22:35:43 +0200423
424 [v1, _, v2, _] = [1, 99, 2, 77]
425 assert_equal(1, v1)
426 assert_equal(2, v2)
427
428 [v1, v2; _] = [1, 2, 3, 4, 5]
429 assert_equal(1, v1)
430 assert_equal(2, v2)
Bram Moolenaar035bd1c2021-06-21 19:44:11 +0200431
Bram Moolenaarbc510062022-02-14 21:19:04 +0000432 var _x: number
433 [_x, v2] = [6, 7]
434 assert_equal(6, _x)
435 assert_equal(7, v2)
436
Bram Moolenaar4d5dfe22021-06-26 13:59:29 +0200437 var reslist = []
438 for text in ['aaa {bbb} ccc', 'ddd {eee} fff']
439 var before: string
440 var middle: string
441 var after: string
442 [_, before, middle, after; _] = text->matchlist('\(.\{-\}\){\(.\{-\}\)}\(.*\)')
443 reslist->add(before)->add(middle)->add(after)
444 endfor
445 assert_equal(['aaa ', 'bbb', ' ccc', 'ddd ', 'eee', ' fff'], reslist)
446
Bram Moolenaar035bd1c2021-06-21 19:44:11 +0200447 var a = 1
448 var b = 3
449 [a, b] += [2, 4]
450 assert_equal(3, a)
451 assert_equal(7, b)
452
453 [a, b] -= [1, 2]
454 assert_equal(2, a)
455 assert_equal(5, b)
456
457 [a, b] *= [3, 2]
458 assert_equal(6, a)
459 assert_equal(10, b)
460
461 [a, b] /= [2, 4]
462 assert_equal(3, a)
463 assert_equal(2, b)
464
465 [a, b] = [17, 15]
466 [a, b] %= [5, 3]
467 assert_equal(2, a)
468 assert_equal(0, b)
Bram Moolenaar8ff16e02020-12-07 21:49:52 +0100469 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000470 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8ff16e02020-12-07 21:49:52 +0100471
472 lines =<< trim END
473 var v1: number
474 var v2: number
Bram Moolenaardb9ff9a2021-12-01 17:38:01 +0000475 [v1, v2] = [1, 2, 3]
476 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000477 v9.CheckDefFailure(lines, 'E1093: Expected 2 items but got 3', 3)
Bram Moolenaardb9ff9a2021-12-01 17:38:01 +0000478
479 lines =<< trim END
480 var v1: number
481 var v2: number
482 [v1, v2] = [1]
483 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000484 v9.CheckDefFailure(lines, 'E1093: Expected 2 items but got 1', 3)
Bram Moolenaardb9ff9a2021-12-01 17:38:01 +0000485
486 lines =<< trim END
487 var v1: number
488 var v2: number
489 [v1, v2; _] = [1]
490 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000491 v9.CheckDefFailure(lines, 'E1093: Expected 2 items but got 1', 3)
Bram Moolenaardb9ff9a2021-12-01 17:38:01 +0000492
493 lines =<< trim END
494 var v1: number
495 var v2: number
Bram Moolenaar8ff16e02020-12-07 21:49:52 +0100496 [v1, v2] =
497 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000498 v9.CheckDefFailure(lines, 'E1097:', 5)
Bram Moolenaar8ff16e02020-12-07 21:49:52 +0100499
500 lines =<< trim END
501 var v1: number
502 var v2: number
503 [v1, v2] = xxx
504 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000505 v9.CheckDefFailure(lines, 'E1001:', 3)
Bram Moolenaar8ff16e02020-12-07 21:49:52 +0100506
507 lines =<< trim END
508 var v1: number
509 var v2: number
510 [v1, v2] = popup_clear()
511 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000512 v9.CheckDefFailure(lines, 'E1031:', 3)
Bram Moolenaar8ff16e02020-12-07 21:49:52 +0100513
514 lines =<< trim END
Bram Moolenaar3862ea32021-01-01 21:05:55 +0100515 [v1, v2] = [1, 2]
516 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000517 v9.CheckDefFailure(lines, 'E1089', 1)
518 v9.CheckScriptFailure(['vim9script'] + lines, 'E1089', 2)
Bram Moolenaar3862ea32021-01-01 21:05:55 +0100519
520 lines =<< trim END
Bram Moolenaar8ff16e02020-12-07 21:49:52 +0100521 var v1: number
522 var v2: number
523 [v1, v2] = ''
524 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000525 v9.CheckDefFailure(lines, 'E1012: Type mismatch; expected list<any> but got string', 3)
Bram Moolenaarf785aa12021-02-11 21:19:34 +0100526
527 lines =<< trim END
528 g:values = [false, 0]
529 var x: bool
530 var y: string
531 [x, y] = g:values
532 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000533 v9.CheckDefExecAndScriptFailure(lines, 'E1163: Variable 2: type mismatch, expected string but got number')
Bram Moolenaar4270d8b2021-08-07 16:30:42 +0200534
535 lines =<< trim END
536 var x: number
537 var y: number
538 var z: string
539 [x, y, z] = [1, 2, 3]
540 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000541 v9.CheckDefAndScriptFailure(lines, 'E1163: Variable 3: type mismatch, expected string but got number')
Bram Moolenaar4270d8b2021-08-07 16:30:42 +0200542
543 lines =<< trim END
544 var x: number
545 var y: string
546 var z: string
547 [x, y, z] = [1, '2', 3]
548 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000549 v9.CheckDefExecAndScriptFailure(lines, 'E1163: Variable 3: type mismatch, expected string but got number')
Bram Moolenaar8ff16e02020-12-07 21:49:52 +0100550enddef
551
Bram Moolenaar7f764942020-12-02 15:11:18 +0100552def Test_assign_linebreak()
553 var nr: number
554 nr =
555 123
556 assert_equal(123, nr)
557
558 var n2: number
559 [nr, n2] =
560 [12, 34]
561 assert_equal(12, nr)
562 assert_equal(34, n2)
563
Bram Moolenaar62aec932022-01-29 21:45:34 +0000564 v9.CheckDefFailure(["var x = #"], 'E1097:', 3)
Bram Moolenaar77709b12021-04-03 21:01:01 +0200565
566 var lines =<< trim END
567 var x: list<string> = ['a']
568 var y: list<number> = x
569 ->copy()
570 ->copy()
571 END
Bram Moolenaar381692b2022-02-02 20:01:27 +0000572 v9.CheckDefExecFailure(lines, 'E1012:', 4)
Bram Moolenaar6977dba2021-07-04 22:48:12 +0200573
574 lines =<< trim END
575 var x: any
576 x.key = 1
577 + 2
578 + 3
579 + 4
580 + 5
581 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000582 v9.CheckDefExecAndScriptFailure(lines, ['E1148:', 'E1203:'], 2)
Bram Moolenaar7f764942020-12-02 15:11:18 +0100583enddef
584
Bram Moolenaardc234ca2020-11-28 18:52:33 +0100585def Test_assign_index()
586 # list of list
587 var l1: list<number>
588 l1[0] = 123
589 assert_equal([123], l1)
590
591 var l2: list<list<number>>
592 l2[0] = []
593 l2[0][0] = 123
594 assert_equal([[123]], l2)
595
596 var l3: list<list<list<number>>>
597 l3[0] = []
598 l3[0][0] = []
599 l3[0][0][0] = 123
600 assert_equal([[[123]]], l3)
601
602 var lines =<< trim END
603 var l3: list<list<number>>
604 l3[0] = []
605 l3[0][0] = []
606 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000607 v9.CheckDefFailure(lines, 'E1012: Type mismatch; expected number but got list<unknown>', 3)
Bram Moolenaardc234ca2020-11-28 18:52:33 +0100608
609 # dict of dict
610 var d1: dict<number>
611 d1.one = 1
612 assert_equal({one: 1}, d1)
613
614 var d2: dict<dict<number>>
615 d2.one = {}
616 d2.one.two = 123
617 assert_equal({one: {two: 123}}, d2)
618
619 var d3: dict<dict<dict<number>>>
620 d3.one = {}
621 d3.one.two = {}
622 d3.one.two.three = 123
623 assert_equal({one: {two: {three: 123}}}, d3)
624
Bram Moolenaare08be092022-02-17 13:08:26 +0000625 # blob
626 var bl: blob = 0z11223344
627 bl[0] = 0x77
628 assert_equal(0z77223344, bl)
629 bl[-2] = 0x66
630 assert_equal(0z77226644, bl)
631
Bram Moolenaar1983f1a2022-02-28 20:55:02 +0000632 lines =<< trim END
633 g:val = '22'
634 var bl = 0z11
635 bl[1] = g:val
636 END
637 v9.CheckDefExecAndScriptFailure(lines, 'E1030: Using a String as a Number: "22"')
638
Bram Moolenaare97976b2021-08-01 13:17:17 +0200639 # should not read the next line when generating "a.b"
640 var a = {}
641 a.b = {}
642 a.b.c = {}
643 ->copy()
644
Bram Moolenaardc234ca2020-11-28 18:52:33 +0100645 lines =<< trim END
646 var d3: dict<dict<number>>
647 d3.one = {}
648 d3.one.two = {}
649 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000650 v9.CheckDefFailure(lines, 'E1012: Type mismatch; expected number but got dict<unknown>', 3)
Bram Moolenaardc234ca2020-11-28 18:52:33 +0100651
Bram Moolenaaracbae182020-12-13 18:44:43 +0100652 lines =<< trim END
653 var lines: list<string>
654 lines['a'] = 'asdf'
655 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000656 v9.CheckDefFailure(lines, 'E1012:', 2)
Bram Moolenaaracbae182020-12-13 18:44:43 +0100657
658 lines =<< trim END
659 var lines: string
660 lines[9] = 'asdf'
661 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000662 v9.CheckDefFailure(lines, 'E1141:', 2)
Bram Moolenaaracbae182020-12-13 18:44:43 +0100663
Bram Moolenaardc234ca2020-11-28 18:52:33 +0100664 # list of dict
665 var ld: list<dict<number>>
666 ld[0] = {}
667 ld[0].one = 123
668 assert_equal([{one: 123}], ld)
669
670 lines =<< trim END
671 var ld: list<dict<number>>
672 ld[0] = []
673 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000674 v9.CheckDefFailure(lines, 'E1012: Type mismatch; expected dict<number> but got list<unknown>', 2)
Bram Moolenaardc234ca2020-11-28 18:52:33 +0100675
676 # dict of list
677 var dl: dict<list<number>>
678 dl.one = []
679 dl.one[0] = 123
680 assert_equal({one: [123]}, dl)
681
682 lines =<< trim END
683 var dl: dict<list<number>>
684 dl.one = {}
685 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000686 v9.CheckDefFailure(lines, 'E1012: Type mismatch; expected list<number> but got dict<unknown>', 2)
Bram Moolenaare08be092022-02-17 13:08:26 +0000687
688 lines =<< trim END
689 g:l = [1, 2]
690 g:l['x'] = 3
691 END
692 v9.CheckDefExecAndScriptFailure(lines, ['E39:', 'E1030:'], 2)
693
694 lines =<< trim END
695 var bl: blob = test_null_blob()
696 bl[1] = 8
697 END
698 v9.CheckDefExecAndScriptFailure(lines, ['E1184:', 'E979:'], 2)
Bram Moolenaarea5c8982022-02-17 14:42:02 +0000699
700 lines =<< trim END
701 g:bl = 'not a blob'
702 g:bl[1 : 2] = 8
703 END
704 v9.CheckDefExecAndScriptFailure(lines, ['E897:', 'E689:'], 2)
Bram Moolenaardc234ca2020-11-28 18:52:33 +0100705enddef
706
Bram Moolenaar38ecd972022-01-15 21:44:44 +0000707def Test_init_in_for_loop()
708 var lines =<< trim END
709 var l: list<number> = []
710 for i in [3, 4]
711 var n: number
712 add(l, n)
713 n = 123
714 endfor
715 assert_equal([0, 0], l)
716 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000717 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar38ecd972022-01-15 21:44:44 +0000718
719 lines =<< trim END
720 var l: list<number> = []
721 for i in [3, 4]
722 var n: number = 0
723 add(l, n)
724 n = 123
725 endfor
726 assert_equal([0, 0], l)
727 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000728 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar38ecd972022-01-15 21:44:44 +0000729
730 lines =<< trim END
731 var l: list<number> = []
732 for i in [3, 4]
733 var n: number = 3
734 add(l, n)
735 n = 123
736 endfor
737 assert_equal([3, 3], l)
738 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000739 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar38ecd972022-01-15 21:44:44 +0000740enddef
741
Bram Moolenaar81ed4962020-09-23 15:56:50 +0200742def Test_extend_list()
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200743 var lines =<< trim END
Bram Moolenaar07802042021-09-09 23:01:14 +0200744 var l1: list<number>
745 var l2 = l1
746 assert_true(l1 is l2)
747 l1 += [123]
748 assert_equal([123], l1)
749 assert_true(l1 is l2)
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100750 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000751 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar81ed4962020-09-23 15:56:50 +0200752
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100753 lines =<< trim END
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100754 var list: list<string>
755 extend(list, ['x'])
756 assert_equal(['x'], list)
Bram Moolenaar81ed4962020-09-23 15:56:50 +0200757 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000758 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar1a739232020-10-10 15:37:58 +0200759
760 # appending to NULL list from a function
761 lines =<< trim END
762 vim9script
763 var list: list<string>
764 def Func()
765 list += ['a', 'b']
766 enddef
767 Func()
768 assert_equal(['a', 'b'], list)
769 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000770 v9.CheckScriptSuccess(lines)
Bram Moolenaar3beaf9c2020-12-18 17:23:14 +0100771 lines =<< trim END
772 vim9script
773 var list: list<string>
774 def Func()
775 extend(list, ['x', 'b'])
776 enddef
777 Func()
778 assert_equal(['x', 'b'], list)
779 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000780 v9.CheckScriptSuccess(lines)
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100781
782 lines =<< trim END
783 vim9script
784 var l: list<string> = test_null_list()
785 extend(l, ['x'])
786 assert_equal(['x'], l)
787 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000788 v9.CheckScriptSuccess(lines)
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100789
790 lines =<< trim END
791 vim9script
792 extend(test_null_list(), ['x'])
793 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000794 v9.CheckScriptFailure(lines, 'E1134:', 2)
Bram Moolenaar078a4612022-01-04 15:17:03 +0000795
796 # using global var has no declared type
797 g:myList = []
798 g:myList->extend([1])
799 g:myList->extend(['x'])
800 assert_equal([1, 'x'], g:myList)
801 unlet g:myList
802
803 # using declared list gives an error
804 lines =<< trim END
805 var l: list<number>
806 g:myList = l
807 g:myList->extend([1])
808 g:myList->extend(['x'])
809 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000810 v9.CheckDefExecAndScriptFailure(lines, 'E1013: Argument 2: type mismatch, expected list<number> but got list<string>', 4)
Bram Moolenaar078a4612022-01-04 15:17:03 +0000811 unlet g:myList
Bram Moolenaar160afdb2022-02-06 17:17:02 +0000812
813 lines =<< trim END
814 vim9script
815 var lds = [1, 2, 3]
816 def Func()
817 echo lds->extend(['x'])
818 enddef
819 defcompile
820 END
821 v9.CheckScriptFailure(lines, 'E1013:')
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100822enddef
823
824def Test_extend_dict()
825 var lines =<< trim END
826 vim9script
827 var d: dict<number>
Bram Moolenaare0de1712020-12-02 17:36:54 +0100828 extend(d, {a: 1})
829 assert_equal({a: 1}, d)
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100830
831 var d2: dict<number>
832 d2['one'] = 1
Bram Moolenaare0de1712020-12-02 17:36:54 +0100833 assert_equal({one: 1}, d2)
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100834 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000835 v9.CheckScriptSuccess(lines)
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100836
837 lines =<< trim END
838 vim9script
839 var d: dict<string> = test_null_dict()
Bram Moolenaare0de1712020-12-02 17:36:54 +0100840 extend(d, {a: 'x'})
841 assert_equal({a: 'x'}, d)
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100842 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000843 v9.CheckScriptSuccess(lines)
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100844
845 lines =<< trim END
846 vim9script
Bram Moolenaare0de1712020-12-02 17:36:54 +0100847 extend(test_null_dict(), {a: 'x'})
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100848 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000849 v9.CheckScriptFailure(lines, 'E1133:', 2)
Bram Moolenaar81ed4962020-09-23 15:56:50 +0200850enddef
851
Bram Moolenaar971caf52020-09-21 22:21:42 +0200852def Test_single_letter_vars()
853 # single letter variables
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200854 var a: number = 123
Bram Moolenaar971caf52020-09-21 22:21:42 +0200855 a = 123
856 assert_equal(123, a)
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200857 var b: number
Bram Moolenaar971caf52020-09-21 22:21:42 +0200858 b = 123
859 assert_equal(123, b)
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200860 var g: number
Bram Moolenaar971caf52020-09-21 22:21:42 +0200861 g = 123
862 assert_equal(123, g)
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200863 var s: number
Bram Moolenaar971caf52020-09-21 22:21:42 +0200864 s = 123
865 assert_equal(123, s)
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200866 var t: number
Bram Moolenaar971caf52020-09-21 22:21:42 +0200867 t = 123
868 assert_equal(123, t)
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200869 var v: number
Bram Moolenaar971caf52020-09-21 22:21:42 +0200870 v = 123
871 assert_equal(123, v)
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200872 var w: number
Bram Moolenaar971caf52020-09-21 22:21:42 +0200873 w = 123
874 assert_equal(123, w)
875enddef
876
877def Test_vim9_single_char_vars()
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200878 var lines =<< trim END
Bram Moolenaar971caf52020-09-21 22:21:42 +0200879 vim9script
880
881 # single character variable declarations work
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200882 var a: string
883 var b: number
884 var l: list<any>
885 var s: string
886 var t: number
887 var v: number
888 var w: number
Bram Moolenaar971caf52020-09-21 22:21:42 +0200889
890 # script-local variables can be used without s: prefix
891 a = 'script-a'
892 b = 111
893 l = [1, 2, 3]
894 s = 'script-s'
895 t = 222
896 v = 333
897 w = 444
898
899 assert_equal('script-a', a)
900 assert_equal(111, b)
901 assert_equal([1, 2, 3], l)
902 assert_equal('script-s', s)
903 assert_equal(222, t)
904 assert_equal(333, v)
905 assert_equal(444, w)
906 END
907 writefile(lines, 'Xsinglechar')
908 source Xsinglechar
909 delete('Xsinglechar')
910enddef
911
912def Test_assignment_list()
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200913 var list1: list<bool> = [false, true, false]
914 var list2: list<number> = [1, 2, 3]
915 var list3: list<string> = ['sdf', 'asdf']
916 var list4: list<any> = ['yes', true, 1234]
917 var list5: list<blob> = [0z01, 0z02]
Bram Moolenaar971caf52020-09-21 22:21:42 +0200918
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200919 var listS: list<string> = []
920 var listN: list<number> = []
Bram Moolenaar971caf52020-09-21 22:21:42 +0200921
922 assert_equal([1, 2, 3], list2)
923 list2[-1] = 99
924 assert_equal([1, 2, 99], list2)
925 list2[-2] = 88
926 assert_equal([1, 88, 99], list2)
927 list2[-3] = 77
928 assert_equal([77, 88, 99], list2)
929 list2 += [100]
930 assert_equal([77, 88, 99, 100], list2)
931
932 list3 += ['end']
933 assert_equal(['sdf', 'asdf', 'end'], list3)
934
Bram Moolenaar62aec932022-01-29 21:45:34 +0000935 v9.CheckDefExecFailure(['var ll = [1, 2, 3]', 'll[-4] = 6'], 'E684:')
Bram Moolenaar6296d1e2022-02-17 16:30:11 +0000936 v9.CheckDefExecFailure(['var ll = [1, 2, 3]', 'unlet ll[8 : 9]'], 'E684:')
937 v9.CheckDefExecFailure(['var ll = [1, 2, 3]', 'unlet ll[1 : -9]'], 'E684:')
938 v9.CheckDefExecFailure(['var ll = [1, 2, 3]', 'unlet ll[2 : 1]'], 'E684:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200939
940 # type becomes list<any>
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200941 var somelist = rand() > 0 ? [1, 2, 3] : ['a', 'b', 'c']
Bram Moolenaar4f5e3972020-12-21 17:30:50 +0100942
Bram Moolenaar114dbda2022-01-03 12:28:03 +0000943 # type is list<any> even though initializer is list<number>
944 var anyList: list<any> = [0]
945 assert_equal([0, 'x'], extend(anyList, ['x']))
946
Bram Moolenaar4f5e3972020-12-21 17:30:50 +0100947 var lines =<< trim END
948 var d = {dd: test_null_list()}
949 d.dd[0] = 0
950 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000951 v9.CheckDefExecFailure(lines, 'E1147:', 2)
Bram Moolenaar7a40ff02021-07-04 15:54:08 +0200952
953 lines =<< trim END
954 def OneArg(x: bool)
955 enddef
956 def TwoArgs(x: bool, y: bool)
957 enddef
958 var fl: list<func(bool, bool, bool)> = [OneArg, TwoArgs]
959 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000960 v9.CheckDefExecAndScriptFailure(lines, 'E1012:', 5)
Bram Moolenaar971caf52020-09-21 22:21:42 +0200961enddef
962
Bram Moolenaarab36e6a2021-11-30 16:14:49 +0000963def Test_list_declaration()
964 var [v1, v2] = [1, 2]
965 v1 += 3
966 assert_equal(4, v1)
967 v2 *= 3
968 assert_equal(6, v2)
969
970 var lines =<< trim END
971 var [v1, v2] = [1]
972 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000973 v9.CheckDefExecAndScriptFailure(lines, ['E1093: Expected 2 items but got 1', 'E688:'])
Bram Moolenaarab36e6a2021-11-30 16:14:49 +0000974 lines =<< trim END
975 var testlist = [1]
976 var [v1, v2] = testlist
977 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000978 v9.CheckDefExecAndScriptFailure(lines, ['E1093: Expected 2 items but got 1', 'E688:'])
Bram Moolenaarab36e6a2021-11-30 16:14:49 +0000979 lines =<< trim END
980 var [v1, v2] = [1, 2, 3]
981 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000982 v9.CheckDefExecAndScriptFailure(lines, ['E1093: Expected 2 items but got 3', 'E687:'])
Bram Moolenaarab36e6a2021-11-30 16:14:49 +0000983 lines =<< trim END
984 var testlist = [1, 2, 3]
985 var [v1, v2] = testlist
986 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000987 v9.CheckDefExecAndScriptFailure(lines, ['E1093: Expected 2 items but got 3', 'E687:'])
Bram Moolenaarab36e6a2021-11-30 16:14:49 +0000988
989 var [vnr, vstr] = [123, 'text']
990 vnr += 3
991 assert_equal(126, vnr)
992 vstr ..= 'end'
993 assert_equal('textend', vstr)
994
995 var [vnr2: number, vstr2: string] = [123, 'text']
996 vnr2 += 3
997 assert_equal(126, vnr2)
998 vstr2 ..= 'end'
999 assert_equal('textend', vstr2)
1000
1001 var [vnr3: number; vlist: list<string>] = [123, 'foo', 'bar']
1002 vnr3 += 5
1003 assert_equal(128, vnr3)
1004 assert_equal(['foo', 'bar'], vlist)
1005
1006 lines =<< trim END
1007 var [vnr2: number, vstr2: number] = [123, 'text']
1008 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001009 v9.CheckDefExecAndScriptFailure(lines, ['E1163: Variable 2: type mismatch, expected number but got string', 'E1012: Type mismatch; expected number but got string'])
Bram Moolenaarab36e6a2021-11-30 16:14:49 +00001010 lines =<< trim END
1011 var testlist = [234, 'text']
1012 var [vnr2: number, vstr2: number] = testlist
1013 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001014 v9.CheckDefExecAndScriptFailure(lines, ['E1163: Variable 2: type mismatch, expected number but got string', 'E1012: Type mismatch; expected number but got string'])
Bram Moolenaarab36e6a2021-11-30 16:14:49 +00001015enddef
1016
Bram Moolenaar97f227d2021-07-04 20:20:52 +02001017def PartFuncBool(b: bool): string
Bram Moolenaarb7480cd2021-07-04 18:28:15 +02001018 return 'done'
1019enddef
1020
1021def Test_assignment_partial()
Bram Moolenaar97f227d2021-07-04 20:20:52 +02001022 var lines =<< trim END
Bram Moolenaar848fadd2022-01-30 15:28:30 +00001023 var Partial: func(): string = function(g:PartFuncBool, [true])
Bram Moolenaar97f227d2021-07-04 20:20:52 +02001024 assert_equal('done', Partial())
1025 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001026 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar22f85d02021-07-04 23:29:30 +02001027
1028 lines =<< trim END
1029 vim9script
1030 def Func(b: bool)
1031 enddef
1032 var Ref: func = function(Func, [true])
1033 assert_equal('func()', typename(Ref))
1034 Ref()
1035 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001036 v9.CheckScriptSuccess(lines)
Bram Moolenaar13789bf2021-12-30 13:29:00 +00001037
1038 lines =<< trim END
1039 vim9script
1040
1041 var nres: any
1042 var sres: any
Bram Moolenaar9a015112021-12-31 14:06:45 +00001043 def Func(nr: number, s = '')
1044 nres = nr
Bram Moolenaar13789bf2021-12-30 13:29:00 +00001045 sres = s
1046 enddef
1047
1048 var n: number
1049 var Ref = function(Func, [n])
1050 Ref('x')
1051 assert_equal(0, nres)
1052 assert_equal('x', sres)
1053 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001054 v9.CheckScriptSuccess(lines)
Bram Moolenaar13789bf2021-12-30 13:29:00 +00001055
1056 lines =<< trim END
1057 vim9script
1058
Bram Moolenaar9a015112021-12-31 14:06:45 +00001059 def Func(nr: number, s = '')
Bram Moolenaar13789bf2021-12-30 13:29:00 +00001060 enddef
1061
1062 var n: number
1063 var Ref = function(Func, [n])
1064 Ref(0)
1065 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001066 v9.CheckScriptFailure(lines, 'E1013: Argument 2: type mismatch, expected string but got number')
Bram Moolenaarb7480cd2021-07-04 18:28:15 +02001067enddef
1068
Bram Moolenaarf30a14d2021-01-17 21:51:24 +01001069def Test_assignment_list_any_index()
1070 var l: list<number> = [1, 2]
1071 for [x, y, _]
1072 in [[0, 1, ''], [1, 3, '']]
1073 l[x] = l[x] + y
1074 endfor
1075 assert_equal([2, 5], l)
1076enddef
1077
Bram Moolenaar971caf52020-09-21 22:21:42 +02001078def Test_assignment_list_vim9script()
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001079 var lines =<< trim END
Bram Moolenaar971caf52020-09-21 22:21:42 +02001080 vim9script
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001081 var v1: number
1082 var v2: number
1083 var v3: number
Bram Moolenaar971caf52020-09-21 22:21:42 +02001084 [v1, v2, v3] = [1, 2, 3]
1085 assert_equal([1, 2, 3], [v1, v2, v3])
1086 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001087 v9.CheckScriptSuccess(lines)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001088enddef
1089
1090def Test_assignment_dict()
Bram Moolenaare0de1712020-12-02 17:36:54 +01001091 var dict1: dict<bool> = {one: false, two: true}
1092 var dict2: dict<number> = {one: 1, two: 2}
1093 var dict3: dict<string> = {key: 'value'}
1094 var dict4: dict<any> = {one: 1, two: '2'}
1095 var dict5: dict<blob> = {one: 0z01, two: 0z02}
Bram Moolenaar971caf52020-09-21 22:21:42 +02001096
1097 # overwrite
1098 dict3['key'] = 'another'
Bram Moolenaare0de1712020-12-02 17:36:54 +01001099 assert_equal(dict3, {key: 'another'})
Bram Moolenaarfc74d032020-11-16 22:11:49 +01001100 dict3.key = 'yet another'
Bram Moolenaare0de1712020-12-02 17:36:54 +01001101 assert_equal(dict3, {key: 'yet another'})
Bram Moolenaarfc74d032020-11-16 22:11:49 +01001102
Bram Moolenaard24602f2020-12-20 15:20:56 +01001103 # member "any" can also be a dict and assigned to
1104 var anydict: dict<any> = {nest: {}, nr: 0}
1105 anydict.nest['this'] = 123
1106 anydict.nest.that = 456
1107 assert_equal({nest: {this: 123, that: 456}, nr: 0}, anydict)
1108
Bram Moolenaarfc74d032020-11-16 22:11:49 +01001109 var lines =<< trim END
Bram Moolenaard88dc4d2020-12-20 14:49:42 +01001110 var dd = {}
1111 dd.two = 2
1112 assert_equal({two: 2}, dd)
1113 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001114 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar4f5e3972020-12-21 17:30:50 +01001115
1116 lines =<< trim END
1117 var d = {dd: {}}
1118 d.dd[0] = 2
1119 d.dd['x'] = 3
1120 d.dd.y = 4
1121 assert_equal({dd: {0: 2, x: 3, y: 4}}, d)
1122 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001123 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaard88dc4d2020-12-20 14:49:42 +01001124
1125 lines =<< trim END
Bram Moolenaar2e17fef2022-03-18 19:44:48 +00001126 var key = 'foo'
1127 g:[key] = 'value'
1128 assert_equal('value', g:foo)
1129 unlet g:foo
1130 END
1131 v9.CheckDefAndScriptSuccess(lines)
1132
1133 lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +01001134 var dd = {one: 1}
Bram Moolenaarfc74d032020-11-16 22:11:49 +01001135 dd.one) = 2
1136 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001137 v9.CheckDefFailure(lines, 'E488:', 2)
Bram Moolenaard88dc4d2020-12-20 14:49:42 +01001138
1139 lines =<< trim END
1140 var dd = {one: 1}
1141 var dd.one = 2
1142 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001143 v9.CheckDefAndScriptFailure(lines, 'E1017:', 2)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001144
1145 # empty key can be used
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001146 var dd = {}
Bram Moolenaar971caf52020-09-21 22:21:42 +02001147 dd[""] = 6
Bram Moolenaare0de1712020-12-02 17:36:54 +01001148 assert_equal({['']: 6}, dd)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001149
1150 # type becomes dict<any>
Bram Moolenaare0de1712020-12-02 17:36:54 +01001151 var somedict = rand() > 0 ? {a: 1, b: 2} : {a: 'a', b: 'b'}
Bram Moolenaar971caf52020-09-21 22:21:42 +02001152
Bram Moolenaar114dbda2022-01-03 12:28:03 +00001153 # type is dict<any> even though initializer is dict<number>
1154 var anyDict: dict<any> = {a: 0}
1155 assert_equal({a: 0, b: 'x'}, extend(anyDict, {b: 'x'}))
1156
Bram Moolenaar078a4612022-01-04 15:17:03 +00001157 # using global var, which has no declared type
1158 g:myDict = {}
1159 g:myDict->extend({a: 1})
1160 g:myDict->extend({b: 'x'})
1161 assert_equal({a: 1, b: 'x'}, g:myDict)
1162 unlet g:myDict
1163
1164 # using list with declared type gives an error
1165 lines =<< trim END
1166 var d: dict<number>
1167 g:myDict = d
1168 g:myDict->extend({a: 1})
1169 g:myDict->extend({b: 'x'})
1170 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001171 v9.CheckDefExecAndScriptFailure(lines, 'E1013: Argument 2: type mismatch, expected dict<number> but got dict<string>', 4)
Bram Moolenaar078a4612022-01-04 15:17:03 +00001172 unlet g:myDict
1173
Bram Moolenaar971caf52020-09-21 22:21:42 +02001174 # assignment to script-local dict
Bram Moolenaarfc74d032020-11-16 22:11:49 +01001175 lines =<< trim END
Bram Moolenaar971caf52020-09-21 22:21:42 +02001176 vim9script
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001177 var test: dict<any> = {}
Bram Moolenaar971caf52020-09-21 22:21:42 +02001178 def FillDict(): dict<any>
1179 test['a'] = 43
1180 return test
1181 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +01001182 assert_equal({a: 43}, FillDict())
Bram Moolenaar971caf52020-09-21 22:21:42 +02001183 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001184 v9.CheckScriptSuccess(lines)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001185
1186 lines =<< trim END
1187 vim9script
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001188 var test: dict<any>
Bram Moolenaar971caf52020-09-21 22:21:42 +02001189 def FillDict(): dict<any>
1190 test['a'] = 43
1191 return test
1192 enddef
1193 FillDict()
Bram Moolenaar3beaf9c2020-12-18 17:23:14 +01001194 assert_equal({a: 43}, test)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001195 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001196 v9.CheckScriptSuccess(lines)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001197
1198 # assignment to global dict
1199 lines =<< trim END
1200 vim9script
1201 g:test = {}
1202 def FillDict(): dict<any>
1203 g:test['a'] = 43
1204 return g:test
1205 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +01001206 assert_equal({a: 43}, FillDict())
Bram Moolenaar971caf52020-09-21 22:21:42 +02001207 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001208 v9.CheckScriptSuccess(lines)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001209
1210 # assignment to buffer dict
1211 lines =<< trim END
1212 vim9script
1213 b:test = {}
1214 def FillDict(): dict<any>
1215 b:test['a'] = 43
1216 return b:test
1217 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +01001218 assert_equal({a: 43}, FillDict())
Bram Moolenaar971caf52020-09-21 22:21:42 +02001219 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001220 v9.CheckScriptSuccess(lines)
Bram Moolenaar4f5e3972020-12-21 17:30:50 +01001221
1222 lines =<< trim END
1223 var d = {dd: test_null_dict()}
1224 d.dd[0] = 0
1225 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001226 v9.CheckDefExecFailure(lines, 'E1103:', 2)
Bram Moolenaar4f5e3972020-12-21 17:30:50 +01001227
1228 lines =<< trim END
1229 var d = {dd: 'string'}
1230 d.dd[0] = 0
1231 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001232 v9.CheckDefExecFailure(lines, 'E1148:', 2)
Bram Moolenaar3a3b10e2021-06-26 15:00:59 +02001233
1234 lines =<< trim END
1235 var n: any
1236 n.key = 5
1237 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001238 v9.CheckDefExecAndScriptFailure(lines, ['E1148:', 'E1203: Dot can only be used on a dictionary: n.key = 5'], 2)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001239enddef
1240
1241def Test_assignment_local()
1242 # Test in a separated file in order not to the current buffer/window/tab is
1243 # changed.
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001244 var script_lines: list<string> =<< trim END
Bram Moolenaar971caf52020-09-21 22:21:42 +02001245 let b:existing = 'yes'
1246 let w:existing = 'yes'
1247 let t:existing = 'yes'
1248
1249 def Test_assignment_local_internal()
1250 b:newvar = 'new'
1251 assert_equal('new', b:newvar)
1252 assert_equal('yes', b:existing)
1253 b:existing = 'no'
1254 assert_equal('no', b:existing)
1255 b:existing ..= 'NO'
1256 assert_equal('noNO', b:existing)
1257
1258 w:newvar = 'new'
1259 assert_equal('new', w:newvar)
1260 assert_equal('yes', w:existing)
1261 w:existing = 'no'
1262 assert_equal('no', w:existing)
1263 w:existing ..= 'NO'
1264 assert_equal('noNO', w:existing)
1265
1266 t:newvar = 'new'
1267 assert_equal('new', t:newvar)
1268 assert_equal('yes', t:existing)
1269 t:existing = 'no'
1270 assert_equal('no', t:existing)
1271 t:existing ..= 'NO'
1272 assert_equal('noNO', t:existing)
1273 enddef
1274 call Test_assignment_local_internal()
1275 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001276 v9.CheckScriptSuccess(script_lines)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001277enddef
1278
1279def Test_assignment_default()
Bram Moolenaar971caf52020-09-21 22:21:42 +02001280 # Test default values.
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001281 var thebool: bool
Bram Moolenaar971caf52020-09-21 22:21:42 +02001282 assert_equal(v:false, thebool)
1283
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001284 var thenumber: number
Bram Moolenaar971caf52020-09-21 22:21:42 +02001285 assert_equal(0, thenumber)
1286
1287 if has('float')
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001288 var thefloat: float
Bram Moolenaar971caf52020-09-21 22:21:42 +02001289 assert_equal(0.0, thefloat)
1290 endif
1291
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001292 var thestring: string
Bram Moolenaar971caf52020-09-21 22:21:42 +02001293 assert_equal('', thestring)
1294
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001295 var theblob: blob
Bram Moolenaar971caf52020-09-21 22:21:42 +02001296 assert_equal(0z, theblob)
1297
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001298 var Thefunc: func
Bram Moolenaar971caf52020-09-21 22:21:42 +02001299 assert_equal(test_null_function(), Thefunc)
1300
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001301 var thelist: list<any>
Bram Moolenaar971caf52020-09-21 22:21:42 +02001302 assert_equal([], thelist)
1303
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001304 var thedict: dict<any>
Bram Moolenaar971caf52020-09-21 22:21:42 +02001305 assert_equal({}, thedict)
1306
1307 if has('channel')
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001308 var thejob: job
Bram Moolenaar971caf52020-09-21 22:21:42 +02001309 assert_equal(test_null_job(), thejob)
1310
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001311 var thechannel: channel
Bram Moolenaar971caf52020-09-21 22:21:42 +02001312 assert_equal(test_null_channel(), thechannel)
1313
1314 if has('unix') && executable('cat')
1315 # check with non-null job and channel, types must match
Bram Moolenaare0de1712020-12-02 17:36:54 +01001316 thejob = job_start("cat ", {})
Bram Moolenaar971caf52020-09-21 22:21:42 +02001317 thechannel = job_getchannel(thejob)
1318 job_stop(thejob, 'kill')
1319 endif
1320 endif
1321
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001322 var nr = 1234 | nr = 5678
Bram Moolenaar971caf52020-09-21 22:21:42 +02001323 assert_equal(5678, nr)
1324enddef
1325
Bram Moolenaare08be092022-02-17 13:08:26 +00001326def Test_script_var_default()
1327 var lines =<< trim END
1328 vim9script
1329 var l: list<number>
Bram Moolenaar1983f1a2022-02-28 20:55:02 +00001330 var li = [1, 2]
Bram Moolenaare08be092022-02-17 13:08:26 +00001331 var bl: blob
Bram Moolenaar1983f1a2022-02-28 20:55:02 +00001332 var bli = 0z12
Bram Moolenaare08be092022-02-17 13:08:26 +00001333 var d: dict<number>
Bram Moolenaar1983f1a2022-02-28 20:55:02 +00001334 var di = {'a': 1, 'b': 2}
Bram Moolenaare08be092022-02-17 13:08:26 +00001335 def Echo()
1336 assert_equal([], l)
Bram Moolenaar1983f1a2022-02-28 20:55:02 +00001337 assert_equal([1, 2], li)
Bram Moolenaare08be092022-02-17 13:08:26 +00001338 assert_equal(0z, bl)
Bram Moolenaar1983f1a2022-02-28 20:55:02 +00001339 assert_equal(0z12, bli)
Bram Moolenaare08be092022-02-17 13:08:26 +00001340 assert_equal({}, d)
Bram Moolenaar1983f1a2022-02-28 20:55:02 +00001341 assert_equal({'a': 1, 'b': 2}, di)
Bram Moolenaare08be092022-02-17 13:08:26 +00001342 enddef
Bram Moolenaarea5c8982022-02-17 14:42:02 +00001343 Echo()
Bram Moolenaare08be092022-02-17 13:08:26 +00001344 END
1345 v9.CheckScriptSuccess(lines)
1346enddef
1347
Bram Moolenaara749a422022-02-12 19:52:25 +00001348let s:scriptvar = 'init'
Bram Moolenaar3862ea32021-01-01 21:05:55 +01001349
Bram Moolenaar971caf52020-09-21 22:21:42 +02001350def Test_assignment_var_list()
Bram Moolenaarda7c20c2020-11-30 21:12:19 +01001351 var lines =<< trim END
1352 var v1: string
1353 var v2: string
1354 var vrem: list<string>
1355 [v1] = ['aaa']
1356 assert_equal('aaa', v1)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001357
Bram Moolenaarda7c20c2020-11-30 21:12:19 +01001358 [v1, v2] = ['one', 'two']
1359 assert_equal('one', v1)
1360 assert_equal('two', v2)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001361
Bram Moolenaarda7c20c2020-11-30 21:12:19 +01001362 [v1, v2; vrem] = ['one', 'two']
1363 assert_equal('one', v1)
1364 assert_equal('two', v2)
1365 assert_equal([], vrem)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001366
Bram Moolenaarda7c20c2020-11-30 21:12:19 +01001367 [v1, v2; vrem] = ['one', 'two', 'three']
1368 assert_equal('one', v1)
1369 assert_equal('two', v2)
1370 assert_equal(['three'], vrem)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001371
Bram Moolenaarda7c20c2020-11-30 21:12:19 +01001372 [&ts, &sw] = [3, 4]
1373 assert_equal(3, &ts)
1374 assert_equal(4, &sw)
1375 set ts=8 sw=4
Bram Moolenaar004d9b02020-11-30 21:40:03 +01001376
1377 [@a, @z] = ['aa', 'zz']
1378 assert_equal('aa', @a)
1379 assert_equal('zz', @z)
1380
1381 [$SOME_VAR, $OTHER_VAR] = ['some', 'other']
1382 assert_equal('some', $SOME_VAR)
1383 assert_equal('other', $OTHER_VAR)
1384
Bram Moolenaar3862ea32021-01-01 21:05:55 +01001385 [g:globalvar, b:bufvar, w:winvar, t:tabvar, v:errmsg] =
1386 ['global', 'buf', 'win', 'tab', 'error']
Bram Moolenaar004d9b02020-11-30 21:40:03 +01001387 assert_equal('global', g:globalvar)
Bram Moolenaar004d9b02020-11-30 21:40:03 +01001388 assert_equal('buf', b:bufvar)
1389 assert_equal('win', w:winvar)
1390 assert_equal('tab', t:tabvar)
1391 assert_equal('error', v:errmsg)
1392 unlet g:globalvar
Bram Moolenaarda7c20c2020-11-30 21:12:19 +01001393 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001394 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar3862ea32021-01-01 21:05:55 +01001395
Bram Moolenaara749a422022-02-12 19:52:25 +00001396 [g:globalvar, scriptvar, b:bufvar] = ['global', 'script', 'buf']
Bram Moolenaar3862ea32021-01-01 21:05:55 +01001397 assert_equal('global', g:globalvar)
Bram Moolenaara749a422022-02-12 19:52:25 +00001398 assert_equal('script', scriptvar)
Bram Moolenaar3862ea32021-01-01 21:05:55 +01001399 assert_equal('buf', b:bufvar)
1400
1401 lines =<< trim END
1402 vim9script
Bram Moolenaara749a422022-02-12 19:52:25 +00001403 var scriptvar = 'init'
1404 [g:globalvar, scriptvar, w:winvar] = ['global', 'script', 'win']
Bram Moolenaar3862ea32021-01-01 21:05:55 +01001405 assert_equal('global', g:globalvar)
Bram Moolenaara749a422022-02-12 19:52:25 +00001406 assert_equal('script', scriptvar)
Bram Moolenaar3862ea32021-01-01 21:05:55 +01001407 assert_equal('win', w:winvar)
1408 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001409 v9.CheckScriptSuccess(lines)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001410enddef
1411
Bram Moolenaar2d3ac2e2022-02-03 12:34:05 +00001412def Test_assignment_empty_list()
1413 var lines =<< trim END
1414 var l2: list<any> = []
1415 var l: list<string>
1416 l = l2
1417 END
1418 v9.CheckDefAndScriptSuccess(lines)
1419enddef
1420
Bram Moolenaar971caf52020-09-21 22:21:42 +02001421def Test_assignment_vim9script()
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001422 var lines =<< trim END
Bram Moolenaar971caf52020-09-21 22:21:42 +02001423 vim9script
1424 def Func(): list<number>
1425 return [1, 2]
1426 enddef
Bram Moolenaar98309382020-09-27 21:58:45 +02001427 var name1: number
1428 var name2: number
1429 [name1, name2] =
Bram Moolenaar971caf52020-09-21 22:21:42 +02001430 Func()
Bram Moolenaar98309382020-09-27 21:58:45 +02001431 assert_equal(1, name1)
1432 assert_equal(2, name2)
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001433 var ll =
Bram Moolenaar971caf52020-09-21 22:21:42 +02001434 Func()
1435 assert_equal([1, 2], ll)
1436
1437 @/ = 'text'
1438 assert_equal('text', @/)
1439 @0 = 'zero'
1440 assert_equal('zero', @0)
1441 @1 = 'one'
1442 assert_equal('one', @1)
1443 @9 = 'nine'
1444 assert_equal('nine', @9)
1445 @- = 'minus'
1446 assert_equal('minus', @-)
1447 if has('clipboard_working')
1448 @* = 'star'
1449 assert_equal('star', @*)
1450 @+ = 'plus'
1451 assert_equal('plus', @+)
1452 endif
1453
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001454 var a: number = 123
Bram Moolenaar971caf52020-09-21 22:21:42 +02001455 assert_equal(123, a)
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001456 var s: string = 'yes'
Bram Moolenaar971caf52020-09-21 22:21:42 +02001457 assert_equal('yes', s)
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001458 var b: number = 42
Bram Moolenaar971caf52020-09-21 22:21:42 +02001459 assert_equal(42, b)
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001460 var w: number = 43
Bram Moolenaar971caf52020-09-21 22:21:42 +02001461 assert_equal(43, w)
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001462 var t: number = 44
Bram Moolenaar971caf52020-09-21 22:21:42 +02001463 assert_equal(44, t)
Bram Moolenaar7a66a172020-10-16 19:56:12 +02001464
1465 var to_var = 0
1466 to_var = 3
1467 assert_equal(3, to_var)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001468 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001469 v9.CheckScriptSuccess(lines)
Bram Moolenaar06f9c692020-09-27 21:27:40 +02001470
1471 lines =<< trim END
1472 vim9script
1473 var n: number
1474 def Func()
1475 n = 'string'
1476 enddef
1477 defcompile
1478 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001479 v9.CheckScriptFailure(lines, 'E1012: Type mismatch; expected number but got string')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001480enddef
1481
1482def Mess(): string
1483 v:foldstart = 123
1484 return 'xxx'
1485enddef
1486
1487def Test_assignment_failure()
Bram Moolenaar62aec932022-01-29 21:45:34 +00001488 v9.CheckDefFailure(['var name=234'], 'E1004:')
1489 v9.CheckDefFailure(['var name =234'], 'E1004:')
1490 v9.CheckDefFailure(['var name= 234'], 'E1004:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001491
Bram Moolenaar62aec932022-01-29 21:45:34 +00001492 v9.CheckScriptFailure(['vim9script', 'var name=234'], 'E1004:')
1493 v9.CheckScriptFailure(['vim9script', 'var name=234'], "before and after '='")
1494 v9.CheckScriptFailure(['vim9script', 'var name =234'], 'E1004:')
1495 v9.CheckScriptFailure(['vim9script', 'var name= 234'], 'E1004:')
1496 v9.CheckScriptFailure(['vim9script', 'var name = 234', 'name+=234'], 'E1004:')
1497 v9.CheckScriptFailure(['vim9script', 'var name = 234', 'name+=234'], "before and after '+='")
1498 v9.CheckScriptFailure(['vim9script', 'var name = "x"', 'name..="y"'], 'E1004:')
1499 v9.CheckScriptFailure(['vim9script', 'var name = "x"', 'name..="y"'], "before and after '..='")
Bram Moolenaar971caf52020-09-21 22:21:42 +02001500
Bram Moolenaar62aec932022-01-29 21:45:34 +00001501 v9.CheckDefFailure(['var true = 1'], 'E1034:')
1502 v9.CheckDefFailure(['var false = 1'], 'E1034:')
1503 v9.CheckDefFailure(['var null = 1'], 'E1034:')
1504 v9.CheckDefFailure(['var this = 1'], 'E1034:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001505
Bram Moolenaar8b716f52022-02-15 21:17:56 +00001506 v9.CheckDefFailure(['[a; b; c] = g:list'], 'E1001:')
1507 v9.CheckDefFailure(['var [a; b; c] = g:list'], 'E1080:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001508 v9.CheckDefExecFailure(['var a: number',
Bram Moolenaar971caf52020-09-21 22:21:42 +02001509 '[a] = test_null_list()'], 'E1093:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001510 v9.CheckDefExecFailure(['var a: number',
Bram Moolenaar971caf52020-09-21 22:21:42 +02001511 '[a] = []'], 'E1093:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001512 v9.CheckDefExecFailure(['var x: number',
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001513 'var y: number',
Bram Moolenaar971caf52020-09-21 22:21:42 +02001514 '[x, y] = [1]'], 'E1093:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001515 v9.CheckDefExecFailure(['var x: string',
Bram Moolenaar352134b2020-10-17 22:04:08 +02001516 'var y: string',
1517 '[x, y] = ["x"]'], 'E1093:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001518 v9.CheckDefExecFailure(['var x: number',
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001519 'var y: number',
1520 'var z: list<number>',
Bram Moolenaar971caf52020-09-21 22:21:42 +02001521 '[x, y; z] = [1]'], 'E1093:')
1522
Bram Moolenaar62aec932022-01-29 21:45:34 +00001523 v9.CheckDefFailure(['var somevar'], "E1022:")
1524 v9.CheckDefFailure(['var &tabstop = 4'], 'E1052:')
1525 v9.CheckDefFailure(['&g:option = 5'], 'E113:')
1526 v9.CheckScriptFailure(['vim9script', 'var &tabstop = 4'], 'E1052:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001527
Bram Moolenaar62aec932022-01-29 21:45:34 +00001528 v9.CheckDefFailure(['var $VAR = 5'], 'E1016: Cannot declare an environment variable:')
1529 v9.CheckScriptFailure(['vim9script', 'var $ENV = "xxx"'], 'E1016:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001530
1531 if has('dnd')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001532 v9.CheckDefFailure(['var @~ = 5'], 'E1066:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001533 else
Bram Moolenaar62aec932022-01-29 21:45:34 +00001534 v9.CheckDefFailure(['var @~ = 5'], 'E354:')
1535 v9.CheckDefFailure(['@~ = 5'], 'E354:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001536 endif
Bram Moolenaar62aec932022-01-29 21:45:34 +00001537 v9.CheckDefFailure(['var @a = 5'], 'E1066:')
1538 v9.CheckDefFailure(['var @/ = "x"'], 'E1066:')
1539 v9.CheckScriptFailure(['vim9script', 'var @a = "abc"'], 'E1066:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001540
Bram Moolenaar62aec932022-01-29 21:45:34 +00001541 v9.CheckDefFailure(['var g:var = 5'], 'E1016: Cannot declare a global variable:')
1542 v9.CheckDefFailure(['var w:var = 5'], 'E1016: Cannot declare a window variable:')
1543 v9.CheckDefFailure(['var b:var = 5'], 'E1016: Cannot declare a buffer variable:')
1544 v9.CheckDefFailure(['var t:var = 5'], 'E1016: Cannot declare a tab variable:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001545
Bram Moolenaar62aec932022-01-29 21:45:34 +00001546 v9.CheckDefFailure(['var anr = 4', 'anr ..= "text"'], 'E1019:')
1547 v9.CheckDefFailure(['var xnr += 4'], 'E1020:', 1)
1548 v9.CheckScriptFailure(['vim9script', 'var xnr += 4'], 'E1020:')
1549 v9.CheckDefFailure(["var xnr = xnr + 1"], 'E1001:', 1)
1550 v9.CheckScriptFailure(['vim9script', 'var xnr = xnr + 4'], 'E121:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001551
Bram Moolenaara749a422022-02-12 19:52:25 +00001552 v9.CheckScriptFailure(['vim9script', 'def Func()', 'var dummy = notfound', 'enddef', 'defcompile'], 'E1001:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001553
Bram Moolenaar62aec932022-01-29 21:45:34 +00001554 v9.CheckDefFailure(['var name: list<string> = [123]'], 'expected list<string> but got list<number>')
1555 v9.CheckDefFailure(['var name: list<number> = ["xx"]'], 'expected list<number> but got list<string>')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001556
Bram Moolenaar62aec932022-01-29 21:45:34 +00001557 v9.CheckDefFailure(['var name: dict<string> = {key: 123}'], 'expected dict<string> but got dict<number>')
1558 v9.CheckDefFailure(['var name: dict<number> = {key: "xx"}'], 'expected dict<number> but got dict<string>')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001559
Bram Moolenaar62aec932022-01-29 21:45:34 +00001560 v9.CheckDefFailure(['var name = feedkeys("0")'], 'E1031:')
1561 v9.CheckDefFailure(['var name: number = feedkeys("0")'], 'expected number but got void')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001562
Bram Moolenaar62aec932022-01-29 21:45:34 +00001563 v9.CheckDefFailure(['var name: dict <number>'], 'E1068:')
1564 v9.CheckDefFailure(['var name: dict<number'], 'E1009:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001565
Bram Moolenaar848fadd2022-01-30 15:28:30 +00001566 assert_fails('s/^/\=g:Mess()/n', 'E794:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001567 v9.CheckDefFailure(['var name: dict<number'], 'E1009:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001568
Bram Moolenaar62aec932022-01-29 21:45:34 +00001569 v9.CheckDefFailure(['w:foo: number = 10'],
Bram Moolenaar971caf52020-09-21 22:21:42 +02001570 'E488: Trailing characters: : number = 1')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001571 v9.CheckDefFailure(['t:foo: bool = true'],
Bram Moolenaar971caf52020-09-21 22:21:42 +02001572 'E488: Trailing characters: : bool = true')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001573 v9.CheckDefFailure(['b:foo: string = "x"'],
Bram Moolenaar971caf52020-09-21 22:21:42 +02001574 'E488: Trailing characters: : string = "x"')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001575 v9.CheckDefFailure(['g:foo: number = 123'],
Bram Moolenaar971caf52020-09-21 22:21:42 +02001576 'E488: Trailing characters: : number = 123')
1577enddef
1578
1579def Test_assign_list()
Bram Moolenaare65081d2021-06-27 15:04:05 +02001580 var lines =<< trim END
1581 var l: list<string> = []
1582 l[0] = 'value'
1583 assert_equal('value', l[0])
Bram Moolenaar971caf52020-09-21 22:21:42 +02001584
Bram Moolenaare65081d2021-06-27 15:04:05 +02001585 l[1] = 'asdf'
1586 assert_equal('value', l[0])
1587 assert_equal('asdf', l[1])
1588 assert_equal('asdf', l[-1])
1589 assert_equal('value', l[-2])
Bram Moolenaar971caf52020-09-21 22:21:42 +02001590
Bram Moolenaare65081d2021-06-27 15:04:05 +02001591 var nrl: list<number> = []
1592 for i in range(5)
1593 nrl[i] = i
1594 endfor
1595 assert_equal([0, 1, 2, 3, 4], nrl)
1596
1597 var ul: list<any>
1598 ul[0] = 1
1599 ul[1] = 2
1600 ul[2] = 3
1601 assert_equal([1, 2, 3], ul)
1602 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001603 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar334a8b42020-10-19 16:07:42 +02001604
Bram Moolenaar1983f1a2022-02-28 20:55:02 +00001605 lines =<< trim END
1606 var l = [1, 2]
1607 g:idx = 'x'
1608 l[g:idx : 1] = [0]
1609 echo l
1610 END
Bram Moolenaar2995e5c2022-03-18 21:41:47 +00001611 v9.CheckDefExecAndScriptFailure(lines, ['E1012: Type mismatch; expected number but got string', 'E1030: Using a String as a Number: "x"'])
Bram Moolenaar1983f1a2022-02-28 20:55:02 +00001612
1613 lines =<< trim END
1614 var l = [1, 2]
1615 g:idx = 3
1616 l[g:idx : 1] = [0]
1617 echo l
1618 END
1619 v9.CheckDefExecAndScriptFailure(lines, 'E684: list index out of range: 3')
1620
1621 lines =<< trim END
1622 var l = [1, 2]
1623 g:idx = 'y'
1624 l[1 : g:idx] = [0]
1625 echo l
1626 END
1627 v9.CheckDefExecAndScriptFailure(lines, ['E1012: Type mismatch; expected number but got string', 'E1030: Using a String as a Number: "y"'])
1628
Bram Moolenaar62aec932022-01-29 21:45:34 +00001629 v9.CheckDefFailure(["var l: list<number> = ['', true]"], 'E1012: Type mismatch; expected list<number> but got list<any>', 1)
1630 v9.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 +02001631enddef
1632
1633def Test_assign_dict()
Bram Moolenaarc3689572021-01-01 19:40:02 +01001634 var lines =<< trim END
1635 var d: dict<string> = {}
1636 d['key'] = 'value'
1637 assert_equal('value', d['key'])
Bram Moolenaar971caf52020-09-21 22:21:42 +02001638
Bram Moolenaarc3689572021-01-01 19:40:02 +01001639 d[123] = 'qwerty'
1640 assert_equal('qwerty', d[123])
1641 assert_equal('qwerty', d['123'])
Bram Moolenaar971caf52020-09-21 22:21:42 +02001642
Bram Moolenaarc3689572021-01-01 19:40:02 +01001643 var nrd: dict<number> = {}
1644 for i in range(3)
1645 nrd[i] = i
1646 endfor
1647 assert_equal({0: 0, 1: 1, 2: 2}, nrd)
1648
1649 d.somekey = 'someval'
1650 assert_equal({key: 'value', '123': 'qwerty', somekey: 'someval'}, d)
Bram Moolenaar23e2e112021-08-03 21:16:18 +02001651 unlet d.somekey
1652 assert_equal({key: 'value', '123': 'qwerty'}, d)
Bram Moolenaarc3689572021-01-01 19:40:02 +01001653 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001654 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarc3689572021-01-01 19:40:02 +01001655
Bram Moolenaar62aec932022-01-29 21:45:34 +00001656 v9.CheckDefFailure(["var d: dict<number> = {a: '', b: true}"], 'E1012: Type mismatch; expected dict<number> but got dict<any>', 1)
1657 v9.CheckDefFailure(["var d: dict<dict<number>> = {x: {a: '', b: true}}"], 'E1012: Type mismatch; expected dict<dict<number>> but got dict<dict<any>>', 1)
Bram Moolenaarbc510062022-02-14 21:19:04 +00001658 v9.CheckDefFailure(["var d = {x: 1}", "d[1 : 2] = {y: 2}"], 'E1165: Cannot use a range with an assignment: d[1 : 2] =', 2)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001659enddef
1660
Bram Moolenaar04bdd572020-09-23 13:25:32 +02001661def Test_assign_dict_unknown_type()
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001662 var lines =<< trim END
Bram Moolenaar04bdd572020-09-23 13:25:32 +02001663 vim9script
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001664 var mylist = []
Bram Moolenaare0de1712020-12-02 17:36:54 +01001665 mylist += [{one: 'one'}]
Bram Moolenaar04bdd572020-09-23 13:25:32 +02001666 def Func()
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001667 var dd = mylist[0]
Bram Moolenaar04bdd572020-09-23 13:25:32 +02001668 assert_equal('one', dd.one)
1669 enddef
1670 Func()
1671 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001672 v9.CheckScriptSuccess(lines)
Bram Moolenaar04bdd572020-09-23 13:25:32 +02001673
Bram Moolenaarce2c5442020-11-28 21:21:17 +01001674 lines =<< trim END
1675 vim9script
1676 var mylist = [[]]
Bram Moolenaare0de1712020-12-02 17:36:54 +01001677 mylist[0] += [{one: 'one'}]
Bram Moolenaarce2c5442020-11-28 21:21:17 +01001678 def Func()
1679 var dd = mylist[0][0]
1680 assert_equal('one', dd.one)
1681 enddef
1682 Func()
1683 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001684 v9.CheckScriptSuccess(lines)
Bram Moolenaar04bdd572020-09-23 13:25:32 +02001685enddef
1686
Bram Moolenaarf76ec1e2021-03-03 17:58:16 +01001687def Test_assign_dict_with_op()
1688 var lines =<< trim END
Bram Moolenaarf76ec1e2021-03-03 17:58:16 +01001689 var ds: dict<string> = {a: 'x'}
1690 ds['a'] ..= 'y'
1691 ds.a ..= 'z'
1692 assert_equal('xyz', ds.a)
1693
1694 var dn: dict<number> = {a: 9}
1695 dn['a'] += 2
1696 assert_equal(11, dn.a)
1697 dn.a += 2
1698 assert_equal(13, dn.a)
1699
1700 dn['a'] -= 3
1701 assert_equal(10, dn.a)
1702 dn.a -= 2
1703 assert_equal(8, dn.a)
1704
1705 dn['a'] *= 2
1706 assert_equal(16, dn.a)
1707 dn.a *= 2
1708 assert_equal(32, dn.a)
1709
1710 dn['a'] /= 3
1711 assert_equal(10, dn.a)
1712 dn.a /= 2
1713 assert_equal(5, dn.a)
1714
1715 dn['a'] %= 3
1716 assert_equal(2, dn.a)
1717 dn.a %= 6
1718 assert_equal(2, dn.a)
Bram Moolenaarb9c0cd82021-04-05 20:51:00 +02001719
1720 var dd: dict<dict<list<any>>>
1721 dd.a = {}
1722 dd.a.b = [0]
1723 dd.a.b += [1]
1724 assert_equal({a: {b: [0, 1]}}, dd)
Bram Moolenaar0d351a02021-04-05 21:05:26 +02001725
1726 var dab = {a: ['b']}
1727 dab.a[0] ..= 'c'
1728 assert_equal({a: ['bc']}, dab)
Bram Moolenaarf76ec1e2021-03-03 17:58:16 +01001729 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001730 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaare42939a2021-04-05 17:11:17 +02001731enddef
1732
1733def Test_assign_list_with_op()
1734 var lines =<< trim END
1735 var ls: list<string> = ['x']
1736 ls[0] ..= 'y'
1737 assert_equal('xy', ls[0])
1738
1739 var ln: list<number> = [9]
1740 ln[0] += 2
1741 assert_equal(11, ln[0])
1742
1743 ln[0] -= 3
1744 assert_equal(8, ln[0])
1745
1746 ln[0] *= 2
1747 assert_equal(16, ln[0])
1748
1749 ln[0] /= 3
1750 assert_equal(5, ln[0])
1751
1752 ln[0] %= 3
1753 assert_equal(2, ln[0])
1754 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001755 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaare42939a2021-04-05 17:11:17 +02001756enddef
1757
1758def Test_assign_with_op_fails()
1759 var lines =<< trim END
1760 var s = 'abc'
1761 s[1] += 'x'
1762 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001763 v9.CheckDefAndScriptFailure(lines, ['E1141:', 'E689:'], 2)
Bram Moolenaare42939a2021-04-05 17:11:17 +02001764
1765 lines =<< trim END
1766 var s = 'abc'
1767 s[1] ..= 'x'
1768 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001769 v9.CheckDefAndScriptFailure(lines, ['E1141:', 'E689:'], 2)
Bram Moolenaarb9c0cd82021-04-05 20:51:00 +02001770
1771 lines =<< trim END
1772 var dd: dict<dict<list<any>>>
1773 dd.a = {}
1774 dd.a.b += [1]
1775 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001776 v9.CheckDefExecAndScriptFailure(lines, 'E716:', 3)
Bram Moolenaarf76ec1e2021-03-03 17:58:16 +01001777enddef
1778
Bram Moolenaar971caf52020-09-21 22:21:42 +02001779def Test_assign_lambda()
1780 # check if assign a lambda to a variable which type is func or any.
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001781 var lines =<< trim END
Bram Moolenaar971caf52020-09-21 22:21:42 +02001782 vim9script
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001783 var FuncRef = () => 123
Bram Moolenaar971caf52020-09-21 22:21:42 +02001784 assert_equal(123, FuncRef())
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001785 var FuncRef_Func: func = () => 123
Bram Moolenaar971caf52020-09-21 22:21:42 +02001786 assert_equal(123, FuncRef_Func())
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001787 var FuncRef_Any: any = () => 123
Bram Moolenaar971caf52020-09-21 22:21:42 +02001788 assert_equal(123, FuncRef_Any())
Bram Moolenaar06409502021-02-17 17:00:27 +01001789 var FuncRef_Number: func(): number = () => 321
1790 assert_equal(321, FuncRef_Number())
Bram Moolenaar971caf52020-09-21 22:21:42 +02001791 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001792 v9.CheckScriptSuccess(lines)
Bram Moolenaar328eac22021-01-07 19:23:08 +01001793
1794 lines =<< trim END
1795 var Ref: func(number)
1796 Ref = (j) => !j
1797 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001798 v9.CheckDefAndScriptFailure(lines, 'E1012: Type mismatch; expected func(number) but got func(any): bool')
Bram Moolenaarc7dac852021-02-17 18:49:11 +01001799
1800 lines =<< trim END
1801 echo filter([1, 2, 3], (_, v: string) => v + 1)
1802 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001803 v9.CheckDefAndScriptFailure(lines, 'E1051:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001804enddef
1805
Bram Moolenaarc0e29012020-09-27 14:22:48 +02001806def Test_heredoc()
1807 var lines =<< trim END # comment
1808 text
1809 END
1810 assert_equal(['text'], lines)
1811
Bram Moolenaar62aec932022-01-29 21:45:34 +00001812 v9.CheckDefFailure(['var lines =<< trim END X', 'END'], 'E488:')
1813 v9.CheckDefFailure(['var lines =<< trim END " comment', 'END'], 'E488:')
Bram Moolenaar2914a202020-09-27 18:24:03 +02001814
1815 lines =<< trim [END]
1816 def Func()
1817 var&lines =<< trim END
1818 x
1819 x
Bram Moolenaarb5b94802020-12-13 17:50:20 +01001820 enddef
1821 defcompile
1822 [END]
Bram Moolenaar62aec932022-01-29 21:45:34 +00001823 v9.CheckScriptFailure(lines, 'E1145: Missing heredoc end marker: END')
Bram Moolenaarb5b94802020-12-13 17:50:20 +01001824 delfunc! g:Func
1825
1826 lines =<< trim [END]
1827 def Func()
1828 var lines =<< trim END
1829 x
1830 x
Bram Moolenaar2914a202020-09-27 18:24:03 +02001831 x
1832 x
1833 x
1834 x
1835 x
1836 x
1837 enddef
1838 call Func()
1839 [END]
Bram Moolenaar62aec932022-01-29 21:45:34 +00001840 v9.CheckScriptFailure(lines, 'E1145: Missing heredoc end marker: END')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001841 delfunc! g:Func
Bram Moolenaar81530e32021-07-28 21:25:49 +02001842
1843 lines =<< trim END
1844 var lines: number =<< trim STOP
1845 aaa
1846 bbb
1847 STOP
1848 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001849 v9.CheckDefAndScriptFailure(lines, 'E1012: Type mismatch; expected number but got list<string>', 1)
Bram Moolenaarc0e29012020-09-27 14:22:48 +02001850enddef
1851
Bram Moolenaar083966f2020-12-08 11:29:40 +01001852def Test_var_func_call()
Bram Moolenaar55759b52020-09-30 22:59:42 +02001853 var lines =<< trim END
1854 vim9script
1855 func GetValue()
1856 if exists('g:count')
1857 let g:count += 1
1858 else
1859 let g:count = 1
1860 endif
1861 return 'this'
1862 endfunc
1863 var val: string = GetValue()
1864 # env var is always a string
1865 var env = $TERM
1866 END
1867 writefile(lines, 'Xfinished')
1868 source Xfinished
1869 # GetValue() is not called during discovery phase
1870 assert_equal(1, g:count)
1871
1872 unlet g:count
1873 delete('Xfinished')
1874enddef
1875
Bram Moolenaar083966f2020-12-08 11:29:40 +01001876def Test_var_missing_type()
Bram Moolenaar55759b52020-09-30 22:59:42 +02001877 var lines =<< trim END
1878 vim9script
1879 var name = g:unknown
1880 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001881 v9.CheckScriptFailure(lines, 'E121:')
Bram Moolenaar55759b52020-09-30 22:59:42 +02001882
1883 lines =<< trim END
1884 vim9script
1885 var nr: number = 123
1886 var name = nr
1887 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001888 v9.CheckScriptSuccess(lines)
Bram Moolenaar55759b52020-09-30 22:59:42 +02001889enddef
1890
Bram Moolenaar083966f2020-12-08 11:29:40 +01001891def Test_var_declaration()
Bram Moolenaar55759b52020-09-30 22:59:42 +02001892 var lines =<< trim END
1893 vim9script
1894 var name: string
1895 g:var_uninit = name
1896 name = 'text'
1897 g:var_test = name
Bram Moolenaara749a422022-02-12 19:52:25 +00001898 # prefixing s: is not allowed
1899 name = 'prefixed'
1900 g:var_prefixed = name
Bram Moolenaar55759b52020-09-30 22:59:42 +02001901
Bram Moolenaar7257af42020-12-08 22:08:51 +01001902 const FOO: number = 123
1903 assert_equal(123, FOO)
Bram Moolenaar89b474d2020-12-22 21:19:39 +01001904 const FOOS = 'foos'
1905 assert_equal('foos', FOOS)
1906 final FLIST = [1]
1907 assert_equal([1], FLIST)
1908 FLIST[0] = 11
1909 assert_equal([11], FLIST)
1910
1911 const g:FOO: number = 321
1912 assert_equal(321, g:FOO)
1913 const g:FOOS = 'gfoos'
1914 assert_equal('gfoos', g:FOOS)
1915 final g:FLIST = [2]
1916 assert_equal([2], g:FLIST)
1917 g:FLIST[0] = 22
1918 assert_equal([22], g:FLIST)
1919
Bram Moolenaard877a572021-04-01 19:42:48 +02001920 def SetGlobalConst()
1921 const g:globConst = 123
1922 enddef
1923 SetGlobalConst()
1924 assert_equal(123, g:globConst)
1925 assert_true(islocked('g:globConst'))
1926
Bram Moolenaar89b474d2020-12-22 21:19:39 +01001927 const w:FOO: number = 46
1928 assert_equal(46, w:FOO)
1929 const w:FOOS = 'wfoos'
1930 assert_equal('wfoos', w:FOOS)
1931 final w:FLIST = [3]
1932 assert_equal([3], w:FLIST)
1933 w:FLIST[0] = 33
1934 assert_equal([33], w:FLIST)
Bram Moolenaar7257af42020-12-08 22:08:51 +01001935
Bram Moolenaar55759b52020-09-30 22:59:42 +02001936 var s:other: number
1937 other = 1234
1938 g:other_var = other
1939
Bram Moolenaarccc25aa2021-03-26 21:27:52 +01001940 var xyz: string # comment
1941
Bram Moolenaar55759b52020-09-30 22:59:42 +02001942 # type is inferred
Bram Moolenaara749a422022-02-12 19:52:25 +00001943 var dict = {['a']: 222}
Bram Moolenaar55759b52020-09-30 22:59:42 +02001944 def GetDictVal(key: any)
Bram Moolenaara749a422022-02-12 19:52:25 +00001945 g:dict_val = dict[key]
Bram Moolenaar55759b52020-09-30 22:59:42 +02001946 enddef
1947 GetDictVal('a')
Bram Moolenaar08251752021-01-11 21:20:18 +01001948
1949 final adict: dict<string> = {}
1950 def ChangeAdict()
1951 adict.foo = 'foo'
1952 enddef
1953 ChangeAdict()
Bram Moolenaar55759b52020-09-30 22:59:42 +02001954 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001955 v9.CheckScriptSuccess(lines)
Bram Moolenaar55759b52020-09-30 22:59:42 +02001956 assert_equal('', g:var_uninit)
1957 assert_equal('text', g:var_test)
1958 assert_equal('prefixed', g:var_prefixed)
1959 assert_equal(1234, g:other_var)
1960 assert_equal(222, g:dict_val)
1961
1962 unlet g:var_uninit
1963 unlet g:var_test
1964 unlet g:var_prefixed
1965 unlet g:other_var
Bram Moolenaar6e50ec22021-04-03 19:32:44 +02001966 unlet g:globConst
Bram Moolenaar89b474d2020-12-22 21:19:39 +01001967 unlet g:FOO
1968 unlet g:FOOS
1969 unlet g:FLIST
1970 unlet w:FOO
1971 unlet w:FOOS
1972 unlet w:FLIST
Bram Moolenaar55759b52020-09-30 22:59:42 +02001973enddef
1974
Bram Moolenaar083966f2020-12-08 11:29:40 +01001975def Test_var_declaration_fails()
Bram Moolenaar55759b52020-09-30 22:59:42 +02001976 var lines =<< trim END
1977 vim9script
1978 final var: string
1979 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001980 v9.CheckScriptFailure(lines, 'E1125:')
Bram Moolenaar55759b52020-09-30 22:59:42 +02001981
1982 lines =<< trim END
1983 vim9script
Bram Moolenaar89b474d2020-12-22 21:19:39 +01001984 const g:constvar = 'string'
1985 g:constvar = 'xx'
1986 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001987 v9.CheckScriptFailure(lines, 'E741:')
Bram Moolenaar89b474d2020-12-22 21:19:39 +01001988 unlet g:constvar
1989
1990 lines =<< trim END
1991 vim9script
Bram Moolenaarf5906aa2021-04-02 14:35:15 +02001992 var name = 'one'
1993 lockvar name
1994 def SetLocked()
1995 name = 'two'
1996 enddef
1997 SetLocked()
1998 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001999 v9.CheckScriptFailure(lines, 'E741: Value is locked: name', 1)
Bram Moolenaardcf29ac2021-04-02 14:44:02 +02002000
2001 lines =<< trim END
2002 let s:legacy = 'one'
2003 lockvar s:legacy
2004 def SetLocked()
2005 s:legacy = 'two'
2006 enddef
2007 call SetLocked()
2008 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002009 v9.CheckScriptFailure(lines, 'E741: Value is locked: s:legacy', 1)
Bram Moolenaarf5906aa2021-04-02 14:35:15 +02002010
2011 lines =<< trim END
2012 vim9script
Bram Moolenaard877a572021-04-01 19:42:48 +02002013 def SetGlobalConst()
2014 const g:globConst = 123
2015 enddef
2016 SetGlobalConst()
2017 g:globConst = 234
2018 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002019 v9.CheckScriptFailure(lines, 'E741: Value is locked: g:globConst', 6)
Bram Moolenaard877a572021-04-01 19:42:48 +02002020 unlet g:globConst
2021
2022 lines =<< trim END
2023 vim9script
Bram Moolenaar08251752021-01-11 21:20:18 +01002024 const cdict: dict<string> = {}
2025 def Change()
2026 cdict.foo = 'foo'
2027 enddef
2028 defcompile
2029 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002030 v9.CheckScriptFailure(lines, 'E46:')
Bram Moolenaar08251752021-01-11 21:20:18 +01002031
2032 lines =<< trim END
2033 vim9script
Bram Moolenaar89b474d2020-12-22 21:19:39 +01002034 final w:finalvar = [9]
2035 w:finalvar = [8]
2036 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002037 v9.CheckScriptFailure(lines, 'E1122:')
Bram Moolenaar89b474d2020-12-22 21:19:39 +01002038 unlet w:finalvar
2039
2040 lines =<< trim END
2041 vim9script
Bram Moolenaar55759b52020-09-30 22:59:42 +02002042 const var: string
2043 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002044 v9.CheckScriptFailure(lines, 'E1021:')
Bram Moolenaar55759b52020-09-30 22:59:42 +02002045
2046 lines =<< trim END
2047 vim9script
2048 var 9var: string
2049 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002050 v9.CheckScriptFailure(lines, 'E488:')
Bram Moolenaar7257af42020-12-08 22:08:51 +01002051
Bram Moolenaar62aec932022-01-29 21:45:34 +00002052 v9.CheckDefFailure(['var foo.bar = 2'], 'E1087:')
2053 v9.CheckDefFailure(['var foo[3] = 2'], 'E1087:')
2054 v9.CheckDefFailure(['const foo: number'], 'E1021:')
Bram Moolenaare1d12112022-03-05 11:37:48 +00002055
2056 lines =<< trim END
2057 va foo = 123
2058 END
2059 v9.CheckDefAndScriptFailure(lines, 'E1065:', 1)
Bram Moolenaar55759b52020-09-30 22:59:42 +02002060enddef
2061
Bram Moolenaare88c6b72022-02-15 15:37:11 +00002062def Test_var_declaration_inferred()
2063 # check that type is set on the list so that extend() fails
2064 var lines =<< trim END
2065 vim9script
2066 def GetList(): list<number>
2067 var l = [1, 2, 3]
2068 return l
2069 enddef
2070 echo GetList()->extend(['x'])
2071 END
2072 v9.CheckScriptFailure(lines, 'E1013:', 6)
2073enddef
2074
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002075def Test_script_local_in_legacy()
Bram Moolenaara749a422022-02-12 19:52:25 +00002076 # OK to define script-local later but before compiling
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002077 var lines =<< trim END
2078 def SetLater()
Bram Moolenaara749a422022-02-12 19:52:25 +00002079 legvar = 'two'
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002080 enddef
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02002081 let s:legvar = 'one'
Bram Moolenaara749a422022-02-12 19:52:25 +00002082 defcompile
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002083 call SetLater()
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02002084 call assert_equal('two', s:legvar)
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002085 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002086 v9.CheckScriptSuccess(lines)
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002087
2088 # OK to leave out s: prefix when script-local already defined
2089 lines =<< trim END
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02002090 let s:legvar = 'one'
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002091 def SetNoPrefix()
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02002092 legvar = 'two'
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002093 enddef
2094 call SetNoPrefix()
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02002095 call assert_equal('two', s:legvar)
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002096 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002097 v9.CheckScriptSuccess(lines)
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002098
Bram Moolenaara749a422022-02-12 19:52:25 +00002099 # Not OK to leave out s: prefix when script-local defined after compiling
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002100 lines =<< trim END
2101 def SetLaterNoPrefix()
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02002102 legvar = 'two'
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002103 enddef
2104 defcompile
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02002105 let s:legvar = 'one'
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002106 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002107 v9.CheckScriptFailure(lines, 'E476:', 1)
Bram Moolenaar47bc9c32021-07-17 21:24:56 +02002108
2109 edit! Xfile
2110 lines =<< trim END
2111 var edit: bool
2112 legacy edit
2113 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002114 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002115enddef
2116
Bram Moolenaar083966f2020-12-08 11:29:40 +01002117def Test_var_type_check()
Bram Moolenaar55759b52020-09-30 22:59:42 +02002118 var lines =<< trim END
2119 vim9script
2120 var name: string
2121 name = 1234
2122 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002123 v9.CheckScriptFailure(lines, 'E1012:')
Bram Moolenaar55759b52020-09-30 22:59:42 +02002124
2125 lines =<< trim END
2126 vim9script
2127 var name:string
2128 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002129 v9.CheckScriptFailure(lines, 'E1069:')
Bram Moolenaar55759b52020-09-30 22:59:42 +02002130
Bram Moolenaar62aec932022-01-29 21:45:34 +00002131 v9.CheckDefAndScriptFailure(['var n:number = 42'], 'E1069:')
Bram Moolenaar60faf862021-08-23 22:22:45 +02002132
Bram Moolenaar55759b52020-09-30 22:59:42 +02002133 lines =<< trim END
2134 vim9script
2135 var name: asdf
2136 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002137 v9.CheckScriptFailure(lines, 'E1010:')
Bram Moolenaar55759b52020-09-30 22:59:42 +02002138
2139 lines =<< trim END
2140 vim9script
Bram Moolenaara749a422022-02-12 19:52:25 +00002141 var l: list<number>
2142 l = []
Bram Moolenaar55759b52020-09-30 22:59:42 +02002143 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002144 v9.CheckScriptSuccess(lines)
Bram Moolenaar55759b52020-09-30 22:59:42 +02002145
2146 lines =<< trim END
2147 vim9script
Bram Moolenaara749a422022-02-12 19:52:25 +00002148 var d: dict<number>
2149 d = {}
Bram Moolenaar55759b52020-09-30 22:59:42 +02002150 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002151 v9.CheckScriptSuccess(lines)
Bram Moolenaar378697a2021-07-15 19:23:18 +02002152
2153 lines =<< trim END
2154 vim9script
2155 var d = {a: 1, b: [2]}
2156 def Func(b: bool)
2157 var l: list<number> = b ? d.b : [3]
2158 enddef
2159 defcompile
2160 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002161 v9.CheckScriptSuccess(lines)
Bram Moolenaar55759b52020-09-30 22:59:42 +02002162enddef
2163
2164let g:dict_number = #{one: 1, two: 2}
2165
Bram Moolenaar083966f2020-12-08 11:29:40 +01002166def Test_var_list_dict_type()
Bram Moolenaar55759b52020-09-30 22:59:42 +02002167 var ll: list<number>
2168 ll = [1, 2, 2, 3, 3, 3]->uniq()
2169 ll->assert_equal([1, 2, 3])
2170
2171 var dd: dict<number>
2172 dd = g:dict_number
2173 dd->assert_equal(g:dict_number)
2174
2175 var lines =<< trim END
2176 var ll: list<number>
2177 ll = [1, 2, 3]->map('"one"')
2178 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002179 v9.CheckDefExecFailure(lines, 'E1012: Type mismatch; expected list<number> but got list<string>')
Bram Moolenaar55759b52020-09-30 22:59:42 +02002180enddef
2181
Bram Moolenaar083966f2020-12-08 11:29:40 +01002182def Test_cannot_use_let()
Bram Moolenaar62aec932022-01-29 21:45:34 +00002183 v9.CheckDefAndScriptFailure(['let a = 34'], 'E1126:', 1)
Bram Moolenaar083966f2020-12-08 11:29:40 +01002184enddef
2185
Bram Moolenaar55759b52020-09-30 22:59:42 +02002186def Test_unlet()
2187 g:somevar = 'yes'
2188 assert_true(exists('g:somevar'))
2189 unlet g:somevar
2190 assert_false(exists('g:somevar'))
2191 unlet! g:somevar
2192
2193 # also works for script-local variable in legacy Vim script
2194 s:somevar = 'legacy'
2195 assert_true(exists('s:somevar'))
2196 unlet s:somevar
2197 assert_false(exists('s:somevar'))
2198 unlet! s:somevar
2199
Bram Moolenaar83d0cec2022-02-04 21:17:58 +00002200 if 0
2201 unlet g:does_not_exist
2202 endif
2203
2204 v9.CheckDefExecFailure(['unlet v:notfound.key'], 'E1001:')
2205
Bram Moolenaar62aec932022-01-29 21:45:34 +00002206 v9.CheckDefExecFailure([
Bram Moolenaar0acbf5a2021-01-05 20:58:25 +01002207 'var dd = 111',
2208 'unlet dd',
2209 ], 'E1081:', 2)
2210
Bram Moolenaar752fc692021-01-04 21:57:11 +01002211 # dict unlet
Bram Moolenaarea5c8982022-02-17 14:42:02 +00002212 var dd = {a: 1, b: 2, c: 3, 4: 4}
Bram Moolenaar752fc692021-01-04 21:57:11 +01002213 unlet dd['a']
2214 unlet dd.c
Bram Moolenaarea5c8982022-02-17 14:42:02 +00002215 unlet dd[4]
Bram Moolenaar752fc692021-01-04 21:57:11 +01002216 assert_equal({b: 2}, dd)
2217
Bram Moolenaar6b8c7ba2022-03-20 17:46:06 +00002218 # null key works like empty string
2219 dd = {'': 1, x: 9}
2220 unlet dd[null_string]
2221 assert_equal({x: 9}, dd)
2222
Bram Moolenaar752fc692021-01-04 21:57:11 +01002223 # list unlet
2224 var ll = [1, 2, 3, 4]
2225 unlet ll[1]
2226 unlet ll[-1]
2227 assert_equal([1, 3], ll)
2228
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01002229 ll = [1, 2, 3, 4]
2230 unlet ll[0 : 1]
2231 assert_equal([3, 4], ll)
2232
2233 ll = [1, 2, 3, 4]
2234 unlet ll[2 : 8]
2235 assert_equal([1, 2], ll)
2236
2237 ll = [1, 2, 3, 4]
2238 unlet ll[-2 : -1]
2239 assert_equal([1, 2], ll)
2240
Bram Moolenaar0c7f2612022-02-17 19:44:07 +00002241 g:nrdict = {1: 1, 2: 2}
2242 g:idx = 1
2243 unlet g:nrdict[g:idx]
2244 assert_equal({2: 2}, g:nrdict)
2245 unlet g:nrdict
2246 unlet g:idx
2247
Bram Moolenaar62aec932022-01-29 21:45:34 +00002248 v9.CheckDefFailure([
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01002249 'var ll = [1, 2]',
2250 'll[1 : 2] = 7',
Bram Moolenaar4f0884d2021-08-11 21:49:23 +02002251 ], 'E1012: Type mismatch; expected list<number> but got number', 2)
Bram Moolenaar62aec932022-01-29 21:45:34 +00002252 v9.CheckDefFailure([
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01002253 'var dd = {a: 1}',
2254 'unlet dd["a" : "a"]',
2255 ], 'E1166:', 2)
Bram Moolenaar62aec932022-01-29 21:45:34 +00002256 v9.CheckDefExecFailure([
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01002257 'unlet g:adict[0 : 1]',
2258 ], 'E1148:', 1)
Bram Moolenaar62aec932022-01-29 21:45:34 +00002259 v9.CheckDefFailure([
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01002260 'var ll = [1, 2]',
2261 'unlet ll[0:1]',
2262 ], 'E1004:', 2)
Bram Moolenaar62aec932022-01-29 21:45:34 +00002263 v9.CheckDefFailure([
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01002264 'var ll = [1, 2]',
2265 'unlet ll[0 :1]',
2266 ], 'E1004:', 2)
Bram Moolenaar62aec932022-01-29 21:45:34 +00002267 v9.CheckDefFailure([
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01002268 'var ll = [1, 2]',
2269 'unlet ll[0: 1]',
2270 ], 'E1004:', 2)
Bram Moolenaare08be092022-02-17 13:08:26 +00002271
2272 v9.CheckDefExecFailure([
2273 'g:ll = [1, 2]',
2274 'g:idx = "x"',
2275 'unlet g:ll[g:idx]',
2276 ], 'E1029: Expected number but got string', 3)
2277
2278 v9.CheckDefExecFailure([
2279 'g:ll = [1, 2, 3]',
2280 'g:idx = "x"',
2281 'unlet g:ll[g:idx : 2]',
2282 ], 'E1029: Expected number but got string', 3)
2283
2284 v9.CheckDefExecFailure([
2285 'g:ll = [1, 2, 3]',
2286 'g:idx = "x"',
2287 'unlet g:ll[0 : g:idx]',
2288 ], 'E1029: Expected number but got string', 3)
2289
Bram Moolenaar7f2c3412021-11-29 16:01:49 +00002290 # command recognized as assignment when skipping, should not give an error
Bram Moolenaar62aec932022-01-29 21:45:34 +00002291 v9.CheckScriptSuccess([
Bram Moolenaar7f2c3412021-11-29 16:01:49 +00002292 'vim9script',
2293 'for i in []',
2294 " put =''",
2295 'endfor'])
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01002296
Bram Moolenaar62aec932022-01-29 21:45:34 +00002297 v9.CheckDefFailure([
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01002298 'var ll = [1, 2]',
2299 'unlet ll["x" : 1]',
2300 ], 'E1012:', 2)
Bram Moolenaar62aec932022-01-29 21:45:34 +00002301 v9.CheckDefFailure([
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01002302 'var ll = [1, 2]',
2303 'unlet ll[0 : "x"]',
2304 ], 'E1012:', 2)
2305
Bram Moolenaar752fc692021-01-04 21:57:11 +01002306 # list of dict unlet
2307 var dl = [{a: 1, b: 2}, {c: 3}]
2308 unlet dl[0]['b']
2309 assert_equal([{a: 1}, {c: 3}], dl)
2310
Bram Moolenaar62aec932022-01-29 21:45:34 +00002311 v9.CheckDefExecFailure([
Bram Moolenaar0acbf5a2021-01-05 20:58:25 +01002312 'var ll = test_null_list()',
2313 'unlet ll[0]',
2314 ], 'E684:', 2)
Bram Moolenaar62aec932022-01-29 21:45:34 +00002315 v9.CheckDefExecFailure([
Bram Moolenaar0acbf5a2021-01-05 20:58:25 +01002316 'var ll = [1]',
2317 'unlet ll[2]',
2318 ], 'E684:', 2)
Bram Moolenaar62aec932022-01-29 21:45:34 +00002319 v9.CheckDefExecFailure([
Bram Moolenaar0acbf5a2021-01-05 20:58:25 +01002320 'var ll = [1]',
2321 'unlet ll[g:astring]',
Bram Moolenaarf30a14d2021-01-17 21:51:24 +01002322 ], 'E1012:', 2)
Bram Moolenaar62aec932022-01-29 21:45:34 +00002323 v9.CheckDefExecFailure([
Bram Moolenaar0acbf5a2021-01-05 20:58:25 +01002324 'var dd = test_null_dict()',
2325 'unlet dd["a"]',
2326 ], 'E716:', 2)
Bram Moolenaar62aec932022-01-29 21:45:34 +00002327 v9.CheckDefExecFailure([
Bram Moolenaar0acbf5a2021-01-05 20:58:25 +01002328 'var dd = {a: 1}',
2329 'unlet dd["b"]',
2330 ], 'E716:', 2)
Bram Moolenaar62aec932022-01-29 21:45:34 +00002331 v9.CheckDefExecFailure([
Bram Moolenaar0acbf5a2021-01-05 20:58:25 +01002332 'var dd = {a: 1}',
2333 'unlet dd[g:alist]',
2334 ], 'E1105:', 2)
Bram Moolenaar752fc692021-01-04 21:57:11 +01002335
Bram Moolenaarea5c8982022-02-17 14:42:02 +00002336 v9.CheckDefExecFailure([
2337 'g:dd = {"a": 1, 2: 2}'
2338 'unlet g:dd[0z11]',
2339 ], 'E1029:', 2)
Bram Moolenaar6296d1e2022-02-17 16:30:11 +00002340 v9.CheckDefExecFailure([
2341 'g:str = "a string"'
2342 'unlet g:str[0]',
2343 ], 'E1148: Cannot index a string', 2)
Bram Moolenaarea5c8982022-02-17 14:42:02 +00002344
Bram Moolenaar2ef951d2021-01-03 20:55:26 +01002345 # can compile unlet before variable exists
Bram Moolenaar752fc692021-01-04 21:57:11 +01002346 g:someDict = {key: 'val'}
2347 var k = 'key'
2348 unlet g:someDict[k]
2349 assert_equal({}, g:someDict)
2350 unlet g:someDict
2351 assert_false(exists('g:someDict'))
Bram Moolenaar2ef951d2021-01-03 20:55:26 +01002352
Bram Moolenaar62aec932022-01-29 21:45:34 +00002353 v9.CheckScriptFailure([
Bram Moolenaar55759b52020-09-30 22:59:42 +02002354 'vim9script',
2355 'var svar = 123',
2356 'unlet svar',
2357 ], 'E1081:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00002358 v9.CheckScriptFailure([
Bram Moolenaar55759b52020-09-30 22:59:42 +02002359 'vim9script',
2360 'var svar = 123',
2361 'unlet s:svar',
Bram Moolenaara749a422022-02-12 19:52:25 +00002362 ], 'E1268:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00002363 v9.CheckScriptFailure([
Bram Moolenaar55759b52020-09-30 22:59:42 +02002364 'vim9script',
2365 'var svar = 123',
2366 'def Func()',
2367 ' unlet svar',
2368 'enddef',
2369 'defcompile',
2370 ], 'E1081:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00002371 v9.CheckScriptFailure([
Bram Moolenaar55759b52020-09-30 22:59:42 +02002372 'vim9script',
2373 'var svar = 123',
Bram Moolenaar9aed7292020-12-18 15:38:00 +01002374 'func Func()',
2375 ' unlet s:svar',
2376 'endfunc',
2377 'Func()',
2378 ], 'E1081:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00002379 v9.CheckScriptFailure([
Bram Moolenaar9aed7292020-12-18 15:38:00 +01002380 'vim9script',
2381 'var svar = 123',
Bram Moolenaar55759b52020-09-30 22:59:42 +02002382 'def Func()',
2383 ' unlet s:svar',
2384 'enddef',
2385 'defcompile',
2386 ], 'E1081:')
2387
Bram Moolenaar62aec932022-01-29 21:45:34 +00002388 v9.CheckScriptFailure([
Bram Moolenaar71b76852021-12-17 20:15:38 +00002389 'vim9script',
2390 'def Delcount(dict: dict<any>)',
2391 ' unlet dict.count',
2392 'enddef',
2393 'Delcount(v:)',
2394 ], 'E742:')
2395
Bram Moolenaar62aec932022-01-29 21:45:34 +00002396 v9.CheckScriptFailure([
Bram Moolenaar71b76852021-12-17 20:15:38 +00002397 'vim9script',
2398 'def DelChangedtick(dict: dict<any>)',
2399 ' unlet dict.changedtick',
2400 'enddef',
2401 'DelChangedtick(b:)',
2402 ], 'E795:')
2403
Bram Moolenaar0acbf5a2021-01-05 20:58:25 +01002404 writefile(['vim9script', 'export var svar = 1234'], 'XunletExport.vim')
2405 var lines =<< trim END
2406 vim9script
Bram Moolenaard5f400c2022-01-06 21:10:28 +00002407 import './XunletExport.vim' as exp
Bram Moolenaar0acbf5a2021-01-05 20:58:25 +01002408 def UnletSvar()
Bram Moolenaard5f400c2022-01-06 21:10:28 +00002409 unlet exp.svar
Bram Moolenaar0acbf5a2021-01-05 20:58:25 +01002410 enddef
2411 defcompile
2412 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002413 v9.CheckScriptFailure(lines, 'E1260:', 1)
Bram Moolenaar0acbf5a2021-01-05 20:58:25 +01002414 delete('XunletExport.vim')
2415
Bram Moolenaar55759b52020-09-30 22:59:42 +02002416 $ENVVAR = 'foobar'
2417 assert_equal('foobar', $ENVVAR)
2418 unlet $ENVVAR
2419 assert_equal('', $ENVVAR)
2420enddef
2421
Bram Moolenaarc5f59fa2021-01-21 12:34:14 +01002422def Test_expr_error_no_assign()
2423 var lines =<< trim END
2424 vim9script
2425 var x = invalid
2426 echo x
2427 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002428 v9.CheckScriptFailureList(lines, ['E121:', 'E121:'])
Bram Moolenaarc5f59fa2021-01-21 12:34:14 +01002429
2430 lines =<< trim END
2431 vim9script
2432 var x = 1 / 0
2433 echo x
2434 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002435 v9.CheckScriptFailure(lines, 'E1154:')
Bram Moolenaarc5f59fa2021-01-21 12:34:14 +01002436
2437 lines =<< trim END
2438 vim9script
2439 var x = 1 % 0
2440 echo x
2441 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002442 v9.CheckScriptFailure(lines, 'E1154:')
Bram Moolenaarccc25aa2021-03-26 21:27:52 +01002443
2444 lines =<< trim END
2445 var x: string 'string'
2446 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002447 v9.CheckDefAndScriptFailure(lines, 'E488:')
Bram Moolenaarc5f59fa2021-01-21 12:34:14 +01002448enddef
2449
2450
Bram Moolenaar17126b12021-01-07 22:03:02 +01002451def Test_assign_command_modifier()
2452 var lines =<< trim END
Bram Moolenaar9e0f8832021-01-09 12:09:22 +01002453 var verbose = 0
2454 verbose = 1
2455 assert_equal(1, verbose)
2456 silent verbose = 2
2457 assert_equal(2, verbose)
2458 silent verbose += 2
2459 assert_equal(4, verbose)
2460 silent verbose -= 1
2461 assert_equal(3, verbose)
Bram Moolenaar17126b12021-01-07 22:03:02 +01002462
Bram Moolenaar9e0f8832021-01-09 12:09:22 +01002463 var topleft = {one: 1}
2464 sandbox topleft.one = 3
2465 assert_equal({one: 3}, topleft)
2466 leftabove topleft[' '] = 4
2467 assert_equal({one: 3, ' ': 4}, topleft)
2468
2469 var x: number
2470 var y: number
2471 silent [x, y] = [1, 2]
2472 assert_equal(1, x)
2473 assert_equal(2, y)
Bram Moolenaar17126b12021-01-07 22:03:02 +01002474 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002475 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar17126b12021-01-07 22:03:02 +01002476enddef
2477
Bram Moolenaar74f4a962021-06-17 21:03:07 +02002478def Test_assign_alt_buf_register()
2479 var lines =<< trim END
2480 edit 'file_b1'
2481 var b1 = bufnr()
2482 edit 'file_b2'
2483 var b2 = bufnr()
2484 assert_equal(b1, bufnr('#'))
2485 @# = b2
2486 assert_equal(b2, bufnr('#'))
2487 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002488 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar74f4a962021-06-17 21:03:07 +02002489enddef
2490
Bram Moolenaar32154662021-03-28 21:14:06 +02002491def Test_script_funcref_case()
2492 var lines =<< trim END
2493 var Len = (s: string): number => len(s) + 1
2494 assert_equal(5, Len('asdf'))
2495 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002496 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar32154662021-03-28 21:14:06 +02002497
2498 lines =<< trim END
2499 var len = (s: string): number => len(s) + 1
2500 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002501 v9.CheckDefAndScriptFailure(lines, 'E704:')
Bram Moolenaar32154662021-03-28 21:14:06 +02002502
2503 lines =<< trim END
2504 vim9script
Bram Moolenaara749a422022-02-12 19:52:25 +00002505 var Len = (s: string): number => len(s) + 2
Bram Moolenaar32154662021-03-28 21:14:06 +02002506 assert_equal(6, Len('asdf'))
2507 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002508 v9.CheckScriptSuccess(lines)
Bram Moolenaar32154662021-03-28 21:14:06 +02002509
2510 lines =<< trim END
2511 vim9script
Bram Moolenaara749a422022-02-12 19:52:25 +00002512 var len = (s: string): number => len(s) + 1
Bram Moolenaar32154662021-03-28 21:14:06 +02002513 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002514 v9.CheckScriptFailure(lines, 'E704:')
Bram Moolenaar32154662021-03-28 21:14:06 +02002515enddef
2516
Bram Moolenaar44a89772021-12-18 12:31:33 +00002517def Test_script_funcref_runtime_type_check()
2518 var lines =<< trim END
2519 vim9script
2520 def FuncWithNumberArg(n: number)
2521 enddef
2522 def Test()
2523 var Ref: func(string) = function(FuncWithNumberArg)
2524 enddef
2525 defcompile
2526 END
2527 # OK at compile time
Bram Moolenaar62aec932022-01-29 21:45:34 +00002528 v9.CheckScriptSuccess(lines)
Bram Moolenaar44a89772021-12-18 12:31:33 +00002529
2530 # Type check fails at runtime
Bram Moolenaar62aec932022-01-29 21:45:34 +00002531 v9.CheckScriptFailure(lines + ['Test()'], 'E1012: Type mismatch; expected func(string) but got func(number)')
Bram Moolenaar44a89772021-12-18 12:31:33 +00002532enddef
2533
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02002534def Test_inc_dec()
2535 var lines =<< trim END
2536 var nr = 7
2537 ++nr
Bram Moolenaar730bf302021-04-24 20:43:56 +02002538 assert_equal(8, nr)
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02002539 --nr
Bram Moolenaar730bf302021-04-24 20:43:56 +02002540 assert_equal(7, nr)
Bram Moolenaarf3d30842021-06-25 19:29:30 +02002541 ++nr | ++nr
2542 assert_equal(9, nr)
2543 ++nr # comment
2544 assert_equal(10, nr)
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02002545
2546 var ll = [1, 2]
2547 --ll[0]
2548 ++ll[1]
Bram Moolenaar730bf302021-04-24 20:43:56 +02002549 assert_equal([0, 3], ll)
2550
2551 g:count = 1
2552 ++g:count
2553 --g:count
2554 assert_equal(1, g:count)
2555 unlet g:count
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02002556 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002557 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar22480d12021-06-25 21:31:09 +02002558
2559 lines =<< trim END
2560 var nr = 7
2561 ++ nr
2562 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002563 v9.CheckDefAndScriptFailure(lines, "E1202: No white space allowed after '++': ++ nr")
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02002564enddef
2565
Bram Moolenaar327d3ee2021-07-28 19:34:14 +02002566def Test_abort_after_error()
2567 # should abort after strpart() fails, not give another type error
2568 var lines =<< trim END
2569 vim9script
2570 var x: string
2571 x = strpart(1, 2)
2572 END
2573 writefile(lines, 'Xtestscript')
2574 var expected = 'E1174: String required for argument 1'
2575 assert_fails('so Xtestscript', [expected, expected], 3)
2576
2577 delete('Xtestscript')
2578enddef
2579
Bram Moolenaarafa048f2022-02-22 20:43:36 +00002580def Test_using_s_var_in_function()
2581 var lines =<< trim END
2582 vim9script
2583 var scriptlevel = 123
2584 def SomeFunc()
2585 echo s:scriptlevel
2586 enddef
2587 SomeFunc()
2588 END
2589 v9.CheckScriptFailure(lines, 'E1268:')
2590
2591 # OK in legacy script
2592 lines =<< trim END
2593 let s:scriptlevel = 123
2594 def s:SomeFunc()
2595 echo s:scriptlevel
2596 enddef
2597 call s:SomeFunc()
2598 END
2599 v9.CheckScriptSuccess(lines)
2600
2601 lines =<< trim END
2602 vim9script
2603 var scriptlevel = 123
2604 def SomeFunc()
2605 s:scriptlevel = 456
2606 enddef
2607 SomeFunc()
2608 END
2609 v9.CheckScriptFailure(lines, 'E1268:')
2610
2611 # OK in legacy script
2612 lines =<< trim END
2613 let s:scriptlevel = 123
2614 def s:SomeFunc()
2615 s:scriptlevel = 456
2616 enddef
2617 call s:SomeFunc()
2618 call assert_equal(456, s:scriptlevel)
2619 END
2620 v9.CheckScriptSuccess(lines)
2621enddef
2622
Bram Moolenaar327d3ee2021-07-28 19:34:14 +02002623
Bram Moolenaar55759b52020-09-30 22:59:42 +02002624
Bram Moolenaar971caf52020-09-21 22:21:42 +02002625" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker