blob: 82dc3e5ca98f0720d52f9ca513241a8e7c42d367 [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
Bram Moolenaar73e28dc2022-09-17 21:08:33 +010099 var float1: float = 3.4
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200100 var Funky1: func
101 var Funky2: func = function('len')
102 var Party2: func = funcref('g:Test_syntax')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200103
104 g:newvar = 'new' #comment
105 assert_equal('new', g:newvar)
106
107 assert_equal('yes', g:existing)
108 g:existing = 'no'
109 assert_equal('no', g:existing)
110
111 v:char = 'abc'
112 assert_equal('abc', v:char)
113
114 $ENVVAR = 'foobar'
115 assert_equal('foobar', $ENVVAR)
116 $ENVVAR = ''
117
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200118 var lines =<< trim END
Bram Moolenaar971caf52020-09-21 22:21:42 +0200119 vim9script
120 $ENVVAR = 'barfoo'
121 assert_equal('barfoo', $ENVVAR)
122 $ENVVAR = ''
123 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000124 v9.CheckScriptSuccess(lines)
Bram Moolenaar971caf52020-09-21 22:21:42 +0200125
Bram Moolenaara749a422022-02-12 19:52:25 +0000126 appendToMe ..= 'yyy'
127 assert_equal('xxxyyy', appendToMe)
128 addToMe += 222
129 assert_equal(333, addToMe)
130 newVar = 'new'
131 assert_equal('new', newVar)
Bram Moolenaar971caf52020-09-21 22:21:42 +0200132
133 set ts=7
Bram Moolenaardd1f4262020-12-31 17:41:01 +0100134 var ts: number = &ts
135 assert_equal(7, ts)
Bram Moolenaar971caf52020-09-21 22:21:42 +0200136 &ts += 1
137 assert_equal(8, &ts)
138 &ts -= 3
139 assert_equal(5, &ts)
140 &ts *= 2
141 assert_equal(10, &ts)
142 &ts /= 3
143 assert_equal(3, &ts)
144 set ts=10
145 &ts %= 4
146 assert_equal(2, &ts)
147
zeertzjq4c7cb372023-06-14 16:39:54 +0100148 assert_fails('&ts /= 0', ['E1154:', 'E1154:'])
149 assert_fails('&ts %= 0', ['E1154:', 'E1154:'])
150 assert_fails('&ts /= []', ['E745:', 'E745:'])
151 assert_fails('&ts %= []', ['E745:', 'E745:'])
152 assert_equal(2, &ts)
153
Bram Moolenaar73e28dc2022-09-17 21:08:33 +0100154 var f100: float = 100.0
155 f100 /= 5
156 assert_equal(20.0, f100)
Bram Moolenaar971caf52020-09-21 22:21:42 +0200157
Bram Moolenaar73e28dc2022-09-17 21:08:33 +0100158 var f200: float = 200.0
159 f200 /= 5.0
160 assert_equal(40.0, f200)
Bram Moolenaar971caf52020-09-21 22:21:42 +0200161
Bram Moolenaar73e28dc2022-09-17 21:08:33 +0100162 v9.CheckDefFailure(['var nr: number = 200', 'nr /= 5.0'], 'E1012:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200163
164 lines =<< trim END
165 &ts = 6
166 &ts += 3
167 assert_equal(9, &ts)
168
169 &l:ts = 6
170 assert_equal(6, &ts)
171 &l:ts += 2
172 assert_equal(8, &ts)
173
174 &g:ts = 6
175 assert_equal(6, &g:ts)
176 &g:ts += 2
177 assert_equal(8, &g:ts)
Bram Moolenaar0ea04402021-01-04 13:37:54 +0100178
179 &number = true
180 assert_equal(true, &number)
181 &number = 0
182 assert_equal(false, &number)
183 &number = 1
184 assert_equal(true, &number)
185 &number = false
186 assert_equal(false, &number)
Bram Moolenaar971caf52020-09-21 22:21:42 +0200187 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000188 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar971caf52020-09-21 22:21:42 +0200189
Bram Moolenaar62aec932022-01-29 21:45:34 +0000190 v9.CheckDefFailure(['&notex += 3'], 'E113:')
191 v9.CheckDefFailure(['&ts ..= "xxx"'], 'E1019:')
192 v9.CheckDefFailure(['&ts = [7]'], 'E1012:')
193 v9.CheckDefExecFailure(['&ts = g:alist'], 'E1012: Type mismatch; expected number but got list<number>')
194 v9.CheckDefFailure(['&ts = "xx"'], 'E1012:')
195 v9.CheckDefExecFailure(['&ts = g:astring'], 'E1012: Type mismatch; expected number but got string')
196 v9.CheckDefFailure(['&path += 3'], 'E1012:')
197 v9.CheckDefExecFailure(['&bs = "asdf"'], 'E474:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200198 # test freeing ISN_STOREOPT
Bram Moolenaar62aec932022-01-29 21:45:34 +0000199 v9.CheckDefFailure(['&ts = 3', 'var asdf'], 'E1022:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200200 &ts = 8
201
202 lines =<< trim END
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200203 var save_TI = &t_TI
Bram Moolenaar971caf52020-09-21 22:21:42 +0200204 &t_TI = ''
205 assert_equal('', &t_TI)
206 &t_TI = 'xxx'
207 assert_equal('xxx', &t_TI)
208 &t_TI = save_TI
209 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000210 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar971caf52020-09-21 22:21:42 +0200211
Bram Moolenaar62aec932022-01-29 21:45:34 +0000212 v9.CheckDefFailure(['&t_TI = 123'], 'E1012:')
213 v9.CheckScriptFailure(['vim9script', '&t_TI = 123'], 'E928:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200214
Bram Moolenaar62aec932022-01-29 21:45:34 +0000215 v9.CheckDefFailure(['var s:var = 123'], 'E1101:')
216 v9.CheckDefFailure(['var s:var: number'], 'E1101:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200217
Bram Moolenaar5cb53b72022-05-26 19:54:05 +0100218 v9.CheckDefAndScriptFailure(['var $VAR: number'], ['E1016:', 'E475:'])
219
Bram Moolenaar971caf52020-09-21 22:21:42 +0200220 lines =<< trim END
221 vim9script
222 def SomeFunc()
223 s:var = 123
224 enddef
225 defcompile
226 END
Bram Moolenaarafa048f2022-02-22 20:43:36 +0000227 v9.CheckScriptFailure(lines, 'E1268:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200228
229 g:inc_counter += 1
230 assert_equal(2, g:inc_counter)
231
Bram Moolenaar73e28dc2022-09-17 21:08:33 +0100232 var f: float
233 f += 1
234 assert_equal(1.0, f)
Bram Moolenaar7bf9a072021-08-02 21:55:15 +0200235
Bram Moolenaar971caf52020-09-21 22:21:42 +0200236 $SOME_ENV_VAR ..= 'more'
237 assert_equal('somemore', $SOME_ENV_VAR)
Bram Moolenaar62aec932022-01-29 21:45:34 +0000238 v9.CheckDefFailure(['$SOME_ENV_VAR += "more"'], 'E1051:')
239 v9.CheckDefFailure(['$SOME_ENV_VAR += 123'], 'E1012:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200240
Bram Moolenaar971caf52020-09-21 22:21:42 +0200241 v:errmsg = 'none'
242 v:errmsg ..= 'again'
243 assert_equal('noneagain', v:errmsg)
Bram Moolenaar62aec932022-01-29 21:45:34 +0000244 v9.CheckDefFailure(['v:errmsg += "more"'], 'E1051:')
245 v9.CheckDefFailure(['v:errmsg += 123'], 'E1012:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200246
Bram Moolenaarfc8aa6d2020-10-12 20:31:26 +0200247 var text =<< trim END
248 some text
249 END
Bram Moolenaar971caf52020-09-21 22:21:42 +0200250enddef
251
Bram Moolenaaraf647e72021-08-05 19:01:17 +0200252def Test_float_and_number()
Bram Moolenaar73e28dc2022-09-17 21:08:33 +0100253 var lines =<< trim END
254 var f: float
255 f += 2
256 f -= 1
257 assert_equal(1.0, f)
258 ++f
259 --f
260 assert_equal(1.0, f)
261 END
262 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaaraf647e72021-08-05 19:01:17 +0200263enddef
264
Bram Moolenaarf5d52c92021-07-31 22:51:10 +0200265let g:someNumber = 43
266
267def Test_assign_concat()
268 var lines =<< trim END
269 var s = '-'
270 s ..= 99
271 s ..= true
272 s ..= '-'
273 s ..= v:null
274 s ..= g:someNumber
275 assert_equal('-99true-null43', s)
276 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000277 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarf5d52c92021-07-31 22:51:10 +0200278
279 lines =<< trim END
280 var s = '-'
281 s ..= [1, 2]
282 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000283 v9.CheckDefAndScriptFailure(lines, ['E1105: Cannot convert list to string', 'E734: Wrong variable type for .='], 2)
Bram Moolenaarf5d52c92021-07-31 22:51:10 +0200284 lines =<< trim END
285 var s = '-'
286 s ..= {a: 2}
287 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000288 v9.CheckDefAndScriptFailure(lines, ['E1105: Cannot convert dict to string', 'E734: Wrong variable type for .='], 2)
Bram Moolenaar22ebd172022-04-01 15:26:58 +0100289
290 lines =<< trim END
291 var ls: list<string> = []
292 ls[-1] ..= 'foo'
293 END
Bram Moolenaarec892232022-05-06 17:53:06 +0100294 v9.CheckDefExecAndScriptFailure(lines, 'E684: List index out of range: -1', 2)
Bram Moolenaarf5d52c92021-07-31 22:51:10 +0200295enddef
296
Bram Moolenaar13e45d12021-06-26 13:28:35 +0200297def Test_assign_register()
298 var lines =<< trim END
299 @c = 'areg'
300 @c ..= 'add'
301 assert_equal('aregadd', @c)
302
303 @@ = 'some text'
304 assert_equal('some text', getreg('"'))
305 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000306 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar13e45d12021-06-26 13:28:35 +0200307
Bram Moolenaar62aec932022-01-29 21:45:34 +0000308 v9.CheckDefFailure(['@a += "more"'], 'E1051:')
309 v9.CheckDefFailure(['@a += 123'], 'E1012:')
Bram Moolenaar13e45d12021-06-26 13:28:35 +0200310enddef
311
Bram Moolenaard0edaf92021-05-28 21:06:08 +0200312def Test_reserved_name()
Bram Moolenaar8acb9cc2022-03-08 13:18:55 +0000313 var more_names = ['null_job', 'null_channel']
314 if !has('job')
315 more_names = []
316 endif
317
318 for name in ['true',
319 'false',
Bram Moolenaarce723f32023-06-10 19:00:12 +0100320 'this',
321 'super',
Bram Moolenaar8acb9cc2022-03-08 13:18:55 +0000322 '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
Bram Moolenaarce723f32023-06-10 19:00:12 +0100333
334 var lines =<< trim END
335 vim9script
336 def Foo(super: bool)
337 echo 'something'
338 enddef
339 defcompile
340 END
341 v9.CheckScriptFailure(lines, 'E1034:')
Bram Moolenaard0edaf92021-05-28 21:06:08 +0200342enddef
343
Bram Moolenaar8acb9cc2022-03-08 13:18:55 +0000344def Test_null_values()
345 var lines =<< trim END
346 var b: blob = null_blob
347 var dn: dict<number> = null_dict
348 var ds: dict<string> = null_dict
349 var ln: list<number> = null_list
350 var ls: list<string> = null_list
351 var Ff: func(string): string = null_function
352 var Fp: func(number): number = null_partial
353 var s: string = null_string
354 if has('job')
355 var j: job = null_job
356 var c: channel = null_channel
357 endif
Bram Moolenaar56b84b12022-03-09 19:46:48 +0000358
359 var d: dict<func> = {a: function('tr'), b: null_function}
Bram Moolenaarbadf04f2022-03-12 21:28:22 +0000360
361 var bl: list<blob> = [0z12, null_blob]
362 var dnl: list<dict<number>> = [{a: 1}, null_dict]
363 var dsl: list<dict<string>> = [{a: 'x'}, null_dict]
364 var lnl: list<list<number>> = [[1], null_list]
365 var lsl: list<list<string>> = [['x'], null_list]
366 def Len(v: string): number
367 return len(v)
368 enddef
369 var Ffl: list<func(string): number> = [Len, null_function]
370 var Fpl: list<func(string): number> = [Len, null_partial]
371 var sl: list<string> = ['x', null_string]
372 if has('job')
373 var jl: list<job> = [null_job]
374 var cl: list<channel> = [null_channel]
375 endif
Bram Moolenaar8acb9cc2022-03-08 13:18:55 +0000376 END
377 v9.CheckDefAndScriptSuccess(lines)
378enddef
379
Bram Moolenaarce93d162023-01-30 21:12:34 +0000380def Test_type_with_extra_white()
381 var lines =<< trim END
382 const x : number = 3
383 END
384 v9.CheckDefExecAndScriptFailure(lines, 'E1059')
385enddef
386
Bram Moolenaar56b84b12022-03-09 19:46:48 +0000387def Test_keep_type_after_assigning_null()
388 var lines =<< trim END
389 var b: blob
390 b = null_blob
391 b = 'text'
392 END
393 v9.CheckDefExecAndScriptFailure(lines, 'E1012: Type mismatch; expected blob but got string')
394
395 lines =<< trim END
396 var l: list<number>
397 l = null_list
398 l = ['text']
399 END
400 v9.CheckDefExecAndScriptFailure(lines, 'E1012: Type mismatch; expected list<number> but got list<string>')
401
402 lines =<< trim END
403 var d: dict<string>
404 d = null_dict
405 d = {a: 1, b: 2}
406 END
407 v9.CheckDefExecAndScriptFailure(lines, 'E1012: Type mismatch; expected dict<string> but got dict<number>')
408enddef
409
Bram Moolenaaraa1959b2021-04-15 22:13:39 +0200410def Test_skipped_assignment()
411 var lines =<< trim END
412 for x in []
413 var i: number = 1
414 while false
415 i += 1
416 endwhile
417 endfor
418 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000419 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaaraa1959b2021-04-15 22:13:39 +0200420enddef
421
Bram Moolenaar7824fc82021-11-26 17:36:51 +0000422def Test_assign_keep_type()
423 var lines =<< trim END
424 vim9script
425 var l: list<number> = [123]
426 l = [123]
427 l->add('string')
428 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000429 v9.CheckScriptFailure(lines, 'E1012:', 4)
Bram Moolenaar7824fc82021-11-26 17:36:51 +0000430enddef
431
Bram Moolenaar8ff16e02020-12-07 21:49:52 +0100432def Test_assign_unpack()
433 var lines =<< trim END
434 var v1: number
435 var v2: number
436 [v1, v2] = [1, 2]
437 assert_equal(1, v1)
438 assert_equal(2, v2)
Bram Moolenaarf93bbd02021-04-10 22:35:43 +0200439
440 [v1, _, v2, _] = [1, 99, 2, 77]
441 assert_equal(1, v1)
442 assert_equal(2, v2)
443
444 [v1, v2; _] = [1, 2, 3, 4, 5]
445 assert_equal(1, v1)
446 assert_equal(2, v2)
Bram Moolenaar035bd1c2021-06-21 19:44:11 +0200447
Bram Moolenaarbc510062022-02-14 21:19:04 +0000448 var _x: number
449 [_x, v2] = [6, 7]
450 assert_equal(6, _x)
451 assert_equal(7, v2)
452
Bram Moolenaar4d5dfe22021-06-26 13:59:29 +0200453 var reslist = []
454 for text in ['aaa {bbb} ccc', 'ddd {eee} fff']
455 var before: string
456 var middle: string
457 var after: string
458 [_, before, middle, after; _] = text->matchlist('\(.\{-\}\){\(.\{-\}\)}\(.*\)')
459 reslist->add(before)->add(middle)->add(after)
460 endfor
461 assert_equal(['aaa ', 'bbb', ' ccc', 'ddd ', 'eee', ' fff'], reslist)
462
Bram Moolenaar035bd1c2021-06-21 19:44:11 +0200463 var a = 1
464 var b = 3
465 [a, b] += [2, 4]
466 assert_equal(3, a)
467 assert_equal(7, b)
468
469 [a, b] -= [1, 2]
470 assert_equal(2, a)
471 assert_equal(5, b)
472
473 [a, b] *= [3, 2]
474 assert_equal(6, a)
475 assert_equal(10, b)
476
477 [a, b] /= [2, 4]
478 assert_equal(3, a)
479 assert_equal(2, b)
480
481 [a, b] = [17, 15]
482 [a, b] %= [5, 3]
483 assert_equal(2, a)
484 assert_equal(0, b)
Bram Moolenaar8ff16e02020-12-07 21:49:52 +0100485 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000486 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8ff16e02020-12-07 21:49:52 +0100487
488 lines =<< trim END
489 var v1: number
490 var v2: number
Bram Moolenaardb9ff9a2021-12-01 17:38:01 +0000491 [v1, v2] = [1, 2, 3]
492 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000493 v9.CheckDefFailure(lines, 'E1093: Expected 2 items but got 3', 3)
Bram Moolenaardb9ff9a2021-12-01 17:38:01 +0000494
495 lines =<< trim END
496 var v1: number
497 var v2: number
498 [v1, v2] = [1]
499 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000500 v9.CheckDefFailure(lines, 'E1093: Expected 2 items but got 1', 3)
Bram Moolenaardb9ff9a2021-12-01 17:38:01 +0000501
502 lines =<< trim END
503 var v1: number
504 var v2: number
505 [v1, v2; _] = [1]
506 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000507 v9.CheckDefFailure(lines, 'E1093: Expected 2 items but got 1', 3)
Bram Moolenaardb9ff9a2021-12-01 17:38:01 +0000508
509 lines =<< trim END
510 var v1: number
511 var v2: number
Bram Moolenaar8ff16e02020-12-07 21:49:52 +0100512 [v1, v2] =
513 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000514 v9.CheckDefFailure(lines, 'E1097:', 5)
Bram Moolenaar8ff16e02020-12-07 21:49:52 +0100515
516 lines =<< trim END
517 var v1: number
518 var v2: number
519 [v1, v2] = xxx
520 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000521 v9.CheckDefFailure(lines, 'E1001:', 3)
Bram Moolenaar8ff16e02020-12-07 21:49:52 +0100522
523 lines =<< trim END
524 var v1: number
525 var v2: number
526 [v1, v2] = popup_clear()
527 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000528 v9.CheckDefFailure(lines, 'E1031:', 3)
Bram Moolenaar8ff16e02020-12-07 21:49:52 +0100529
530 lines =<< trim END
Bram Moolenaar3862ea32021-01-01 21:05:55 +0100531 [v1, v2] = [1, 2]
532 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000533 v9.CheckDefFailure(lines, 'E1089', 1)
534 v9.CheckScriptFailure(['vim9script'] + lines, 'E1089', 2)
Bram Moolenaar3862ea32021-01-01 21:05:55 +0100535
536 lines =<< trim END
Bram Moolenaar8ff16e02020-12-07 21:49:52 +0100537 var v1: number
538 var v2: number
539 [v1, v2] = ''
540 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000541 v9.CheckDefFailure(lines, 'E1012: Type mismatch; expected list<any> but got string', 3)
Bram Moolenaarf785aa12021-02-11 21:19:34 +0100542
543 lines =<< trim END
544 g:values = [false, 0]
545 var x: bool
546 var y: string
547 [x, y] = g:values
548 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000549 v9.CheckDefExecAndScriptFailure(lines, 'E1163: Variable 2: type mismatch, expected string but got number')
Bram Moolenaar4270d8b2021-08-07 16:30:42 +0200550
551 lines =<< trim END
552 var x: number
553 var y: number
554 var z: string
555 [x, y, z] = [1, 2, 3]
556 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000557 v9.CheckDefAndScriptFailure(lines, 'E1163: Variable 3: type mismatch, expected string but got number')
Bram Moolenaar4270d8b2021-08-07 16:30:42 +0200558
559 lines =<< trim END
560 var x: number
561 var y: string
562 var z: string
563 [x, y, z] = [1, '2', 3]
564 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000565 v9.CheckDefExecAndScriptFailure(lines, 'E1163: Variable 3: type mismatch, expected string but got number')
Bram Moolenaar8ff16e02020-12-07 21:49:52 +0100566enddef
567
Bram Moolenaar7f764942020-12-02 15:11:18 +0100568def Test_assign_linebreak()
569 var nr: number
570 nr =
571 123
572 assert_equal(123, nr)
573
574 var n2: number
575 [nr, n2] =
576 [12, 34]
577 assert_equal(12, nr)
578 assert_equal(34, n2)
579
Bram Moolenaar62aec932022-01-29 21:45:34 +0000580 v9.CheckDefFailure(["var x = #"], 'E1097:', 3)
Bram Moolenaar77709b12021-04-03 21:01:01 +0200581
582 var lines =<< trim END
583 var x: list<string> = ['a']
584 var y: list<number> = x
585 ->copy()
586 ->copy()
587 END
Bram Moolenaar381692b2022-02-02 20:01:27 +0000588 v9.CheckDefExecFailure(lines, 'E1012:', 4)
Bram Moolenaar6977dba2021-07-04 22:48:12 +0200589
590 lines =<< trim END
591 var x: any
592 x.key = 1
593 + 2
594 + 3
595 + 4
596 + 5
597 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000598 v9.CheckDefExecAndScriptFailure(lines, ['E1148:', 'E1203:'], 2)
Bram Moolenaar7f764942020-12-02 15:11:18 +0100599enddef
600
Bram Moolenaardc234ca2020-11-28 18:52:33 +0100601def Test_assign_index()
602 # list of list
603 var l1: list<number>
604 l1[0] = 123
605 assert_equal([123], l1)
606
607 var l2: list<list<number>>
608 l2[0] = []
609 l2[0][0] = 123
610 assert_equal([[123]], l2)
611
612 var l3: list<list<list<number>>>
613 l3[0] = []
614 l3[0][0] = []
615 l3[0][0][0] = 123
616 assert_equal([[[123]]], l3)
617
618 var lines =<< trim END
619 var l3: list<list<number>>
620 l3[0] = []
621 l3[0][0] = []
622 END
Yegappan Lakshmanan66897192023-12-05 15:51:50 +0100623 v9.CheckDefFailure(lines, 'E1012: Type mismatch; expected number but got list<any>', 3)
Bram Moolenaardc234ca2020-11-28 18:52:33 +0100624
625 # dict of dict
626 var d1: dict<number>
627 d1.one = 1
628 assert_equal({one: 1}, d1)
629
630 var d2: dict<dict<number>>
631 d2.one = {}
632 d2.one.two = 123
633 assert_equal({one: {two: 123}}, d2)
634
635 var d3: dict<dict<dict<number>>>
636 d3.one = {}
637 d3.one.two = {}
638 d3.one.two.three = 123
639 assert_equal({one: {two: {three: 123}}}, d3)
640
Bram Moolenaare08be092022-02-17 13:08:26 +0000641 # blob
642 var bl: blob = 0z11223344
643 bl[0] = 0x77
644 assert_equal(0z77223344, bl)
645 bl[-2] = 0x66
646 assert_equal(0z77226644, bl)
647
Bram Moolenaar1983f1a2022-02-28 20:55:02 +0000648 lines =<< trim END
649 g:val = '22'
650 var bl = 0z11
651 bl[1] = g:val
652 END
653 v9.CheckDefExecAndScriptFailure(lines, 'E1030: Using a String as a Number: "22"')
654
Bram Moolenaare97976b2021-08-01 13:17:17 +0200655 # should not read the next line when generating "a.b"
656 var a = {}
657 a.b = {}
658 a.b.c = {}
659 ->copy()
660
Bram Moolenaardc234ca2020-11-28 18:52:33 +0100661 lines =<< trim END
662 var d3: dict<dict<number>>
663 d3.one = {}
664 d3.one.two = {}
665 END
Yegappan Lakshmanan66897192023-12-05 15:51:50 +0100666 v9.CheckDefFailure(lines, 'E1012: Type mismatch; expected number but got dict<any>', 3)
Bram Moolenaardc234ca2020-11-28 18:52:33 +0100667
Bram Moolenaaracbae182020-12-13 18:44:43 +0100668 lines =<< trim END
669 var lines: list<string>
670 lines['a'] = 'asdf'
671 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000672 v9.CheckDefFailure(lines, 'E1012:', 2)
Bram Moolenaaracbae182020-12-13 18:44:43 +0100673
674 lines =<< trim END
675 var lines: string
676 lines[9] = 'asdf'
677 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000678 v9.CheckDefFailure(lines, 'E1141:', 2)
Bram Moolenaaracbae182020-12-13 18:44:43 +0100679
Bram Moolenaardc234ca2020-11-28 18:52:33 +0100680 # list of dict
681 var ld: list<dict<number>>
682 ld[0] = {}
683 ld[0].one = 123
684 assert_equal([{one: 123}], ld)
685
686 lines =<< trim END
687 var ld: list<dict<number>>
688 ld[0] = []
689 END
Yegappan Lakshmanan66897192023-12-05 15:51:50 +0100690 v9.CheckDefFailure(lines, 'E1012: Type mismatch; expected dict<number> but got list<any>', 2)
Bram Moolenaardc234ca2020-11-28 18:52:33 +0100691
692 # dict of list
693 var dl: dict<list<number>>
694 dl.one = []
695 dl.one[0] = 123
696 assert_equal({one: [123]}, dl)
697
698 lines =<< trim END
699 var dl: dict<list<number>>
700 dl.one = {}
701 END
Yegappan Lakshmanan66897192023-12-05 15:51:50 +0100702 v9.CheckDefFailure(lines, 'E1012: Type mismatch; expected list<number> but got dict<any>', 2)
Bram Moolenaare08be092022-02-17 13:08:26 +0000703
704 lines =<< trim END
705 g:l = [1, 2]
706 g:l['x'] = 3
707 END
708 v9.CheckDefExecAndScriptFailure(lines, ['E39:', 'E1030:'], 2)
709
710 lines =<< trim END
711 var bl: blob = test_null_blob()
712 bl[1] = 8
713 END
714 v9.CheckDefExecAndScriptFailure(lines, ['E1184:', 'E979:'], 2)
Bram Moolenaarea5c8982022-02-17 14:42:02 +0000715
716 lines =<< trim END
717 g:bl = 'not a blob'
718 g:bl[1 : 2] = 8
719 END
720 v9.CheckDefExecAndScriptFailure(lines, ['E897:', 'E689:'], 2)
Bram Moolenaardc234ca2020-11-28 18:52:33 +0100721enddef
722
Bram Moolenaar38ecd972022-01-15 21:44:44 +0000723def Test_init_in_for_loop()
724 var lines =<< trim END
725 var l: list<number> = []
726 for i in [3, 4]
727 var n: number
728 add(l, n)
729 n = 123
730 endfor
731 assert_equal([0, 0], l)
732 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000733 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar38ecd972022-01-15 21:44:44 +0000734
735 lines =<< trim END
736 var l: list<number> = []
737 for i in [3, 4]
738 var n: number = 0
739 add(l, n)
740 n = 123
741 endfor
742 assert_equal([0, 0], l)
743 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000744 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar38ecd972022-01-15 21:44:44 +0000745
746 lines =<< trim END
747 var l: list<number> = []
748 for i in [3, 4]
749 var n: number = 3
750 add(l, n)
751 n = 123
752 endfor
753 assert_equal([3, 3], l)
754 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000755 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar38ecd972022-01-15 21:44:44 +0000756enddef
757
Bram Moolenaarbc6f2bf2022-05-06 14:29:09 +0100758def Test_redir_is_not_assign()
759 if false
760 redir => res
761 echo var_job
762 redir END
763 endif
764enddef
765
Bram Moolenaar81ed4962020-09-23 15:56:50 +0200766def Test_extend_list()
Yegappan Lakshmananefbfa862022-04-17 12:47:40 +0100767 # using uninitialized list assigns empty list
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200768 var lines =<< trim END
Bram Moolenaar07802042021-09-09 23:01:14 +0200769 var l1: list<number>
770 var l2 = l1
771 assert_true(l1 is l2)
772 l1 += [123]
773 assert_equal([123], l1)
774 assert_true(l1 is l2)
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100775 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000776 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar81ed4962020-09-23 15:56:50 +0200777
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100778 lines =<< trim END
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100779 var list: list<string>
780 extend(list, ['x'])
781 assert_equal(['x'], list)
Bram Moolenaar81ed4962020-09-23 15:56:50 +0200782 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000783 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar1a739232020-10-10 15:37:58 +0200784
Yegappan Lakshmananefbfa862022-04-17 12:47:40 +0100785 # appending to uninitialized list from a function works
Bram Moolenaar1a739232020-10-10 15:37:58 +0200786 lines =<< trim END
787 vim9script
788 var list: list<string>
789 def Func()
790 list += ['a', 'b']
791 enddef
792 Func()
793 assert_equal(['a', 'b'], list)
794 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000795 v9.CheckScriptSuccess(lines)
Bram Moolenaar3beaf9c2020-12-18 17:23:14 +0100796 lines =<< trim END
797 vim9script
798 var list: list<string>
799 def Func()
800 extend(list, ['x', 'b'])
801 enddef
802 Func()
803 assert_equal(['x', 'b'], list)
804 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000805 v9.CheckScriptSuccess(lines)
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100806
Bram Moolenaaraa7d0c22022-04-05 21:40:38 +0100807 # initialized to null, with type, does not default to empty list
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100808 lines =<< trim END
809 vim9script
810 var l: list<string> = test_null_list()
811 extend(l, ['x'])
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100812 END
Bram Moolenaaraa7d0c22022-04-05 21:40:38 +0100813 v9.CheckScriptFailure(lines, 'E1134:', 3)
814
815 # initialized to null, without type, does not default to empty list
816 lines =<< trim END
817 vim9script
818 var l = null_list
819 extend(l, ['x'])
820 END
821 v9.CheckScriptFailure(lines, 'E1134:', 3)
822
823 # assigned null, does not default to empty list
824 lines =<< trim END
825 vim9script
826 var l: list<string>
827 l = null_list
828 extend(l, ['x'])
829 END
830 v9.CheckScriptFailure(lines, 'E1134:', 4)
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100831
832 lines =<< trim END
833 vim9script
834 extend(test_null_list(), ['x'])
835 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000836 v9.CheckScriptFailure(lines, 'E1134:', 2)
Bram Moolenaar078a4612022-01-04 15:17:03 +0000837
838 # using global var has no declared type
839 g:myList = []
840 g:myList->extend([1])
841 g:myList->extend(['x'])
842 assert_equal([1, 'x'], g:myList)
843 unlet g:myList
844
845 # using declared list gives an error
846 lines =<< trim END
847 var l: list<number>
848 g:myList = l
849 g:myList->extend([1])
850 g:myList->extend(['x'])
851 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000852 v9.CheckDefExecAndScriptFailure(lines, 'E1013: Argument 2: type mismatch, expected list<number> but got list<string>', 4)
Bram Moolenaar078a4612022-01-04 15:17:03 +0000853 unlet g:myList
Bram Moolenaar160afdb2022-02-06 17:17:02 +0000854
855 lines =<< trim END
856 vim9script
857 var lds = [1, 2, 3]
858 def Func()
859 echo lds->extend(['x'])
860 enddef
861 defcompile
862 END
863 v9.CheckScriptFailure(lines, 'E1013:')
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100864enddef
865
866def Test_extend_dict()
867 var lines =<< trim END
868 vim9script
869 var d: dict<number>
Bram Moolenaare0de1712020-12-02 17:36:54 +0100870 extend(d, {a: 1})
871 assert_equal({a: 1}, d)
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100872
873 var d2: dict<number>
874 d2['one'] = 1
Bram Moolenaare0de1712020-12-02 17:36:54 +0100875 assert_equal({one: 1}, d2)
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100876 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000877 v9.CheckScriptSuccess(lines)
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100878
879 lines =<< trim END
880 vim9script
881 var d: dict<string> = test_null_dict()
Bram Moolenaare0de1712020-12-02 17:36:54 +0100882 extend(d, {a: 'x'})
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100883 END
Bram Moolenaaraa7d0c22022-04-05 21:40:38 +0100884 v9.CheckScriptFailure(lines, 'E1133:', 3)
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100885
886 lines =<< trim END
887 vim9script
Bram Moolenaare0de1712020-12-02 17:36:54 +0100888 extend(test_null_dict(), {a: 'x'})
Bram Moolenaar348be7e2020-11-04 11:36:35 +0100889 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000890 v9.CheckScriptFailure(lines, 'E1133:', 2)
Bram Moolenaar81ed4962020-09-23 15:56:50 +0200891enddef
892
Bram Moolenaar971caf52020-09-21 22:21:42 +0200893def Test_single_letter_vars()
894 # single letter variables
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200895 var a: number = 123
Bram Moolenaar971caf52020-09-21 22:21:42 +0200896 a = 123
897 assert_equal(123, a)
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200898 var b: number
Bram Moolenaar971caf52020-09-21 22:21:42 +0200899 b = 123
900 assert_equal(123, b)
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200901 var g: number
Bram Moolenaar971caf52020-09-21 22:21:42 +0200902 g = 123
903 assert_equal(123, g)
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200904 var s: number
Bram Moolenaar971caf52020-09-21 22:21:42 +0200905 s = 123
906 assert_equal(123, s)
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200907 var t: number
Bram Moolenaar971caf52020-09-21 22:21:42 +0200908 t = 123
909 assert_equal(123, t)
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200910 var v: number
Bram Moolenaar971caf52020-09-21 22:21:42 +0200911 v = 123
912 assert_equal(123, v)
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200913 var w: number
Bram Moolenaar971caf52020-09-21 22:21:42 +0200914 w = 123
915 assert_equal(123, w)
916enddef
917
918def Test_vim9_single_char_vars()
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200919 var lines =<< trim END
Bram Moolenaar971caf52020-09-21 22:21:42 +0200920 vim9script
921
922 # single character variable declarations work
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200923 var a: string
924 var b: number
925 var l: list<any>
926 var s: string
927 var t: number
928 var v: number
929 var w: number
Bram Moolenaar971caf52020-09-21 22:21:42 +0200930
931 # script-local variables can be used without s: prefix
932 a = 'script-a'
933 b = 111
934 l = [1, 2, 3]
935 s = 'script-s'
936 t = 222
937 v = 333
938 w = 444
939
940 assert_equal('script-a', a)
941 assert_equal(111, b)
942 assert_equal([1, 2, 3], l)
943 assert_equal('script-s', s)
944 assert_equal(222, t)
945 assert_equal(333, v)
946 assert_equal(444, w)
947 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +0100948 writefile(lines, 'Xsinglechar', 'D')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200949 source Xsinglechar
Bram Moolenaar971caf52020-09-21 22:21:42 +0200950enddef
951
952def Test_assignment_list()
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200953 var list1: list<bool> = [false, true, false]
954 var list2: list<number> = [1, 2, 3]
955 var list3: list<string> = ['sdf', 'asdf']
956 var list4: list<any> = ['yes', true, 1234]
957 var list5: list<blob> = [0z01, 0z02]
Bram Moolenaar971caf52020-09-21 22:21:42 +0200958
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200959 var listS: list<string> = []
960 var listN: list<number> = []
Bram Moolenaar971caf52020-09-21 22:21:42 +0200961
962 assert_equal([1, 2, 3], list2)
963 list2[-1] = 99
964 assert_equal([1, 2, 99], list2)
965 list2[-2] = 88
966 assert_equal([1, 88, 99], list2)
967 list2[-3] = 77
968 assert_equal([77, 88, 99], list2)
969 list2 += [100]
970 assert_equal([77, 88, 99, 100], list2)
971
972 list3 += ['end']
973 assert_equal(['sdf', 'asdf', 'end'], list3)
974
Bram Moolenaar62aec932022-01-29 21:45:34 +0000975 v9.CheckDefExecFailure(['var ll = [1, 2, 3]', 'll[-4] = 6'], 'E684:')
Bram Moolenaar6296d1e2022-02-17 16:30:11 +0000976 v9.CheckDefExecFailure(['var ll = [1, 2, 3]', 'unlet ll[8 : 9]'], 'E684:')
977 v9.CheckDefExecFailure(['var ll = [1, 2, 3]', 'unlet ll[1 : -9]'], 'E684:')
978 v9.CheckDefExecFailure(['var ll = [1, 2, 3]', 'unlet ll[2 : 1]'], 'E684:')
Bram Moolenaar971caf52020-09-21 22:21:42 +0200979
980 # type becomes list<any>
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200981 var somelist = rand() > 0 ? [1, 2, 3] : ['a', 'b', 'c']
Bram Moolenaar4f5e3972020-12-21 17:30:50 +0100982
Bram Moolenaar114dbda2022-01-03 12:28:03 +0000983 # type is list<any> even though initializer is list<number>
984 var anyList: list<any> = [0]
985 assert_equal([0, 'x'], extend(anyList, ['x']))
986
Bram Moolenaar4f5e3972020-12-21 17:30:50 +0100987 var lines =<< trim END
988 var d = {dd: test_null_list()}
989 d.dd[0] = 0
990 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000991 v9.CheckDefExecFailure(lines, 'E1147:', 2)
Bram Moolenaar7a40ff02021-07-04 15:54:08 +0200992
993 lines =<< trim END
994 def OneArg(x: bool)
995 enddef
996 def TwoArgs(x: bool, y: bool)
997 enddef
998 var fl: list<func(bool, bool, bool)> = [OneArg, TwoArgs]
999 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001000 v9.CheckDefExecAndScriptFailure(lines, 'E1012:', 5)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001001enddef
1002
Bram Moolenaarab36e6a2021-11-30 16:14:49 +00001003def Test_list_declaration()
1004 var [v1, v2] = [1, 2]
1005 v1 += 3
1006 assert_equal(4, v1)
1007 v2 *= 3
1008 assert_equal(6, v2)
1009
1010 var lines =<< trim END
1011 var [v1, v2] = [1]
1012 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001013 v9.CheckDefExecAndScriptFailure(lines, ['E1093: Expected 2 items but got 1', 'E688:'])
Bram Moolenaarab36e6a2021-11-30 16:14:49 +00001014 lines =<< trim END
1015 var testlist = [1]
1016 var [v1, v2] = testlist
1017 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001018 v9.CheckDefExecAndScriptFailure(lines, ['E1093: Expected 2 items but got 1', 'E688:'])
Bram Moolenaarab36e6a2021-11-30 16:14:49 +00001019 lines =<< trim END
1020 var [v1, v2] = [1, 2, 3]
1021 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001022 v9.CheckDefExecAndScriptFailure(lines, ['E1093: Expected 2 items but got 3', 'E687:'])
Bram Moolenaarab36e6a2021-11-30 16:14:49 +00001023 lines =<< trim END
1024 var testlist = [1, 2, 3]
1025 var [v1, v2] = testlist
1026 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001027 v9.CheckDefExecAndScriptFailure(lines, ['E1093: Expected 2 items but got 3', 'E687:'])
Bram Moolenaarab36e6a2021-11-30 16:14:49 +00001028
1029 var [vnr, vstr] = [123, 'text']
1030 vnr += 3
1031 assert_equal(126, vnr)
1032 vstr ..= 'end'
1033 assert_equal('textend', vstr)
1034
1035 var [vnr2: number, vstr2: string] = [123, 'text']
1036 vnr2 += 3
1037 assert_equal(126, vnr2)
1038 vstr2 ..= 'end'
1039 assert_equal('textend', vstr2)
1040
1041 var [vnr3: number; vlist: list<string>] = [123, 'foo', 'bar']
1042 vnr3 += 5
1043 assert_equal(128, vnr3)
1044 assert_equal(['foo', 'bar'], vlist)
1045
1046 lines =<< trim END
1047 var [vnr2: number, vstr2: number] = [123, 'text']
1048 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001049 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 +00001050 lines =<< trim END
1051 var testlist = [234, 'text']
1052 var [vnr2: number, vstr2: number] = testlist
1053 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001054 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 +00001055enddef
1056
Bram Moolenaar97f227d2021-07-04 20:20:52 +02001057def PartFuncBool(b: bool): string
Bram Moolenaarb7480cd2021-07-04 18:28:15 +02001058 return 'done'
1059enddef
1060
1061def Test_assignment_partial()
Bram Moolenaar97f227d2021-07-04 20:20:52 +02001062 var lines =<< trim END
Bram Moolenaar848fadd2022-01-30 15:28:30 +00001063 var Partial: func(): string = function(g:PartFuncBool, [true])
Bram Moolenaar97f227d2021-07-04 20:20:52 +02001064 assert_equal('done', Partial())
1065 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001066 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar22f85d02021-07-04 23:29:30 +02001067
1068 lines =<< trim END
1069 vim9script
1070 def Func(b: bool)
1071 enddef
1072 var Ref: func = function(Func, [true])
1073 assert_equal('func()', typename(Ref))
1074 Ref()
1075 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001076 v9.CheckScriptSuccess(lines)
Bram Moolenaar13789bf2021-12-30 13:29:00 +00001077
1078 lines =<< trim END
1079 vim9script
1080
1081 var nres: any
1082 var sres: any
Bram Moolenaar9a015112021-12-31 14:06:45 +00001083 def Func(nr: number, s = '')
1084 nres = nr
Bram Moolenaar13789bf2021-12-30 13:29:00 +00001085 sres = s
1086 enddef
1087
1088 var n: number
1089 var Ref = function(Func, [n])
1090 Ref('x')
1091 assert_equal(0, nres)
1092 assert_equal('x', sres)
1093 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001094 v9.CheckScriptSuccess(lines)
Bram Moolenaar13789bf2021-12-30 13:29:00 +00001095
1096 lines =<< trim END
1097 vim9script
1098
Bram Moolenaar9a015112021-12-31 14:06:45 +00001099 def Func(nr: number, s = '')
Bram Moolenaar13789bf2021-12-30 13:29:00 +00001100 enddef
1101
1102 var n: number
1103 var Ref = function(Func, [n])
1104 Ref(0)
1105 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001106 v9.CheckScriptFailure(lines, 'E1013: Argument 2: type mismatch, expected string but got number')
Bram Moolenaarb7480cd2021-07-04 18:28:15 +02001107enddef
1108
Bram Moolenaarf30a14d2021-01-17 21:51:24 +01001109def Test_assignment_list_any_index()
1110 var l: list<number> = [1, 2]
1111 for [x, y, _]
1112 in [[0, 1, ''], [1, 3, '']]
1113 l[x] = l[x] + y
1114 endfor
1115 assert_equal([2, 5], l)
1116enddef
1117
Bram Moolenaar971caf52020-09-21 22:21:42 +02001118def Test_assignment_list_vim9script()
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001119 var lines =<< trim END
Bram Moolenaar971caf52020-09-21 22:21:42 +02001120 vim9script
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001121 var v1: number
1122 var v2: number
1123 var v3: number
Bram Moolenaar971caf52020-09-21 22:21:42 +02001124 [v1, v2, v3] = [1, 2, 3]
1125 assert_equal([1, 2, 3], [v1, v2, v3])
1126 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001127 v9.CheckScriptSuccess(lines)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001128enddef
1129
1130def Test_assignment_dict()
Bram Moolenaare0de1712020-12-02 17:36:54 +01001131 var dict1: dict<bool> = {one: false, two: true}
1132 var dict2: dict<number> = {one: 1, two: 2}
1133 var dict3: dict<string> = {key: 'value'}
1134 var dict4: dict<any> = {one: 1, two: '2'}
1135 var dict5: dict<blob> = {one: 0z01, two: 0z02}
Bram Moolenaar971caf52020-09-21 22:21:42 +02001136
Bram Moolenaar31d99482022-05-26 22:24:43 +01001137 # check the type is OK
1138 var events: dict<string> = v:event
1139
Bram Moolenaar971caf52020-09-21 22:21:42 +02001140 # overwrite
1141 dict3['key'] = 'another'
Bram Moolenaare0de1712020-12-02 17:36:54 +01001142 assert_equal(dict3, {key: 'another'})
Bram Moolenaarfc74d032020-11-16 22:11:49 +01001143 dict3.key = 'yet another'
Bram Moolenaare0de1712020-12-02 17:36:54 +01001144 assert_equal(dict3, {key: 'yet another'})
Bram Moolenaarfc74d032020-11-16 22:11:49 +01001145
Bram Moolenaard24602f2020-12-20 15:20:56 +01001146 # member "any" can also be a dict and assigned to
1147 var anydict: dict<any> = {nest: {}, nr: 0}
1148 anydict.nest['this'] = 123
1149 anydict.nest.that = 456
1150 assert_equal({nest: {this: 123, that: 456}, nr: 0}, anydict)
1151
Bram Moolenaarfc74d032020-11-16 22:11:49 +01001152 var lines =<< trim END
Bram Moolenaard88dc4d2020-12-20 14:49:42 +01001153 var dd = {}
1154 dd.two = 2
1155 assert_equal({two: 2}, dd)
1156 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001157 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar4f5e3972020-12-21 17:30:50 +01001158
1159 lines =<< trim END
1160 var d = {dd: {}}
1161 d.dd[0] = 2
1162 d.dd['x'] = 3
1163 d.dd.y = 4
1164 assert_equal({dd: {0: 2, x: 3, y: 4}}, d)
1165 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001166 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaard88dc4d2020-12-20 14:49:42 +01001167
1168 lines =<< trim END
Bram Moolenaar2e17fef2022-03-18 19:44:48 +00001169 var key = 'foo'
1170 g:[key] = 'value'
1171 assert_equal('value', g:foo)
1172 unlet g:foo
1173 END
1174 v9.CheckDefAndScriptSuccess(lines)
1175
1176 lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +01001177 var dd = {one: 1}
Bram Moolenaarfc74d032020-11-16 22:11:49 +01001178 dd.one) = 2
1179 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001180 v9.CheckDefFailure(lines, 'E488:', 2)
Bram Moolenaard88dc4d2020-12-20 14:49:42 +01001181
1182 lines =<< trim END
1183 var dd = {one: 1}
1184 var dd.one = 2
1185 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001186 v9.CheckDefAndScriptFailure(lines, 'E1017:', 2)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001187
1188 # empty key can be used
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001189 var dd = {}
Bram Moolenaar971caf52020-09-21 22:21:42 +02001190 dd[""] = 6
Bram Moolenaare0de1712020-12-02 17:36:54 +01001191 assert_equal({['']: 6}, dd)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001192
1193 # type becomes dict<any>
Bram Moolenaare0de1712020-12-02 17:36:54 +01001194 var somedict = rand() > 0 ? {a: 1, b: 2} : {a: 'a', b: 'b'}
Bram Moolenaar971caf52020-09-21 22:21:42 +02001195
Bram Moolenaar114dbda2022-01-03 12:28:03 +00001196 # type is dict<any> even though initializer is dict<number>
1197 var anyDict: dict<any> = {a: 0}
1198 assert_equal({a: 0, b: 'x'}, extend(anyDict, {b: 'x'}))
1199
Bram Moolenaar078a4612022-01-04 15:17:03 +00001200 # using global var, which has no declared type
1201 g:myDict = {}
1202 g:myDict->extend({a: 1})
1203 g:myDict->extend({b: 'x'})
1204 assert_equal({a: 1, b: 'x'}, g:myDict)
1205 unlet g:myDict
1206
1207 # using list with declared type gives an error
1208 lines =<< trim END
1209 var d: dict<number>
1210 g:myDict = d
1211 g:myDict->extend({a: 1})
1212 g:myDict->extend({b: 'x'})
1213 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001214 v9.CheckDefExecAndScriptFailure(lines, 'E1013: Argument 2: type mismatch, expected dict<number> but got dict<string>', 4)
Bram Moolenaar078a4612022-01-04 15:17:03 +00001215 unlet g:myDict
1216
Bram Moolenaar971caf52020-09-21 22:21:42 +02001217 # assignment to script-local dict
Bram Moolenaarfc74d032020-11-16 22:11:49 +01001218 lines =<< trim END
Bram Moolenaar971caf52020-09-21 22:21:42 +02001219 vim9script
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001220 var test: dict<any> = {}
Bram Moolenaar971caf52020-09-21 22:21:42 +02001221 def FillDict(): dict<any>
1222 test['a'] = 43
1223 return test
1224 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +01001225 assert_equal({a: 43}, FillDict())
Bram Moolenaar971caf52020-09-21 22:21:42 +02001226 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001227 v9.CheckScriptSuccess(lines)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001228
1229 lines =<< trim END
1230 vim9script
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001231 var test: dict<any>
Bram Moolenaar971caf52020-09-21 22:21:42 +02001232 def FillDict(): dict<any>
1233 test['a'] = 43
1234 return test
1235 enddef
1236 FillDict()
Bram Moolenaar3beaf9c2020-12-18 17:23:14 +01001237 assert_equal({a: 43}, test)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001238 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001239 v9.CheckScriptSuccess(lines)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001240
1241 # assignment to global dict
1242 lines =<< trim END
1243 vim9script
1244 g:test = {}
1245 def FillDict(): dict<any>
1246 g:test['a'] = 43
1247 return g:test
1248 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +01001249 assert_equal({a: 43}, FillDict())
Bram Moolenaar971caf52020-09-21 22:21:42 +02001250 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001251 v9.CheckScriptSuccess(lines)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001252
1253 # assignment to buffer dict
1254 lines =<< trim END
1255 vim9script
1256 b:test = {}
1257 def FillDict(): dict<any>
1258 b:test['a'] = 43
1259 return b:test
1260 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +01001261 assert_equal({a: 43}, FillDict())
Bram Moolenaar971caf52020-09-21 22:21:42 +02001262 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001263 v9.CheckScriptSuccess(lines)
Bram Moolenaar4f5e3972020-12-21 17:30:50 +01001264
1265 lines =<< trim END
1266 var d = {dd: test_null_dict()}
1267 d.dd[0] = 0
1268 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001269 v9.CheckDefExecFailure(lines, 'E1103:', 2)
Bram Moolenaar4f5e3972020-12-21 17:30:50 +01001270
1271 lines =<< trim END
1272 var d = {dd: 'string'}
1273 d.dd[0] = 0
1274 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001275 v9.CheckDefExecFailure(lines, 'E1148:', 2)
Bram Moolenaar3a3b10e2021-06-26 15:00:59 +02001276
1277 lines =<< trim END
1278 var n: any
1279 n.key = 5
1280 END
Ernie Raelf8da3242023-10-11 21:22:12 +02001281 v9.CheckDefExecAndScriptFailure(lines, ['E1148:', 'E1203: Dot not allowed after a number: n.key = 5'], 2)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001282enddef
1283
1284def Test_assignment_local()
1285 # Test in a separated file in order not to the current buffer/window/tab is
1286 # changed.
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001287 var script_lines: list<string> =<< trim END
Bram Moolenaar971caf52020-09-21 22:21:42 +02001288 let b:existing = 'yes'
1289 let w:existing = 'yes'
1290 let t:existing = 'yes'
1291
1292 def Test_assignment_local_internal()
1293 b:newvar = 'new'
1294 assert_equal('new', b:newvar)
1295 assert_equal('yes', b:existing)
1296 b:existing = 'no'
1297 assert_equal('no', b:existing)
1298 b:existing ..= 'NO'
1299 assert_equal('noNO', b:existing)
1300
1301 w:newvar = 'new'
1302 assert_equal('new', w:newvar)
1303 assert_equal('yes', w:existing)
1304 w:existing = 'no'
1305 assert_equal('no', w:existing)
1306 w:existing ..= 'NO'
1307 assert_equal('noNO', w:existing)
1308
1309 t:newvar = 'new'
1310 assert_equal('new', t:newvar)
1311 assert_equal('yes', t:existing)
1312 t:existing = 'no'
1313 assert_equal('no', t:existing)
1314 t:existing ..= 'NO'
1315 assert_equal('noNO', t:existing)
1316 enddef
1317 call Test_assignment_local_internal()
1318 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001319 v9.CheckScriptSuccess(script_lines)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001320enddef
1321
1322def Test_assignment_default()
Bram Moolenaar971caf52020-09-21 22:21:42 +02001323 # Test default values.
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001324 var thebool: bool
Bram Moolenaar971caf52020-09-21 22:21:42 +02001325 assert_equal(v:false, thebool)
1326
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001327 var thenumber: number
Bram Moolenaar971caf52020-09-21 22:21:42 +02001328 assert_equal(0, thenumber)
1329
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01001330 var thefloat: float
1331 assert_equal(0.0, thefloat)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001332
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001333 var thestring: string
Bram Moolenaar971caf52020-09-21 22:21:42 +02001334 assert_equal('', thestring)
1335
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001336 var theblob: blob
Bram Moolenaar971caf52020-09-21 22:21:42 +02001337 assert_equal(0z, theblob)
1338
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001339 var Thefunc: func
Bram Moolenaar971caf52020-09-21 22:21:42 +02001340 assert_equal(test_null_function(), Thefunc)
1341
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001342 var thelist: list<any>
Bram Moolenaar971caf52020-09-21 22:21:42 +02001343 assert_equal([], thelist)
1344
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001345 var thedict: dict<any>
Bram Moolenaar971caf52020-09-21 22:21:42 +02001346 assert_equal({}, thedict)
1347
1348 if has('channel')
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001349 var thejob: job
Bram Moolenaar971caf52020-09-21 22:21:42 +02001350 assert_equal(test_null_job(), thejob)
1351
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001352 var thechannel: channel
Bram Moolenaar971caf52020-09-21 22:21:42 +02001353 assert_equal(test_null_channel(), thechannel)
1354
1355 if has('unix') && executable('cat')
1356 # check with non-null job and channel, types must match
Bram Moolenaare0de1712020-12-02 17:36:54 +01001357 thejob = job_start("cat ", {})
Bram Moolenaar971caf52020-09-21 22:21:42 +02001358 thechannel = job_getchannel(thejob)
1359 job_stop(thejob, 'kill')
1360 endif
1361 endif
1362
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001363 var nr = 1234 | nr = 5678
Bram Moolenaar971caf52020-09-21 22:21:42 +02001364 assert_equal(5678, nr)
1365enddef
1366
Bram Moolenaare08be092022-02-17 13:08:26 +00001367def Test_script_var_default()
1368 var lines =<< trim END
1369 vim9script
1370 var l: list<number>
Bram Moolenaar1983f1a2022-02-28 20:55:02 +00001371 var li = [1, 2]
Bram Moolenaare08be092022-02-17 13:08:26 +00001372 var bl: blob
Bram Moolenaar1983f1a2022-02-28 20:55:02 +00001373 var bli = 0z12
Bram Moolenaare08be092022-02-17 13:08:26 +00001374 var d: dict<number>
Bram Moolenaar1983f1a2022-02-28 20:55:02 +00001375 var di = {'a': 1, 'b': 2}
Bram Moolenaare08be092022-02-17 13:08:26 +00001376 def Echo()
1377 assert_equal([], l)
Bram Moolenaar1983f1a2022-02-28 20:55:02 +00001378 assert_equal([1, 2], li)
Bram Moolenaare08be092022-02-17 13:08:26 +00001379 assert_equal(0z, bl)
Bram Moolenaar1983f1a2022-02-28 20:55:02 +00001380 assert_equal(0z12, bli)
Bram Moolenaare08be092022-02-17 13:08:26 +00001381 assert_equal({}, d)
Bram Moolenaar1983f1a2022-02-28 20:55:02 +00001382 assert_equal({'a': 1, 'b': 2}, di)
Bram Moolenaare08be092022-02-17 13:08:26 +00001383 enddef
Bram Moolenaarea5c8982022-02-17 14:42:02 +00001384 Echo()
Bram Moolenaare08be092022-02-17 13:08:26 +00001385 END
1386 v9.CheckScriptSuccess(lines)
1387enddef
1388
Bram Moolenaara749a422022-02-12 19:52:25 +00001389let s:scriptvar = 'init'
Bram Moolenaar3862ea32021-01-01 21:05:55 +01001390
Bram Moolenaar971caf52020-09-21 22:21:42 +02001391def Test_assignment_var_list()
Bram Moolenaarda7c20c2020-11-30 21:12:19 +01001392 var lines =<< trim END
1393 var v1: string
1394 var v2: string
1395 var vrem: list<string>
1396 [v1] = ['aaa']
1397 assert_equal('aaa', v1)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001398
Bram Moolenaarda7c20c2020-11-30 21:12:19 +01001399 [v1, v2] = ['one', 'two']
1400 assert_equal('one', v1)
1401 assert_equal('two', v2)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001402
Bram Moolenaarda7c20c2020-11-30 21:12:19 +01001403 [v1, v2; vrem] = ['one', 'two']
1404 assert_equal('one', v1)
1405 assert_equal('two', v2)
1406 assert_equal([], vrem)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001407
Bram Moolenaarda7c20c2020-11-30 21:12:19 +01001408 [v1, v2; vrem] = ['one', 'two', 'three']
1409 assert_equal('one', v1)
1410 assert_equal('two', v2)
1411 assert_equal(['three'], vrem)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001412
Bram Moolenaarda7c20c2020-11-30 21:12:19 +01001413 [&ts, &sw] = [3, 4]
1414 assert_equal(3, &ts)
1415 assert_equal(4, &sw)
1416 set ts=8 sw=4
Bram Moolenaar004d9b02020-11-30 21:40:03 +01001417
1418 [@a, @z] = ['aa', 'zz']
1419 assert_equal('aa', @a)
1420 assert_equal('zz', @z)
1421
1422 [$SOME_VAR, $OTHER_VAR] = ['some', 'other']
1423 assert_equal('some', $SOME_VAR)
1424 assert_equal('other', $OTHER_VAR)
1425
Bram Moolenaar3862ea32021-01-01 21:05:55 +01001426 [g:globalvar, b:bufvar, w:winvar, t:tabvar, v:errmsg] =
1427 ['global', 'buf', 'win', 'tab', 'error']
Bram Moolenaar004d9b02020-11-30 21:40:03 +01001428 assert_equal('global', g:globalvar)
Bram Moolenaar004d9b02020-11-30 21:40:03 +01001429 assert_equal('buf', b:bufvar)
1430 assert_equal('win', w:winvar)
1431 assert_equal('tab', t:tabvar)
1432 assert_equal('error', v:errmsg)
1433 unlet g:globalvar
Bram Moolenaarda7c20c2020-11-30 21:12:19 +01001434 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001435 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar3862ea32021-01-01 21:05:55 +01001436
Bram Moolenaara749a422022-02-12 19:52:25 +00001437 [g:globalvar, scriptvar, b:bufvar] = ['global', 'script', 'buf']
Bram Moolenaar3862ea32021-01-01 21:05:55 +01001438 assert_equal('global', g:globalvar)
Bram Moolenaara749a422022-02-12 19:52:25 +00001439 assert_equal('script', scriptvar)
Bram Moolenaar3862ea32021-01-01 21:05:55 +01001440 assert_equal('buf', b:bufvar)
1441
1442 lines =<< trim END
1443 vim9script
Bram Moolenaara749a422022-02-12 19:52:25 +00001444 var scriptvar = 'init'
1445 [g:globalvar, scriptvar, w:winvar] = ['global', 'script', 'win']
Bram Moolenaar3862ea32021-01-01 21:05:55 +01001446 assert_equal('global', g:globalvar)
Bram Moolenaara749a422022-02-12 19:52:25 +00001447 assert_equal('script', scriptvar)
Bram Moolenaar3862ea32021-01-01 21:05:55 +01001448 assert_equal('win', w:winvar)
1449 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001450 v9.CheckScriptSuccess(lines)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001451enddef
1452
Bram Moolenaar2d3ac2e2022-02-03 12:34:05 +00001453def Test_assignment_empty_list()
1454 var lines =<< trim END
1455 var l2: list<any> = []
1456 var l: list<string>
1457 l = l2
1458 END
1459 v9.CheckDefAndScriptSuccess(lines)
1460enddef
1461
Bram Moolenaar971caf52020-09-21 22:21:42 +02001462def Test_assignment_vim9script()
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001463 var lines =<< trim END
Bram Moolenaar971caf52020-09-21 22:21:42 +02001464 vim9script
1465 def Func(): list<number>
1466 return [1, 2]
1467 enddef
Bram Moolenaar98309382020-09-27 21:58:45 +02001468 var name1: number
1469 var name2: number
1470 [name1, name2] =
Bram Moolenaar971caf52020-09-21 22:21:42 +02001471 Func()
Bram Moolenaar98309382020-09-27 21:58:45 +02001472 assert_equal(1, name1)
1473 assert_equal(2, name2)
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001474 var ll =
Bram Moolenaar971caf52020-09-21 22:21:42 +02001475 Func()
1476 assert_equal([1, 2], ll)
1477
1478 @/ = 'text'
1479 assert_equal('text', @/)
1480 @0 = 'zero'
1481 assert_equal('zero', @0)
1482 @1 = 'one'
1483 assert_equal('one', @1)
1484 @9 = 'nine'
1485 assert_equal('nine', @9)
1486 @- = 'minus'
1487 assert_equal('minus', @-)
1488 if has('clipboard_working')
1489 @* = 'star'
1490 assert_equal('star', @*)
1491 @+ = 'plus'
1492 assert_equal('plus', @+)
1493 endif
1494
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001495 var a: number = 123
Bram Moolenaar971caf52020-09-21 22:21:42 +02001496 assert_equal(123, a)
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001497 var s: string = 'yes'
Bram Moolenaar971caf52020-09-21 22:21:42 +02001498 assert_equal('yes', s)
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001499 var b: number = 42
Bram Moolenaar971caf52020-09-21 22:21:42 +02001500 assert_equal(42, b)
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001501 var w: number = 43
Bram Moolenaar971caf52020-09-21 22:21:42 +02001502 assert_equal(43, w)
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001503 var t: number = 44
Bram Moolenaar971caf52020-09-21 22:21:42 +02001504 assert_equal(44, t)
Bram Moolenaar7a66a172020-10-16 19:56:12 +02001505
1506 var to_var = 0
1507 to_var = 3
1508 assert_equal(3, to_var)
Bram Moolenaar971caf52020-09-21 22:21:42 +02001509 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001510 v9.CheckScriptSuccess(lines)
Bram Moolenaar06f9c692020-09-27 21:27:40 +02001511
1512 lines =<< trim END
1513 vim9script
1514 var n: number
1515 def Func()
1516 n = 'string'
1517 enddef
1518 defcompile
1519 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001520 v9.CheckScriptFailure(lines, 'E1012: Type mismatch; expected number but got string')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001521enddef
1522
1523def Mess(): string
1524 v:foldstart = 123
1525 return 'xxx'
1526enddef
1527
1528def Test_assignment_failure()
Bram Moolenaar62aec932022-01-29 21:45:34 +00001529 v9.CheckDefFailure(['var name=234'], 'E1004:')
1530 v9.CheckDefFailure(['var name =234'], 'E1004:')
1531 v9.CheckDefFailure(['var name= 234'], 'E1004:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001532
Bram Moolenaar62aec932022-01-29 21:45:34 +00001533 v9.CheckScriptFailure(['vim9script', 'var name=234'], 'E1004:')
1534 v9.CheckScriptFailure(['vim9script', 'var name=234'], "before and after '='")
1535 v9.CheckScriptFailure(['vim9script', 'var name =234'], 'E1004:')
1536 v9.CheckScriptFailure(['vim9script', 'var name= 234'], 'E1004:')
1537 v9.CheckScriptFailure(['vim9script', 'var name = 234', 'name+=234'], 'E1004:')
1538 v9.CheckScriptFailure(['vim9script', 'var name = 234', 'name+=234'], "before and after '+='")
1539 v9.CheckScriptFailure(['vim9script', 'var name = "x"', 'name..="y"'], 'E1004:')
1540 v9.CheckScriptFailure(['vim9script', 'var name = "x"', 'name..="y"'], "before and after '..='")
Bram Moolenaar971caf52020-09-21 22:21:42 +02001541
Bram Moolenaar62aec932022-01-29 21:45:34 +00001542 v9.CheckDefFailure(['var true = 1'], 'E1034:')
1543 v9.CheckDefFailure(['var false = 1'], 'E1034:')
1544 v9.CheckDefFailure(['var null = 1'], 'E1034:')
1545 v9.CheckDefFailure(['var this = 1'], 'E1034:')
Bram Moolenaarce723f32023-06-10 19:00:12 +01001546 v9.CheckDefFailure(['var super = 1'], 'E1034:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001547
Bram Moolenaar8b716f52022-02-15 21:17:56 +00001548 v9.CheckDefFailure(['[a; b; c] = g:list'], 'E1001:')
1549 v9.CheckDefFailure(['var [a; b; c] = g:list'], 'E1080:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001550 v9.CheckDefExecFailure(['var a: number',
Bram Moolenaar971caf52020-09-21 22:21:42 +02001551 '[a] = test_null_list()'], 'E1093:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001552 v9.CheckDefExecFailure(['var a: number',
Bram Moolenaar971caf52020-09-21 22:21:42 +02001553 '[a] = []'], 'E1093:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001554 v9.CheckDefExecFailure(['var x: number',
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001555 'var y: number',
Bram Moolenaar971caf52020-09-21 22:21:42 +02001556 '[x, y] = [1]'], 'E1093:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001557 v9.CheckDefExecFailure(['var x: string',
Bram Moolenaar352134b2020-10-17 22:04:08 +02001558 'var y: string',
1559 '[x, y] = ["x"]'], 'E1093:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001560 v9.CheckDefExecFailure(['var x: number',
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001561 'var y: number',
1562 'var z: list<number>',
Bram Moolenaar971caf52020-09-21 22:21:42 +02001563 '[x, y; z] = [1]'], 'E1093:')
1564
Bram Moolenaar62aec932022-01-29 21:45:34 +00001565 v9.CheckDefFailure(['var somevar'], "E1022:")
1566 v9.CheckDefFailure(['var &tabstop = 4'], 'E1052:')
1567 v9.CheckDefFailure(['&g:option = 5'], 'E113:')
1568 v9.CheckScriptFailure(['vim9script', 'var &tabstop = 4'], 'E1052:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001569
Bram Moolenaar62aec932022-01-29 21:45:34 +00001570 v9.CheckDefFailure(['var $VAR = 5'], 'E1016: Cannot declare an environment variable:')
1571 v9.CheckScriptFailure(['vim9script', 'var $ENV = "xxx"'], 'E1016:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001572
1573 if has('dnd')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001574 v9.CheckDefFailure(['var @~ = 5'], 'E1066:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001575 else
Bram Moolenaar62aec932022-01-29 21:45:34 +00001576 v9.CheckDefFailure(['var @~ = 5'], 'E354:')
1577 v9.CheckDefFailure(['@~ = 5'], 'E354:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001578 endif
Bram Moolenaar62aec932022-01-29 21:45:34 +00001579 v9.CheckDefFailure(['var @a = 5'], 'E1066:')
1580 v9.CheckDefFailure(['var @/ = "x"'], 'E1066:')
1581 v9.CheckScriptFailure(['vim9script', 'var @a = "abc"'], 'E1066:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001582
Bram Moolenaar62aec932022-01-29 21:45:34 +00001583 v9.CheckDefFailure(['var g:var = 5'], 'E1016: Cannot declare a global variable:')
1584 v9.CheckDefFailure(['var w:var = 5'], 'E1016: Cannot declare a window variable:')
1585 v9.CheckDefFailure(['var b:var = 5'], 'E1016: Cannot declare a buffer variable:')
1586 v9.CheckDefFailure(['var t:var = 5'], 'E1016: Cannot declare a tab variable:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001587
Bram Moolenaar62aec932022-01-29 21:45:34 +00001588 v9.CheckDefFailure(['var anr = 4', 'anr ..= "text"'], 'E1019:')
1589 v9.CheckDefFailure(['var xnr += 4'], 'E1020:', 1)
1590 v9.CheckScriptFailure(['vim9script', 'var xnr += 4'], 'E1020:')
1591 v9.CheckDefFailure(["var xnr = xnr + 1"], 'E1001:', 1)
1592 v9.CheckScriptFailure(['vim9script', 'var xnr = xnr + 4'], 'E121:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001593
Bram Moolenaara749a422022-02-12 19:52:25 +00001594 v9.CheckScriptFailure(['vim9script', 'def Func()', 'var dummy = notfound', 'enddef', 'defcompile'], 'E1001:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001595
Bram Moolenaar62aec932022-01-29 21:45:34 +00001596 v9.CheckDefFailure(['var name: list<string> = [123]'], 'expected list<string> but got list<number>')
1597 v9.CheckDefFailure(['var name: list<number> = ["xx"]'], 'expected list<number> but got list<string>')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001598
Bram Moolenaar62aec932022-01-29 21:45:34 +00001599 v9.CheckDefFailure(['var name: dict<string> = {key: 123}'], 'expected dict<string> but got dict<number>')
1600 v9.CheckDefFailure(['var name: dict<number> = {key: "xx"}'], 'expected dict<number> but got dict<string>')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001601
Bram Moolenaar62aec932022-01-29 21:45:34 +00001602 v9.CheckDefFailure(['var name = feedkeys("0")'], 'E1031:')
1603 v9.CheckDefFailure(['var name: number = feedkeys("0")'], 'expected number but got void')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001604
Bram Moolenaar62aec932022-01-29 21:45:34 +00001605 v9.CheckDefFailure(['var name: dict <number>'], 'E1068:')
Bram Moolenaar62e0e2e2022-08-20 12:07:58 +01001606 v9.CheckDefFailure(['var name: dict<number'], 'E1009: Missing > after type: <number')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001607
Bram Moolenaar848fadd2022-01-30 15:28:30 +00001608 assert_fails('s/^/\=g:Mess()/n', 'E794:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001609 v9.CheckDefFailure(['var name: dict<number'], 'E1009:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001610
Bram Moolenaar62aec932022-01-29 21:45:34 +00001611 v9.CheckDefFailure(['w:foo: number = 10'],
Bram Moolenaar9510d222022-09-11 15:14:05 +01001612 'E1016: Cannot declare a window variable: w:foo')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001613 v9.CheckDefFailure(['t:foo: bool = true'],
Bram Moolenaar9510d222022-09-11 15:14:05 +01001614 'E1016: Cannot declare a tab variable: t:foo')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001615 v9.CheckDefFailure(['b:foo: string = "x"'],
Bram Moolenaar9510d222022-09-11 15:14:05 +01001616 'E1016: Cannot declare a buffer variable: b:foo')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001617 v9.CheckDefFailure(['g:foo: number = 123'],
Bram Moolenaar9510d222022-09-11 15:14:05 +01001618 'E1016: Cannot declare a global variable: g:foo')
1619
1620 v9.CheckScriptFailure(['vim9script', 'w:foo: number = 123'],
1621 'E1304: Cannot use type with this variable: w:foo:')
1622 v9.CheckScriptFailure(['vim9script', 't:foo: number = 123'],
1623 'E1304: Cannot use type with this variable: t:foo:')
1624 v9.CheckScriptFailure(['vim9script', 'b:foo: number = 123'],
1625 'E1304: Cannot use type with this variable: b:foo:')
1626 v9.CheckScriptFailure(['vim9script', 'g:foo: number = 123'],
1627 'E1304: Cannot use type with this variable: g:foo:')
1628
1629 v9.CheckScriptFailure(['vim9script', 'const w:FOO: number = 123'],
1630 'E1304: Cannot use type with this variable: w:FOO:')
1631 v9.CheckScriptFailure(['vim9script', 'const t:FOO: number = 123'],
1632 'E1304: Cannot use type with this variable: t:FOO:')
1633 v9.CheckScriptFailure(['vim9script', 'const b:FOO: number = 123'],
1634 'E1304: Cannot use type with this variable: b:FOO:')
1635 v9.CheckScriptFailure(['vim9script', 'const g:FOO: number = 123'],
1636 'E1304: Cannot use type with this variable: g:FOO:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001637enddef
1638
1639def Test_assign_list()
Bram Moolenaare65081d2021-06-27 15:04:05 +02001640 var lines =<< trim END
1641 var l: list<string> = []
1642 l[0] = 'value'
1643 assert_equal('value', l[0])
Bram Moolenaar971caf52020-09-21 22:21:42 +02001644
Bram Moolenaare65081d2021-06-27 15:04:05 +02001645 l[1] = 'asdf'
1646 assert_equal('value', l[0])
1647 assert_equal('asdf', l[1])
1648 assert_equal('asdf', l[-1])
1649 assert_equal('value', l[-2])
Bram Moolenaar971caf52020-09-21 22:21:42 +02001650
Bram Moolenaare65081d2021-06-27 15:04:05 +02001651 var nrl: list<number> = []
1652 for i in range(5)
1653 nrl[i] = i
1654 endfor
1655 assert_equal([0, 1, 2, 3, 4], nrl)
1656
1657 var ul: list<any>
1658 ul[0] = 1
1659 ul[1] = 2
1660 ul[2] = 3
1661 assert_equal([1, 2, 3], ul)
1662 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001663 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar334a8b42020-10-19 16:07:42 +02001664
Bram Moolenaar1983f1a2022-02-28 20:55:02 +00001665 lines =<< trim END
1666 var l = [1, 2]
1667 g:idx = 'x'
1668 l[g:idx : 1] = [0]
1669 echo l
1670 END
Bram Moolenaar2995e5c2022-03-18 21:41:47 +00001671 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 +00001672
1673 lines =<< trim END
1674 var l = [1, 2]
1675 g:idx = 3
1676 l[g:idx : 1] = [0]
1677 echo l
1678 END
Bram Moolenaarec892232022-05-06 17:53:06 +01001679 v9.CheckDefExecAndScriptFailure(lines, 'E684: List index out of range: 3')
Bram Moolenaar1983f1a2022-02-28 20:55:02 +00001680
1681 lines =<< trim END
1682 var l = [1, 2]
1683 g:idx = 'y'
1684 l[1 : g:idx] = [0]
1685 echo l
1686 END
1687 v9.CheckDefExecAndScriptFailure(lines, ['E1012: Type mismatch; expected number but got string', 'E1030: Using a String as a Number: "y"'])
1688
Bram Moolenaar62aec932022-01-29 21:45:34 +00001689 v9.CheckDefFailure(["var l: list<number> = ['', true]"], 'E1012: Type mismatch; expected list<number> but got list<any>', 1)
1690 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 +02001691enddef
1692
1693def Test_assign_dict()
Bram Moolenaarc3689572021-01-01 19:40:02 +01001694 var lines =<< trim END
1695 var d: dict<string> = {}
1696 d['key'] = 'value'
1697 assert_equal('value', d['key'])
Bram Moolenaar971caf52020-09-21 22:21:42 +02001698
Bram Moolenaarc3689572021-01-01 19:40:02 +01001699 d[123] = 'qwerty'
1700 assert_equal('qwerty', d[123])
1701 assert_equal('qwerty', d['123'])
Bram Moolenaar971caf52020-09-21 22:21:42 +02001702
Bram Moolenaarc3689572021-01-01 19:40:02 +01001703 var nrd: dict<number> = {}
1704 for i in range(3)
1705 nrd[i] = i
1706 endfor
1707 assert_equal({0: 0, 1: 1, 2: 2}, nrd)
1708
1709 d.somekey = 'someval'
1710 assert_equal({key: 'value', '123': 'qwerty', somekey: 'someval'}, d)
Bram Moolenaar23e2e112021-08-03 21:16:18 +02001711 unlet d.somekey
1712 assert_equal({key: 'value', '123': 'qwerty'}, d)
Bram Moolenaarc3689572021-01-01 19:40:02 +01001713 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001714 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarc3689572021-01-01 19:40:02 +01001715
Bram Moolenaar62aec932022-01-29 21:45:34 +00001716 v9.CheckDefFailure(["var d: dict<number> = {a: '', b: true}"], 'E1012: Type mismatch; expected dict<number> but got dict<any>', 1)
1717 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 +00001718 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 +02001719enddef
1720
Bram Moolenaar04bdd572020-09-23 13:25:32 +02001721def Test_assign_dict_unknown_type()
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001722 var lines =<< trim END
Bram Moolenaar04bdd572020-09-23 13:25:32 +02001723 vim9script
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001724 var mylist = []
Bram Moolenaare0de1712020-12-02 17:36:54 +01001725 mylist += [{one: 'one'}]
Bram Moolenaar04bdd572020-09-23 13:25:32 +02001726 def Func()
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001727 var dd = mylist[0]
Bram Moolenaar04bdd572020-09-23 13:25:32 +02001728 assert_equal('one', dd.one)
1729 enddef
1730 Func()
1731 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001732 v9.CheckScriptSuccess(lines)
Bram Moolenaar04bdd572020-09-23 13:25:32 +02001733
Bram Moolenaarce2c5442020-11-28 21:21:17 +01001734 lines =<< trim END
1735 vim9script
1736 var mylist = [[]]
Bram Moolenaare0de1712020-12-02 17:36:54 +01001737 mylist[0] += [{one: 'one'}]
Bram Moolenaarce2c5442020-11-28 21:21:17 +01001738 def Func()
1739 var dd = mylist[0][0]
1740 assert_equal('one', dd.one)
1741 enddef
1742 Func()
1743 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001744 v9.CheckScriptSuccess(lines)
Bram Moolenaar04bdd572020-09-23 13:25:32 +02001745enddef
1746
Bram Moolenaarf76ec1e2021-03-03 17:58:16 +01001747def Test_assign_dict_with_op()
1748 var lines =<< trim END
Bram Moolenaarf76ec1e2021-03-03 17:58:16 +01001749 var ds: dict<string> = {a: 'x'}
1750 ds['a'] ..= 'y'
1751 ds.a ..= 'z'
1752 assert_equal('xyz', ds.a)
1753
1754 var dn: dict<number> = {a: 9}
1755 dn['a'] += 2
1756 assert_equal(11, dn.a)
1757 dn.a += 2
1758 assert_equal(13, dn.a)
1759
1760 dn['a'] -= 3
1761 assert_equal(10, dn.a)
1762 dn.a -= 2
1763 assert_equal(8, dn.a)
1764
1765 dn['a'] *= 2
1766 assert_equal(16, dn.a)
1767 dn.a *= 2
1768 assert_equal(32, dn.a)
1769
1770 dn['a'] /= 3
1771 assert_equal(10, dn.a)
1772 dn.a /= 2
1773 assert_equal(5, dn.a)
1774
1775 dn['a'] %= 3
1776 assert_equal(2, dn.a)
1777 dn.a %= 6
1778 assert_equal(2, dn.a)
Bram Moolenaarb9c0cd82021-04-05 20:51:00 +02001779
1780 var dd: dict<dict<list<any>>>
1781 dd.a = {}
1782 dd.a.b = [0]
1783 dd.a.b += [1]
1784 assert_equal({a: {b: [0, 1]}}, dd)
Bram Moolenaar0d351a02021-04-05 21:05:26 +02001785
1786 var dab = {a: ['b']}
1787 dab.a[0] ..= 'c'
1788 assert_equal({a: ['bc']}, dab)
Bram Moolenaarf76ec1e2021-03-03 17:58:16 +01001789 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001790 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaare42939a2021-04-05 17:11:17 +02001791enddef
1792
1793def Test_assign_list_with_op()
1794 var lines =<< trim END
1795 var ls: list<string> = ['x']
1796 ls[0] ..= 'y'
1797 assert_equal('xy', ls[0])
1798
1799 var ln: list<number> = [9]
1800 ln[0] += 2
1801 assert_equal(11, ln[0])
1802
1803 ln[0] -= 3
1804 assert_equal(8, ln[0])
1805
1806 ln[0] *= 2
1807 assert_equal(16, ln[0])
1808
1809 ln[0] /= 3
1810 assert_equal(5, ln[0])
1811
1812 ln[0] %= 3
1813 assert_equal(2, ln[0])
1814 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001815 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaare42939a2021-04-05 17:11:17 +02001816enddef
1817
1818def Test_assign_with_op_fails()
1819 var lines =<< trim END
1820 var s = 'abc'
1821 s[1] += 'x'
1822 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001823 v9.CheckDefAndScriptFailure(lines, ['E1141:', 'E689:'], 2)
Bram Moolenaare42939a2021-04-05 17:11:17 +02001824
1825 lines =<< trim END
1826 var s = 'abc'
1827 s[1] ..= 'x'
1828 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001829 v9.CheckDefAndScriptFailure(lines, ['E1141:', 'E689:'], 2)
Bram Moolenaarb9c0cd82021-04-05 20:51:00 +02001830
1831 lines =<< trim END
1832 var dd: dict<dict<list<any>>>
1833 dd.a = {}
1834 dd.a.b += [1]
1835 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001836 v9.CheckDefExecAndScriptFailure(lines, 'E716:', 3)
Bram Moolenaarf76ec1e2021-03-03 17:58:16 +01001837enddef
1838
Bram Moolenaar971caf52020-09-21 22:21:42 +02001839def Test_assign_lambda()
1840 # check if assign a lambda to a variable which type is func or any.
Bram Moolenaar30fd8202020-09-26 15:09:30 +02001841 var lines =<< trim END
Bram Moolenaar971caf52020-09-21 22:21:42 +02001842 vim9script
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001843 var FuncRef = () => 123
Bram Moolenaar971caf52020-09-21 22:21:42 +02001844 assert_equal(123, FuncRef())
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001845 var FuncRef_Func: func = () => 123
Bram Moolenaar971caf52020-09-21 22:21:42 +02001846 assert_equal(123, FuncRef_Func())
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001847 var FuncRef_Any: any = () => 123
Bram Moolenaar971caf52020-09-21 22:21:42 +02001848 assert_equal(123, FuncRef_Any())
Bram Moolenaar06409502021-02-17 17:00:27 +01001849 var FuncRef_Number: func(): number = () => 321
1850 assert_equal(321, FuncRef_Number())
Bram Moolenaar971caf52020-09-21 22:21:42 +02001851 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001852 v9.CheckScriptSuccess(lines)
Bram Moolenaar328eac22021-01-07 19:23:08 +01001853
1854 lines =<< trim END
1855 var Ref: func(number)
1856 Ref = (j) => !j
1857 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001858 v9.CheckDefAndScriptFailure(lines, 'E1012: Type mismatch; expected func(number) but got func(any): bool')
Bram Moolenaarc7dac852021-02-17 18:49:11 +01001859
1860 lines =<< trim END
Bram Moolenaar94722c52023-01-28 19:19:03 +00001861 echo filter([1, 2, 3], (_, v: string) => v + 1)
Bram Moolenaarc7dac852021-02-17 18:49:11 +01001862 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001863 v9.CheckDefAndScriptFailure(lines, 'E1051:')
Bram Moolenaar971caf52020-09-21 22:21:42 +02001864enddef
1865
Ernie Rael96952b22023-10-17 18:15:01 +02001866def Test_assign_funcref_args()
1867 # unspecified arguments match everything, including varargs
1868 var lines =<< trim END
1869 vim9script
1870
1871 var FuncUnknown: func: number
1872
1873 FuncUnknown = (v): number => v
1874 assert_equal(5, FuncUnknown(5))
1875
1876 FuncUnknown = (v1, v2): number => v1 + v2
1877 assert_equal(7, FuncUnknown(3, 4))
1878
1879 FuncUnknown = (...v1): number => v1[0] + v1[1] + len(v1) * 1000
1880 assert_equal(4007, FuncUnknown(3, 4, 5, 6))
1881
1882 FuncUnknown = (v: list<any>): number => v[0] + v[1] + len(v) * 1000
1883 assert_equal(5009, FuncUnknown([4, 5, 6, 7, 8]))
1884 END
1885 v9.CheckScriptSuccess(lines)
1886
1887 # varargs must match
1888 lines =<< trim END
1889 vim9script
1890 var FuncAnyVA: func(...any): number
1891 FuncAnyVA = (v): number => v
1892 END
Ernie Rael3ec6c1f2023-10-21 11:45:38 +02001893 v9.CheckScriptFailure(lines, 'E1180: Variable arguments type must be a list: any')
Ernie Rael96952b22023-10-17 18:15:01 +02001894
1895 # varargs must match
1896 lines =<< trim END
1897 vim9script
1898 var FuncAnyVA: func(...any): number
1899 FuncAnyVA = (v1, v2): number => v1 + v2
1900 END
Ernie Rael3ec6c1f2023-10-21 11:45:38 +02001901 v9.CheckScriptFailure(lines, 'E1180: Variable arguments type must be a list: any')
Ernie Rael96952b22023-10-17 18:15:01 +02001902
1903 # varargs must match
1904 lines =<< trim END
1905 vim9script
1906 var FuncAnyVA: func(...any): number
1907 FuncAnyVA = (v1: list<any>): number => 3
1908 END
Ernie Rael3ec6c1f2023-10-21 11:45:38 +02001909 v9.CheckScriptFailure(lines, 'E1180: Variable arguments type must be a list: any')
Ernie Rael96952b22023-10-17 18:15:01 +02001910enddef
1911
1912def Test_assign_funcref_arg_any()
1913 var lines =<< trim END
1914 vim9script
1915 var FuncAnyVA: func(any): number
1916 FuncAnyVA = (v): number => v
1917 END
1918 # TODO: Verify this should succeed.
1919 v9.CheckScriptSuccess(lines)
1920enddef
1921
Bram Moolenaarc0e29012020-09-27 14:22:48 +02001922def Test_heredoc()
Yegappan Lakshmanan1fc6ea92022-04-21 23:30:15 +01001923 # simple heredoc
1924 var lines =<< trim END
zeertzjqa93d9cd2023-05-02 16:25:47 +01001925 var text =<< trim TEXT # comment
1926 abc
1927 TEXT
1928 assert_equal(['abc'], text)
Bram Moolenaarc0e29012020-09-27 14:22:48 +02001929 END
Yegappan Lakshmanan1fc6ea92022-04-21 23:30:15 +01001930 v9.CheckDefAndScriptSuccess(lines)
1931
1932 # empty heredoc
1933 lines =<< trim END
zeertzjqa93d9cd2023-05-02 16:25:47 +01001934 var text =<< trim TEXT
1935 TEXT
1936 assert_equal([], text)
Yegappan Lakshmanan1fc6ea92022-04-21 23:30:15 +01001937 END
1938 v9.CheckDefAndScriptSuccess(lines)
1939
1940 # heredoc with a single empty line
1941 lines =<< trim END
zeertzjqa93d9cd2023-05-02 16:25:47 +01001942 var text =<< trim TEXT
Yegappan Lakshmanan1fc6ea92022-04-21 23:30:15 +01001943
zeertzjqa93d9cd2023-05-02 16:25:47 +01001944 TEXT
1945 assert_equal([''], text)
Yegappan Lakshmanan1fc6ea92022-04-21 23:30:15 +01001946 END
1947 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarc0e29012020-09-27 14:22:48 +02001948
zeertzjqa93d9cd2023-05-02 16:25:47 +01001949 # assign heredoc to variable with type
1950 lines =<< trim END
1951 var text: list<string> =<< trim TEXT
1952 var foo =<< trim FOO
1953 TEXT
1954 assert_equal(['var foo =<< trim FOO'], text)
1955 END
1956 v9.CheckDefAndScriptSuccess(lines)
1957
1958 # extra whitespace before type is allowed
1959 lines =<< trim END
1960 var text: list<string> =<< trim TEXT
1961 var foo =<< trim FOO
1962 TEXT
1963 assert_equal(['var foo =<< trim FOO'], text)
1964 END
1965 v9.CheckDefAndScriptSuccess(lines)
1966
1967 # missing whitespace before type is an error
1968 lines =<< trim END
1969 var text:list<string> =<< trim TEXT
1970 var foo =<< trim FOO
1971 TEXT
1972 assert_equal(['var foo =<< trim FOO'], text)
1973 END
1974 v9.CheckDefAndScriptFailure(lines, 'E1069:')
1975
1976 # assign heredoc to list slice
1977 lines =<< trim END
1978 var text = ['']
1979 text[ : ] =<< trim TEXT
1980 var foo =<< trim FOO
1981 TEXT
1982 assert_equal(['var foo =<< trim FOO'], text)
1983 END
1984 v9.CheckDefAndScriptSuccess(lines)
1985
1986 # assign heredoc to curly braces name in legacy function in Vim9 script
1987 lines =<< trim END
1988 vim9script
1989 func Func()
1990 let foo_3_bar = ['']
1991 let foo_{1 + 2}_bar[ : ] =<< trim TEXT
1992 var foo =<< trim FOO
1993 TEXT
1994 call assert_equal(['var foo =<< trim FOO'], foo_3_bar)
1995 endfunc
1996 Func()
1997 END
1998 v9.CheckScriptSuccess(lines)
1999
zeertzjq9a91d2b2024-04-09 21:47:10 +02002000 # commented out heredoc assignment without space after '#'
2001 lines =<< trim END
2002 vim9script
2003 def Func()
2004 #x =<< trim [CODE]
2005 #[CODE]
2006 enddef
2007 Func()
2008 END
2009 v9.CheckScriptSuccess(lines)
2010
Bram Moolenaar62aec932022-01-29 21:45:34 +00002011 v9.CheckDefFailure(['var lines =<< trim END X', 'END'], 'E488:')
2012 v9.CheckDefFailure(['var lines =<< trim END " comment', 'END'], 'E488:')
Bram Moolenaar2914a202020-09-27 18:24:03 +02002013
2014 lines =<< trim [END]
2015 def Func()
2016 var&lines =<< trim END
2017 x
2018 x
Bram Moolenaarb5b94802020-12-13 17:50:20 +01002019 enddef
2020 defcompile
2021 [END]
Bram Moolenaar62aec932022-01-29 21:45:34 +00002022 v9.CheckScriptFailure(lines, 'E1145: Missing heredoc end marker: END')
Bram Moolenaarb5b94802020-12-13 17:50:20 +01002023 delfunc! g:Func
2024
2025 lines =<< trim [END]
2026 def Func()
2027 var lines =<< trim END
2028 x
2029 x
Bram Moolenaar2914a202020-09-27 18:24:03 +02002030 x
2031 x
2032 x
2033 x
2034 x
2035 x
2036 enddef
2037 call Func()
2038 [END]
Bram Moolenaar62aec932022-01-29 21:45:34 +00002039 v9.CheckScriptFailure(lines, 'E1145: Missing heredoc end marker: END')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002040 delfunc! g:Func
Bram Moolenaar81530e32021-07-28 21:25:49 +02002041
2042 lines =<< trim END
2043 var lines: number =<< trim STOP
2044 aaa
2045 bbb
2046 STOP
2047 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002048 v9.CheckDefAndScriptFailure(lines, 'E1012: Type mismatch; expected number but got list<string>', 1)
Bram Moolenaard9876422022-10-12 12:58:54 +01002049
2050 lines =<< trim END
2051 var lines=<< STOP
2052 xxx
2053 STOP
2054 END
2055 v9.CheckDefAndScriptFailure(lines, 'E1004: White space required before and after ''=<<'' at "=<< STOP"', 1)
2056 lines =<< trim END
2057 var lines =<<STOP
2058 xxx
2059 STOP
2060 END
2061 v9.CheckDefAndScriptFailure(lines, 'E1004: White space required before and after ''=<<'' at "=<<STOP"', 1)
2062 lines =<< trim END
2063 var lines=<<STOP
2064 xxx
2065 STOP
2066 END
2067 v9.CheckDefAndScriptFailure(lines, 'E1004: White space required before and after ''=<<'' at "=<<STOP"', 1)
Bram Moolenaarc0e29012020-09-27 14:22:48 +02002068enddef
2069
Bram Moolenaar083966f2020-12-08 11:29:40 +01002070def Test_var_func_call()
Bram Moolenaar55759b52020-09-30 22:59:42 +02002071 var lines =<< trim END
2072 vim9script
2073 func GetValue()
2074 if exists('g:count')
2075 let g:count += 1
2076 else
2077 let g:count = 1
2078 endif
2079 return 'this'
2080 endfunc
Bram Moolenaar94722c52023-01-28 19:19:03 +00002081 var val: string = GetValue()
Bram Moolenaar55759b52020-09-30 22:59:42 +02002082 # env var is always a string
2083 var env = $TERM
2084 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01002085 writefile(lines, 'Xfinished', 'D')
Bram Moolenaar55759b52020-09-30 22:59:42 +02002086 source Xfinished
2087 # GetValue() is not called during discovery phase
2088 assert_equal(1, g:count)
2089
2090 unlet g:count
Bram Moolenaar55759b52020-09-30 22:59:42 +02002091enddef
2092
Bram Moolenaar083966f2020-12-08 11:29:40 +01002093def Test_var_missing_type()
Bram Moolenaar55759b52020-09-30 22:59:42 +02002094 var lines =<< trim END
2095 vim9script
2096 var name = g:unknown
2097 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002098 v9.CheckScriptFailure(lines, 'E121:')
Bram Moolenaar55759b52020-09-30 22:59:42 +02002099
2100 lines =<< trim END
2101 vim9script
2102 var nr: number = 123
2103 var name = nr
2104 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002105 v9.CheckScriptSuccess(lines)
Bram Moolenaar55759b52020-09-30 22:59:42 +02002106enddef
2107
Bram Moolenaar083966f2020-12-08 11:29:40 +01002108def Test_var_declaration()
Bram Moolenaar55759b52020-09-30 22:59:42 +02002109 var lines =<< trim END
2110 vim9script
2111 var name: string
2112 g:var_uninit = name
2113 name = 'text'
2114 g:var_test = name
Bram Moolenaara749a422022-02-12 19:52:25 +00002115 # prefixing s: is not allowed
2116 name = 'prefixed'
2117 g:var_prefixed = name
Bram Moolenaar55759b52020-09-30 22:59:42 +02002118
Bram Moolenaar7257af42020-12-08 22:08:51 +01002119 const FOO: number = 123
2120 assert_equal(123, FOO)
Bram Moolenaar89b474d2020-12-22 21:19:39 +01002121 const FOOS = 'foos'
2122 assert_equal('foos', FOOS)
2123 final FLIST = [1]
2124 assert_equal([1], FLIST)
2125 FLIST[0] = 11
2126 assert_equal([11], FLIST)
2127
Bram Moolenaar89b474d2020-12-22 21:19:39 +01002128 const g:FOOS = 'gfoos'
2129 assert_equal('gfoos', g:FOOS)
2130 final g:FLIST = [2]
2131 assert_equal([2], g:FLIST)
2132 g:FLIST[0] = 22
2133 assert_equal([22], g:FLIST)
2134
Bram Moolenaard877a572021-04-01 19:42:48 +02002135 def SetGlobalConst()
2136 const g:globConst = 123
2137 enddef
2138 SetGlobalConst()
2139 assert_equal(123, g:globConst)
2140 assert_true(islocked('g:globConst'))
2141
Bram Moolenaar89b474d2020-12-22 21:19:39 +01002142 const w:FOOS = 'wfoos'
2143 assert_equal('wfoos', w:FOOS)
2144 final w:FLIST = [3]
2145 assert_equal([3], w:FLIST)
2146 w:FLIST[0] = 33
2147 assert_equal([33], w:FLIST)
Bram Moolenaar7257af42020-12-08 22:08:51 +01002148
Bram Moolenaar55759b52020-09-30 22:59:42 +02002149 var s:other: number
2150 other = 1234
2151 g:other_var = other
2152
Bram Moolenaarccc25aa2021-03-26 21:27:52 +01002153 var xyz: string # comment
2154
Bram Moolenaar55759b52020-09-30 22:59:42 +02002155 # type is inferred
Bram Moolenaara749a422022-02-12 19:52:25 +00002156 var dict = {['a']: 222}
Bram Moolenaar55759b52020-09-30 22:59:42 +02002157 def GetDictVal(key: any)
Bram Moolenaara749a422022-02-12 19:52:25 +00002158 g:dict_val = dict[key]
Bram Moolenaar55759b52020-09-30 22:59:42 +02002159 enddef
2160 GetDictVal('a')
Bram Moolenaar08251752021-01-11 21:20:18 +01002161
2162 final adict: dict<string> = {}
2163 def ChangeAdict()
2164 adict.foo = 'foo'
2165 enddef
2166 ChangeAdict()
Bram Moolenaar55759b52020-09-30 22:59:42 +02002167 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002168 v9.CheckScriptSuccess(lines)
Bram Moolenaar55759b52020-09-30 22:59:42 +02002169 assert_equal('', g:var_uninit)
2170 assert_equal('text', g:var_test)
2171 assert_equal('prefixed', g:var_prefixed)
2172 assert_equal(1234, g:other_var)
2173 assert_equal(222, g:dict_val)
2174
2175 unlet g:var_uninit
2176 unlet g:var_test
2177 unlet g:var_prefixed
2178 unlet g:other_var
Bram Moolenaar6e50ec22021-04-03 19:32:44 +02002179 unlet g:globConst
Bram Moolenaar89b474d2020-12-22 21:19:39 +01002180 unlet g:FOOS
2181 unlet g:FLIST
Bram Moolenaar89b474d2020-12-22 21:19:39 +01002182 unlet w:FOOS
2183 unlet w:FLIST
Bram Moolenaar55759b52020-09-30 22:59:42 +02002184enddef
2185
Bram Moolenaar566badc2022-09-18 13:46:08 +01002186def Test_create_list_after_const()
2187 const a = 1
2188 g:ll = []
2189 assert_equal(0, islocked('g:ll'))
2190 unlet g:ll
2191enddef
2192
Bram Moolenaar083966f2020-12-08 11:29:40 +01002193def Test_var_declaration_fails()
Bram Moolenaar55759b52020-09-30 22:59:42 +02002194 var lines =<< trim END
2195 vim9script
2196 final var: string
2197 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002198 v9.CheckScriptFailure(lines, 'E1125:')
Bram Moolenaar55759b52020-09-30 22:59:42 +02002199
2200 lines =<< trim END
2201 vim9script
Bram Moolenaar89b474d2020-12-22 21:19:39 +01002202 const g:constvar = 'string'
2203 g:constvar = 'xx'
2204 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002205 v9.CheckScriptFailure(lines, 'E741:')
Bram Moolenaar89b474d2020-12-22 21:19:39 +01002206 unlet g:constvar
2207
2208 lines =<< trim END
2209 vim9script
Bram Moolenaarf5906aa2021-04-02 14:35:15 +02002210 var name = 'one'
2211 lockvar name
2212 def SetLocked()
2213 name = 'two'
2214 enddef
2215 SetLocked()
2216 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002217 v9.CheckScriptFailure(lines, 'E741: Value is locked: name', 1)
Bram Moolenaardcf29ac2021-04-02 14:44:02 +02002218
2219 lines =<< trim END
2220 let s:legacy = 'one'
2221 lockvar s:legacy
2222 def SetLocked()
2223 s:legacy = 'two'
2224 enddef
2225 call SetLocked()
2226 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002227 v9.CheckScriptFailure(lines, 'E741: Value is locked: s:legacy', 1)
Bram Moolenaarf5906aa2021-04-02 14:35:15 +02002228
2229 lines =<< trim END
2230 vim9script
Bram Moolenaard877a572021-04-01 19:42:48 +02002231 def SetGlobalConst()
2232 const g:globConst = 123
2233 enddef
2234 SetGlobalConst()
2235 g:globConst = 234
2236 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002237 v9.CheckScriptFailure(lines, 'E741: Value is locked: g:globConst', 6)
Bram Moolenaard877a572021-04-01 19:42:48 +02002238 unlet g:globConst
2239
2240 lines =<< trim END
2241 vim9script
Bram Moolenaar08251752021-01-11 21:20:18 +01002242 const cdict: dict<string> = {}
2243 def Change()
2244 cdict.foo = 'foo'
2245 enddef
2246 defcompile
2247 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002248 v9.CheckScriptFailure(lines, 'E46:')
Bram Moolenaar08251752021-01-11 21:20:18 +01002249
2250 lines =<< trim END
2251 vim9script
Bram Moolenaar89b474d2020-12-22 21:19:39 +01002252 final w:finalvar = [9]
2253 w:finalvar = [8]
2254 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002255 v9.CheckScriptFailure(lines, 'E1122:')
Bram Moolenaar89b474d2020-12-22 21:19:39 +01002256 unlet w:finalvar
2257
2258 lines =<< trim END
2259 vim9script
Bram Moolenaar55759b52020-09-30 22:59:42 +02002260 const var: string
2261 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002262 v9.CheckScriptFailure(lines, 'E1021:')
Bram Moolenaar55759b52020-09-30 22:59:42 +02002263
2264 lines =<< trim END
2265 vim9script
2266 var 9var: string
2267 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002268 v9.CheckScriptFailure(lines, 'E488:')
Bram Moolenaar7257af42020-12-08 22:08:51 +01002269
Bram Moolenaar62aec932022-01-29 21:45:34 +00002270 v9.CheckDefFailure(['var foo.bar = 2'], 'E1087:')
2271 v9.CheckDefFailure(['var foo[3] = 2'], 'E1087:')
2272 v9.CheckDefFailure(['const foo: number'], 'E1021:')
Bram Moolenaare1d12112022-03-05 11:37:48 +00002273
2274 lines =<< trim END
2275 va foo = 123
2276 END
2277 v9.CheckDefAndScriptFailure(lines, 'E1065:', 1)
Bram Moolenaar31d99482022-05-26 22:24:43 +01002278
2279 lines =<< trim END
2280 var foo: func(number
2281 END
2282 v9.CheckDefAndScriptFailure(lines, 'E110:', 1)
2283
2284 lines =<< trim END
2285 var foo: func(number): func(
2286 END
2287 v9.CheckDefAndScriptFailure(lines, 'E110:', 1)
2288
2289 for type in ['num_ber',
2290 'anys', 'ani',
2291 'bools', 'boel',
2292 'blobs', 'blub',
2293 'channels', 'channol',
2294 'dicts', 'duct',
2295 'floats', 'floot',
2296 'funcs', 'funk',
2297 'jobs', 'jop',
Bram Moolenaar2984ed32022-08-20 14:51:17 +01002298 'lists', 'last',
Bram Moolenaar31d99482022-05-26 22:24:43 +01002299 'numbers', 'numbar',
2300 'strings', 'strung',
2301 'voids', 'viod']
2302 v9.CheckDefAndScriptFailure([$'var foo: {type}'], 'E1010:', 1)
2303 endfor
Bram Moolenaar55759b52020-09-30 22:59:42 +02002304enddef
2305
Bram Moolenaare88c6b72022-02-15 15:37:11 +00002306def Test_var_declaration_inferred()
2307 # check that type is set on the list so that extend() fails
2308 var lines =<< trim END
2309 vim9script
2310 def GetList(): list<number>
2311 var l = [1, 2, 3]
2312 return l
2313 enddef
2314 echo GetList()->extend(['x'])
2315 END
2316 v9.CheckScriptFailure(lines, 'E1013:', 6)
Bram Moolenaar31d99482022-05-26 22:24:43 +01002317
2318 lines =<< trim END
2319 vim9script
2320 def GetNr(): number
2321 return 5
2322 enddef
2323 def TestOne()
2324 var some = [function('len'), GetNr]
2325 g:res = typename(some)
2326 enddef
2327 TestOne()
2328 assert_equal('list<func(): number>', g:res)
2329
2330 def TestTwo()
2331 var some = [function('len'), GetNr]
2332 g:res = typename(some)
2333 enddef
2334 TestTwo()
2335 assert_equal('list<func(): number>', g:res)
2336 unlet g:res
2337
2338 # FIXME: why is the type different?
2339 var first = [function('len'), GetNr]
2340 assert_equal('list<func(...): number>', typename(first))
2341 var second = [GetNr, function('len')]
2342 assert_equal('list<func(...): number>', typename(second))
2343 END
2344 v9.CheckScriptSuccess(lines)
Bram Moolenaare88c6b72022-02-15 15:37:11 +00002345enddef
2346
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002347def Test_script_local_in_legacy()
Bram Moolenaara749a422022-02-12 19:52:25 +00002348 # OK to define script-local later but before compiling
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002349 var lines =<< trim END
2350 def SetLater()
Bram Moolenaara749a422022-02-12 19:52:25 +00002351 legvar = 'two'
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002352 enddef
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02002353 let s:legvar = 'one'
Bram Moolenaara749a422022-02-12 19:52:25 +00002354 defcompile
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002355 call SetLater()
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02002356 call assert_equal('two', s:legvar)
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002357 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002358 v9.CheckScriptSuccess(lines)
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002359
2360 # OK to leave out s: prefix when script-local already defined
2361 lines =<< trim END
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02002362 let s:legvar = 'one'
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002363 def SetNoPrefix()
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02002364 legvar = 'two'
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002365 enddef
2366 call SetNoPrefix()
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02002367 call assert_equal('two', s:legvar)
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002368 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002369 v9.CheckScriptSuccess(lines)
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002370
Bram Moolenaara749a422022-02-12 19:52:25 +00002371 # Not OK to leave out s: prefix when script-local defined after compiling
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002372 lines =<< trim END
2373 def SetLaterNoPrefix()
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02002374 legvar = 'two'
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002375 enddef
2376 defcompile
Bram Moolenaar96cf4ba2021-04-24 14:15:41 +02002377 let s:legvar = 'one'
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002378 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002379 v9.CheckScriptFailure(lines, 'E476:', 1)
Bram Moolenaar47bc9c32021-07-17 21:24:56 +02002380
Bram Moolenaarb18b4962022-09-02 21:55:50 +01002381 edit! Xslfile
Bram Moolenaar47bc9c32021-07-17 21:24:56 +02002382 lines =<< trim END
2383 var edit: bool
2384 legacy edit
2385 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002386 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar643ce6c2021-04-06 21:17:27 +02002387enddef
2388
Bram Moolenaar083966f2020-12-08 11:29:40 +01002389def Test_var_type_check()
Bram Moolenaar55759b52020-09-30 22:59:42 +02002390 var lines =<< trim END
2391 vim9script
2392 var name: string
2393 name = 1234
2394 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002395 v9.CheckScriptFailure(lines, 'E1012:')
Bram Moolenaar55759b52020-09-30 22:59:42 +02002396
2397 lines =<< trim END
2398 vim9script
2399 var name:string
2400 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002401 v9.CheckScriptFailure(lines, 'E1069:')
Bram Moolenaar55759b52020-09-30 22:59:42 +02002402
Bram Moolenaar62aec932022-01-29 21:45:34 +00002403 v9.CheckDefAndScriptFailure(['var n:number = 42'], 'E1069:')
Bram Moolenaar60faf862021-08-23 22:22:45 +02002404
Bram Moolenaar55759b52020-09-30 22:59:42 +02002405 lines =<< trim END
2406 vim9script
2407 var name: asdf
2408 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002409 v9.CheckScriptFailure(lines, 'E1010:')
Bram Moolenaar55759b52020-09-30 22:59:42 +02002410
2411 lines =<< trim END
2412 vim9script
Bram Moolenaara749a422022-02-12 19:52:25 +00002413 var l: list<number>
2414 l = []
Bram Moolenaar55759b52020-09-30 22:59:42 +02002415 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002416 v9.CheckScriptSuccess(lines)
Bram Moolenaar55759b52020-09-30 22:59:42 +02002417
2418 lines =<< trim END
2419 vim9script
Bram Moolenaara749a422022-02-12 19:52:25 +00002420 var d: dict<number>
2421 d = {}
Bram Moolenaar55759b52020-09-30 22:59:42 +02002422 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002423 v9.CheckScriptSuccess(lines)
Bram Moolenaar378697a2021-07-15 19:23:18 +02002424
2425 lines =<< trim END
2426 vim9script
2427 var d = {a: 1, b: [2]}
2428 def Func(b: bool)
2429 var l: list<number> = b ? d.b : [3]
2430 enddef
2431 defcompile
2432 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002433 v9.CheckScriptSuccess(lines)
Bram Moolenaar55759b52020-09-30 22:59:42 +02002434enddef
2435
2436let g:dict_number = #{one: 1, two: 2}
2437
Bram Moolenaar083966f2020-12-08 11:29:40 +01002438def Test_var_list_dict_type()
Bram Moolenaar55759b52020-09-30 22:59:42 +02002439 var ll: list<number>
2440 ll = [1, 2, 2, 3, 3, 3]->uniq()
2441 ll->assert_equal([1, 2, 3])
2442
2443 var dd: dict<number>
2444 dd = g:dict_number
2445 dd->assert_equal(g:dict_number)
2446
2447 var lines =<< trim END
2448 var ll: list<number>
2449 ll = [1, 2, 3]->map('"one"')
2450 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002451 v9.CheckDefExecFailure(lines, 'E1012: Type mismatch; expected list<number> but got list<string>')
Bram Moolenaar55759b52020-09-30 22:59:42 +02002452enddef
2453
Bram Moolenaar083966f2020-12-08 11:29:40 +01002454def Test_cannot_use_let()
Bram Moolenaar62aec932022-01-29 21:45:34 +00002455 v9.CheckDefAndScriptFailure(['let a = 34'], 'E1126:', 1)
Bram Moolenaar083966f2020-12-08 11:29:40 +01002456enddef
2457
Bram Moolenaar55759b52020-09-30 22:59:42 +02002458def Test_unlet()
2459 g:somevar = 'yes'
2460 assert_true(exists('g:somevar'))
2461 unlet g:somevar
2462 assert_false(exists('g:somevar'))
2463 unlet! g:somevar
2464
2465 # also works for script-local variable in legacy Vim script
2466 s:somevar = 'legacy'
2467 assert_true(exists('s:somevar'))
2468 unlet s:somevar
2469 assert_false(exists('s:somevar'))
2470 unlet! s:somevar
2471
Bram Moolenaar83d0cec2022-02-04 21:17:58 +00002472 if 0
2473 unlet g:does_not_exist
2474 endif
2475
2476 v9.CheckDefExecFailure(['unlet v:notfound.key'], 'E1001:')
2477
Bram Moolenaar62aec932022-01-29 21:45:34 +00002478 v9.CheckDefExecFailure([
Bram Moolenaar0acbf5a2021-01-05 20:58:25 +01002479 'var dd = 111',
2480 'unlet dd',
2481 ], 'E1081:', 2)
2482
Bram Moolenaar752fc692021-01-04 21:57:11 +01002483 # dict unlet
Bram Moolenaarea5c8982022-02-17 14:42:02 +00002484 var dd = {a: 1, b: 2, c: 3, 4: 4}
Bram Moolenaar752fc692021-01-04 21:57:11 +01002485 unlet dd['a']
2486 unlet dd.c
Bram Moolenaarea5c8982022-02-17 14:42:02 +00002487 unlet dd[4]
Bram Moolenaar752fc692021-01-04 21:57:11 +01002488 assert_equal({b: 2}, dd)
2489
Bram Moolenaar6b8c7ba2022-03-20 17:46:06 +00002490 # null key works like empty string
2491 dd = {'': 1, x: 9}
2492 unlet dd[null_string]
2493 assert_equal({x: 9}, dd)
2494
Bram Moolenaar752fc692021-01-04 21:57:11 +01002495 # list unlet
2496 var ll = [1, 2, 3, 4]
2497 unlet ll[1]
2498 unlet ll[-1]
2499 assert_equal([1, 3], ll)
2500
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01002501 ll = [1, 2, 3, 4]
2502 unlet ll[0 : 1]
2503 assert_equal([3, 4], ll)
2504
2505 ll = [1, 2, 3, 4]
2506 unlet ll[2 : 8]
2507 assert_equal([1, 2], ll)
2508
2509 ll = [1, 2, 3, 4]
2510 unlet ll[-2 : -1]
2511 assert_equal([1, 2], ll)
2512
Bram Moolenaar0c7f2612022-02-17 19:44:07 +00002513 g:nrdict = {1: 1, 2: 2}
2514 g:idx = 1
2515 unlet g:nrdict[g:idx]
2516 assert_equal({2: 2}, g:nrdict)
2517 unlet g:nrdict
2518 unlet g:idx
2519
Bram Moolenaar62aec932022-01-29 21:45:34 +00002520 v9.CheckDefFailure([
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01002521 'var ll = [1, 2]',
2522 'll[1 : 2] = 7',
Bram Moolenaar4f0884d2021-08-11 21:49:23 +02002523 ], 'E1012: Type mismatch; expected list<number> but got number', 2)
Bram Moolenaar62aec932022-01-29 21:45:34 +00002524 v9.CheckDefFailure([
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01002525 'var dd = {a: 1}',
2526 'unlet dd["a" : "a"]',
2527 ], 'E1166:', 2)
Bram Moolenaar62aec932022-01-29 21:45:34 +00002528 v9.CheckDefExecFailure([
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01002529 'unlet g:adict[0 : 1]',
2530 ], 'E1148:', 1)
Bram Moolenaar62aec932022-01-29 21:45:34 +00002531 v9.CheckDefFailure([
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01002532 'var ll = [1, 2]',
2533 'unlet ll[0:1]',
2534 ], 'E1004:', 2)
Bram Moolenaar62aec932022-01-29 21:45:34 +00002535 v9.CheckDefFailure([
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01002536 'var ll = [1, 2]',
2537 'unlet ll[0 :1]',
2538 ], 'E1004:', 2)
Bram Moolenaar62aec932022-01-29 21:45:34 +00002539 v9.CheckDefFailure([
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01002540 'var ll = [1, 2]',
2541 'unlet ll[0: 1]',
2542 ], 'E1004:', 2)
Bram Moolenaare08be092022-02-17 13:08:26 +00002543
2544 v9.CheckDefExecFailure([
2545 'g:ll = [1, 2]',
2546 'g:idx = "x"',
2547 'unlet g:ll[g:idx]',
2548 ], 'E1029: Expected number but got string', 3)
2549
2550 v9.CheckDefExecFailure([
2551 'g:ll = [1, 2, 3]',
2552 'g:idx = "x"',
2553 'unlet g:ll[g:idx : 2]',
2554 ], 'E1029: Expected number but got string', 3)
2555
2556 v9.CheckDefExecFailure([
2557 'g:ll = [1, 2, 3]',
2558 'g:idx = "x"',
2559 'unlet g:ll[0 : g:idx]',
2560 ], 'E1029: Expected number but got string', 3)
2561
Bram Moolenaar7f2c3412021-11-29 16:01:49 +00002562 # command recognized as assignment when skipping, should not give an error
Bram Moolenaar62aec932022-01-29 21:45:34 +00002563 v9.CheckScriptSuccess([
Bram Moolenaar7f2c3412021-11-29 16:01:49 +00002564 'vim9script',
2565 'for i in []',
2566 " put =''",
2567 'endfor'])
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01002568
Bram Moolenaar62aec932022-01-29 21:45:34 +00002569 v9.CheckDefFailure([
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01002570 'var ll = [1, 2]',
2571 'unlet ll["x" : 1]',
2572 ], 'E1012:', 2)
Bram Moolenaar62aec932022-01-29 21:45:34 +00002573 v9.CheckDefFailure([
Bram Moolenaar5b5ae292021-02-20 17:04:02 +01002574 'var ll = [1, 2]',
2575 'unlet ll[0 : "x"]',
2576 ], 'E1012:', 2)
2577
Bram Moolenaar752fc692021-01-04 21:57:11 +01002578 # list of dict unlet
2579 var dl = [{a: 1, b: 2}, {c: 3}]
2580 unlet dl[0]['b']
2581 assert_equal([{a: 1}, {c: 3}], dl)
2582
Bram Moolenaar62aec932022-01-29 21:45:34 +00002583 v9.CheckDefExecFailure([
Bram Moolenaar0acbf5a2021-01-05 20:58:25 +01002584 'var ll = test_null_list()',
2585 'unlet ll[0]',
2586 ], 'E684:', 2)
Bram Moolenaar62aec932022-01-29 21:45:34 +00002587 v9.CheckDefExecFailure([
Bram Moolenaar0acbf5a2021-01-05 20:58:25 +01002588 'var ll = [1]',
2589 'unlet ll[2]',
2590 ], 'E684:', 2)
Bram Moolenaar62aec932022-01-29 21:45:34 +00002591 v9.CheckDefExecFailure([
Bram Moolenaar0acbf5a2021-01-05 20:58:25 +01002592 'var ll = [1]',
2593 'unlet ll[g:astring]',
Bram Moolenaarf30a14d2021-01-17 21:51:24 +01002594 ], 'E1012:', 2)
Bram Moolenaar62aec932022-01-29 21:45:34 +00002595 v9.CheckDefExecFailure([
Bram Moolenaar0acbf5a2021-01-05 20:58:25 +01002596 'var dd = test_null_dict()',
2597 'unlet dd["a"]',
2598 ], 'E716:', 2)
Bram Moolenaar62aec932022-01-29 21:45:34 +00002599 v9.CheckDefExecFailure([
Bram Moolenaar0acbf5a2021-01-05 20:58:25 +01002600 'var dd = {a: 1}',
2601 'unlet dd["b"]',
2602 ], 'E716:', 2)
Bram Moolenaar62aec932022-01-29 21:45:34 +00002603 v9.CheckDefExecFailure([
Bram Moolenaar0acbf5a2021-01-05 20:58:25 +01002604 'var dd = {a: 1}',
2605 'unlet dd[g:alist]',
2606 ], 'E1105:', 2)
Bram Moolenaar752fc692021-01-04 21:57:11 +01002607
Bram Moolenaarea5c8982022-02-17 14:42:02 +00002608 v9.CheckDefExecFailure([
Bram Moolenaar2984ed32022-08-20 14:51:17 +01002609 'g:dd = {"a": 1, 2: 2}',
Bram Moolenaarea5c8982022-02-17 14:42:02 +00002610 'unlet g:dd[0z11]',
2611 ], 'E1029:', 2)
Bram Moolenaar6296d1e2022-02-17 16:30:11 +00002612 v9.CheckDefExecFailure([
Bram Moolenaar2984ed32022-08-20 14:51:17 +01002613 'g:str = "a string"',
Bram Moolenaar6296d1e2022-02-17 16:30:11 +00002614 'unlet g:str[0]',
2615 ], 'E1148: Cannot index a string', 2)
Bram Moolenaarea5c8982022-02-17 14:42:02 +00002616
Bram Moolenaar2ef951d2021-01-03 20:55:26 +01002617 # can compile unlet before variable exists
Bram Moolenaar752fc692021-01-04 21:57:11 +01002618 g:someDict = {key: 'val'}
2619 var k = 'key'
2620 unlet g:someDict[k]
2621 assert_equal({}, g:someDict)
2622 unlet g:someDict
2623 assert_false(exists('g:someDict'))
Bram Moolenaar2ef951d2021-01-03 20:55:26 +01002624
Bram Moolenaar62aec932022-01-29 21:45:34 +00002625 v9.CheckScriptFailure([
Bram Moolenaar55759b52020-09-30 22:59:42 +02002626 'vim9script',
2627 'var svar = 123',
2628 'unlet svar',
2629 ], 'E1081:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00002630 v9.CheckScriptFailure([
Bram Moolenaar55759b52020-09-30 22:59:42 +02002631 'vim9script',
2632 'var svar = 123',
2633 'unlet s:svar',
Bram Moolenaara749a422022-02-12 19:52:25 +00002634 ], 'E1268:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00002635 v9.CheckScriptFailure([
Bram Moolenaar55759b52020-09-30 22:59:42 +02002636 'vim9script',
2637 'var svar = 123',
2638 'def Func()',
2639 ' unlet svar',
2640 'enddef',
2641 'defcompile',
2642 ], 'E1081:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00002643 v9.CheckScriptFailure([
Bram Moolenaar55759b52020-09-30 22:59:42 +02002644 'vim9script',
2645 'var svar = 123',
Bram Moolenaar9aed7292020-12-18 15:38:00 +01002646 'func Func()',
2647 ' unlet s:svar',
2648 'endfunc',
2649 'Func()',
2650 ], 'E1081:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00002651 v9.CheckScriptFailure([
Bram Moolenaar9aed7292020-12-18 15:38:00 +01002652 'vim9script',
2653 'var svar = 123',
Bram Moolenaar55759b52020-09-30 22:59:42 +02002654 'def Func()',
2655 ' unlet s:svar',
2656 'enddef',
2657 'defcompile',
2658 ], 'E1081:')
2659
Bram Moolenaar62aec932022-01-29 21:45:34 +00002660 v9.CheckScriptFailure([
Bram Moolenaar71b76852021-12-17 20:15:38 +00002661 'vim9script',
2662 'def Delcount(dict: dict<any>)',
2663 ' unlet dict.count',
2664 'enddef',
2665 'Delcount(v:)',
2666 ], 'E742:')
2667
Bram Moolenaar62aec932022-01-29 21:45:34 +00002668 v9.CheckScriptFailure([
Bram Moolenaar71b76852021-12-17 20:15:38 +00002669 'vim9script',
2670 'def DelChangedtick(dict: dict<any>)',
2671 ' unlet dict.changedtick',
2672 'enddef',
2673 'DelChangedtick(b:)',
2674 ], 'E795:')
2675
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01002676 writefile(['vim9script', 'export var svar = 1234'], 'XunletExport.vim', 'D')
Bram Moolenaar0acbf5a2021-01-05 20:58:25 +01002677 var lines =<< trim END
2678 vim9script
Bram Moolenaard5f400c2022-01-06 21:10:28 +00002679 import './XunletExport.vim' as exp
Bram Moolenaar0acbf5a2021-01-05 20:58:25 +01002680 def UnletSvar()
Bram Moolenaard5f400c2022-01-06 21:10:28 +00002681 unlet exp.svar
Bram Moolenaar0acbf5a2021-01-05 20:58:25 +01002682 enddef
2683 defcompile
2684 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002685 v9.CheckScriptFailure(lines, 'E1260:', 1)
Bram Moolenaar0acbf5a2021-01-05 20:58:25 +01002686
Bram Moolenaar55759b52020-09-30 22:59:42 +02002687 $ENVVAR = 'foobar'
2688 assert_equal('foobar', $ENVVAR)
2689 unlet $ENVVAR
2690 assert_equal('', $ENVVAR)
2691enddef
2692
Bram Moolenaarc5f59fa2021-01-21 12:34:14 +01002693def Test_expr_error_no_assign()
2694 var lines =<< trim END
2695 vim9script
2696 var x = invalid
2697 echo x
2698 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002699 v9.CheckScriptFailureList(lines, ['E121:', 'E121:'])
Bram Moolenaarc5f59fa2021-01-21 12:34:14 +01002700
2701 lines =<< trim END
2702 vim9script
2703 var x = 1 / 0
2704 echo x
2705 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002706 v9.CheckScriptFailure(lines, 'E1154:')
Bram Moolenaarc5f59fa2021-01-21 12:34:14 +01002707
2708 lines =<< trim END
2709 vim9script
2710 var x = 1 % 0
2711 echo x
2712 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002713 v9.CheckScriptFailure(lines, 'E1154:')
Bram Moolenaarccc25aa2021-03-26 21:27:52 +01002714
2715 lines =<< trim END
2716 var x: string 'string'
2717 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002718 v9.CheckDefAndScriptFailure(lines, 'E488:')
Bram Moolenaarc5f59fa2021-01-21 12:34:14 +01002719enddef
2720
2721
Bram Moolenaar17126b12021-01-07 22:03:02 +01002722def Test_assign_command_modifier()
2723 var lines =<< trim END
Bram Moolenaar9e0f8832021-01-09 12:09:22 +01002724 var verbose = 0
2725 verbose = 1
2726 assert_equal(1, verbose)
2727 silent verbose = 2
2728 assert_equal(2, verbose)
2729 silent verbose += 2
2730 assert_equal(4, verbose)
2731 silent verbose -= 1
2732 assert_equal(3, verbose)
Bram Moolenaar17126b12021-01-07 22:03:02 +01002733
Bram Moolenaar9e0f8832021-01-09 12:09:22 +01002734 var topleft = {one: 1}
2735 sandbox topleft.one = 3
2736 assert_equal({one: 3}, topleft)
2737 leftabove topleft[' '] = 4
2738 assert_equal({one: 3, ' ': 4}, topleft)
2739
2740 var x: number
2741 var y: number
2742 silent [x, y] = [1, 2]
2743 assert_equal(1, x)
2744 assert_equal(2, y)
Bram Moolenaar17126b12021-01-07 22:03:02 +01002745 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002746 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar17126b12021-01-07 22:03:02 +01002747enddef
2748
Bram Moolenaar74f4a962021-06-17 21:03:07 +02002749def Test_assign_alt_buf_register()
2750 var lines =<< trim END
2751 edit 'file_b1'
2752 var b1 = bufnr()
2753 edit 'file_b2'
2754 var b2 = bufnr()
2755 assert_equal(b1, bufnr('#'))
2756 @# = b2
2757 assert_equal(b2, bufnr('#'))
2758 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002759 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar74f4a962021-06-17 21:03:07 +02002760enddef
2761
Bram Moolenaar32154662021-03-28 21:14:06 +02002762def Test_script_funcref_case()
2763 var lines =<< trim END
2764 var Len = (s: string): number => len(s) + 1
2765 assert_equal(5, Len('asdf'))
2766 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002767 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar32154662021-03-28 21:14:06 +02002768
2769 lines =<< trim END
2770 var len = (s: string): number => len(s) + 1
2771 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002772 v9.CheckDefAndScriptFailure(lines, 'E704:')
Bram Moolenaar32154662021-03-28 21:14:06 +02002773
2774 lines =<< trim END
2775 vim9script
Bram Moolenaara749a422022-02-12 19:52:25 +00002776 var Len = (s: string): number => len(s) + 2
Bram Moolenaar32154662021-03-28 21:14:06 +02002777 assert_equal(6, Len('asdf'))
2778 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002779 v9.CheckScriptSuccess(lines)
Bram Moolenaar32154662021-03-28 21:14:06 +02002780
2781 lines =<< trim END
2782 vim9script
Bram Moolenaara749a422022-02-12 19:52:25 +00002783 var len = (s: string): number => len(s) + 1
Bram Moolenaar32154662021-03-28 21:14:06 +02002784 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002785 v9.CheckScriptFailure(lines, 'E704:')
Bram Moolenaar32154662021-03-28 21:14:06 +02002786enddef
2787
Bram Moolenaar44a89772021-12-18 12:31:33 +00002788def Test_script_funcref_runtime_type_check()
2789 var lines =<< trim END
2790 vim9script
2791 def FuncWithNumberArg(n: number)
2792 enddef
2793 def Test()
2794 var Ref: func(string) = function(FuncWithNumberArg)
2795 enddef
2796 defcompile
2797 END
2798 # OK at compile time
Bram Moolenaar62aec932022-01-29 21:45:34 +00002799 v9.CheckScriptSuccess(lines)
Bram Moolenaar44a89772021-12-18 12:31:33 +00002800
2801 # Type check fails at runtime
Bram Moolenaar62aec932022-01-29 21:45:34 +00002802 v9.CheckScriptFailure(lines + ['Test()'], 'E1012: Type mismatch; expected func(string) but got func(number)')
Bram Moolenaar44a89772021-12-18 12:31:33 +00002803enddef
2804
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02002805def Test_inc_dec()
2806 var lines =<< trim END
2807 var nr = 7
2808 ++nr
Bram Moolenaar730bf302021-04-24 20:43:56 +02002809 assert_equal(8, nr)
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02002810 --nr
Bram Moolenaar730bf302021-04-24 20:43:56 +02002811 assert_equal(7, nr)
Bram Moolenaarf3d30842021-06-25 19:29:30 +02002812 ++nr | ++nr
2813 assert_equal(9, nr)
2814 ++nr # comment
2815 assert_equal(10, nr)
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02002816
2817 var ll = [1, 2]
2818 --ll[0]
2819 ++ll[1]
Bram Moolenaar730bf302021-04-24 20:43:56 +02002820 assert_equal([0, 3], ll)
2821
2822 g:count = 1
2823 ++g:count
2824 --g:count
2825 assert_equal(1, g:count)
2826 unlet g:count
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02002827 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002828 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar22480d12021-06-25 21:31:09 +02002829
2830 lines =<< trim END
2831 var nr = 7
2832 ++ nr
2833 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002834 v9.CheckDefAndScriptFailure(lines, "E1202: No white space allowed after '++': ++ nr")
Bram Moolenaarbdc0f1c2021-04-24 19:08:24 +02002835enddef
2836
Bram Moolenaar327d3ee2021-07-28 19:34:14 +02002837def Test_abort_after_error()
2838 # should abort after strpart() fails, not give another type error
2839 var lines =<< trim END
2840 vim9script
2841 var x: string
2842 x = strpart(1, 2)
2843 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01002844 writefile(lines, 'Xtestscript', 'D')
Bram Moolenaar327d3ee2021-07-28 19:34:14 +02002845 var expected = 'E1174: String required for argument 1'
2846 assert_fails('so Xtestscript', [expected, expected], 3)
Bram Moolenaar327d3ee2021-07-28 19:34:14 +02002847enddef
2848
Bram Moolenaarafa048f2022-02-22 20:43:36 +00002849def Test_using_s_var_in_function()
2850 var lines =<< trim END
2851 vim9script
2852 var scriptlevel = 123
2853 def SomeFunc()
2854 echo s:scriptlevel
2855 enddef
2856 SomeFunc()
2857 END
2858 v9.CheckScriptFailure(lines, 'E1268:')
2859
2860 # OK in legacy script
2861 lines =<< trim END
2862 let s:scriptlevel = 123
2863 def s:SomeFunc()
2864 echo s:scriptlevel
2865 enddef
2866 call s:SomeFunc()
2867 END
2868 v9.CheckScriptSuccess(lines)
2869
2870 lines =<< trim END
2871 vim9script
2872 var scriptlevel = 123
2873 def SomeFunc()
2874 s:scriptlevel = 456
2875 enddef
2876 SomeFunc()
2877 END
2878 v9.CheckScriptFailure(lines, 'E1268:')
2879
2880 # OK in legacy script
2881 lines =<< trim END
2882 let s:scriptlevel = 123
2883 def s:SomeFunc()
2884 s:scriptlevel = 456
2885 enddef
2886 call s:SomeFunc()
2887 call assert_equal(456, s:scriptlevel)
2888 END
2889 v9.CheckScriptSuccess(lines)
2890enddef
2891
Yegappan Lakshmananb5a07192023-10-05 20:14:43 +02002892" Test for specifying a type in assignment
2893def Test_type_specification_in_assignment()
2894 # specify type for an existing script local variable without "var"
2895 var lines =<< trim END
2896 vim9script
2897 var n: number = 10
2898 n: number = 20
2899 END
2900 v9.CheckSourceFailure(lines, 'E488: Trailing characters: : number = 20', 3)
2901
2902 # specify type for a non-existing script local variable without "var"
2903 lines =<< trim END
2904 vim9script
2905 MyVar: string = 'abc'
2906 END
2907 v9.CheckSourceFailure(lines, "E492: Not an editor command: MyVar: string = 'abc'", 2)
2908
2909 # specify type for an existing def local variable without "var"
2910 lines =<< trim END
2911 vim9script
2912 def Foo()
2913 var n: number = 10
2914 n: number = 20
2915 enddef
2916 Foo()
2917 END
2918 v9.CheckSourceFailure(lines, 'E488: Trailing characters: : number = 20', 2)
2919
2920 # specify type for a non-existing def local variable without "var"
2921 lines =<< trim END
2922 vim9script
2923 def Foo()
2924 MyVar: string = 'abc'
2925 enddef
2926 Foo()
2927 END
2928 v9.CheckSourceFailure(lines, "E476: Invalid command: MyVar: string = 'abc'", 1)
2929enddef
2930
Yegappan Lakshmananefbfa862022-04-17 12:47:40 +01002931let g:someVar = 'X'
2932
2933" Test for heredoc with Vim expressions.
2934" This messes up highlighting, keep it near the end.
2935def Test_heredoc_expr()
Yegappan Lakshmanan1fc6ea92022-04-21 23:30:15 +01002936 var lines =<< trim CODE
2937 var s = "local"
2938 var a1 = "1"
2939 var a2 = "2"
2940 var a3 = "3"
2941 var a4 = ""
2942 var code =<< trim eval END
LemonBoy2eaef102022-05-06 13:14:50 +01002943 var a = {5 + 10}
2944 var b = {min([10, 6])} + {max([4, 6])}
2945 var c = "{s}"
2946 var d = x{a1}x{a2}x{a3}x{a4}
Yegappan Lakshmanan1fc6ea92022-04-21 23:30:15 +01002947 END
2948 assert_equal(['var a = 15', 'var b = 6 + 6', 'var c = "local"', 'var d = x1x2x3x'], code)
2949 CODE
2950 v9.CheckDefAndScriptSuccess(lines)
Yegappan Lakshmananefbfa862022-04-17 12:47:40 +01002951
Yegappan Lakshmanan1fc6ea92022-04-21 23:30:15 +01002952 lines =<< trim CODE
2953 var code =<< eval trim END
LemonBoy2eaef102022-05-06 13:14:50 +01002954 var s = "{$SOME_ENV_VAR}"
Yegappan Lakshmanan1fc6ea92022-04-21 23:30:15 +01002955 END
2956 assert_equal(['var s = "somemore"'], code)
2957 CODE
2958 v9.CheckDefAndScriptSuccess(lines)
Yegappan Lakshmananefbfa862022-04-17 12:47:40 +01002959
Yegappan Lakshmanan1fc6ea92022-04-21 23:30:15 +01002960 lines =<< trim CODE
2961 var code =<< eval END
LemonBoy2eaef102022-05-06 13:14:50 +01002962 var s = "{$SOME_ENV_VAR}"
Yegappan Lakshmanan1fc6ea92022-04-21 23:30:15 +01002963 END
2964 assert_equal([' var s = "somemore"'], code)
2965 CODE
2966 v9.CheckDefAndScriptSuccess(lines)
Yegappan Lakshmananefbfa862022-04-17 12:47:40 +01002967
Yegappan Lakshmanan1fc6ea92022-04-21 23:30:15 +01002968 lines =<< trim CODE
2969 var code =<< eval trim END
LemonBoy2eaef102022-05-06 13:14:50 +01002970 let a = {{abc}}
2971 let b = {g:someVar}
2972 let c = {{
Yegappan Lakshmanan1fc6ea92022-04-21 23:30:15 +01002973 END
LemonBoy2eaef102022-05-06 13:14:50 +01002974 assert_equal(['let a = {abc}', 'let b = X', 'let c = {'], code)
Yegappan Lakshmanan1fc6ea92022-04-21 23:30:15 +01002975 CODE
2976 v9.CheckDefAndScriptSuccess(lines)
Yegappan Lakshmananefbfa862022-04-17 12:47:40 +01002977
Yegappan Lakshmanan1fc6ea92022-04-21 23:30:15 +01002978 lines =<< trim LINES
Yegappan Lakshmananefbfa862022-04-17 12:47:40 +01002979 var text =<< eval trim END
LemonBoy2eaef102022-05-06 13:14:50 +01002980 let b = {
Yegappan Lakshmananefbfa862022-04-17 12:47:40 +01002981 END
2982 LINES
LemonBoy2eaef102022-05-06 13:14:50 +01002983 v9.CheckDefAndScriptFailure(lines, "E1279: Missing '}'")
Yegappan Lakshmananefbfa862022-04-17 12:47:40 +01002984
2985 lines =<< trim LINES
2986 var text =<< eval trim END
LemonBoy2eaef102022-05-06 13:14:50 +01002987 let b = {abc
Yegappan Lakshmananefbfa862022-04-17 12:47:40 +01002988 END
2989 LINES
LemonBoy2eaef102022-05-06 13:14:50 +01002990 v9.CheckDefAndScriptFailure(lines, "E1279: Missing '}'")
Yegappan Lakshmananefbfa862022-04-17 12:47:40 +01002991
2992 lines =<< trim LINES
2993 var text =<< eval trim END
LemonBoy2eaef102022-05-06 13:14:50 +01002994 let b = {}
Yegappan Lakshmananefbfa862022-04-17 12:47:40 +01002995 END
2996 LINES
LemonBoy2eaef102022-05-06 13:14:50 +01002997 v9.CheckDefAndScriptFailure(lines, 'E15: Invalid expression: "}"')
Yegappan Lakshmananefbfa862022-04-17 12:47:40 +01002998enddef
2999
Yegappan Lakshmananc229a6a2023-10-26 23:05:07 +02003000" Test for assigning to a multi-dimensional list item.
3001def Test_list_item_assign()
3002 var lines =<< trim END
3003 vim9script
3004
3005 def Foo()
Yegappan Lakshmanan67098162023-11-05 10:07:03 +01003006 var l: list<list<string>> = [['x', 'x', 'x'], ['y', 'y', 'y']]
3007 var z: number = 1
Yegappan Lakshmananc229a6a2023-10-26 23:05:07 +02003008
Yegappan Lakshmanan67098162023-11-05 10:07:03 +01003009 [l[1][2], z] = ['a', 20]
3010 assert_equal([['x', 'x', 'x'], ['y', 'y', 'a']], l)
Yegappan Lakshmananc229a6a2023-10-26 23:05:07 +02003011 enddef
3012 Foo()
3013 END
3014 v9.CheckSourceSuccess(lines)
Yegappan Lakshmanan67098162023-11-05 10:07:03 +01003015
3016 lines =<< trim END
3017 vim9script
3018
3019 var l: list<list<string>> = [['x', 'x', 'x'], ['y', 'y', 'y']]
3020 var z: number = 1
3021
3022 [l[1][2], z] = ['a', 20]
3023 assert_equal([['x', 'x', 'x'], ['y', 'y', 'a']], l)
3024 END
3025 v9.CheckSourceSuccess(lines)
3026enddef
3027
3028" Test for assigning to a multi-dimensional dict item.
3029def Test_dict_item_assign()
3030 # This used to fail with the error "E1105: Cannot convert list to string"
3031 # (Github issue #13485)
3032 var lines =<< trim END
3033 vim9script
3034 def F()
3035 var d: dict<dict<number>> = {a: {b: 0}}
3036
3037 for group in keys(d)
3038 d['a']['b'] += 1
3039 endfor
3040 assert_equal({a: {b: 1}}, d)
3041 enddef
3042 F()
3043 END
3044 v9.CheckSourceSuccess(lines)
3045
3046 # This used to crash Vim
3047 lines =<< trim END
3048 vim9script
3049 def F()
3050 var d: dict<dict<number>> = {a: {b: 0}}
3051 d['a']['b'] += 1
3052 assert_equal({a: {b: 1}}, d)
3053 enddef
3054 F()
3055 END
3056 v9.CheckSourceSuccess(lines)
3057
3058 # Assignment at script level
3059 lines =<< trim END
3060 vim9script
3061 var d: dict<dict<number>> = {a: {b: 0}}
3062
3063 for group in keys(d)
3064 d['a']['b'] += 1
3065 endfor
3066 assert_equal({a: {b: 1}}, d)
3067 END
3068 v9.CheckSourceSuccess(lines)
Yegappan Lakshmananc229a6a2023-10-26 23:05:07 +02003069enddef
3070
Ernie Rael9ed53752023-12-11 17:40:46 +01003071def Test_class_assign()
3072 var lines =<< trim END
3073 vim9script
3074 class C
3075 endclass
3076 class D
3077 endclass
Ernie Rael2025af12023-12-12 16:58:00 +01003078 assert_fails('C = D', 'E1405: Class "D" cannot be used as a value')
Ernie Rael9ed53752023-12-11 17:40:46 +01003079 END
3080 v9.CheckSourceSuccess(lines)
3081enddef
3082
Yegappan Lakshmanan1fc47c22023-11-08 21:02:48 +01003083" Test for using various types (dict, list, blob, funcref, class) as variable
3084" in assignments with a different type
3085def Test_type_check()
3086 var lines =<< trim END
3087 vim9script
3088 class A
3089 endclass
Ernie Raelb5011082023-12-18 08:34:41 +01003090 type T = number
Yegappan Lakshmanan1fc47c22023-11-08 21:02:48 +01003091 var N: number = 1
3092 var S: string = 'abc'
3093 var d: dict<number> = {}
3094 var l: list<number> = []
3095 var b: blob = 0z10
3096 var Fn: func = function('min')
Yegappan Lakshmanan1fc47c22023-11-08 21:02:48 +01003097 var o: A = A.new()
3098
3099 # Assign a number
3100 assert_fails('d = N', 'E1012: Type mismatch; expected dict<number> but got number')
3101 assert_fails('l = N', 'E1012: Type mismatch; expected list<number> but got number')
3102 assert_fails('b = N', 'E1012: Type mismatch; expected blob but got number')
3103 assert_fails('Fn = N', 'E1012: Type mismatch; expected func(...): unknown but got number')
Ernie Raele75fde62023-12-21 17:18:54 +01003104 assert_fails('A = N', 'E1405: Class "A" cannot be used as a value')
Yegappan Lakshmanan1fc47c22023-11-08 21:02:48 +01003105 assert_fails('o = N', 'E1012: Type mismatch; expected object<A> but got number')
Ernie Raele75fde62023-12-21 17:18:54 +01003106 assert_fails('T = N', 'E1403: Type alias "T" cannot be used as a value')
Yegappan Lakshmanan1fc47c22023-11-08 21:02:48 +01003107
3108 # Use a compound operator with different LHS types
3109 assert_fails('d += N', 'E734: Wrong variable type for +=')
3110 assert_fails('l += N', 'E734: Wrong variable type for +=')
3111 assert_fails('b += N', 'E734: Wrong variable type for +=')
3112 assert_fails('Fn += N', 'E734: Wrong variable type for +=')
Ernie Raele75fde62023-12-21 17:18:54 +01003113 assert_fails('A += N', 'E1405: Class "A" cannot be used as a value')
Yegappan Lakshmanan1fc47c22023-11-08 21:02:48 +01003114 assert_fails('o += N', 'E734: Wrong variable type for +=')
Ernie Raele75fde62023-12-21 17:18:54 +01003115 assert_fails('T += N', 'E1403: Type alias "T" cannot be used as a value')
Yegappan Lakshmanan1fc47c22023-11-08 21:02:48 +01003116
3117 # Assign to a number variable
3118 assert_fails('N = d', 'E1012: Type mismatch; expected number but got dict<number>')
3119 assert_fails('N = l', 'E1012: Type mismatch; expected number but got list<number>')
3120 assert_fails('N = b', 'E1012: Type mismatch; expected number but got blob')
3121 assert_fails('N = Fn', 'E1012: Type mismatch; expected number but got func([unknown]): number')
Ernie Rael2025af12023-12-12 16:58:00 +01003122 assert_fails('N = A', 'E1405: Class "A" cannot be used as a value')
Yegappan Lakshmanan1fc47c22023-11-08 21:02:48 +01003123 assert_fails('N = o', 'E1012: Type mismatch; expected number but got object<A>')
Ernie Raelb5011082023-12-18 08:34:41 +01003124 assert_fails('N = T', 'E1403: Type alias "T" cannot be used as a value')
Yegappan Lakshmanan1fc47c22023-11-08 21:02:48 +01003125
3126 # Use a compound operator with different RHS types
3127 assert_fails('N += d', 'E734: Wrong variable type for +=')
3128 assert_fails('N += l', 'E734: Wrong variable type for +=')
3129 assert_fails('N += b', 'E974: Using a Blob as a Number')
3130 assert_fails('N += Fn', 'E734: Wrong variable type for +=')
Ernie Rael2025af12023-12-12 16:58:00 +01003131 assert_fails('N += A', 'E1405: Class "A" cannot be used as a value')
Yegappan Lakshmanan1fc47c22023-11-08 21:02:48 +01003132 assert_fails('N += o', 'E1320: Using an Object as a Number')
Ernie Raelb5011082023-12-18 08:34:41 +01003133 assert_fails('N += T', 'E1403: Type alias "T" cannot be used as a value')
Yegappan Lakshmanan1fc47c22023-11-08 21:02:48 +01003134
3135 # Initialize multiple variables using []
3136 assert_fails('var [X1: number, Y: number] = [1, d]', 'E1012: Type mismatch; expected number but got dict<number>')
3137 assert_fails('var [X2: number, Y: number] = [1, l]', 'E1012: Type mismatch; expected number but got list<number>')
3138 assert_fails('var [X3: number, Y: number] = [1, b]', 'E1012: Type mismatch; expected number but got blob')
3139 assert_fails('var [X4: number, Y: number] = [1, Fn]', 'E1012: Type mismatch; expected number but got func([unknown]): number')
Ernie Rael2025af12023-12-12 16:58:00 +01003140 assert_fails('var [X7: number, Y: number] = [1, A]', 'E1405: Class "A" cannot be used as a value')
Yegappan Lakshmanan1fc47c22023-11-08 21:02:48 +01003141 assert_fails('var [X8: number, Y: number] = [1, o]', 'E1012: Type mismatch; expected number but got object<A>')
Ernie Raelb5011082023-12-18 08:34:41 +01003142 assert_fails('var [X8: number, Y: number] = [1, T]', 'E1403: Type alias "T" cannot be used as a value')
Yegappan Lakshmanan1fc47c22023-11-08 21:02:48 +01003143
3144 # String concatenation with various LHS types
3145 assert_fails('S ..= d', 'E734: Wrong variable type for .=')
3146 assert_fails('S ..= l', 'E734: Wrong variable type for .=')
3147 assert_fails('S ..= b', 'E976: Using a Blob as a String')
3148 assert_fails('S ..= Fn', 'E734: Wrong variable type for .=')
Ernie Rael2025af12023-12-12 16:58:00 +01003149 assert_fails('S ..= A', 'E1405: Class "A" cannot be used as a value')
Yegappan Lakshmanan1fc47c22023-11-08 21:02:48 +01003150 assert_fails('S ..= o', 'E1324: Using an Object as a String')
Ernie Raelb5011082023-12-18 08:34:41 +01003151 assert_fails('S ..= T', 'E1403: Type alias "T" cannot be used as a value')
Yegappan Lakshmanan1fc47c22023-11-08 21:02:48 +01003152
3153 # String concatenation with various RHS types
3154 assert_fails('d ..= S', 'E734: Wrong variable type for .=')
3155 assert_fails('l ..= S', 'E734: Wrong variable type for .=')
3156 assert_fails('b ..= S', 'E734: Wrong variable type for .=')
3157 assert_fails('Fn ..= S', 'E734: Wrong variable type for .=')
Ernie Raele75fde62023-12-21 17:18:54 +01003158 assert_fails('A ..= S', 'E1405: Class "A" cannot be used as a value')
Yegappan Lakshmanan1fc47c22023-11-08 21:02:48 +01003159 assert_fails('o ..= S', 'E734: Wrong variable type for .=')
Ernie Raele75fde62023-12-21 17:18:54 +01003160 assert_fails('T ..= S', 'E1403: Type alias "T" cannot be used as a value')
Yegappan Lakshmanan1fc47c22023-11-08 21:02:48 +01003161 END
3162 v9.CheckSourceSuccess(lines)
Yegappan Lakshmanan3ee25962023-12-04 20:31:14 +01003163
3164 if has('channel')
3165 lines =<< trim END
3166 vim9script
3167 var N: number = 1
3168 var S: string = 'abc'
3169 var j: job = test_null_job()
3170 var ch: channel = test_null_channel()
3171 assert_fails('j = N', 'E1012: Type mismatch; expected job but got number')
3172 assert_fails('ch = N', 'E1012: Type mismatch; expected channel but got number')
3173 assert_fails('j += N', 'E734: Wrong variable type for +=')
3174 assert_fails('ch += N', 'E734: Wrong variable type for +=')
3175 assert_fails('N = j', 'E1012: Type mismatch; expected number but got job')
3176 assert_fails('N = ch', 'E1012: Type mismatch; expected number but got channel')
3177 assert_fails('N += j', 'E910: Using a Job as a Number')
3178 assert_fails('N += ch', 'E913: Using a Channel as a Number')
3179 assert_fails('var [X5: number, Y: number] = [1, j]', 'E1012: Type mismatch; expected number but got job')
3180 assert_fails('var [X6: number, Y: number] = [1, ch]', 'E1012: Type mismatch; expected number but got channel')
3181 assert_fails('S ..= j', 'E908: Using an invalid value as a String: job')
3182 assert_fails('S ..= ch', 'E908: Using an invalid value as a String: channel')
3183 assert_fails('j ..= S', 'E734: Wrong variable type for .=')
3184 assert_fails('ch ..= S', 'E734: Wrong variable type for .=')
3185 END
3186 v9.CheckSourceSuccess(lines)
3187 endif
Ernie Rael5e133152023-12-19 22:15:27 +01003188
3189 lines =<< trim END
3190 vim9script
3191 class A
3192 endclass
3193
3194 def F()
3195 A += 3
3196 enddef
3197 F()
3198 END
3199 v9.CheckScriptFailure(lines, 'E1405: Class "A" cannot be used as a value')
3200
3201 lines =<< trim END
3202 vim9script
3203 class A
3204 endclass
3205
3206 var o = A.new()
3207 def F()
3208 o += 4
3209 enddef
3210 F()
3211 END
3212 v9.CheckScriptFailure(lines, 'E1411: Missing dot after object "o"')
Yegappan Lakshmanan1fc47c22023-11-08 21:02:48 +01003213enddef
3214
3215" Test for checking the argument type of a def function
3216def Test_func_argtype_check()
3217 var lines =<< trim END
3218 vim9script
3219
3220 # Passing different types as argument to a function expecting a number
3221 def IntArg(n: number)
3222 enddef
3223
3224 class A
3225 endclass
3226 var N: number = 1
3227 var S: string = 'abc'
3228 var d: dict<number> = {}
3229 var l: list<number> = []
3230 var b: blob = 0z10
3231 var Fn: func = function('min')
Yegappan Lakshmanan1fc47c22023-11-08 21:02:48 +01003232 var o: A = A.new()
3233
3234 assert_fails('IntArg(d)', 'E1013: Argument 1: type mismatch, expected number but got dict<number>')
3235 assert_fails('IntArg(l)', 'E1013: Argument 1: type mismatch, expected number but got list<number>')
3236 assert_fails('IntArg(b)', 'E1013: Argument 1: type mismatch, expected number but got blob')
3237 assert_fails('IntArg(Fn)', 'E1013: Argument 1: type mismatch, expected number but got func([unknown]): number')
Yegappan Lakshmanan3ee25962023-12-04 20:31:14 +01003238 if has('channel')
3239 var j: job = test_null_job()
3240 var ch: channel = test_null_channel()
3241 assert_fails('IntArg(j)', 'E1013: Argument 1: type mismatch, expected number but got job')
3242 assert_fails('IntArg(ch)', 'E1013: Argument 1: type mismatch, expected number but got channel')
3243 endif
Ernie Raelb077b582023-12-14 20:11:44 +01003244 assert_fails('IntArg(A)', 'E1405: Class "A" cannot be used as a value')
Yegappan Lakshmanan1fc47c22023-11-08 21:02:48 +01003245 assert_fails('IntArg(o)', 'E1013: Argument 1: type mismatch, expected number but got object<A>')
3246
3247 # Passing a number to functions accepting different argument types
3248 def DictArg(_: dict<number>)
3249 enddef
3250 assert_fails('DictArg(N)', 'E1013: Argument 1: type mismatch, expected dict<number> but got number')
3251
3252 def ListArg(_: list<number>)
3253 enddef
3254 assert_fails('ListArg(N)', 'E1013: Argument 1: type mismatch, expected list<number> but got number')
3255
3256 def BlobArg(_: blob)
3257 enddef
3258 assert_fails('BlobArg(N)', 'E1013: Argument 1: type mismatch, expected blob but got number')
3259
3260 def FuncArg(Fn_arg: func)
3261 enddef
3262 assert_fails('FuncArg(N)', 'E1013: Argument 1: type mismatch, expected func(...): unknown but got number')
3263
Yegappan Lakshmanan3ee25962023-12-04 20:31:14 +01003264 if has('channel')
3265 def JobArg(_: job)
3266 enddef
3267 assert_fails('JobArg(N)', 'E1013: Argument 1: type mismatch, expected job but got number')
Yegappan Lakshmanan1fc47c22023-11-08 21:02:48 +01003268
Yegappan Lakshmanan3ee25962023-12-04 20:31:14 +01003269 def ChannelArg(_: channel)
3270 enddef
3271 assert_fails('ChannelArg(N)', 'E1013: Argument 1: type mismatch, expected channel but got number')
3272 endif
Yegappan Lakshmanan1fc47c22023-11-08 21:02:48 +01003273
3274 def ObjectArg(_: A)
3275 enddef
3276 assert_fails('ObjectArg(N)', 'E1013: Argument 1: type mismatch, expected object<A> but got number')
3277 END
3278 v9.CheckSourceSuccess(lines)
3279
3280 # Calling a function expecting a number type with different argument types
3281 # from another function
3282 var pre_lines =<< trim END
3283 vim9script
3284 class A
3285 endclass
3286 def IntArg(n: number)
3287 enddef
3288 def Foo()
3289 END
3290 var post_lines =<< trim END
3291 enddef
3292 defcompile
3293 END
3294 lines = pre_lines + ['var d: dict<number> = {}', 'IntArg(d)'] + post_lines
3295 v9.CheckSourceFailure(lines, 'E1013: Argument 1: type mismatch, expected number but got dict<number>', 2)
3296 lines = pre_lines + ['var l: list<number> = []', 'IntArg(l)'] + post_lines
3297 v9.CheckSourceFailure(lines, 'E1013: Argument 1: type mismatch, expected number but got list<number>', 2)
3298 lines = pre_lines + ['var b: blob = 0z12', 'IntArg(b)'] + post_lines
3299 v9.CheckSourceFailure(lines, 'E1013: Argument 1: type mismatch, expected number but got blob', 2)
3300 lines = pre_lines + ['var Fn: func = function("min")', 'IntArg(Fn)'] + post_lines
3301 v9.CheckSourceFailure(lines, 'E1013: Argument 1: type mismatch, expected number but got func(...): unknown', 2)
Yegappan Lakshmanan3ee25962023-12-04 20:31:14 +01003302 if has('channel')
3303 lines = pre_lines + ['var j: job = test_null_job()', 'IntArg(j)'] + post_lines
3304 v9.CheckSourceFailure(lines, 'E1013: Argument 1: type mismatch, expected number but got job', 2)
3305 lines = pre_lines + ['var ch: channel = test_null_channel()', 'IntArg(ch)'] + post_lines
3306 v9.CheckSourceFailure(lines, 'E1013: Argument 1: type mismatch, expected number but got channel', 2)
3307 endif
Yegappan Lakshmanan1fc47c22023-11-08 21:02:48 +01003308 lines = pre_lines + ['IntArg(A)'] + post_lines
Ernie Raelb077b582023-12-14 20:11:44 +01003309 v9.CheckSourceFailure(lines, 'E1405: Class "A" cannot be used as a value', 1)
Yegappan Lakshmanan1fc47c22023-11-08 21:02:48 +01003310 lines = pre_lines + ['var o: A = A.new()', 'IntArg(o)'] + post_lines
3311 v9.CheckSourceFailure(lines, 'E1013: Argument 1: type mismatch, expected number but got object<A>', 2)
3312enddef
3313
3314" Test for checking the return type of a def function
3315def Test_func_rettype_check()
3316 var lines =<< trim END
3317 vim9script
3318 def Fn(): dict<number>
3319 return 10
3320 enddef
3321 defcompile
3322 END
3323 v9.CheckSourceFailure(lines, 'E1012: Type mismatch; expected dict<number> but got number', 1)
3324
3325 lines =<< trim END
3326 vim9script
3327 def Fn(): list<number>
3328 return 10
3329 enddef
3330 defcompile
3331 END
3332 v9.CheckSourceFailure(lines, 'E1012: Type mismatch; expected list<number> but got number', 1)
3333
3334 lines =<< trim END
3335 vim9script
3336 def Fn(): blob
3337 return 10
3338 enddef
3339 defcompile
3340 END
3341 v9.CheckSourceFailure(lines, 'E1012: Type mismatch; expected blob but got number', 1)
3342
3343 lines =<< trim END
3344 vim9script
3345 def Fn(): func
3346 return 10
3347 enddef
3348 defcompile
3349 END
3350 v9.CheckSourceFailure(lines, 'E1012: Type mismatch; expected func(...): unknown but got number', 1)
3351
3352 lines =<< trim END
3353 vim9script
3354 def Fn(): job
3355 return 10
3356 enddef
3357 defcompile
3358 END
3359 v9.CheckSourceFailure(lines, 'E1012: Type mismatch; expected job but got number', 1)
3360
3361 lines =<< trim END
3362 vim9script
3363 def Fn(): channel
3364 return 10
3365 enddef
3366 defcompile
3367 END
3368 v9.CheckSourceFailure(lines, 'E1012: Type mismatch; expected channel but got number', 1)
3369
3370 lines =<< trim END
3371 vim9script
3372 class A
3373 endclass
3374 def Fn(): A
3375 return 10
3376 enddef
3377 defcompile
3378 END
3379 v9.CheckSourceFailure(lines, 'E1012: Type mismatch; expected object<A> but got number', 1)
3380enddef
3381
Yegappan Lakshmanand3351852023-12-08 21:41:23 +01003382" Test for assigning different types of value to a variable of type "any"
3383def Test_assign_to_any()
3384 for [typestr, val] in [
3385 ["'bool'", 'true'],
3386 ["'number'", '100'],
3387 ["'float'", '1.1'],
3388 ["'string'", '"abc"'],
3389 ["'blob'", '0z10'],
3390 ["'list<number>'", '[1, 2, 3]'],
3391 ["'dict<number>'", '{a: 1}'],
3392 ]
3393 var lines =<< trim eval END
3394 vim9script
3395 var x: any = {val}
3396 assert_equal({typestr}, typename(x))
3397 x = [{{a: 1}}, {{b: 2}}]
3398 assert_equal('list<dict<number>>', typename(x))
3399 def Foo(xarg: any, s: string)
3400 assert_equal(s, typename(xarg))
3401 enddef
3402 Foo({val}, {typestr})
3403 END
3404 v9.CheckSourceSuccess(lines)
3405 endfor
3406enddef
3407
Ernie Raelfa831102023-12-14 20:06:39 +01003408def Test_assign_type_to_list_dict()
3409 var lines =<< trim END
3410 vim9script
3411 class C
3412 endclass
3413
3414 var x = [C]
3415 END
3416 v9.CheckScriptFailure(lines, 'E1405: Class "C" cannot be used as a value')
3417
3418 lines =<< trim END
3419 vim9script
3420 class C
3421 endclass
3422 type T = C
3423
3424 def F()
3425 var x = [3, T, C]
3426 enddef
3427 F()
3428 END
3429 v9.CheckScriptFailure(lines, 'E1405: Class "C" cannot be used as a value')
3430
3431 lines =<< trim END
3432 vim9script
3433 type T = number
3434
3435 def F()
3436 var x = [3, T]
3437 enddef
3438 F()
3439 END
3440 v9.CheckScriptFailure(lines, 'E1407: Cannot use a Typealias as a variable or value')
3441
3442 lines =<< trim END
3443 vim9script
3444 class C
3445 endclass
3446
3447 var x = {e: C}
3448 END
3449 v9.CheckScriptFailure(lines, 'E1405: Class "C" cannot be used as a value')
3450
3451 lines =<< trim END
3452 vim9script
3453 class C
3454 endclass
3455
3456 def F()
3457 var x = {e: C}
3458 enddef
3459 F()
3460 END
3461 v9.CheckScriptFailure(lines, 'E1405: Class "C" cannot be used as a value')
3462
3463 lines =<< trim END
3464 vim9script
3465 type T = number
3466
3467 def F()
3468 var x = {e: T}
3469 enddef
3470 F()
3471 END
3472 v9.CheckScriptFailure(lines, 'E1407: Cannot use a Typealias as a variable or value')
3473
3474 lines =<< trim END
3475 vim9script
3476 class C
3477 endclass
3478
3479 def F()
3480 var x = {e: [C]}
3481 enddef
3482 F()
3483 END
3484 v9.CheckScriptFailure(lines, 'E1405: Class "C" cannot be used as a value')
3485
3486 lines =<< trim END
3487 vim9script
3488 type T = number
3489
3490 def F()
3491 var x = {e: [T]}
3492 enddef
3493 F()
3494 END
3495 v9.CheckScriptFailure(lines, 'E1407: Cannot use a Typealias as a variable or value')
3496enddef
3497
Yegappan Lakshmanan1af35632024-02-06 11:03:36 +01003498" Test for modifying a final variable using a compound operator
3499def Test_final_var_modification_with_compound_op()
3500 var lines =<< trim END
3501 vim9script
3502
3503 final i: number = 1000
3504 assert_fails('i += 2', 'E46: Cannot change read-only variable "i"')
3505 assert_fails('i -= 2', 'E46: Cannot change read-only variable "i"')
3506 assert_fails('i *= 2', 'E46: Cannot change read-only variable "i"')
3507 assert_fails('i /= 2', 'E46: Cannot change read-only variable "i"')
3508 assert_fails('i %= 2', 'E46: Cannot change read-only variable "i"')
3509 assert_equal(1000, i)
3510
3511 final f: float = 1000.0
3512 assert_fails('f += 2', 'E46: Cannot change read-only variable "f"')
3513 assert_fails('f -= 2', 'E46: Cannot change read-only variable "f"')
3514 assert_fails('f *= 2', 'E46: Cannot change read-only variable "f"')
3515 assert_fails('f /= 2', 'E46: Cannot change read-only variable "f"')
3516 assert_equal(1000.0, f)
3517
3518 final s: string = 'abc'
3519 assert_fails('s ..= "y"', 'E46: Cannot change read-only variable "s"')
3520 assert_equal('abc', s)
3521 END
3522 v9.CheckScriptSuccess(lines)
3523enddef
3524
3525" Test for modifying a final variable with a List value
3526def Test_final_var_with_list_value()
3527 var lines =<< trim END
3528 vim9script
3529
3530 final listA: list<string> = []
3531 var listB = listA
3532
3533 listB->add('a')
3534 assert_true(listA is listB)
3535 assert_equal(['a'], listA)
3536 assert_equal(['a'], listB)
3537
3538 listB += ['b']
3539 assert_true(listA is listB)
3540 assert_equal(['a', 'b'], listA)
3541 assert_equal(['a', 'b'], listB)
3542
3543 listA->add('c')
3544 assert_true(listA is listB)
3545 assert_equal(['a', 'b', 'c'], listA)
3546 assert_equal(['a', 'b', 'c'], listB)
3547
3548 listA += ['d']
3549 assert_true(listA is listB)
3550 assert_equal(['a', 'b', 'c', 'd'], listA)
3551 assert_equal(['a', 'b', 'c', 'd'], listB)
3552 END
3553 v9.CheckScriptSuccess(lines)
3554enddef
3555
3556" Test for modifying a final variable with a List value using "+=" from a legacy
3557" function.
3558func Test_final_var_with_list_value_legacy()
3559 vim9cmd final g:TestVar = ['a']
3560 vim9cmd g:TestVar += ['b']
3561 call assert_equal(['a', 'b'], g:TestVar)
3562endfunc
3563
3564" Test for modifying a final variable with a Blob value
3565def Test_final_var_with_blob_value()
3566 var lines =<< trim END
3567 vim9script
3568
3569 final blobA: blob = 0z10
3570 var blobB = blobA
3571
3572 blobB->add(32)
3573 assert_true(blobA is blobB)
3574 assert_equal(0z1020, blobA)
3575 assert_equal(0z1020, blobB)
3576
3577 blobB += 0z30
3578 assert_true(blobA is blobB)
3579 assert_equal(0z102030, blobA)
3580 assert_equal(0z102030, blobB)
3581
3582 blobA->add(64)
3583 assert_true(blobA is blobB)
3584 assert_equal(0z10203040, blobA)
3585 assert_equal(0z10203040, blobB)
3586
3587 blobA += 0z50
3588 assert_true(blobA is blobB)
3589 assert_equal(0z1020304050, blobA)
3590 assert_equal(0z1020304050, blobB)
3591 END
3592 v9.CheckScriptSuccess(lines)
3593enddef
3594
Bram Moolenaar971caf52020-09-21 22:21:42 +02003595" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker