blob: a13e3707c358bf53f50612e9171066c8fd45c0c6 [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
Bram Moolenaarec892232022-05-06 17:53:06 +0100296 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 Moolenaarbc6f2bf2022-05-06 14:29:09 +0100742def Test_redir_is_not_assign()
743 if false
744 redir => res
745 echo var_job
746 redir END
747 endif
748enddef
749
Bram Moolenaar81ed4962020-09-23 15:56:50 +0200750def Test_extend_list()
Yegappan Lakshmananefbfa862022-04-17 12:47:40 +0100751 # using uninitialized list assigns empty list
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200752 var lines =<< trim END
Bram Moolenaar07802042021-09-09 23:01:14 +0200753 var l1: list<number>
754 var l2 = l1
755 assert_true(l1 is l2)
756 l1 += [123]
757 assert_equal([123], l1)
758 assert_true(l1 is l2)
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100759 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000760 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar81ed4962020-09-23 15:56:50 +0200761
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100762 lines =<< trim END
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100763 var list: list<string>
764 extend(list, ['x'])
765 assert_equal(['x'], list)
Bram Moolenaar81ed4962020-09-23 15:56:50 +0200766 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000767 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar1a739232020-10-10 15:37:58 +0200768
Yegappan Lakshmananefbfa862022-04-17 12:47:40 +0100769 # appending to uninitialized list from a function works
Bram Moolenaar1a739232020-10-10 15:37:58 +0200770 lines =<< trim END
771 vim9script
772 var list: list<string>
773 def Func()
774 list += ['a', 'b']
775 enddef
776 Func()
777 assert_equal(['a', 'b'], list)
778 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000779 v9.CheckScriptSuccess(lines)
Bram Moolenaar3beaf9c2020-12-18 17:23:14 +0100780 lines =<< trim END
781 vim9script
782 var list: list<string>
783 def Func()
784 extend(list, ['x', 'b'])
785 enddef
786 Func()
787 assert_equal(['x', 'b'], list)
788 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000789 v9.CheckScriptSuccess(lines)
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100790
Bram Moolenaaraa7d0c22022-04-05 21:40:38 +0100791 # initialized to null, with type, does not default to empty list
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100792 lines =<< trim END
793 vim9script
794 var l: list<string> = test_null_list()
795 extend(l, ['x'])
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100796 END
Bram Moolenaaraa7d0c22022-04-05 21:40:38 +0100797 v9.CheckScriptFailure(lines, 'E1134:', 3)
798
799 # initialized to null, without type, does not default to empty list
800 lines =<< trim END
801 vim9script
802 var l = null_list
803 extend(l, ['x'])
804 END
805 v9.CheckScriptFailure(lines, 'E1134:', 3)
806
807 # assigned null, does not default to empty list
808 lines =<< trim END
809 vim9script
810 var l: list<string>
811 l = null_list
812 extend(l, ['x'])
813 END
814 v9.CheckScriptFailure(lines, 'E1134:', 4)
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100815
816 lines =<< trim END
817 vim9script
818 extend(test_null_list(), ['x'])
819 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000820 v9.CheckScriptFailure(lines, 'E1134:', 2)
Bram Moolenaar078a4612022-01-04 15:17:03 +0000821
822 # using global var has no declared type
823 g:myList = []
824 g:myList->extend([1])
825 g:myList->extend(['x'])
826 assert_equal([1, 'x'], g:myList)
827 unlet g:myList
828
829 # using declared list gives an error
830 lines =<< trim END
831 var l: list<number>
832 g:myList = l
833 g:myList->extend([1])
834 g:myList->extend(['x'])
835 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000836 v9.CheckDefExecAndScriptFailure(lines, 'E1013: Argument 2: type mismatch, expected list<number> but got list<string>', 4)
Bram Moolenaar078a4612022-01-04 15:17:03 +0000837 unlet g:myList
Bram Moolenaar160afdb2022-02-06 17:17:02 +0000838
839 lines =<< trim END
840 vim9script
841 var lds = [1, 2, 3]
842 def Func()
843 echo lds->extend(['x'])
844 enddef
845 defcompile
846 END
847 v9.CheckScriptFailure(lines, 'E1013:')
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100848enddef
849
850def Test_extend_dict()
851 var lines =<< trim END
852 vim9script
853 var d: dict<number>
Bram Moolenaare0de1712020-12-02 17:36:54 +0100854 extend(d, {a: 1})
855 assert_equal({a: 1}, d)
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100856
857 var d2: dict<number>
858 d2['one'] = 1
Bram Moolenaare0de1712020-12-02 17:36:54 +0100859 assert_equal({one: 1}, d2)
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100860 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000861 v9.CheckScriptSuccess(lines)
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100862
863 lines =<< trim END
864 vim9script
865 var d: dict<string> = test_null_dict()
Bram Moolenaare0de1712020-12-02 17:36:54 +0100866 extend(d, {a: 'x'})
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100867 END
Bram Moolenaaraa7d0c22022-04-05 21:40:38 +0100868 v9.CheckScriptFailure(lines, 'E1133:', 3)
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100869
870 lines =<< trim END
871 vim9script
Bram Moolenaare0de1712020-12-02 17:36:54 +0100872 extend(test_null_dict(), {a: 'x'})
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100873 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000874 v9.CheckScriptFailure(lines, 'E1133:', 2)
Bram Moolenaar81ed4962020-09-23 15:56:50 +0200875enddef
876
Bram Moolenaar971caf52020-09-21 22:21:42 +0200877def Test_single_letter_vars()
878 # single letter variables
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200879 var a: number = 123
Bram Moolenaar971caf52020-09-21 22:21:42 +0200880 a = 123
881 assert_equal(123, a)
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200882 var b: number
Bram Moolenaar971caf52020-09-21 22:21:42 +0200883 b = 123
884 assert_equal(123, b)
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200885 var g: number
Bram Moolenaar971caf52020-09-21 22:21:42 +0200886 g = 123
887 assert_equal(123, g)
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200888 var s: number
Bram Moolenaar971caf52020-09-21 22:21:42 +0200889 s = 123
890 assert_equal(123, s)
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200891 var t: number
Bram Moolenaar971caf52020-09-21 22:21:42 +0200892 t = 123
893 assert_equal(123, t)
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200894 var v: number
Bram Moolenaar971caf52020-09-21 22:21:42 +0200895 v = 123
896 assert_equal(123, v)
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200897 var w: number
Bram Moolenaar971caf52020-09-21 22:21:42 +0200898 w = 123
899 assert_equal(123, w)
900enddef
901
902def Test_vim9_single_char_vars()
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200903 var lines =<< trim END
Bram Moolenaar971caf52020-09-21 22:21:42 +0200904 vim9script
905
906 # single character variable declarations work
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200907 var a: string
908 var b: number
909 var l: list<any>
910 var s: string
911 var t: number
912 var v: number
913 var w: number
Bram Moolenaar971caf52020-09-21 22:21:42 +0200914
915 # script-local variables can be used without s: prefix
916 a = 'script-a'
917 b = 111
918 l = [1, 2, 3]
919 s = 'script-s'
920 t = 222
921 v = 333
922 w = 444
923
924 assert_equal('script-a', a)
925 assert_equal(111, b)
926 assert_equal([1, 2, 3], l)
927 assert_equal('script-s', s)
928 assert_equal(222, t)
929 assert_equal(333, v)
930 assert_equal(444, w)
931 END
932 writefile(lines, 'Xsinglechar')
933 source Xsinglechar
934 delete('Xsinglechar')
935enddef
936
937def Test_assignment_list()
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200938 var list1: list<bool> = [false, true, false]
939 var list2: list<number> = [1, 2, 3]
940 var list3: list<string> = ['sdf', 'asdf']
941 var list4: list<any> = ['yes', true, 1234]
942 var list5: list<blob> = [0z01, 0z02]
Bram Moolenaar971caf52020-09-21 22:21:42 +0200943
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200944 var listS: list<string> = []
945 var listN: list<number> = []
Bram Moolenaar971caf52020-09-21 22:21:42 +0200946
947 assert_equal([1, 2, 3], list2)
948 list2[-1] = 99
949 assert_equal([1, 2, 99], list2)
950 list2[-2] = 88
951 assert_equal([1, 88, 99], list2)
952 list2[-3] = 77
953 assert_equal([77, 88, 99], list2)
954 list2 += [100]
955 assert_equal([77, 88, 99, 100], list2)
956
957 list3 += ['end']
958 assert_equal(['sdf', 'asdf', 'end'], list3)
959
Bram Moolenaar62aec932022-01-29 21:45:34 +0000960 v9.CheckDefExecFailure(['var ll = [1, 2, 3]', 'll[-4] = 6'], 'E684:')
Bram Moolenaar6296d1e2022-02-17 16:30:11 +0000961 v9.CheckDefExecFailure(['var ll = [1, 2, 3]', 'unlet ll[8 : 9]'], 'E684:')
962 v9.CheckDefExecFailure(['var ll = [1, 2, 3]', 'unlet ll[1 : -9]'], 'E684:')
963 v9.CheckDefExecFailure(['var ll = [1, 2, 3]', 'unlet ll[2 : 1]'], 'E684:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200964
965 # type becomes list<any>
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200966 var somelist = rand() > 0 ? [1, 2, 3] : ['a', 'b', 'c']
Bram Moolenaar4f5e3972020-12-21 17:30:50 +0100967
Bram Moolenaar114dbda2022-01-03 12:28:03 +0000968 # type is list<any> even though initializer is list<number>
969 var anyList: list<any> = [0]
970 assert_equal([0, 'x'], extend(anyList, ['x']))
971
Bram Moolenaar4f5e3972020-12-21 17:30:50 +0100972 var lines =<< trim END
973 var d = {dd: test_null_list()}
974 d.dd[0] = 0
975 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000976 v9.CheckDefExecFailure(lines, 'E1147:', 2)
Bram Moolenaar7a40ff02021-07-04 15:54:08 +0200977
978 lines =<< trim END
979 def OneArg(x: bool)
980 enddef
981 def TwoArgs(x: bool, y: bool)
982 enddef
983 var fl: list<func(bool, bool, bool)> = [OneArg, TwoArgs]
984 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000985 v9.CheckDefExecAndScriptFailure(lines, 'E1012:', 5)
Bram Moolenaar971caf52020-09-21 22:21:42 +0200986enddef
987
Bram Moolenaarab36e6a2021-11-30 16:14:49 +0000988def Test_list_declaration()
989 var [v1, v2] = [1, 2]
990 v1 += 3
991 assert_equal(4, v1)
992 v2 *= 3
993 assert_equal(6, v2)
994
995 var lines =<< trim END
996 var [v1, v2] = [1]
997 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000998 v9.CheckDefExecAndScriptFailure(lines, ['E1093: Expected 2 items but got 1', 'E688:'])
Bram Moolenaarab36e6a2021-11-30 16:14:49 +0000999 lines =<< trim END
1000 var testlist = [1]
1001 var [v1, v2] = testlist
1002 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001003 v9.CheckDefExecAndScriptFailure(lines, ['E1093: Expected 2 items but got 1', 'E688:'])
Bram Moolenaarab36e6a2021-11-30 16:14:49 +00001004 lines =<< trim END
1005 var [v1, v2] = [1, 2, 3]
1006 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001007 v9.CheckDefExecAndScriptFailure(lines, ['E1093: Expected 2 items but got 3', 'E687:'])
Bram Moolenaarab36e6a2021-11-30 16:14:49 +00001008 lines =<< trim END
1009 var testlist = [1, 2, 3]
1010 var [v1, v2] = testlist
1011 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001012 v9.CheckDefExecAndScriptFailure(lines, ['E1093: Expected 2 items but got 3', 'E687:'])
Bram Moolenaarab36e6a2021-11-30 16:14:49 +00001013
1014 var [vnr, vstr] = [123, 'text']
1015 vnr += 3
1016 assert_equal(126, vnr)
1017 vstr ..= 'end'
1018 assert_equal('textend', vstr)
1019
1020 var [vnr2: number, vstr2: string] = [123, 'text']
1021 vnr2 += 3
1022 assert_equal(126, vnr2)
1023 vstr2 ..= 'end'
1024 assert_equal('textend', vstr2)
1025
1026 var [vnr3: number; vlist: list<string>] = [123, 'foo', 'bar']
1027 vnr3 += 5
1028 assert_equal(128, vnr3)
1029 assert_equal(['foo', 'bar'], vlist)
1030
1031 lines =<< trim END
1032 var [vnr2: number, vstr2: number] = [123, 'text']
1033 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001034 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 +00001035 lines =<< trim END
1036 var testlist = [234, 'text']
1037 var [vnr2: number, vstr2: number] = testlist
1038 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001039 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 +00001040enddef
1041
Bram Moolenaar97f227d2021-07-04 20:20:52 +02001042def PartFuncBool(b: bool): string
Bram Moolenaarb7480cd2021-07-04 18:28:15 +02001043 return 'done'
1044enddef
1045
1046def Test_assignment_partial()
Bram Moolenaar97f227d2021-07-04 20:20:52 +02001047 var lines =<< trim END
Bram Moolenaar848fadd2022-01-30 15:28:30 +00001048 var Partial: func(): string = function(g:PartFuncBool, [true])
Bram Moolenaar97f227d2021-07-04 20:20:52 +02001049 assert_equal('done', Partial())
1050 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001051 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar22f85d02021-07-04 23:29:30 +02001052
1053 lines =<< trim END
1054 vim9script
1055 def Func(b: bool)
1056 enddef
1057 var Ref: func = function(Func, [true])
1058 assert_equal('func()', typename(Ref))
1059 Ref()
1060 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001061 v9.CheckScriptSuccess(lines)
Bram Moolenaar13789bf2021-12-30 13:29:00 +00001062
1063 lines =<< trim END
1064 vim9script
1065
1066 var nres: any
1067 var sres: any
Bram Moolenaar9a015112021-12-31 14:06:45 +00001068 def Func(nr: number, s = '')
1069 nres = nr
Bram Moolenaar13789bf2021-12-30 13:29:00 +00001070 sres = s
1071 enddef
1072
1073 var n: number
1074 var Ref = function(Func, [n])
1075 Ref('x')
1076 assert_equal(0, nres)
1077 assert_equal('x', sres)
1078 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001079 v9.CheckScriptSuccess(lines)
Bram Moolenaar13789bf2021-12-30 13:29:00 +00001080
1081 lines =<< trim END
1082 vim9script
1083
Bram Moolenaar9a015112021-12-31 14:06:45 +00001084 def Func(nr: number, s = '')
Bram Moolenaar13789bf2021-12-30 13:29:00 +00001085 enddef
1086
1087 var n: number
1088 var Ref = function(Func, [n])
1089 Ref(0)
1090 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001091 v9.CheckScriptFailure(lines, 'E1013: Argument 2: type mismatch, expected string but got number')
Bram Moolenaarb7480cd2021-07-04 18:28:15 +02001092enddef
1093
Bram Moolenaarf30a14d2021-01-17 21:51:24 +01001094def Test_assignment_list_any_index()
1095 var l: list<number> = [1, 2]
1096 for [x, y, _]
1097 in [[0, 1, ''], [1, 3, '']]
1098 l[x] = l[x] + y
1099 endfor
1100 assert_equal([2, 5], l)
1101enddef
1102
Bram Moolenaar971caf52020-09-21 22:21:42 +02001103def Test_assignment_list_vim9script()
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001104 var lines =<< trim END
Bram Moolenaar971caf52020-09-21 22:21:42 +02001105 vim9script
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001106 var v1: number
1107 var v2: number
1108 var v3: number
Bram Moolenaar971caf52020-09-21 22:21:42 +02001109 [v1, v2, v3] = [1, 2, 3]
1110 assert_equal([1, 2, 3], [v1, v2, v3])
1111 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001112 v9.CheckScriptSuccess(lines)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001113enddef
1114
1115def Test_assignment_dict()
Bram Moolenaare0de1712020-12-02 17:36:54 +01001116 var dict1: dict<bool> = {one: false, two: true}
1117 var dict2: dict<number> = {one: 1, two: 2}
1118 var dict3: dict<string> = {key: 'value'}
1119 var dict4: dict<any> = {one: 1, two: '2'}
1120 var dict5: dict<blob> = {one: 0z01, two: 0z02}
Bram Moolenaar971caf52020-09-21 22:21:42 +02001121
1122 # overwrite
1123 dict3['key'] = 'another'
Bram Moolenaare0de1712020-12-02 17:36:54 +01001124 assert_equal(dict3, {key: 'another'})
Bram Moolenaarfc74d032020-11-16 22:11:49 +01001125 dict3.key = 'yet another'
Bram Moolenaare0de1712020-12-02 17:36:54 +01001126 assert_equal(dict3, {key: 'yet another'})
Bram Moolenaarfc74d032020-11-16 22:11:49 +01001127
Bram Moolenaard24602f2020-12-20 15:20:56 +01001128 # member "any" can also be a dict and assigned to
1129 var anydict: dict<any> = {nest: {}, nr: 0}
1130 anydict.nest['this'] = 123
1131 anydict.nest.that = 456
1132 assert_equal({nest: {this: 123, that: 456}, nr: 0}, anydict)
1133
Bram Moolenaarfc74d032020-11-16 22:11:49 +01001134 var lines =<< trim END
Bram Moolenaard88dc4d2020-12-20 14:49:42 +01001135 var dd = {}
1136 dd.two = 2
1137 assert_equal({two: 2}, dd)
1138 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001139 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar4f5e3972020-12-21 17:30:50 +01001140
1141 lines =<< trim END
1142 var d = {dd: {}}
1143 d.dd[0] = 2
1144 d.dd['x'] = 3
1145 d.dd.y = 4
1146 assert_equal({dd: {0: 2, x: 3, y: 4}}, d)
1147 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001148 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaard88dc4d2020-12-20 14:49:42 +01001149
1150 lines =<< trim END
Bram Moolenaar2e17fef2022-03-18 19:44:48 +00001151 var key = 'foo'
1152 g:[key] = 'value'
1153 assert_equal('value', g:foo)
1154 unlet g:foo
1155 END
1156 v9.CheckDefAndScriptSuccess(lines)
1157
1158 lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +01001159 var dd = {one: 1}
Bram Moolenaarfc74d032020-11-16 22:11:49 +01001160 dd.one) = 2
1161 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001162 v9.CheckDefFailure(lines, 'E488:', 2)
Bram Moolenaard88dc4d2020-12-20 14:49:42 +01001163
1164 lines =<< trim END
1165 var dd = {one: 1}
1166 var dd.one = 2
1167 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001168 v9.CheckDefAndScriptFailure(lines, 'E1017:', 2)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001169
1170 # empty key can be used
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001171 var dd = {}
Bram Moolenaar971caf52020-09-21 22:21:42 +02001172 dd[""] = 6
Bram Moolenaare0de1712020-12-02 17:36:54 +01001173 assert_equal({['']: 6}, dd)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001174
1175 # type becomes dict<any>
Bram Moolenaare0de1712020-12-02 17:36:54 +01001176 var somedict = rand() > 0 ? {a: 1, b: 2} : {a: 'a', b: 'b'}
Bram Moolenaar971caf52020-09-21 22:21:42 +02001177
Bram Moolenaar114dbda2022-01-03 12:28:03 +00001178 # type is dict<any> even though initializer is dict<number>
1179 var anyDict: dict<any> = {a: 0}
1180 assert_equal({a: 0, b: 'x'}, extend(anyDict, {b: 'x'}))
1181
Bram Moolenaar078a4612022-01-04 15:17:03 +00001182 # using global var, which has no declared type
1183 g:myDict = {}
1184 g:myDict->extend({a: 1})
1185 g:myDict->extend({b: 'x'})
1186 assert_equal({a: 1, b: 'x'}, g:myDict)
1187 unlet g:myDict
1188
1189 # using list with declared type gives an error
1190 lines =<< trim END
1191 var d: dict<number>
1192 g:myDict = d
1193 g:myDict->extend({a: 1})
1194 g:myDict->extend({b: 'x'})
1195 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001196 v9.CheckDefExecAndScriptFailure(lines, 'E1013: Argument 2: type mismatch, expected dict<number> but got dict<string>', 4)
Bram Moolenaar078a4612022-01-04 15:17:03 +00001197 unlet g:myDict
1198
Bram Moolenaar971caf52020-09-21 22:21:42 +02001199 # assignment to script-local dict
Bram Moolenaarfc74d032020-11-16 22:11:49 +01001200 lines =<< trim END
Bram Moolenaar971caf52020-09-21 22:21:42 +02001201 vim9script
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001202 var test: dict<any> = {}
Bram Moolenaar971caf52020-09-21 22:21:42 +02001203 def FillDict(): dict<any>
1204 test['a'] = 43
1205 return test
1206 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +01001207 assert_equal({a: 43}, FillDict())
Bram Moolenaar971caf52020-09-21 22:21:42 +02001208 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001209 v9.CheckScriptSuccess(lines)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001210
1211 lines =<< trim END
1212 vim9script
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001213 var test: dict<any>
Bram Moolenaar971caf52020-09-21 22:21:42 +02001214 def FillDict(): dict<any>
1215 test['a'] = 43
1216 return test
1217 enddef
1218 FillDict()
Bram Moolenaar3beaf9c2020-12-18 17:23:14 +01001219 assert_equal({a: 43}, test)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001220 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001221 v9.CheckScriptSuccess(lines)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001222
1223 # assignment to global dict
1224 lines =<< trim END
1225 vim9script
1226 g:test = {}
1227 def FillDict(): dict<any>
1228 g:test['a'] = 43
1229 return g:test
1230 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +01001231 assert_equal({a: 43}, FillDict())
Bram Moolenaar971caf52020-09-21 22:21:42 +02001232 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001233 v9.CheckScriptSuccess(lines)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001234
1235 # assignment to buffer dict
1236 lines =<< trim END
1237 vim9script
1238 b:test = {}
1239 def FillDict(): dict<any>
1240 b:test['a'] = 43
1241 return b:test
1242 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +01001243 assert_equal({a: 43}, FillDict())
Bram Moolenaar971caf52020-09-21 22:21:42 +02001244 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001245 v9.CheckScriptSuccess(lines)
Bram Moolenaar4f5e3972020-12-21 17:30:50 +01001246
1247 lines =<< trim END
1248 var d = {dd: test_null_dict()}
1249 d.dd[0] = 0
1250 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001251 v9.CheckDefExecFailure(lines, 'E1103:', 2)
Bram Moolenaar4f5e3972020-12-21 17:30:50 +01001252
1253 lines =<< trim END
1254 var d = {dd: 'string'}
1255 d.dd[0] = 0
1256 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001257 v9.CheckDefExecFailure(lines, 'E1148:', 2)
Bram Moolenaar3a3b10e2021-06-26 15:00:59 +02001258
1259 lines =<< trim END
1260 var n: any
1261 n.key = 5
1262 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001263 v9.CheckDefExecAndScriptFailure(lines, ['E1148:', 'E1203: Dot can only be used on a dictionary: n.key = 5'], 2)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001264enddef
1265
1266def Test_assignment_local()
1267 # Test in a separated file in order not to the current buffer/window/tab is
1268 # changed.
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001269 var script_lines: list<string> =<< trim END
Bram Moolenaar971caf52020-09-21 22:21:42 +02001270 let b:existing = 'yes'
1271 let w:existing = 'yes'
1272 let t:existing = 'yes'
1273
1274 def Test_assignment_local_internal()
1275 b:newvar = 'new'
1276 assert_equal('new', b:newvar)
1277 assert_equal('yes', b:existing)
1278 b:existing = 'no'
1279 assert_equal('no', b:existing)
1280 b:existing ..= 'NO'
1281 assert_equal('noNO', b:existing)
1282
1283 w:newvar = 'new'
1284 assert_equal('new', w:newvar)
1285 assert_equal('yes', w:existing)
1286 w:existing = 'no'
1287 assert_equal('no', w:existing)
1288 w:existing ..= 'NO'
1289 assert_equal('noNO', w:existing)
1290
1291 t:newvar = 'new'
1292 assert_equal('new', t:newvar)
1293 assert_equal('yes', t:existing)
1294 t:existing = 'no'
1295 assert_equal('no', t:existing)
1296 t:existing ..= 'NO'
1297 assert_equal('noNO', t:existing)
1298 enddef
1299 call Test_assignment_local_internal()
1300 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001301 v9.CheckScriptSuccess(script_lines)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001302enddef
1303
1304def Test_assignment_default()
Bram Moolenaar971caf52020-09-21 22:21:42 +02001305 # Test default values.
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001306 var thebool: bool
Bram Moolenaar971caf52020-09-21 22:21:42 +02001307 assert_equal(v:false, thebool)
1308
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001309 var thenumber: number
Bram Moolenaar971caf52020-09-21 22:21:42 +02001310 assert_equal(0, thenumber)
1311
1312 if has('float')
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001313 var thefloat: float
Bram Moolenaar971caf52020-09-21 22:21:42 +02001314 assert_equal(0.0, thefloat)
1315 endif
1316
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001317 var thestring: string
Bram Moolenaar971caf52020-09-21 22:21:42 +02001318 assert_equal('', thestring)
1319
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001320 var theblob: blob
Bram Moolenaar971caf52020-09-21 22:21:42 +02001321 assert_equal(0z, theblob)
1322
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001323 var Thefunc: func
Bram Moolenaar971caf52020-09-21 22:21:42 +02001324 assert_equal(test_null_function(), Thefunc)
1325
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001326 var thelist: list<any>
Bram Moolenaar971caf52020-09-21 22:21:42 +02001327 assert_equal([], thelist)
1328
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001329 var thedict: dict<any>
Bram Moolenaar971caf52020-09-21 22:21:42 +02001330 assert_equal({}, thedict)
1331
1332 if has('channel')
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001333 var thejob: job
Bram Moolenaar971caf52020-09-21 22:21:42 +02001334 assert_equal(test_null_job(), thejob)
1335
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001336 var thechannel: channel
Bram Moolenaar971caf52020-09-21 22:21:42 +02001337 assert_equal(test_null_channel(), thechannel)
1338
1339 if has('unix') && executable('cat')
1340 # check with non-null job and channel, types must match
Bram Moolenaare0de1712020-12-02 17:36:54 +01001341 thejob = job_start("cat ", {})
Bram Moolenaar971caf52020-09-21 22:21:42 +02001342 thechannel = job_getchannel(thejob)
1343 job_stop(thejob, 'kill')
1344 endif
1345 endif
1346
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001347 var nr = 1234 | nr = 5678
Bram Moolenaar971caf52020-09-21 22:21:42 +02001348 assert_equal(5678, nr)
1349enddef
1350
Bram Moolenaare08be092022-02-17 13:08:26 +00001351def Test_script_var_default()
1352 var lines =<< trim END
1353 vim9script
1354 var l: list<number>
Bram Moolenaar1983f1a2022-02-28 20:55:02 +00001355 var li = [1, 2]
Bram Moolenaare08be092022-02-17 13:08:26 +00001356 var bl: blob
Bram Moolenaar1983f1a2022-02-28 20:55:02 +00001357 var bli = 0z12
Bram Moolenaare08be092022-02-17 13:08:26 +00001358 var d: dict<number>
Bram Moolenaar1983f1a2022-02-28 20:55:02 +00001359 var di = {'a': 1, 'b': 2}
Bram Moolenaare08be092022-02-17 13:08:26 +00001360 def Echo()
1361 assert_equal([], l)
Bram Moolenaar1983f1a2022-02-28 20:55:02 +00001362 assert_equal([1, 2], li)
Bram Moolenaare08be092022-02-17 13:08:26 +00001363 assert_equal(0z, bl)
Bram Moolenaar1983f1a2022-02-28 20:55:02 +00001364 assert_equal(0z12, bli)
Bram Moolenaare08be092022-02-17 13:08:26 +00001365 assert_equal({}, d)
Bram Moolenaar1983f1a2022-02-28 20:55:02 +00001366 assert_equal({'a': 1, 'b': 2}, di)
Bram Moolenaare08be092022-02-17 13:08:26 +00001367 enddef
Bram Moolenaarea5c8982022-02-17 14:42:02 +00001368 Echo()
Bram Moolenaare08be092022-02-17 13:08:26 +00001369 END
1370 v9.CheckScriptSuccess(lines)
1371enddef
1372
Bram Moolenaara749a422022-02-12 19:52:25 +00001373let s:scriptvar = 'init'
Bram Moolenaar3862ea32021-01-01 21:05:55 +01001374
Bram Moolenaar971caf52020-09-21 22:21:42 +02001375def Test_assignment_var_list()
Bram Moolenaarda7c20c2020-11-30 21:12:19 +01001376 var lines =<< trim END
1377 var v1: string
1378 var v2: string
1379 var vrem: list<string>
1380 [v1] = ['aaa']
1381 assert_equal('aaa', v1)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001382
Bram Moolenaarda7c20c2020-11-30 21:12:19 +01001383 [v1, v2] = ['one', 'two']
1384 assert_equal('one', v1)
1385 assert_equal('two', v2)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001386
Bram Moolenaarda7c20c2020-11-30 21:12:19 +01001387 [v1, v2; vrem] = ['one', 'two']
1388 assert_equal('one', v1)
1389 assert_equal('two', v2)
1390 assert_equal([], vrem)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001391
Bram Moolenaarda7c20c2020-11-30 21:12:19 +01001392 [v1, v2; vrem] = ['one', 'two', 'three']
1393 assert_equal('one', v1)
1394 assert_equal('two', v2)
1395 assert_equal(['three'], vrem)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001396
Bram Moolenaarda7c20c2020-11-30 21:12:19 +01001397 [&ts, &sw] = [3, 4]
1398 assert_equal(3, &ts)
1399 assert_equal(4, &sw)
1400 set ts=8 sw=4
Bram Moolenaar004d9b02020-11-30 21:40:03 +01001401
1402 [@a, @z] = ['aa', 'zz']
1403 assert_equal('aa', @a)
1404 assert_equal('zz', @z)
1405
1406 [$SOME_VAR, $OTHER_VAR] = ['some', 'other']
1407 assert_equal('some', $SOME_VAR)
1408 assert_equal('other', $OTHER_VAR)
1409
Bram Moolenaar3862ea32021-01-01 21:05:55 +01001410 [g:globalvar, b:bufvar, w:winvar, t:tabvar, v:errmsg] =
1411 ['global', 'buf', 'win', 'tab', 'error']
Bram Moolenaar004d9b02020-11-30 21:40:03 +01001412 assert_equal('global', g:globalvar)
Bram Moolenaar004d9b02020-11-30 21:40:03 +01001413 assert_equal('buf', b:bufvar)
1414 assert_equal('win', w:winvar)
1415 assert_equal('tab', t:tabvar)
1416 assert_equal('error', v:errmsg)
1417 unlet g:globalvar
Bram Moolenaarda7c20c2020-11-30 21:12:19 +01001418 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001419 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar3862ea32021-01-01 21:05:55 +01001420
Bram Moolenaara749a422022-02-12 19:52:25 +00001421 [g:globalvar, scriptvar, b:bufvar] = ['global', 'script', 'buf']
Bram Moolenaar3862ea32021-01-01 21:05:55 +01001422 assert_equal('global', g:globalvar)
Bram Moolenaara749a422022-02-12 19:52:25 +00001423 assert_equal('script', scriptvar)
Bram Moolenaar3862ea32021-01-01 21:05:55 +01001424 assert_equal('buf', b:bufvar)
1425
1426 lines =<< trim END
1427 vim9script
Bram Moolenaara749a422022-02-12 19:52:25 +00001428 var scriptvar = 'init'
1429 [g:globalvar, scriptvar, w:winvar] = ['global', 'script', 'win']
Bram Moolenaar3862ea32021-01-01 21:05:55 +01001430 assert_equal('global', g:globalvar)
Bram Moolenaara749a422022-02-12 19:52:25 +00001431 assert_equal('script', scriptvar)
Bram Moolenaar3862ea32021-01-01 21:05:55 +01001432 assert_equal('win', w:winvar)
1433 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001434 v9.CheckScriptSuccess(lines)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001435enddef
1436
Bram Moolenaar2d3ac2e2022-02-03 12:34:05 +00001437def Test_assignment_empty_list()
1438 var lines =<< trim END
1439 var l2: list<any> = []
1440 var l: list<string>
1441 l = l2
1442 END
1443 v9.CheckDefAndScriptSuccess(lines)
1444enddef
1445
Bram Moolenaar971caf52020-09-21 22:21:42 +02001446def Test_assignment_vim9script()
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001447 var lines =<< trim END
Bram Moolenaar971caf52020-09-21 22:21:42 +02001448 vim9script
1449 def Func(): list<number>
1450 return [1, 2]
1451 enddef
Bram Moolenaar98309382020-09-27 21:58:45 +02001452 var name1: number
1453 var name2: number
1454 [name1, name2] =
Bram Moolenaar971caf52020-09-21 22:21:42 +02001455 Func()
Bram Moolenaar98309382020-09-27 21:58:45 +02001456 assert_equal(1, name1)
1457 assert_equal(2, name2)
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001458 var ll =
Bram Moolenaar971caf52020-09-21 22:21:42 +02001459 Func()
1460 assert_equal([1, 2], ll)
1461
1462 @/ = 'text'
1463 assert_equal('text', @/)
1464 @0 = 'zero'
1465 assert_equal('zero', @0)
1466 @1 = 'one'
1467 assert_equal('one', @1)
1468 @9 = 'nine'
1469 assert_equal('nine', @9)
1470 @- = 'minus'
1471 assert_equal('minus', @-)
1472 if has('clipboard_working')
1473 @* = 'star'
1474 assert_equal('star', @*)
1475 @+ = 'plus'
1476 assert_equal('plus', @+)
1477 endif
1478
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001479 var a: number = 123
Bram Moolenaar971caf52020-09-21 22:21:42 +02001480 assert_equal(123, a)
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001481 var s: string = 'yes'
Bram Moolenaar971caf52020-09-21 22:21:42 +02001482 assert_equal('yes', s)
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001483 var b: number = 42
Bram Moolenaar971caf52020-09-21 22:21:42 +02001484 assert_equal(42, b)
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001485 var w: number = 43
Bram Moolenaar971caf52020-09-21 22:21:42 +02001486 assert_equal(43, w)
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001487 var t: number = 44
Bram Moolenaar971caf52020-09-21 22:21:42 +02001488 assert_equal(44, t)
Bram Moolenaar7a66a172020-10-16 19:56:12 +02001489
1490 var to_var = 0
1491 to_var = 3
1492 assert_equal(3, to_var)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001493 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001494 v9.CheckScriptSuccess(lines)
Bram Moolenaar06f9c692020-09-27 21:27:40 +02001495
1496 lines =<< trim END
1497 vim9script
1498 var n: number
1499 def Func()
1500 n = 'string'
1501 enddef
1502 defcompile
1503 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001504 v9.CheckScriptFailure(lines, 'E1012: Type mismatch; expected number but got string')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001505enddef
1506
1507def Mess(): string
1508 v:foldstart = 123
1509 return 'xxx'
1510enddef
1511
1512def Test_assignment_failure()
Bram Moolenaar62aec932022-01-29 21:45:34 +00001513 v9.CheckDefFailure(['var name=234'], 'E1004:')
1514 v9.CheckDefFailure(['var name =234'], 'E1004:')
1515 v9.CheckDefFailure(['var name= 234'], 'E1004:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001516
Bram Moolenaar62aec932022-01-29 21:45:34 +00001517 v9.CheckScriptFailure(['vim9script', 'var name=234'], 'E1004:')
1518 v9.CheckScriptFailure(['vim9script', 'var name=234'], "before and after '='")
1519 v9.CheckScriptFailure(['vim9script', 'var name =234'], 'E1004:')
1520 v9.CheckScriptFailure(['vim9script', 'var name= 234'], 'E1004:')
1521 v9.CheckScriptFailure(['vim9script', 'var name = 234', 'name+=234'], 'E1004:')
1522 v9.CheckScriptFailure(['vim9script', 'var name = 234', 'name+=234'], "before and after '+='")
1523 v9.CheckScriptFailure(['vim9script', 'var name = "x"', 'name..="y"'], 'E1004:')
1524 v9.CheckScriptFailure(['vim9script', 'var name = "x"', 'name..="y"'], "before and after '..='")
Bram Moolenaar971caf52020-09-21 22:21:42 +02001525
Bram Moolenaar62aec932022-01-29 21:45:34 +00001526 v9.CheckDefFailure(['var true = 1'], 'E1034:')
1527 v9.CheckDefFailure(['var false = 1'], 'E1034:')
1528 v9.CheckDefFailure(['var null = 1'], 'E1034:')
1529 v9.CheckDefFailure(['var this = 1'], 'E1034:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001530
Bram Moolenaar8b716f52022-02-15 21:17:56 +00001531 v9.CheckDefFailure(['[a; b; c] = g:list'], 'E1001:')
1532 v9.CheckDefFailure(['var [a; b; c] = g:list'], 'E1080:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001533 v9.CheckDefExecFailure(['var a: number',
Bram Moolenaar971caf52020-09-21 22:21:42 +02001534 '[a] = test_null_list()'], 'E1093:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001535 v9.CheckDefExecFailure(['var a: number',
Bram Moolenaar971caf52020-09-21 22:21:42 +02001536 '[a] = []'], 'E1093:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001537 v9.CheckDefExecFailure(['var x: number',
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001538 'var y: number',
Bram Moolenaar971caf52020-09-21 22:21:42 +02001539 '[x, y] = [1]'], 'E1093:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001540 v9.CheckDefExecFailure(['var x: string',
Bram Moolenaar352134b2020-10-17 22:04:08 +02001541 'var y: string',
1542 '[x, y] = ["x"]'], 'E1093:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001543 v9.CheckDefExecFailure(['var x: number',
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001544 'var y: number',
1545 'var z: list<number>',
Bram Moolenaar971caf52020-09-21 22:21:42 +02001546 '[x, y; z] = [1]'], 'E1093:')
1547
Bram Moolenaar62aec932022-01-29 21:45:34 +00001548 v9.CheckDefFailure(['var somevar'], "E1022:")
1549 v9.CheckDefFailure(['var &tabstop = 4'], 'E1052:')
1550 v9.CheckDefFailure(['&g:option = 5'], 'E113:')
1551 v9.CheckScriptFailure(['vim9script', 'var &tabstop = 4'], 'E1052:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001552
Bram Moolenaar62aec932022-01-29 21:45:34 +00001553 v9.CheckDefFailure(['var $VAR = 5'], 'E1016: Cannot declare an environment variable:')
1554 v9.CheckScriptFailure(['vim9script', 'var $ENV = "xxx"'], 'E1016:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001555
1556 if has('dnd')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001557 v9.CheckDefFailure(['var @~ = 5'], 'E1066:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001558 else
Bram Moolenaar62aec932022-01-29 21:45:34 +00001559 v9.CheckDefFailure(['var @~ = 5'], 'E354:')
1560 v9.CheckDefFailure(['@~ = 5'], 'E354:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001561 endif
Bram Moolenaar62aec932022-01-29 21:45:34 +00001562 v9.CheckDefFailure(['var @a = 5'], 'E1066:')
1563 v9.CheckDefFailure(['var @/ = "x"'], 'E1066:')
1564 v9.CheckScriptFailure(['vim9script', 'var @a = "abc"'], 'E1066:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001565
Bram Moolenaar62aec932022-01-29 21:45:34 +00001566 v9.CheckDefFailure(['var g:var = 5'], 'E1016: Cannot declare a global variable:')
1567 v9.CheckDefFailure(['var w:var = 5'], 'E1016: Cannot declare a window variable:')
1568 v9.CheckDefFailure(['var b:var = 5'], 'E1016: Cannot declare a buffer variable:')
1569 v9.CheckDefFailure(['var t:var = 5'], 'E1016: Cannot declare a tab variable:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001570
Bram Moolenaar62aec932022-01-29 21:45:34 +00001571 v9.CheckDefFailure(['var anr = 4', 'anr ..= "text"'], 'E1019:')
1572 v9.CheckDefFailure(['var xnr += 4'], 'E1020:', 1)
1573 v9.CheckScriptFailure(['vim9script', 'var xnr += 4'], 'E1020:')
1574 v9.CheckDefFailure(["var xnr = xnr + 1"], 'E1001:', 1)
1575 v9.CheckScriptFailure(['vim9script', 'var xnr = xnr + 4'], 'E121:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001576
Bram Moolenaara749a422022-02-12 19:52:25 +00001577 v9.CheckScriptFailure(['vim9script', 'def Func()', 'var dummy = notfound', 'enddef', 'defcompile'], 'E1001:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001578
Bram Moolenaar62aec932022-01-29 21:45:34 +00001579 v9.CheckDefFailure(['var name: list<string> = [123]'], 'expected list<string> but got list<number>')
1580 v9.CheckDefFailure(['var name: list<number> = ["xx"]'], 'expected list<number> but got list<string>')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001581
Bram Moolenaar62aec932022-01-29 21:45:34 +00001582 v9.CheckDefFailure(['var name: dict<string> = {key: 123}'], 'expected dict<string> but got dict<number>')
1583 v9.CheckDefFailure(['var name: dict<number> = {key: "xx"}'], 'expected dict<number> but got dict<string>')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001584
Bram Moolenaar62aec932022-01-29 21:45:34 +00001585 v9.CheckDefFailure(['var name = feedkeys("0")'], 'E1031:')
1586 v9.CheckDefFailure(['var name: number = feedkeys("0")'], 'expected number but got void')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001587
Bram Moolenaar62aec932022-01-29 21:45:34 +00001588 v9.CheckDefFailure(['var name: dict <number>'], 'E1068:')
1589 v9.CheckDefFailure(['var name: dict<number'], 'E1009:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001590
Bram Moolenaar848fadd2022-01-30 15:28:30 +00001591 assert_fails('s/^/\=g:Mess()/n', 'E794:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001592 v9.CheckDefFailure(['var name: dict<number'], 'E1009:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001593
Bram Moolenaar62aec932022-01-29 21:45:34 +00001594 v9.CheckDefFailure(['w:foo: number = 10'],
Bram Moolenaar971caf52020-09-21 22:21:42 +02001595 'E488: Trailing characters: : number = 1')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001596 v9.CheckDefFailure(['t:foo: bool = true'],
Bram Moolenaar971caf52020-09-21 22:21:42 +02001597 'E488: Trailing characters: : bool = true')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001598 v9.CheckDefFailure(['b:foo: string = "x"'],
Bram Moolenaar971caf52020-09-21 22:21:42 +02001599 'E488: Trailing characters: : string = "x"')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001600 v9.CheckDefFailure(['g:foo: number = 123'],
Bram Moolenaar971caf52020-09-21 22:21:42 +02001601 'E488: Trailing characters: : number = 123')
1602enddef
1603
1604def Test_assign_list()
Bram Moolenaare65081d2021-06-27 15:04:05 +02001605 var lines =<< trim END
1606 var l: list<string> = []
1607 l[0] = 'value'
1608 assert_equal('value', l[0])
Bram Moolenaar971caf52020-09-21 22:21:42 +02001609
Bram Moolenaare65081d2021-06-27 15:04:05 +02001610 l[1] = 'asdf'
1611 assert_equal('value', l[0])
1612 assert_equal('asdf', l[1])
1613 assert_equal('asdf', l[-1])
1614 assert_equal('value', l[-2])
Bram Moolenaar971caf52020-09-21 22:21:42 +02001615
Bram Moolenaare65081d2021-06-27 15:04:05 +02001616 var nrl: list<number> = []
1617 for i in range(5)
1618 nrl[i] = i
1619 endfor
1620 assert_equal([0, 1, 2, 3, 4], nrl)
1621
1622 var ul: list<any>
1623 ul[0] = 1
1624 ul[1] = 2
1625 ul[2] = 3
1626 assert_equal([1, 2, 3], ul)
1627 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001628 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar334a8b42020-10-19 16:07:42 +02001629
Bram Moolenaar1983f1a2022-02-28 20:55:02 +00001630 lines =<< trim END
1631 var l = [1, 2]
1632 g:idx = 'x'
1633 l[g:idx : 1] = [0]
1634 echo l
1635 END
Bram Moolenaar2995e5c2022-03-18 21:41:47 +00001636 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 +00001637
1638 lines =<< trim END
1639 var l = [1, 2]
1640 g:idx = 3
1641 l[g:idx : 1] = [0]
1642 echo l
1643 END
Bram Moolenaarec892232022-05-06 17:53:06 +01001644 v9.CheckDefExecAndScriptFailure(lines, 'E684: List index out of range: 3')
Bram Moolenaar1983f1a2022-02-28 20:55:02 +00001645
1646 lines =<< trim END
1647 var l = [1, 2]
1648 g:idx = 'y'
1649 l[1 : g:idx] = [0]
1650 echo l
1651 END
1652 v9.CheckDefExecAndScriptFailure(lines, ['E1012: Type mismatch; expected number but got string', 'E1030: Using a String as a Number: "y"'])
1653
Bram Moolenaar62aec932022-01-29 21:45:34 +00001654 v9.CheckDefFailure(["var l: list<number> = ['', true]"], 'E1012: Type mismatch; expected list<number> but got list<any>', 1)
1655 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 +02001656enddef
1657
1658def Test_assign_dict()
Bram Moolenaarc3689572021-01-01 19:40:02 +01001659 var lines =<< trim END
1660 var d: dict<string> = {}
1661 d['key'] = 'value'
1662 assert_equal('value', d['key'])
Bram Moolenaar971caf52020-09-21 22:21:42 +02001663
Bram Moolenaarc3689572021-01-01 19:40:02 +01001664 d[123] = 'qwerty'
1665 assert_equal('qwerty', d[123])
1666 assert_equal('qwerty', d['123'])
Bram Moolenaar971caf52020-09-21 22:21:42 +02001667
Bram Moolenaarc3689572021-01-01 19:40:02 +01001668 var nrd: dict<number> = {}
1669 for i in range(3)
1670 nrd[i] = i
1671 endfor
1672 assert_equal({0: 0, 1: 1, 2: 2}, nrd)
1673
1674 d.somekey = 'someval'
1675 assert_equal({key: 'value', '123': 'qwerty', somekey: 'someval'}, d)
Bram Moolenaar23e2e112021-08-03 21:16:18 +02001676 unlet d.somekey
1677 assert_equal({key: 'value', '123': 'qwerty'}, d)
Bram Moolenaarc3689572021-01-01 19:40:02 +01001678 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001679 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarc3689572021-01-01 19:40:02 +01001680
Bram Moolenaar62aec932022-01-29 21:45:34 +00001681 v9.CheckDefFailure(["var d: dict<number> = {a: '', b: true}"], 'E1012: Type mismatch; expected dict<number> but got dict<any>', 1)
1682 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 +00001683 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 +02001684enddef
1685
Bram Moolenaar04bdd572020-09-23 13:25:32 +02001686def Test_assign_dict_unknown_type()
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001687 var lines =<< trim END
Bram Moolenaar04bdd572020-09-23 13:25:32 +02001688 vim9script
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001689 var mylist = []
Bram Moolenaare0de1712020-12-02 17:36:54 +01001690 mylist += [{one: 'one'}]
Bram Moolenaar04bdd572020-09-23 13:25:32 +02001691 def Func()
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001692 var dd = mylist[0]
Bram Moolenaar04bdd572020-09-23 13:25:32 +02001693 assert_equal('one', dd.one)
1694 enddef
1695 Func()
1696 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001697 v9.CheckScriptSuccess(lines)
Bram Moolenaar04bdd572020-09-23 13:25:32 +02001698
Bram Moolenaarce2c5442020-11-28 21:21:17 +01001699 lines =<< trim END
1700 vim9script
1701 var mylist = [[]]
Bram Moolenaare0de1712020-12-02 17:36:54 +01001702 mylist[0] += [{one: 'one'}]
Bram Moolenaarce2c5442020-11-28 21:21:17 +01001703 def Func()
1704 var dd = mylist[0][0]
1705 assert_equal('one', dd.one)
1706 enddef
1707 Func()
1708 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001709 v9.CheckScriptSuccess(lines)
Bram Moolenaar04bdd572020-09-23 13:25:32 +02001710enddef
1711
Bram Moolenaarf76ec1e2021-03-03 17:58:16 +01001712def Test_assign_dict_with_op()
1713 var lines =<< trim END
Bram Moolenaarf76ec1e2021-03-03 17:58:16 +01001714 var ds: dict<string> = {a: 'x'}
1715 ds['a'] ..= 'y'
1716 ds.a ..= 'z'
1717 assert_equal('xyz', ds.a)
1718
1719 var dn: dict<number> = {a: 9}
1720 dn['a'] += 2
1721 assert_equal(11, dn.a)
1722 dn.a += 2
1723 assert_equal(13, dn.a)
1724
1725 dn['a'] -= 3
1726 assert_equal(10, dn.a)
1727 dn.a -= 2
1728 assert_equal(8, dn.a)
1729
1730 dn['a'] *= 2
1731 assert_equal(16, dn.a)
1732 dn.a *= 2
1733 assert_equal(32, dn.a)
1734
1735 dn['a'] /= 3
1736 assert_equal(10, dn.a)
1737 dn.a /= 2
1738 assert_equal(5, dn.a)
1739
1740 dn['a'] %= 3
1741 assert_equal(2, dn.a)
1742 dn.a %= 6
1743 assert_equal(2, dn.a)
Bram Moolenaarb9c0cd82021-04-05 20:51:00 +02001744
1745 var dd: dict<dict<list<any>>>
1746 dd.a = {}
1747 dd.a.b = [0]
1748 dd.a.b += [1]
1749 assert_equal({a: {b: [0, 1]}}, dd)
Bram Moolenaar0d351a02021-04-05 21:05:26 +02001750
1751 var dab = {a: ['b']}
1752 dab.a[0] ..= 'c'
1753 assert_equal({a: ['bc']}, dab)
Bram Moolenaarf76ec1e2021-03-03 17:58:16 +01001754 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001755 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaare42939a2021-04-05 17:11:17 +02001756enddef
1757
1758def Test_assign_list_with_op()
1759 var lines =<< trim END
1760 var ls: list<string> = ['x']
1761 ls[0] ..= 'y'
1762 assert_equal('xy', ls[0])
1763
1764 var ln: list<number> = [9]
1765 ln[0] += 2
1766 assert_equal(11, ln[0])
1767
1768 ln[0] -= 3
1769 assert_equal(8, ln[0])
1770
1771 ln[0] *= 2
1772 assert_equal(16, ln[0])
1773
1774 ln[0] /= 3
1775 assert_equal(5, ln[0])
1776
1777 ln[0] %= 3
1778 assert_equal(2, ln[0])
1779 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001780 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaare42939a2021-04-05 17:11:17 +02001781enddef
1782
1783def Test_assign_with_op_fails()
1784 var lines =<< trim END
1785 var s = 'abc'
1786 s[1] += 'x'
1787 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001788 v9.CheckDefAndScriptFailure(lines, ['E1141:', 'E689:'], 2)
Bram Moolenaare42939a2021-04-05 17:11:17 +02001789
1790 lines =<< trim END
1791 var s = 'abc'
1792 s[1] ..= 'x'
1793 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001794 v9.CheckDefAndScriptFailure(lines, ['E1141:', 'E689:'], 2)
Bram Moolenaarb9c0cd82021-04-05 20:51:00 +02001795
1796 lines =<< trim END
1797 var dd: dict<dict<list<any>>>
1798 dd.a = {}
1799 dd.a.b += [1]
1800 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001801 v9.CheckDefExecAndScriptFailure(lines, 'E716:', 3)
Bram Moolenaarf76ec1e2021-03-03 17:58:16 +01001802enddef
1803
Bram Moolenaar971caf52020-09-21 22:21:42 +02001804def Test_assign_lambda()
1805 # check if assign a lambda to a variable which type is func or any.
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001806 var lines =<< trim END
Bram Moolenaar971caf52020-09-21 22:21:42 +02001807 vim9script
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001808 var FuncRef = () => 123
Bram Moolenaar971caf52020-09-21 22:21:42 +02001809 assert_equal(123, FuncRef())
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001810 var FuncRef_Func: func = () => 123
Bram Moolenaar971caf52020-09-21 22:21:42 +02001811 assert_equal(123, FuncRef_Func())
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001812 var FuncRef_Any: any = () => 123
Bram Moolenaar971caf52020-09-21 22:21:42 +02001813 assert_equal(123, FuncRef_Any())
Bram Moolenaar06409502021-02-17 17:00:27 +01001814 var FuncRef_Number: func(): number = () => 321
1815 assert_equal(321, FuncRef_Number())
Bram Moolenaar971caf52020-09-21 22:21:42 +02001816 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001817 v9.CheckScriptSuccess(lines)
Bram Moolenaar328eac22021-01-07 19:23:08 +01001818
1819 lines =<< trim END
1820 var Ref: func(number)
1821 Ref = (j) => !j
1822 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001823 v9.CheckDefAndScriptFailure(lines, 'E1012: Type mismatch; expected func(number) but got func(any): bool')
Bram Moolenaarc7dac852021-02-17 18:49:11 +01001824
1825 lines =<< trim END
1826 echo filter([1, 2, 3], (_, v: string) => v + 1)
1827 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001828 v9.CheckDefAndScriptFailure(lines, 'E1051:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001829enddef
1830
Bram Moolenaarc0e29012020-09-27 14:22:48 +02001831def Test_heredoc()
Yegappan Lakshmanan1fc6ea92022-04-21 23:30:15 +01001832 # simple heredoc
1833 var lines =<< trim END
1834 var text =<< trim TEXT # comment
1835 abc
1836 TEXT
1837 assert_equal(['abc'], text)
Bram Moolenaarc0e29012020-09-27 14:22:48 +02001838 END
Yegappan Lakshmanan1fc6ea92022-04-21 23:30:15 +01001839 v9.CheckDefAndScriptSuccess(lines)
1840
1841 # empty heredoc
1842 lines =<< trim END
1843 var text =<< trim TEXT
1844 TEXT
1845 assert_equal([], text)
1846 END
1847 v9.CheckDefAndScriptSuccess(lines)
1848
1849 # heredoc with a single empty line
1850 lines =<< trim END
1851 var text =<< trim TEXT
1852
1853 TEXT
1854 assert_equal([''], text)
1855 END
1856 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarc0e29012020-09-27 14:22:48 +02001857
Bram Moolenaar62aec932022-01-29 21:45:34 +00001858 v9.CheckDefFailure(['var lines =<< trim END X', 'END'], 'E488:')
1859 v9.CheckDefFailure(['var lines =<< trim END " comment', 'END'], 'E488:')
Bram Moolenaar2914a202020-09-27 18:24:03 +02001860
1861 lines =<< trim [END]
1862 def Func()
1863 var&lines =<< trim END
1864 x
1865 x
Bram Moolenaarb5b94802020-12-13 17:50:20 +01001866 enddef
1867 defcompile
1868 [END]
Bram Moolenaar62aec932022-01-29 21:45:34 +00001869 v9.CheckScriptFailure(lines, 'E1145: Missing heredoc end marker: END')
Bram Moolenaarb5b94802020-12-13 17:50:20 +01001870 delfunc! g:Func
1871
1872 lines =<< trim [END]
1873 def Func()
1874 var lines =<< trim END
1875 x
1876 x
Bram Moolenaar2914a202020-09-27 18:24:03 +02001877 x
1878 x
1879 x
1880 x
1881 x
1882 x
1883 enddef
1884 call Func()
1885 [END]
Bram Moolenaar62aec932022-01-29 21:45:34 +00001886 v9.CheckScriptFailure(lines, 'E1145: Missing heredoc end marker: END')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001887 delfunc! g:Func
Bram Moolenaar81530e32021-07-28 21:25:49 +02001888
1889 lines =<< trim END
1890 var lines: number =<< trim STOP
1891 aaa
1892 bbb
1893 STOP
1894 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001895 v9.CheckDefAndScriptFailure(lines, 'E1012: Type mismatch; expected number but got list<string>', 1)
Bram Moolenaarc0e29012020-09-27 14:22:48 +02001896enddef
1897
Bram Moolenaar083966f2020-12-08 11:29:40 +01001898def Test_var_func_call()
Bram Moolenaar55759b52020-09-30 22:59:42 +02001899 var lines =<< trim END
1900 vim9script
1901 func GetValue()
1902 if exists('g:count')
1903 let g:count += 1
1904 else
1905 let g:count = 1
1906 endif
1907 return 'this'
1908 endfunc
1909 var val: string = GetValue()
1910 # env var is always a string
1911 var env = $TERM
1912 END
1913 writefile(lines, 'Xfinished')
1914 source Xfinished
1915 # GetValue() is not called during discovery phase
1916 assert_equal(1, g:count)
1917
1918 unlet g:count
1919 delete('Xfinished')
1920enddef
1921
Bram Moolenaar083966f2020-12-08 11:29:40 +01001922def Test_var_missing_type()
Bram Moolenaar55759b52020-09-30 22:59:42 +02001923 var lines =<< trim END
1924 vim9script
1925 var name = g:unknown
1926 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001927 v9.CheckScriptFailure(lines, 'E121:')
Bram Moolenaar55759b52020-09-30 22:59:42 +02001928
1929 lines =<< trim END
1930 vim9script
1931 var nr: number = 123
1932 var name = nr
1933 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001934 v9.CheckScriptSuccess(lines)
Bram Moolenaar55759b52020-09-30 22:59:42 +02001935enddef
1936
Bram Moolenaar083966f2020-12-08 11:29:40 +01001937def Test_var_declaration()
Bram Moolenaar55759b52020-09-30 22:59:42 +02001938 var lines =<< trim END
1939 vim9script
1940 var name: string
1941 g:var_uninit = name
1942 name = 'text'
1943 g:var_test = name
Bram Moolenaara749a422022-02-12 19:52:25 +00001944 # prefixing s: is not allowed
1945 name = 'prefixed'
1946 g:var_prefixed = name
Bram Moolenaar55759b52020-09-30 22:59:42 +02001947
Bram Moolenaar7257af42020-12-08 22:08:51 +01001948 const FOO: number = 123
1949 assert_equal(123, FOO)
Bram Moolenaar89b474d2020-12-22 21:19:39 +01001950 const FOOS = 'foos'
1951 assert_equal('foos', FOOS)
1952 final FLIST = [1]
1953 assert_equal([1], FLIST)
1954 FLIST[0] = 11
1955 assert_equal([11], FLIST)
1956
1957 const g:FOO: number = 321
1958 assert_equal(321, g:FOO)
1959 const g:FOOS = 'gfoos'
1960 assert_equal('gfoos', g:FOOS)
1961 final g:FLIST = [2]
1962 assert_equal([2], g:FLIST)
1963 g:FLIST[0] = 22
1964 assert_equal([22], g:FLIST)
1965
Bram Moolenaard877a572021-04-01 19:42:48 +02001966 def SetGlobalConst()
1967 const g:globConst = 123
1968 enddef
1969 SetGlobalConst()
1970 assert_equal(123, g:globConst)
1971 assert_true(islocked('g:globConst'))
1972
Bram Moolenaar89b474d2020-12-22 21:19:39 +01001973 const w:FOO: number = 46
1974 assert_equal(46, w:FOO)
1975 const w:FOOS = 'wfoos'
1976 assert_equal('wfoos', w:FOOS)
1977 final w:FLIST = [3]
1978 assert_equal([3], w:FLIST)
1979 w:FLIST[0] = 33
1980 assert_equal([33], w:FLIST)
Bram Moolenaar7257af42020-12-08 22:08:51 +01001981
Bram Moolenaar55759b52020-09-30 22:59:42 +02001982 var s:other: number
1983 other = 1234
1984 g:other_var = other
1985
Bram Moolenaarccc25aa2021-03-26 21:27:52 +01001986 var xyz: string # comment
1987
Bram Moolenaar55759b52020-09-30 22:59:42 +02001988 # type is inferred
Bram Moolenaara749a422022-02-12 19:52:25 +00001989 var dict = {['a']: 222}
Bram Moolenaar55759b52020-09-30 22:59:42 +02001990 def GetDictVal(key: any)
Bram Moolenaara749a422022-02-12 19:52:25 +00001991 g:dict_val = dict[key]
Bram Moolenaar55759b52020-09-30 22:59:42 +02001992 enddef
1993 GetDictVal('a')
Bram Moolenaar08251752021-01-11 21:20:18 +01001994
1995 final adict: dict<string> = {}
1996 def ChangeAdict()
1997 adict.foo = 'foo'
1998 enddef
1999 ChangeAdict()
Bram Moolenaar55759b52020-09-30 22:59:42 +02002000 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002001 v9.CheckScriptSuccess(lines)
Bram Moolenaar55759b52020-09-30 22:59:42 +02002002 assert_equal('', g:var_uninit)
2003 assert_equal('text', g:var_test)
2004 assert_equal('prefixed', g:var_prefixed)
2005 assert_equal(1234, g:other_var)
2006 assert_equal(222, g:dict_val)
2007
2008 unlet g:var_uninit
2009 unlet g:var_test
2010 unlet g:var_prefixed
2011 unlet g:other_var
Bram Moolenaar6e50ec22021-04-03 19:32:44 +02002012 unlet g:globConst
Bram Moolenaar89b474d2020-12-22 21:19:39 +01002013 unlet g:FOO
2014 unlet g:FOOS
2015 unlet g:FLIST
2016 unlet w:FOO
2017 unlet w:FOOS
2018 unlet w:FLIST
Bram Moolenaar55759b52020-09-30 22:59:42 +02002019enddef
2020
Bram Moolenaar083966f2020-12-08 11:29:40 +01002021def Test_var_declaration_fails()
Bram Moolenaar55759b52020-09-30 22:59:42 +02002022 var lines =<< trim END
2023 vim9script
2024 final var: string
2025 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002026 v9.CheckScriptFailure(lines, 'E1125:')
Bram Moolenaar55759b52020-09-30 22:59:42 +02002027
2028 lines =<< trim END
2029 vim9script
Bram Moolenaar89b474d2020-12-22 21:19:39 +01002030 const g:constvar = 'string'
2031 g:constvar = 'xx'
2032 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002033 v9.CheckScriptFailure(lines, 'E741:')
Bram Moolenaar89b474d2020-12-22 21:19:39 +01002034 unlet g:constvar
2035
2036 lines =<< trim END
2037 vim9script
Bram Moolenaarf5906aa2021-04-02 14:35:15 +02002038 var name = 'one'
2039 lockvar name
2040 def SetLocked()
2041 name = 'two'
2042 enddef
2043 SetLocked()
2044 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002045 v9.CheckScriptFailure(lines, 'E741: Value is locked: name', 1)
Bram Moolenaardcf29ac2021-04-02 14:44:02 +02002046
2047 lines =<< trim END
2048 let s:legacy = 'one'
2049 lockvar s:legacy
2050 def SetLocked()
2051 s:legacy = 'two'
2052 enddef
2053 call SetLocked()
2054 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002055 v9.CheckScriptFailure(lines, 'E741: Value is locked: s:legacy', 1)
Bram Moolenaarf5906aa2021-04-02 14:35:15 +02002056
2057 lines =<< trim END
2058 vim9script
Bram Moolenaard877a572021-04-01 19:42:48 +02002059 def SetGlobalConst()
2060 const g:globConst = 123
2061 enddef
2062 SetGlobalConst()
2063 g:globConst = 234
2064 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002065 v9.CheckScriptFailure(lines, 'E741: Value is locked: g:globConst', 6)
Bram Moolenaard877a572021-04-01 19:42:48 +02002066 unlet g:globConst
2067
2068 lines =<< trim END
2069 vim9script
Bram Moolenaar08251752021-01-11 21:20:18 +01002070 const cdict: dict<string> = {}
2071 def Change()
2072 cdict.foo = 'foo'
2073 enddef
2074 defcompile
2075 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002076 v9.CheckScriptFailure(lines, 'E46:')
Bram Moolenaar08251752021-01-11 21:20:18 +01002077
2078 lines =<< trim END
2079 vim9script
Bram Moolenaar89b474d2020-12-22 21:19:39 +01002080 final w:finalvar = [9]
2081 w:finalvar = [8]
2082 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002083 v9.CheckScriptFailure(lines, 'E1122:')
Bram Moolenaar89b474d2020-12-22 21:19:39 +01002084 unlet w:finalvar
2085
2086 lines =<< trim END
2087 vim9script
Bram Moolenaar55759b52020-09-30 22:59:42 +02002088 const var: string
2089 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002090 v9.CheckScriptFailure(lines, 'E1021:')
Bram Moolenaar55759b52020-09-30 22:59:42 +02002091
2092 lines =<< trim END
2093 vim9script
2094 var 9var: string
2095 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002096 v9.CheckScriptFailure(lines, 'E488:')
Bram Moolenaar7257af42020-12-08 22:08:51 +01002097
Bram Moolenaar62aec932022-01-29 21:45:34 +00002098 v9.CheckDefFailure(['var foo.bar = 2'], 'E1087:')
2099 v9.CheckDefFailure(['var foo[3] = 2'], 'E1087:')
2100 v9.CheckDefFailure(['const foo: number'], 'E1021:')
Bram Moolenaare1d12112022-03-05 11:37:48 +00002101
2102 lines =<< trim END
2103 va foo = 123
2104 END
2105 v9.CheckDefAndScriptFailure(lines, 'E1065:', 1)
Bram Moolenaar55759b52020-09-30 22:59:42 +02002106enddef
2107
Bram Moolenaare88c6b72022-02-15 15:37:11 +00002108def Test_var_declaration_inferred()
2109 # check that type is set on the list so that extend() fails
2110 var lines =<< trim END
2111 vim9script
2112 def GetList(): list<number>
2113 var l = [1, 2, 3]
2114 return l
2115 enddef
2116 echo GetList()->extend(['x'])
2117 END
2118 v9.CheckScriptFailure(lines, 'E1013:', 6)
2119enddef
2120
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002121def Test_script_local_in_legacy()
Bram Moolenaara749a422022-02-12 19:52:25 +00002122 # OK to define script-local later but before compiling
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002123 var lines =<< trim END
2124 def SetLater()
Bram Moolenaara749a422022-02-12 19:52:25 +00002125 legvar = 'two'
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002126 enddef
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02002127 let s:legvar = 'one'
Bram Moolenaara749a422022-02-12 19:52:25 +00002128 defcompile
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002129 call SetLater()
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02002130 call assert_equal('two', s:legvar)
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002131 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002132 v9.CheckScriptSuccess(lines)
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002133
2134 # OK to leave out s: prefix when script-local already defined
2135 lines =<< trim END
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02002136 let s:legvar = 'one'
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002137 def SetNoPrefix()
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02002138 legvar = 'two'
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002139 enddef
2140 call SetNoPrefix()
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02002141 call assert_equal('two', s:legvar)
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002142 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002143 v9.CheckScriptSuccess(lines)
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002144
Bram Moolenaara749a422022-02-12 19:52:25 +00002145 # Not OK to leave out s: prefix when script-local defined after compiling
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002146 lines =<< trim END
2147 def SetLaterNoPrefix()
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02002148 legvar = 'two'
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002149 enddef
2150 defcompile
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02002151 let s:legvar = 'one'
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002152 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002153 v9.CheckScriptFailure(lines, 'E476:', 1)
Bram Moolenaar47bc9c32021-07-17 21:24:56 +02002154
2155 edit! Xfile
2156 lines =<< trim END
2157 var edit: bool
2158 legacy edit
2159 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002160 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002161enddef
2162
Bram Moolenaar083966f2020-12-08 11:29:40 +01002163def Test_var_type_check()
Bram Moolenaar55759b52020-09-30 22:59:42 +02002164 var lines =<< trim END
2165 vim9script
2166 var name: string
2167 name = 1234
2168 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002169 v9.CheckScriptFailure(lines, 'E1012:')
Bram Moolenaar55759b52020-09-30 22:59:42 +02002170
2171 lines =<< trim END
2172 vim9script
2173 var name:string
2174 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002175 v9.CheckScriptFailure(lines, 'E1069:')
Bram Moolenaar55759b52020-09-30 22:59:42 +02002176
Bram Moolenaar62aec932022-01-29 21:45:34 +00002177 v9.CheckDefAndScriptFailure(['var n:number = 42'], 'E1069:')
Bram Moolenaar60faf862021-08-23 22:22:45 +02002178
Bram Moolenaar55759b52020-09-30 22:59:42 +02002179 lines =<< trim END
2180 vim9script
2181 var name: asdf
2182 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002183 v9.CheckScriptFailure(lines, 'E1010:')
Bram Moolenaar55759b52020-09-30 22:59:42 +02002184
2185 lines =<< trim END
2186 vim9script
Bram Moolenaara749a422022-02-12 19:52:25 +00002187 var l: list<number>
2188 l = []
Bram Moolenaar55759b52020-09-30 22:59:42 +02002189 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002190 v9.CheckScriptSuccess(lines)
Bram Moolenaar55759b52020-09-30 22:59:42 +02002191
2192 lines =<< trim END
2193 vim9script
Bram Moolenaara749a422022-02-12 19:52:25 +00002194 var d: dict<number>
2195 d = {}
Bram Moolenaar55759b52020-09-30 22:59:42 +02002196 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002197 v9.CheckScriptSuccess(lines)
Bram Moolenaar378697a2021-07-15 19:23:18 +02002198
2199 lines =<< trim END
2200 vim9script
2201 var d = {a: 1, b: [2]}
2202 def Func(b: bool)
2203 var l: list<number> = b ? d.b : [3]
2204 enddef
2205 defcompile
2206 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002207 v9.CheckScriptSuccess(lines)
Bram Moolenaar55759b52020-09-30 22:59:42 +02002208enddef
2209
2210let g:dict_number = #{one: 1, two: 2}
2211
Bram Moolenaar083966f2020-12-08 11:29:40 +01002212def Test_var_list_dict_type()
Bram Moolenaar55759b52020-09-30 22:59:42 +02002213 var ll: list<number>
2214 ll = [1, 2, 2, 3, 3, 3]->uniq()
2215 ll->assert_equal([1, 2, 3])
2216
2217 var dd: dict<number>
2218 dd = g:dict_number
2219 dd->assert_equal(g:dict_number)
2220
2221 var lines =<< trim END
2222 var ll: list<number>
2223 ll = [1, 2, 3]->map('"one"')
2224 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002225 v9.CheckDefExecFailure(lines, 'E1012: Type mismatch; expected list<number> but got list<string>')
Bram Moolenaar55759b52020-09-30 22:59:42 +02002226enddef
2227
Bram Moolenaar083966f2020-12-08 11:29:40 +01002228def Test_cannot_use_let()
Bram Moolenaar62aec932022-01-29 21:45:34 +00002229 v9.CheckDefAndScriptFailure(['let a = 34'], 'E1126:', 1)
Bram Moolenaar083966f2020-12-08 11:29:40 +01002230enddef
2231
Bram Moolenaar55759b52020-09-30 22:59:42 +02002232def Test_unlet()
2233 g:somevar = 'yes'
2234 assert_true(exists('g:somevar'))
2235 unlet g:somevar
2236 assert_false(exists('g:somevar'))
2237 unlet! g:somevar
2238
2239 # also works for script-local variable in legacy Vim script
2240 s:somevar = 'legacy'
2241 assert_true(exists('s:somevar'))
2242 unlet s:somevar
2243 assert_false(exists('s:somevar'))
2244 unlet! s:somevar
2245
Bram Moolenaar83d0cec2022-02-04 21:17:58 +00002246 if 0
2247 unlet g:does_not_exist
2248 endif
2249
2250 v9.CheckDefExecFailure(['unlet v:notfound.key'], 'E1001:')
2251
Bram Moolenaar62aec932022-01-29 21:45:34 +00002252 v9.CheckDefExecFailure([
Bram Moolenaar0acbf5a2021-01-05 20:58:25 +01002253 'var dd = 111',
2254 'unlet dd',
2255 ], 'E1081:', 2)
2256
Bram Moolenaar752fc692021-01-04 21:57:11 +01002257 # dict unlet
Bram Moolenaarea5c8982022-02-17 14:42:02 +00002258 var dd = {a: 1, b: 2, c: 3, 4: 4}
Bram Moolenaar752fc692021-01-04 21:57:11 +01002259 unlet dd['a']
2260 unlet dd.c
Bram Moolenaarea5c8982022-02-17 14:42:02 +00002261 unlet dd[4]
Bram Moolenaar752fc692021-01-04 21:57:11 +01002262 assert_equal({b: 2}, dd)
2263
Bram Moolenaar6b8c7ba2022-03-20 17:46:06 +00002264 # null key works like empty string
2265 dd = {'': 1, x: 9}
2266 unlet dd[null_string]
2267 assert_equal({x: 9}, dd)
2268
Bram Moolenaar752fc692021-01-04 21:57:11 +01002269 # list unlet
2270 var ll = [1, 2, 3, 4]
2271 unlet ll[1]
2272 unlet ll[-1]
2273 assert_equal([1, 3], ll)
2274
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01002275 ll = [1, 2, 3, 4]
2276 unlet ll[0 : 1]
2277 assert_equal([3, 4], ll)
2278
2279 ll = [1, 2, 3, 4]
2280 unlet ll[2 : 8]
2281 assert_equal([1, 2], ll)
2282
2283 ll = [1, 2, 3, 4]
2284 unlet ll[-2 : -1]
2285 assert_equal([1, 2], ll)
2286
Bram Moolenaar0c7f2612022-02-17 19:44:07 +00002287 g:nrdict = {1: 1, 2: 2}
2288 g:idx = 1
2289 unlet g:nrdict[g:idx]
2290 assert_equal({2: 2}, g:nrdict)
2291 unlet g:nrdict
2292 unlet g:idx
2293
Bram Moolenaar62aec932022-01-29 21:45:34 +00002294 v9.CheckDefFailure([
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01002295 'var ll = [1, 2]',
2296 'll[1 : 2] = 7',
Bram Moolenaar4f0884d2021-08-11 21:49:23 +02002297 ], 'E1012: Type mismatch; expected list<number> but got number', 2)
Bram Moolenaar62aec932022-01-29 21:45:34 +00002298 v9.CheckDefFailure([
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01002299 'var dd = {a: 1}',
2300 'unlet dd["a" : "a"]',
2301 ], 'E1166:', 2)
Bram Moolenaar62aec932022-01-29 21:45:34 +00002302 v9.CheckDefExecFailure([
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01002303 'unlet g:adict[0 : 1]',
2304 ], 'E1148:', 1)
Bram Moolenaar62aec932022-01-29 21:45:34 +00002305 v9.CheckDefFailure([
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01002306 'var ll = [1, 2]',
2307 'unlet ll[0:1]',
2308 ], 'E1004:', 2)
Bram Moolenaar62aec932022-01-29 21:45:34 +00002309 v9.CheckDefFailure([
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01002310 'var ll = [1, 2]',
2311 'unlet ll[0 :1]',
2312 ], 'E1004:', 2)
Bram Moolenaar62aec932022-01-29 21:45:34 +00002313 v9.CheckDefFailure([
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01002314 'var ll = [1, 2]',
2315 'unlet ll[0: 1]',
2316 ], 'E1004:', 2)
Bram Moolenaare08be092022-02-17 13:08:26 +00002317
2318 v9.CheckDefExecFailure([
2319 'g:ll = [1, 2]',
2320 'g:idx = "x"',
2321 'unlet g:ll[g:idx]',
2322 ], 'E1029: Expected number but got string', 3)
2323
2324 v9.CheckDefExecFailure([
2325 'g:ll = [1, 2, 3]',
2326 'g:idx = "x"',
2327 'unlet g:ll[g:idx : 2]',
2328 ], 'E1029: Expected number but got string', 3)
2329
2330 v9.CheckDefExecFailure([
2331 'g:ll = [1, 2, 3]',
2332 'g:idx = "x"',
2333 'unlet g:ll[0 : g:idx]',
2334 ], 'E1029: Expected number but got string', 3)
2335
Bram Moolenaar7f2c3412021-11-29 16:01:49 +00002336 # command recognized as assignment when skipping, should not give an error
Bram Moolenaar62aec932022-01-29 21:45:34 +00002337 v9.CheckScriptSuccess([
Bram Moolenaar7f2c3412021-11-29 16:01:49 +00002338 'vim9script',
2339 'for i in []',
2340 " put =''",
2341 'endfor'])
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01002342
Bram Moolenaar62aec932022-01-29 21:45:34 +00002343 v9.CheckDefFailure([
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01002344 'var ll = [1, 2]',
2345 'unlet ll["x" : 1]',
2346 ], 'E1012:', 2)
Bram Moolenaar62aec932022-01-29 21:45:34 +00002347 v9.CheckDefFailure([
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01002348 'var ll = [1, 2]',
2349 'unlet ll[0 : "x"]',
2350 ], 'E1012:', 2)
2351
Bram Moolenaar752fc692021-01-04 21:57:11 +01002352 # list of dict unlet
2353 var dl = [{a: 1, b: 2}, {c: 3}]
2354 unlet dl[0]['b']
2355 assert_equal([{a: 1}, {c: 3}], dl)
2356
Bram Moolenaar62aec932022-01-29 21:45:34 +00002357 v9.CheckDefExecFailure([
Bram Moolenaar0acbf5a2021-01-05 20:58:25 +01002358 'var ll = test_null_list()',
2359 'unlet ll[0]',
2360 ], 'E684:', 2)
Bram Moolenaar62aec932022-01-29 21:45:34 +00002361 v9.CheckDefExecFailure([
Bram Moolenaar0acbf5a2021-01-05 20:58:25 +01002362 'var ll = [1]',
2363 'unlet ll[2]',
2364 ], 'E684:', 2)
Bram Moolenaar62aec932022-01-29 21:45:34 +00002365 v9.CheckDefExecFailure([
Bram Moolenaar0acbf5a2021-01-05 20:58:25 +01002366 'var ll = [1]',
2367 'unlet ll[g:astring]',
Bram Moolenaarf30a14d2021-01-17 21:51:24 +01002368 ], 'E1012:', 2)
Bram Moolenaar62aec932022-01-29 21:45:34 +00002369 v9.CheckDefExecFailure([
Bram Moolenaar0acbf5a2021-01-05 20:58:25 +01002370 'var dd = test_null_dict()',
2371 'unlet dd["a"]',
2372 ], 'E716:', 2)
Bram Moolenaar62aec932022-01-29 21:45:34 +00002373 v9.CheckDefExecFailure([
Bram Moolenaar0acbf5a2021-01-05 20:58:25 +01002374 'var dd = {a: 1}',
2375 'unlet dd["b"]',
2376 ], 'E716:', 2)
Bram Moolenaar62aec932022-01-29 21:45:34 +00002377 v9.CheckDefExecFailure([
Bram Moolenaar0acbf5a2021-01-05 20:58:25 +01002378 'var dd = {a: 1}',
2379 'unlet dd[g:alist]',
2380 ], 'E1105:', 2)
Bram Moolenaar752fc692021-01-04 21:57:11 +01002381
Bram Moolenaarea5c8982022-02-17 14:42:02 +00002382 v9.CheckDefExecFailure([
2383 'g:dd = {"a": 1, 2: 2}'
2384 'unlet g:dd[0z11]',
2385 ], 'E1029:', 2)
Bram Moolenaar6296d1e2022-02-17 16:30:11 +00002386 v9.CheckDefExecFailure([
2387 'g:str = "a string"'
2388 'unlet g:str[0]',
2389 ], 'E1148: Cannot index a string', 2)
Bram Moolenaarea5c8982022-02-17 14:42:02 +00002390
Bram Moolenaar2ef951d2021-01-03 20:55:26 +01002391 # can compile unlet before variable exists
Bram Moolenaar752fc692021-01-04 21:57:11 +01002392 g:someDict = {key: 'val'}
2393 var k = 'key'
2394 unlet g:someDict[k]
2395 assert_equal({}, g:someDict)
2396 unlet g:someDict
2397 assert_false(exists('g:someDict'))
Bram Moolenaar2ef951d2021-01-03 20:55:26 +01002398
Bram Moolenaar62aec932022-01-29 21:45:34 +00002399 v9.CheckScriptFailure([
Bram Moolenaar55759b52020-09-30 22:59:42 +02002400 'vim9script',
2401 'var svar = 123',
2402 'unlet svar',
2403 ], 'E1081:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00002404 v9.CheckScriptFailure([
Bram Moolenaar55759b52020-09-30 22:59:42 +02002405 'vim9script',
2406 'var svar = 123',
2407 'unlet s:svar',
Bram Moolenaara749a422022-02-12 19:52:25 +00002408 ], 'E1268:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00002409 v9.CheckScriptFailure([
Bram Moolenaar55759b52020-09-30 22:59:42 +02002410 'vim9script',
2411 'var svar = 123',
2412 'def Func()',
2413 ' unlet svar',
2414 'enddef',
2415 'defcompile',
2416 ], 'E1081:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00002417 v9.CheckScriptFailure([
Bram Moolenaar55759b52020-09-30 22:59:42 +02002418 'vim9script',
2419 'var svar = 123',
Bram Moolenaar9aed7292020-12-18 15:38:00 +01002420 'func Func()',
2421 ' unlet s:svar',
2422 'endfunc',
2423 'Func()',
2424 ], 'E1081:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00002425 v9.CheckScriptFailure([
Bram Moolenaar9aed7292020-12-18 15:38:00 +01002426 'vim9script',
2427 'var svar = 123',
Bram Moolenaar55759b52020-09-30 22:59:42 +02002428 'def Func()',
2429 ' unlet s:svar',
2430 'enddef',
2431 'defcompile',
2432 ], 'E1081:')
2433
Bram Moolenaar62aec932022-01-29 21:45:34 +00002434 v9.CheckScriptFailure([
Bram Moolenaar71b76852021-12-17 20:15:38 +00002435 'vim9script',
2436 'def Delcount(dict: dict<any>)',
2437 ' unlet dict.count',
2438 'enddef',
2439 'Delcount(v:)',
2440 ], 'E742:')
2441
Bram Moolenaar62aec932022-01-29 21:45:34 +00002442 v9.CheckScriptFailure([
Bram Moolenaar71b76852021-12-17 20:15:38 +00002443 'vim9script',
2444 'def DelChangedtick(dict: dict<any>)',
2445 ' unlet dict.changedtick',
2446 'enddef',
2447 'DelChangedtick(b:)',
2448 ], 'E795:')
2449
Bram Moolenaar0acbf5a2021-01-05 20:58:25 +01002450 writefile(['vim9script', 'export var svar = 1234'], 'XunletExport.vim')
2451 var lines =<< trim END
2452 vim9script
Bram Moolenaard5f400c2022-01-06 21:10:28 +00002453 import './XunletExport.vim' as exp
Bram Moolenaar0acbf5a2021-01-05 20:58:25 +01002454 def UnletSvar()
Bram Moolenaard5f400c2022-01-06 21:10:28 +00002455 unlet exp.svar
Bram Moolenaar0acbf5a2021-01-05 20:58:25 +01002456 enddef
2457 defcompile
2458 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002459 v9.CheckScriptFailure(lines, 'E1260:', 1)
Bram Moolenaar0acbf5a2021-01-05 20:58:25 +01002460 delete('XunletExport.vim')
2461
Bram Moolenaar55759b52020-09-30 22:59:42 +02002462 $ENVVAR = 'foobar'
2463 assert_equal('foobar', $ENVVAR)
2464 unlet $ENVVAR
2465 assert_equal('', $ENVVAR)
2466enddef
2467
Bram Moolenaarc5f59fa2021-01-21 12:34:14 +01002468def Test_expr_error_no_assign()
2469 var lines =<< trim END
2470 vim9script
2471 var x = invalid
2472 echo x
2473 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002474 v9.CheckScriptFailureList(lines, ['E121:', 'E121:'])
Bram Moolenaarc5f59fa2021-01-21 12:34:14 +01002475
2476 lines =<< trim END
2477 vim9script
2478 var x = 1 / 0
2479 echo x
2480 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002481 v9.CheckScriptFailure(lines, 'E1154:')
Bram Moolenaarc5f59fa2021-01-21 12:34:14 +01002482
2483 lines =<< trim END
2484 vim9script
2485 var x = 1 % 0
2486 echo x
2487 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002488 v9.CheckScriptFailure(lines, 'E1154:')
Bram Moolenaarccc25aa2021-03-26 21:27:52 +01002489
2490 lines =<< trim END
2491 var x: string 'string'
2492 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002493 v9.CheckDefAndScriptFailure(lines, 'E488:')
Bram Moolenaarc5f59fa2021-01-21 12:34:14 +01002494enddef
2495
2496
Bram Moolenaar17126b12021-01-07 22:03:02 +01002497def Test_assign_command_modifier()
2498 var lines =<< trim END
Bram Moolenaar9e0f8832021-01-09 12:09:22 +01002499 var verbose = 0
2500 verbose = 1
2501 assert_equal(1, verbose)
2502 silent verbose = 2
2503 assert_equal(2, verbose)
2504 silent verbose += 2
2505 assert_equal(4, verbose)
2506 silent verbose -= 1
2507 assert_equal(3, verbose)
Bram Moolenaar17126b12021-01-07 22:03:02 +01002508
Bram Moolenaar9e0f8832021-01-09 12:09:22 +01002509 var topleft = {one: 1}
2510 sandbox topleft.one = 3
2511 assert_equal({one: 3}, topleft)
2512 leftabove topleft[' '] = 4
2513 assert_equal({one: 3, ' ': 4}, topleft)
2514
2515 var x: number
2516 var y: number
2517 silent [x, y] = [1, 2]
2518 assert_equal(1, x)
2519 assert_equal(2, y)
Bram Moolenaar17126b12021-01-07 22:03:02 +01002520 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002521 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar17126b12021-01-07 22:03:02 +01002522enddef
2523
Bram Moolenaar74f4a962021-06-17 21:03:07 +02002524def Test_assign_alt_buf_register()
2525 var lines =<< trim END
2526 edit 'file_b1'
2527 var b1 = bufnr()
2528 edit 'file_b2'
2529 var b2 = bufnr()
2530 assert_equal(b1, bufnr('#'))
2531 @# = b2
2532 assert_equal(b2, bufnr('#'))
2533 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002534 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar74f4a962021-06-17 21:03:07 +02002535enddef
2536
Bram Moolenaar32154662021-03-28 21:14:06 +02002537def Test_script_funcref_case()
2538 var lines =<< trim END
2539 var Len = (s: string): number => len(s) + 1
2540 assert_equal(5, Len('asdf'))
2541 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002542 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar32154662021-03-28 21:14:06 +02002543
2544 lines =<< trim END
2545 var len = (s: string): number => len(s) + 1
2546 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002547 v9.CheckDefAndScriptFailure(lines, 'E704:')
Bram Moolenaar32154662021-03-28 21:14:06 +02002548
2549 lines =<< trim END
2550 vim9script
Bram Moolenaara749a422022-02-12 19:52:25 +00002551 var Len = (s: string): number => len(s) + 2
Bram Moolenaar32154662021-03-28 21:14:06 +02002552 assert_equal(6, Len('asdf'))
2553 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002554 v9.CheckScriptSuccess(lines)
Bram Moolenaar32154662021-03-28 21:14:06 +02002555
2556 lines =<< trim END
2557 vim9script
Bram Moolenaara749a422022-02-12 19:52:25 +00002558 var len = (s: string): number => len(s) + 1
Bram Moolenaar32154662021-03-28 21:14:06 +02002559 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002560 v9.CheckScriptFailure(lines, 'E704:')
Bram Moolenaar32154662021-03-28 21:14:06 +02002561enddef
2562
Bram Moolenaar44a89772021-12-18 12:31:33 +00002563def Test_script_funcref_runtime_type_check()
2564 var lines =<< trim END
2565 vim9script
2566 def FuncWithNumberArg(n: number)
2567 enddef
2568 def Test()
2569 var Ref: func(string) = function(FuncWithNumberArg)
2570 enddef
2571 defcompile
2572 END
2573 # OK at compile time
Bram Moolenaar62aec932022-01-29 21:45:34 +00002574 v9.CheckScriptSuccess(lines)
Bram Moolenaar44a89772021-12-18 12:31:33 +00002575
2576 # Type check fails at runtime
Bram Moolenaar62aec932022-01-29 21:45:34 +00002577 v9.CheckScriptFailure(lines + ['Test()'], 'E1012: Type mismatch; expected func(string) but got func(number)')
Bram Moolenaar44a89772021-12-18 12:31:33 +00002578enddef
2579
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02002580def Test_inc_dec()
2581 var lines =<< trim END
2582 var nr = 7
2583 ++nr
Bram Moolenaar730bf302021-04-24 20:43:56 +02002584 assert_equal(8, nr)
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02002585 --nr
Bram Moolenaar730bf302021-04-24 20:43:56 +02002586 assert_equal(7, nr)
Bram Moolenaarf3d30842021-06-25 19:29:30 +02002587 ++nr | ++nr
2588 assert_equal(9, nr)
2589 ++nr # comment
2590 assert_equal(10, nr)
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02002591
2592 var ll = [1, 2]
2593 --ll[0]
2594 ++ll[1]
Bram Moolenaar730bf302021-04-24 20:43:56 +02002595 assert_equal([0, 3], ll)
2596
2597 g:count = 1
2598 ++g:count
2599 --g:count
2600 assert_equal(1, g:count)
2601 unlet g:count
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02002602 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002603 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar22480d12021-06-25 21:31:09 +02002604
2605 lines =<< trim END
2606 var nr = 7
2607 ++ nr
2608 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002609 v9.CheckDefAndScriptFailure(lines, "E1202: No white space allowed after '++': ++ nr")
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02002610enddef
2611
Bram Moolenaar327d3ee2021-07-28 19:34:14 +02002612def Test_abort_after_error()
2613 # should abort after strpart() fails, not give another type error
2614 var lines =<< trim END
2615 vim9script
2616 var x: string
2617 x = strpart(1, 2)
2618 END
2619 writefile(lines, 'Xtestscript')
2620 var expected = 'E1174: String required for argument 1'
2621 assert_fails('so Xtestscript', [expected, expected], 3)
2622
2623 delete('Xtestscript')
2624enddef
2625
Bram Moolenaarafa048f2022-02-22 20:43:36 +00002626def Test_using_s_var_in_function()
2627 var lines =<< trim END
2628 vim9script
2629 var scriptlevel = 123
2630 def SomeFunc()
2631 echo s:scriptlevel
2632 enddef
2633 SomeFunc()
2634 END
2635 v9.CheckScriptFailure(lines, 'E1268:')
2636
2637 # OK in legacy script
2638 lines =<< trim END
2639 let s:scriptlevel = 123
2640 def s:SomeFunc()
2641 echo s:scriptlevel
2642 enddef
2643 call s:SomeFunc()
2644 END
2645 v9.CheckScriptSuccess(lines)
2646
2647 lines =<< trim END
2648 vim9script
2649 var scriptlevel = 123
2650 def SomeFunc()
2651 s:scriptlevel = 456
2652 enddef
2653 SomeFunc()
2654 END
2655 v9.CheckScriptFailure(lines, 'E1268:')
2656
2657 # OK in legacy script
2658 lines =<< trim END
2659 let s:scriptlevel = 123
2660 def s:SomeFunc()
2661 s:scriptlevel = 456
2662 enddef
2663 call s:SomeFunc()
2664 call assert_equal(456, s:scriptlevel)
2665 END
2666 v9.CheckScriptSuccess(lines)
2667enddef
2668
Yegappan Lakshmananefbfa862022-04-17 12:47:40 +01002669let g:someVar = 'X'
2670
2671" Test for heredoc with Vim expressions.
2672" This messes up highlighting, keep it near the end.
2673def Test_heredoc_expr()
Yegappan Lakshmanan1fc6ea92022-04-21 23:30:15 +01002674 var lines =<< trim CODE
2675 var s = "local"
2676 var a1 = "1"
2677 var a2 = "2"
2678 var a3 = "3"
2679 var a4 = ""
2680 var code =<< trim eval END
LemonBoy2eaef102022-05-06 13:14:50 +01002681 var a = {5 + 10}
2682 var b = {min([10, 6])} + {max([4, 6])}
2683 var c = "{s}"
2684 var d = x{a1}x{a2}x{a3}x{a4}
Yegappan Lakshmanan1fc6ea92022-04-21 23:30:15 +01002685 END
2686 assert_equal(['var a = 15', 'var b = 6 + 6', 'var c = "local"', 'var d = x1x2x3x'], code)
2687 CODE
2688 v9.CheckDefAndScriptSuccess(lines)
Yegappan Lakshmananefbfa862022-04-17 12:47:40 +01002689
Yegappan Lakshmanan1fc6ea92022-04-21 23:30:15 +01002690 lines =<< trim CODE
2691 var code =<< eval trim END
LemonBoy2eaef102022-05-06 13:14:50 +01002692 var s = "{$SOME_ENV_VAR}"
Yegappan Lakshmanan1fc6ea92022-04-21 23:30:15 +01002693 END
2694 assert_equal(['var s = "somemore"'], code)
2695 CODE
2696 v9.CheckDefAndScriptSuccess(lines)
Yegappan Lakshmananefbfa862022-04-17 12:47:40 +01002697
Yegappan Lakshmanan1fc6ea92022-04-21 23:30:15 +01002698 lines =<< trim CODE
2699 var code =<< eval END
LemonBoy2eaef102022-05-06 13:14:50 +01002700 var s = "{$SOME_ENV_VAR}"
Yegappan Lakshmanan1fc6ea92022-04-21 23:30:15 +01002701 END
2702 assert_equal([' var s = "somemore"'], code)
2703 CODE
2704 v9.CheckDefAndScriptSuccess(lines)
Yegappan Lakshmananefbfa862022-04-17 12:47:40 +01002705
Yegappan Lakshmanan1fc6ea92022-04-21 23:30:15 +01002706 lines =<< trim CODE
2707 var code =<< eval trim END
LemonBoy2eaef102022-05-06 13:14:50 +01002708 let a = {{abc}}
2709 let b = {g:someVar}
2710 let c = {{
Yegappan Lakshmanan1fc6ea92022-04-21 23:30:15 +01002711 END
LemonBoy2eaef102022-05-06 13:14:50 +01002712 assert_equal(['let a = {abc}', 'let b = X', 'let c = {'], code)
Yegappan Lakshmanan1fc6ea92022-04-21 23:30:15 +01002713 CODE
2714 v9.CheckDefAndScriptSuccess(lines)
Yegappan Lakshmananefbfa862022-04-17 12:47:40 +01002715
Yegappan Lakshmanan1fc6ea92022-04-21 23:30:15 +01002716 lines =<< trim LINES
Yegappan Lakshmananefbfa862022-04-17 12:47:40 +01002717 var text =<< eval trim END
LemonBoy2eaef102022-05-06 13:14:50 +01002718 let b = {
Yegappan Lakshmananefbfa862022-04-17 12:47:40 +01002719 END
2720 LINES
LemonBoy2eaef102022-05-06 13:14:50 +01002721 v9.CheckDefAndScriptFailure(lines, "E1279: Missing '}'")
Yegappan Lakshmananefbfa862022-04-17 12:47:40 +01002722
2723 lines =<< trim LINES
2724 var text =<< eval trim END
LemonBoy2eaef102022-05-06 13:14:50 +01002725 let b = {abc
Yegappan Lakshmananefbfa862022-04-17 12:47:40 +01002726 END
2727 LINES
LemonBoy2eaef102022-05-06 13:14:50 +01002728 v9.CheckDefAndScriptFailure(lines, "E1279: Missing '}'")
Yegappan Lakshmananefbfa862022-04-17 12:47:40 +01002729
2730 lines =<< trim LINES
2731 var text =<< eval trim END
LemonBoy2eaef102022-05-06 13:14:50 +01002732 let b = {}
Yegappan Lakshmananefbfa862022-04-17 12:47:40 +01002733 END
2734 LINES
LemonBoy2eaef102022-05-06 13:14:50 +01002735 v9.CheckDefAndScriptFailure(lines, 'E15: Invalid expression: "}"')
Yegappan Lakshmananefbfa862022-04-17 12:47:40 +01002736enddef
2737
Bram Moolenaar971caf52020-09-21 22:21:42 +02002738" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker