blob: d442dc2548127542b24c75ab073bb250649cee11 [file] [log] [blame]
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001" Test various aspects of the Vim9 script language.
2
Bram Moolenaar673660a2020-01-26 16:50:05 +01003source check.vim
Bram Moolenaar101f4812020-06-16 23:18:51 +02004source term_util.vim
Bram Moolenaarad39c092020-02-26 18:23:43 +01005source view_util.vim
Bram Moolenaarcfe435d2020-04-25 20:02:55 +02006source vim9.vim
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007
8def Test_syntax()
9 let var = 234
10 let other: list<string> = ['asdf']
11enddef
12
Bram Moolenaar6e587dc2020-02-06 13:15:52 +010013let s:appendToMe = 'xxx'
14let s:addToMe = 111
Bram Moolenaar401d9ff2020-02-19 18:14:44 +010015let g:existing = 'yes'
Bram Moolenaara8c17702020-04-01 21:17:24 +020016let g:inc_counter = 1
17let $SOME_ENV_VAR = 'some'
Bram Moolenaara6e67e42020-05-15 23:36:40 +020018let g:alist = [7]
19let g:astring = 'text'
Bram Moolenaarf0b9f432020-07-17 23:03:17 +020020let g:anumber = 123
Bram Moolenaar6e587dc2020-02-06 13:15:52 +010021
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010022def Test_assignment()
23 let bool1: bool = true
24 assert_equal(v:true, bool1)
25 let bool2: bool = false
26 assert_equal(v:false, bool2)
27
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +020028 call CheckDefFailure(['let x:string'], 'E1069:')
29 call CheckDefFailure(['let x:string = "x"'], 'E1069:')
Bram Moolenaar1cc2a942020-05-10 19:10:31 +020030 call CheckDefFailure(['let a:string = "x"'], 'E1069:')
Bram Moolenaar98b4f142020-08-08 15:46:01 +020031 call CheckDefFailure(['let lambda = {-> "lambda"}'], 'E704:')
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +020032
Bram Moolenaar4cdb13c2020-07-22 21:45:14 +020033 let nr: number = 1234
Bram Moolenaar451c2e32020-08-15 16:33:28 +020034 call CheckDefFailure(['let nr: number = "asdf"'], 'E1012:')
Bram Moolenaar4cdb13c2020-07-22 21:45:14 +020035
Bram Moolenaarb2097502020-07-19 17:17:02 +020036 let a: number = 6 #comment
Bram Moolenaar9be61bb2020-03-30 22:51:24 +020037 assert_equal(6, a)
38
Bram Moolenaar42a480b2020-02-29 23:23:47 +010039 if has('channel')
40 let chan1: channel
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +010041 let job1: job
Bram Moolenaarf51cb4e2020-03-01 17:55:14 +010042 let job2: job = job_start('willfail')
Bram Moolenaar42a480b2020-02-29 23:23:47 +010043 endif
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +010044 if has('float')
45 let float1: float = 3.4
46 endif
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +020047 let Funky1: func
48 let Funky2: func = function('len')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +020049 let Party2: func = funcref('g:Test_syntax')
Bram Moolenaar42a480b2020-02-29 23:23:47 +010050
Bram Moolenaarb2097502020-07-19 17:17:02 +020051 g:newvar = 'new' #comment
Bram Moolenaar401d9ff2020-02-19 18:14:44 +010052 assert_equal('new', g:newvar)
53
54 assert_equal('yes', g:existing)
55 g:existing = 'no'
56 assert_equal('no', g:existing)
57
Bram Moolenaarb283a8a2020-02-02 22:24:04 +010058 v:char = 'abc'
Bram Moolenaar6e587dc2020-02-06 13:15:52 +010059 assert_equal('abc', v:char)
Bram Moolenaarb283a8a2020-02-02 22:24:04 +010060
61 $ENVVAR = 'foobar'
Bram Moolenaar6e587dc2020-02-06 13:15:52 +010062 assert_equal('foobar', $ENVVAR)
Bram Moolenaarb283a8a2020-02-02 22:24:04 +010063 $ENVVAR = ''
Bram Moolenaar6e587dc2020-02-06 13:15:52 +010064
Bram Moolenaarb5ed2662020-07-28 22:38:37 +020065 let lines =<< trim END
66 vim9script
67 $ENVVAR = 'barfoo'
68 assert_equal('barfoo', $ENVVAR)
69 $ENVVAR = ''
70 END
71 call CheckScriptSuccess(lines)
72
Bram Moolenaarfd1823e2020-02-19 20:23:11 +010073 s:appendToMe ..= 'yyy'
74 assert_equal('xxxyyy', s:appendToMe)
75 s:addToMe += 222
76 assert_equal(333, s:addToMe)
Bram Moolenaar0bbf7222020-02-19 22:31:48 +010077 s:newVar = 'new'
78 assert_equal('new', s:newVar)
Bram Moolenaara8c17702020-04-01 21:17:24 +020079
80 set ts=7
81 &ts += 1
82 assert_equal(8, &ts)
Bram Moolenaar80c34ca2020-04-01 23:05:18 +020083 &ts -= 3
84 assert_equal(5, &ts)
85 &ts *= 2
86 assert_equal(10, &ts)
87 &ts /= 3
88 assert_equal(3, &ts)
89 set ts=10
90 &ts %= 4
91 assert_equal(2, &ts)
Bram Moolenaarb5ed2662020-07-28 22:38:37 +020092
Bram Moolenaar93ad1472020-08-19 22:02:41 +020093 if has('float')
94 let f100: float = 100.0
95 f100 /= 5
96 assert_equal(20.0, f100)
97
98 let f200: float = 200.0
99 f200 /= 5.0
100 assert_equal(40.0, f200)
101
102 CheckDefFailure(['let nr: number = 200', 'nr /= 5.0'], 'E1012:')
103 endif
104
Bram Moolenaarb5ed2662020-07-28 22:38:37 +0200105 lines =<< trim END
106 vim9script
107 &ts = 6
108 &ts += 3
109 assert_equal(9, &ts)
110 END
Bram Moolenaar0aae4802020-08-16 21:29:05 +0200111 CheckScriptSuccess(lines)
Bram Moolenaarb5ed2662020-07-28 22:38:37 +0200112
Bram Moolenaar0aae4802020-08-16 21:29:05 +0200113 CheckDefFailure(['&notex += 3'], 'E113:')
114 CheckDefFailure(['&ts ..= "xxx"'], 'E1019:')
115 CheckDefFailure(['&ts = [7]'], 'E1012:')
116 CheckDefExecFailure(['&ts = g:alist'], 'E1029: Expected number but got list')
117 CheckDefFailure(['&ts = "xx"'], 'E1012:')
118 CheckDefExecFailure(['&ts = g:astring'], 'E1029: Expected number but got string')
119 CheckDefFailure(['&path += 3'], 'E1012:')
120 CheckDefExecFailure(['&bs = "asdf"'], 'E474:')
Bram Moolenaarcb711ab2020-04-16 13:00:29 +0200121 # test freeing ISN_STOREOPT
Bram Moolenaar0aae4802020-08-16 21:29:05 +0200122 CheckDefFailure(['&ts = 3', 'let asdf'], 'E1022:')
Bram Moolenaar80c34ca2020-04-01 23:05:18 +0200123 &ts = 8
Bram Moolenaara8c17702020-04-01 21:17:24 +0200124
Bram Moolenaar0aae4802020-08-16 21:29:05 +0200125 lines =<< trim END
126 let save_TI = &t_TI
127 &t_TI = ''
128 assert_equal('', &t_TI)
129 &t_TI = 'xxx'
130 assert_equal('xxx', &t_TI)
131 &t_TI = save_TI
132 END
133 CheckDefSuccess(lines)
134 CheckScriptSuccess(['vim9script'] + lines)
135
136 CheckDefFailure(['&t_TI = 123'], 'E1012:')
137 CheckScriptFailure(['vim9script', '&t_TI = 123'], 'E928:')
138
139 CheckDefFailure(['let s:var = 123'], 'E1101:')
140 CheckDefFailure(['let s:var: number'], 'E1101:')
Bram Moolenaar33afa242020-07-29 19:18:00 +0200141
Bram Moolenaarf9b2b492020-08-05 14:34:14 +0200142 lines =<< trim END
143 vim9script
144 def SomeFunc()
145 s:var = 123
146 enddef
147 defcompile
148 END
149 call CheckScriptFailure(lines, 'E1089:')
150
Bram Moolenaara8c17702020-04-01 21:17:24 +0200151 g:inc_counter += 1
152 assert_equal(2, g:inc_counter)
153
154 $SOME_ENV_VAR ..= 'more'
155 assert_equal('somemore', $SOME_ENV_VAR)
Bram Moolenaardd29f1b2020-08-07 20:46:20 +0200156 call CheckDefFailure(['$SOME_ENV_VAR += "more"'], 'E1051:')
Bram Moolenaar451c2e32020-08-15 16:33:28 +0200157 call CheckDefFailure(['$SOME_ENV_VAR += 123'], 'E1012:')
Bram Moolenaara8c17702020-04-01 21:17:24 +0200158
159 @a = 'areg'
160 @a ..= 'add'
161 assert_equal('aregadd', @a)
Bram Moolenaardd29f1b2020-08-07 20:46:20 +0200162 call CheckDefFailure(['@a += "more"'], 'E1051:')
Bram Moolenaar451c2e32020-08-15 16:33:28 +0200163 call CheckDefFailure(['@a += 123'], 'E1012:')
Bram Moolenaare69f6d02020-04-01 22:11:01 +0200164
Bram Moolenaarb5ed2662020-07-28 22:38:37 +0200165 lines =<< trim END
166 vim9script
167 @c = 'areg'
168 @c ..= 'add'
169 assert_equal('aregadd', @c)
170 END
171 call CheckScriptSuccess(lines)
172
Bram Moolenaare69f6d02020-04-01 22:11:01 +0200173 v:errmsg = 'none'
174 v:errmsg ..= 'again'
175 assert_equal('noneagain', v:errmsg)
Bram Moolenaardd29f1b2020-08-07 20:46:20 +0200176 call CheckDefFailure(['v:errmsg += "more"'], 'E1051:')
Bram Moolenaar451c2e32020-08-15 16:33:28 +0200177 call CheckDefFailure(['v:errmsg += 123'], 'E1012:')
Bram Moolenaar33afa242020-07-29 19:18:00 +0200178
179 # single letter variables
180 a = 123
181 assert_equal(123, a)
182 let b: number
183 b = 123
184 assert_equal(123, b)
185 let g: number
186 g = 123
187 assert_equal(123, g)
188 let s: number
189 s = 123
190 assert_equal(123, s)
191 let t: number
192 t = 123
193 assert_equal(123, t)
194 let v: number
195 v = 123
196 assert_equal(123, v)
197 let w: number
198 w = 123
199 assert_equal(123, w)
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200200enddef
201
Bram Moolenaar3b74b6b2020-06-19 19:01:43 +0200202def Test_vim9_single_char_vars()
203 let lines =<< trim END
204 vim9script
205
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200206 # single character variable declarations work
Bram Moolenaar3b74b6b2020-06-19 19:01:43 +0200207 let a: string
208 let b: number
209 let l: list<any>
210 let s: string
211 let t: number
212 let v: number
213 let w: number
214
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200215 # script-local variables can be used without s: prefix
Bram Moolenaar3b74b6b2020-06-19 19:01:43 +0200216 a = 'script-a'
217 b = 111
218 l = [1, 2, 3]
219 s = 'script-s'
220 t = 222
221 v = 333
222 w = 444
223
224 assert_equal('script-a', a)
225 assert_equal(111, b)
226 assert_equal([1, 2, 3], l)
227 assert_equal('script-s', s)
228 assert_equal(222, t)
229 assert_equal(333, v)
230 assert_equal(444, w)
231 END
232 writefile(lines, 'Xsinglechar')
233 source Xsinglechar
234 delete('Xsinglechar')
235enddef
236
Bram Moolenaar84370082020-05-18 14:20:36 +0200237def Test_assignment_list()
238 let list1: list<bool> = [false, true, false]
239 let list2: list<number> = [1, 2, 3]
240 let list3: list<string> = ['sdf', 'asdf']
241 let list4: list<any> = ['yes', true, 1234]
242 let list5: list<blob> = [0z01, 0z02]
243
244 let listS: list<string> = []
245 let listN: list<number> = []
246
247 assert_equal([1, 2, 3], list2)
248 list2[-1] = 99
249 assert_equal([1, 2, 99], list2)
250 list2[-2] = 88
251 assert_equal([1, 88, 99], list2)
252 list2[-3] = 77
253 assert_equal([77, 88, 99], list2)
Bram Moolenaardd29f1b2020-08-07 20:46:20 +0200254 list2 += [100]
255 assert_equal([77, 88, 99, 100], list2)
256
257 list3 += ['end']
258 assert_equal(['sdf', 'asdf', 'end'], list3)
259
260
Bram Moolenaar84370082020-05-18 14:20:36 +0200261 call CheckDefExecFailure(['let ll = [1, 2, 3]', 'll[-4] = 6'], 'E684:')
Bram Moolenaarc5b1c202020-06-18 22:43:27 +0200262 call CheckDefExecFailure(['let [v1, v2] = [1, 2]'], 'E1092:')
Bram Moolenaar84370082020-05-18 14:20:36 +0200263
264 # type becomes list<any>
265 let somelist = rand() > 0 ? [1, 2, 3] : ['a', 'b', 'c']
266enddef
267
Bram Moolenaarb31be3f2020-07-20 22:37:44 +0200268def Test_assignment_list_vim9script()
269 let lines =<< trim END
270 vim9script
271 let v1: number
272 let v2: number
273 let v3: number
274 [v1, v2, v3] = [1, 2, 3]
275 assert_equal([1, 2, 3], [v1, v2, v3])
276 END
277 call CheckScriptSuccess(lines)
278enddef
279
Bram Moolenaar84370082020-05-18 14:20:36 +0200280def Test_assignment_dict()
281 let dict1: dict<bool> = #{one: false, two: true}
282 let dict2: dict<number> = #{one: 1, two: 2}
283 let dict3: dict<string> = #{key: 'value'}
284 let dict4: dict<any> = #{one: 1, two: '2'}
Bram Moolenaar74fae512020-05-21 21:50:58 +0200285 let dict5: dict<blob> = #{one: 0z01, two: 0z02}
Bram Moolenaar84370082020-05-18 14:20:36 +0200286
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200287 # overwrite
Bram Moolenaarc785b9a2020-06-19 18:34:15 +0200288 dict3['key'] = 'another'
289
Bram Moolenaar58626872020-08-01 14:06:38 +0200290 # empty key can be used
291 let dd = {}
292 dd[""] = 6
293 assert_equal({'': 6}, dd)
Bram Moolenaar84370082020-05-18 14:20:36 +0200294
295 # type becomes dict<any>
296 let somedict = rand() > 0 ? #{a: 1, b: 2} : #{a: 'a', b: 'b'}
Bram Moolenaar8e4c8c82020-08-01 15:38:38 +0200297
298 # assignment to script-local dict
299 let lines =<< trim END
300 vim9script
301 let test: dict<any> = {}
302 def FillDict(): dict<any>
303 test['a'] = 43
304 return test
305 enddef
306 assert_equal(#{a: 43}, FillDict())
307 END
308 call CheckScriptSuccess(lines)
309
310 lines =<< trim END
311 vim9script
312 let test: dict<any>
313 def FillDict(): dict<any>
314 test['a'] = 43
315 return test
316 enddef
317 FillDict()
318 END
319 call CheckScriptFailure(lines, 'E1103:')
Bram Moolenaar2caa1592020-08-01 15:53:19 +0200320
321 # assignment to global dict
322 lines =<< trim END
323 vim9script
324 g:test = {}
325 def FillDict(): dict<any>
326 g:test['a'] = 43
327 return g:test
328 enddef
329 assert_equal(#{a: 43}, FillDict())
330 END
331 call CheckScriptSuccess(lines)
332
333 # assignment to buffer dict
334 lines =<< trim END
335 vim9script
336 b:test = {}
337 def FillDict(): dict<any>
338 b:test['a'] = 43
339 return b:test
340 enddef
341 assert_equal(#{a: 43}, FillDict())
342 END
343 call CheckScriptSuccess(lines)
Bram Moolenaar84370082020-05-18 14:20:36 +0200344enddef
345
Bram Moolenaard3aac292020-04-19 14:32:17 +0200346def Test_assignment_local()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200347 # Test in a separated file in order not to the current buffer/window/tab is
348 # changed.
Bram Moolenaard3aac292020-04-19 14:32:17 +0200349 let script_lines: list<string> =<< trim END
350 let b:existing = 'yes'
351 let w:existing = 'yes'
352 let t:existing = 'yes'
353
354 def Test_assignment_local_internal()
355 b:newvar = 'new'
356 assert_equal('new', b:newvar)
357 assert_equal('yes', b:existing)
358 b:existing = 'no'
359 assert_equal('no', b:existing)
Bram Moolenaar396f3132020-05-09 18:44:56 +0200360 b:existing ..= 'NO'
361 assert_equal('noNO', b:existing)
Bram Moolenaard3aac292020-04-19 14:32:17 +0200362
363 w:newvar = 'new'
364 assert_equal('new', w:newvar)
365 assert_equal('yes', w:existing)
366 w:existing = 'no'
367 assert_equal('no', w:existing)
Bram Moolenaar396f3132020-05-09 18:44:56 +0200368 w:existing ..= 'NO'
369 assert_equal('noNO', w:existing)
Bram Moolenaard3aac292020-04-19 14:32:17 +0200370
371 t:newvar = 'new'
372 assert_equal('new', t:newvar)
373 assert_equal('yes', t:existing)
374 t:existing = 'no'
375 assert_equal('no', t:existing)
Bram Moolenaar396f3132020-05-09 18:44:56 +0200376 t:existing ..= 'NO'
377 assert_equal('noNO', t:existing)
Bram Moolenaard3aac292020-04-19 14:32:17 +0200378 enddef
379 call Test_assignment_local_internal()
380 END
381 call CheckScriptSuccess(script_lines)
382enddef
383
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200384def Test_assignment_default()
Bram Moolenaare69f6d02020-04-01 22:11:01 +0200385
Bram Moolenaarcb711ab2020-04-16 13:00:29 +0200386 # Test default values.
Bram Moolenaare69f6d02020-04-01 22:11:01 +0200387 let thebool: bool
388 assert_equal(v:false, thebool)
389
390 let thenumber: number
391 assert_equal(0, thenumber)
392
393 if has('float')
394 let thefloat: float
395 assert_equal(0.0, thefloat)
396 endif
397
398 let thestring: string
399 assert_equal('', thestring)
400
401 let theblob: blob
402 assert_equal(0z, theblob)
403
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200404 let Thefunc: func
405 assert_equal(test_null_function(), Thefunc)
Bram Moolenaare69f6d02020-04-01 22:11:01 +0200406
Bram Moolenaare69f6d02020-04-01 22:11:01 +0200407 let thelist: list<any>
408 assert_equal([], thelist)
409
410 let thedict: dict<any>
411 assert_equal({}, thedict)
412
Bram Moolenaar2c869de2020-04-02 19:12:08 +0200413 if has('channel')
414 let thejob: job
415 assert_equal(test_null_job(), thejob)
Bram Moolenaare69f6d02020-04-01 22:11:01 +0200416
Bram Moolenaar2c869de2020-04-02 19:12:08 +0200417 let thechannel: channel
418 assert_equal(test_null_channel(), thechannel)
Bram Moolenaarc785b9a2020-06-19 18:34:15 +0200419
420 if has('unix') && executable('cat')
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200421 # check with non-null job and channel, types must match
Bram Moolenaarc785b9a2020-06-19 18:34:15 +0200422 thejob = job_start("cat ", #{})
423 thechannel = job_getchannel(thejob)
424 job_stop(thejob, 'kill')
425 endif
Bram Moolenaar2c869de2020-04-02 19:12:08 +0200426 endif
Bram Moolenaar585fea72020-04-02 22:33:21 +0200427
428 let nr = 1234 | nr = 5678
429 assert_equal(5678, nr)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100430enddef
431
Bram Moolenaar47a519a2020-06-14 23:05:10 +0200432def Test_assignment_var_list()
433 let v1: string
434 let v2: string
Bram Moolenaar9af78762020-06-16 11:34:42 +0200435 let vrem: list<string>
436 [v1] = ['aaa']
437 assert_equal('aaa', v1)
438
Bram Moolenaar47a519a2020-06-14 23:05:10 +0200439 [v1, v2] = ['one', 'two']
440 assert_equal('one', v1)
441 assert_equal('two', v2)
Bram Moolenaar9af78762020-06-16 11:34:42 +0200442
443 [v1, v2; vrem] = ['one', 'two']
444 assert_equal('one', v1)
445 assert_equal('two', v2)
446 assert_equal([], vrem)
447
448 [v1, v2; vrem] = ['one', 'two', 'three']
449 assert_equal('one', v1)
450 assert_equal('two', v2)
451 assert_equal(['three'], vrem)
Bram Moolenaar1c199f92020-08-07 21:28:34 +0200452
453 [&ts, &sw] = [3, 4]
454 assert_equal(3, &ts)
455 assert_equal(4, &sw)
456 set ts=8 sw=4
Bram Moolenaar47a519a2020-06-14 23:05:10 +0200457enddef
458
Bram Moolenaarc7e44a72020-07-29 21:37:43 +0200459def Test_assignment_vim9script()
460 let lines =<< trim END
461 vim9script
462 def Func(): list<number>
463 return [1, 2]
464 enddef
465 let var1: number
466 let var2: number
467 [var1, var2] =
468 Func()
469 assert_equal(1, var1)
470 assert_equal(2, var2)
471 let ll =
472 Func()
473 assert_equal([1, 2], ll)
Bram Moolenaar83144542020-08-02 20:40:43 +0200474
475 @/ = 'text'
476 assert_equal('text', @/)
477 @0 = 'zero'
478 assert_equal('zero', @0)
479 @1 = 'one'
480 assert_equal('one', @1)
481 @9 = 'nine'
482 assert_equal('nine', @9)
483 @- = 'minus'
484 assert_equal('minus', @-)
485 if has('clipboard_working')
486 @* = 'star'
487 assert_equal('star', @*)
488 @+ = 'plus'
489 assert_equal('plus', @+)
490 endif
Bram Moolenaar95dd9f22020-08-07 19:28:08 +0200491
492 let a: number = 123
493 assert_equal(123, a)
494 let s: string = 'yes'
495 assert_equal('yes', s)
496 let b: number = 42
497 assert_equal(42, b)
498 let w: number = 43
499 assert_equal(43, w)
500 let t: number = 44
501 assert_equal(44, t)
Bram Moolenaarc7e44a72020-07-29 21:37:43 +0200502 END
503 CheckScriptSuccess(lines)
504enddef
505
Bram Moolenaarcab27672020-04-09 20:10:55 +0200506def Mess(): string
507 v:foldstart = 123
508 return 'xxx'
509enddef
510
Bram Moolenaard72c1bf2020-04-19 16:28:59 +0200511def Test_assignment_failure()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100512 call CheckDefFailure(['let var=234'], 'E1004:')
513 call CheckDefFailure(['let var =234'], 'E1004:')
514 call CheckDefFailure(['let var= 234'], 'E1004:')
515
Bram Moolenaar63be3d42020-07-23 13:11:37 +0200516 call CheckScriptFailure(['vim9script', 'let var=234'], 'E1004:')
517 call CheckScriptFailure(['vim9script', 'let var=234'], "before and after '='")
518 call CheckScriptFailure(['vim9script', 'let var =234'], 'E1004:')
519 call CheckScriptFailure(['vim9script', 'let var= 234'], 'E1004:')
520 call CheckScriptFailure(['vim9script', 'let var = 234', 'var+=234'], 'E1004:')
521 call CheckScriptFailure(['vim9script', 'let var = 234', 'var+=234'], "before and after '+='")
522 call CheckScriptFailure(['vim9script', 'let var = "x"', 'var..="y"'], 'E1004:')
523 call CheckScriptFailure(['vim9script', 'let var = "x"', 'var..="y"'], "before and after '..='")
524
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100525 call CheckDefFailure(['let true = 1'], 'E1034:')
526 call CheckDefFailure(['let false = 1'], 'E1034:')
527
Bram Moolenaar9b7bf9e2020-07-11 22:14:59 +0200528 call CheckDefFailure(['[a; b; c] = g:list'], 'E452:')
Bram Moolenaar9af78762020-06-16 11:34:42 +0200529 call CheckDefExecFailure(['let a: number',
530 '[a] = test_null_list()'], 'E1093:')
531 call CheckDefExecFailure(['let a: number',
532 '[a] = []'], 'E1093:')
533 call CheckDefExecFailure(['let x: number',
534 'let y: number',
535 '[x, y] = [1]'], 'E1093:')
536 call CheckDefExecFailure(['let x: number',
537 'let y: number',
538 'let z: list<number>',
539 '[x, y; z] = [1]'], 'E1093:')
Bram Moolenaar9be61bb2020-03-30 22:51:24 +0200540
Bram Moolenaare69f6d02020-04-01 22:11:01 +0200541 call CheckDefFailure(['let somevar'], "E1022:")
Bram Moolenaarc2ee44c2020-08-02 16:59:00 +0200542 call CheckDefFailure(['let &tabstop = 4'], 'E1052:')
Bram Moolenaar9be61bb2020-03-30 22:51:24 +0200543 call CheckDefFailure(['&g:option = 5'], 'E113:')
Bram Moolenaarc2ee44c2020-08-02 16:59:00 +0200544 call CheckScriptFailure(['vim9script', 'let &tabstop = 4'], 'E1052:')
Bram Moolenaar9be61bb2020-03-30 22:51:24 +0200545
Bram Moolenaare55b1c02020-06-21 15:52:59 +0200546 call CheckDefFailure(['let $VAR = 5'], 'E1016: Cannot declare an environment variable:')
Bram Moolenaarc2ee44c2020-08-02 16:59:00 +0200547 call CheckScriptFailure(['vim9script', 'let $ENV = "xxx"'], 'E1016:')
Bram Moolenaar9be61bb2020-03-30 22:51:24 +0200548
Bram Moolenaar434d72c2020-08-02 20:03:25 +0200549 if has('dnd')
550 call CheckDefFailure(['let @~ = 5'], 'E1066:')
551 else
552 call CheckDefFailure(['let @~ = 5'], 'E354:')
553 call CheckDefFailure(['@~ = 5'], 'E354:')
554 endif
Bram Moolenaar9be61bb2020-03-30 22:51:24 +0200555 call CheckDefFailure(['let @a = 5'], 'E1066:')
Bram Moolenaar65821722020-08-02 18:58:54 +0200556 call CheckDefFailure(['let @/ = "x"'], 'E1066:')
Bram Moolenaarc2ee44c2020-08-02 16:59:00 +0200557 call CheckScriptFailure(['vim9script', 'let @a = "abc"'], 'E1066:')
Bram Moolenaar9be61bb2020-03-30 22:51:24 +0200558
Bram Moolenaare55b1c02020-06-21 15:52:59 +0200559 call CheckDefFailure(['let g:var = 5'], 'E1016: Cannot declare a global variable:')
560 call CheckDefFailure(['let w:var = 5'], 'E1016: Cannot declare a window variable:')
561 call CheckDefFailure(['let b:var = 5'], 'E1016: Cannot declare a buffer variable:')
562 call CheckDefFailure(['let t:var = 5'], 'E1016: Cannot declare a tab variable:')
Bram Moolenaar9be61bb2020-03-30 22:51:24 +0200563
564 call CheckDefFailure(['let anr = 4', 'anr ..= "text"'], 'E1019:')
565 call CheckDefFailure(['let xnr += 4'], 'E1020:')
566
Bram Moolenaar451c2e32020-08-15 16:33:28 +0200567 call CheckScriptFailure(['vim9script', 'def Func()', 'let dummy = s:notfound', 'enddef', 'defcompile'], 'E1108:')
Bram Moolenaar33fa29c2020-03-28 19:41:33 +0100568
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100569 call CheckDefFailure(['let var: list<string> = [123]'], 'expected list<string> but got list<number>')
570 call CheckDefFailure(['let var: list<number> = ["xx"]'], 'expected list<number> but got list<string>')
571
572 call CheckDefFailure(['let var: dict<string> = #{key: 123}'], 'expected dict<string> but got dict<number>')
573 call CheckDefFailure(['let var: dict<number> = #{key: "xx"}'], 'expected dict<number> but got dict<string>')
574
575 call CheckDefFailure(['let var = feedkeys("0")'], 'E1031:')
576 call CheckDefFailure(['let var: number = feedkeys("0")'], 'expected number but got void')
Bram Moolenaar42a480b2020-02-29 23:23:47 +0100577
Bram Moolenaard77a8522020-04-03 21:59:57 +0200578 call CheckDefFailure(['let var: dict <number>'], 'E1068:')
Bram Moolenaar42a480b2020-02-29 23:23:47 +0100579 call CheckDefFailure(['let var: dict<number'], 'E1009:')
Bram Moolenaarcab27672020-04-09 20:10:55 +0200580
581 call assert_fails('s/^/\=Mess()/n', 'E794:')
582 call CheckDefFailure(['let var: dict<number'], 'E1009:')
Bram Moolenaar43e969d2020-07-23 21:14:43 +0200583
584 call CheckDefFailure(['w:foo: number = 10'],
585 'E488: Trailing characters: : number = 1')
586 call CheckDefFailure(['t:foo: bool = true'],
587 'E488: Trailing characters: : bool = true')
588 call CheckDefFailure(['b:foo: string = "x"'],
589 'E488: Trailing characters: : string = "x"')
590 call CheckDefFailure(['g:foo: number = 123'],
591 'E488: Trailing characters: : number = 123')
Bram Moolenaard72c1bf2020-04-19 16:28:59 +0200592enddef
593
594def Test_unlet()
595 g:somevar = 'yes'
596 assert_true(exists('g:somevar'))
597 unlet g:somevar
598 assert_false(exists('g:somevar'))
599 unlet! g:somevar
600
601 call CheckScriptFailure([
602 'vim9script',
603 'let svar = 123',
604 'unlet svar',
605 ], 'E1081:')
606 call CheckScriptFailure([
607 'vim9script',
608 'let svar = 123',
609 'unlet s:svar',
610 ], 'E1081:')
611 call CheckScriptFailure([
612 'vim9script',
613 'let svar = 123',
614 'def Func()',
615 ' unlet svar',
616 'enddef',
Bram Moolenaar822ba242020-05-24 23:00:18 +0200617 'defcompile',
Bram Moolenaard72c1bf2020-04-19 16:28:59 +0200618 ], 'E1081:')
619 call CheckScriptFailure([
620 'vim9script',
621 'let svar = 123',
622 'def Func()',
623 ' unlet s:svar',
624 'enddef',
Bram Moolenaar822ba242020-05-24 23:00:18 +0200625 'defcompile',
Bram Moolenaard72c1bf2020-04-19 16:28:59 +0200626 ], 'E1081:')
Bram Moolenaar7bdaea62020-04-19 18:27:26 +0200627
628 $ENVVAR = 'foobar'
629 assert_equal('foobar', $ENVVAR)
630 unlet $ENVVAR
631 assert_equal('', $ENVVAR)
Bram Moolenaard72c1bf2020-04-19 16:28:59 +0200632enddef
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100633
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200634def Test_delfunction()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200635 # Check function is defined in script namespace
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200636 CheckScriptSuccess([
637 'vim9script',
638 'func CheckMe()',
639 ' return 123',
640 'endfunc',
641 'assert_equal(123, s:CheckMe())',
642 ])
643
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200644 # Check function in script namespace cannot be deleted
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200645 CheckScriptFailure([
646 'vim9script',
647 'func DeleteMe1()',
648 'endfunc',
649 'delfunction DeleteMe1',
650 ], 'E1084:')
651 CheckScriptFailure([
652 'vim9script',
653 'func DeleteMe2()',
654 'endfunc',
655 'def DoThat()',
656 ' delfunction DeleteMe2',
657 'enddef',
658 'DoThat()',
659 ], 'E1084:')
660 CheckScriptFailure([
661 'vim9script',
662 'def DeleteMe3()',
663 'enddef',
664 'delfunction DeleteMe3',
665 ], 'E1084:')
666 CheckScriptFailure([
667 'vim9script',
668 'def DeleteMe4()',
669 'enddef',
670 'def DoThat()',
671 ' delfunction DeleteMe4',
672 'enddef',
673 'DoThat()',
674 ], 'E1084:')
Bram Moolenaar925e9fd2020-07-25 15:41:11 +0200675
676 # Check that global :def function can be replaced and deleted
677 let lines =<< trim END
678 vim9script
679 def g:Global(): string
680 return "yes"
681 enddef
682 assert_equal("yes", g:Global())
683 def! g:Global(): string
684 return "no"
685 enddef
686 assert_equal("no", g:Global())
687 delfunc g:Global
688 assert_false(exists('*g:Global'))
689 END
690 CheckScriptSuccess(lines)
691
692 # Check that global function can be replaced by a :def function and deleted
693 lines =<< trim END
694 vim9script
695 func g:Global()
696 return "yes"
697 endfunc
698 assert_equal("yes", g:Global())
699 def! g:Global(): string
700 return "no"
701 enddef
702 assert_equal("no", g:Global())
703 delfunc g:Global
704 assert_false(exists('*g:Global'))
705 END
706 CheckScriptSuccess(lines)
707
708 # Check that global :def function can be replaced by a function and deleted
709 lines =<< trim END
710 vim9script
711 def g:Global(): string
712 return "yes"
713 enddef
714 assert_equal("yes", g:Global())
715 func! g:Global()
716 return "no"
717 endfunc
718 assert_equal("no", g:Global())
719 delfunc g:Global
720 assert_false(exists('*g:Global'))
721 END
722 CheckScriptSuccess(lines)
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200723enddef
724
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100725func Test_wrong_type()
726 call CheckDefFailure(['let var: list<nothing>'], 'E1010:')
727 call CheckDefFailure(['let var: list<list<nothing>>'], 'E1010:')
728 call CheckDefFailure(['let var: dict<nothing>'], 'E1010:')
729 call CheckDefFailure(['let var: dict<dict<nothing>>'], 'E1010:')
730
731 call CheckDefFailure(['let var: dict<number'], 'E1009:')
732 call CheckDefFailure(['let var: dict<list<number>'], 'E1009:')
Bram Moolenaar42a480b2020-02-29 23:23:47 +0100733
734 call CheckDefFailure(['let var: ally'], 'E1010:')
735 call CheckDefFailure(['let var: bram'], 'E1010:')
736 call CheckDefFailure(['let var: cathy'], 'E1010:')
737 call CheckDefFailure(['let var: dom'], 'E1010:')
738 call CheckDefFailure(['let var: freddy'], 'E1010:')
739 call CheckDefFailure(['let var: john'], 'E1010:')
740 call CheckDefFailure(['let var: larry'], 'E1010:')
741 call CheckDefFailure(['let var: ned'], 'E1010:')
742 call CheckDefFailure(['let var: pam'], 'E1010:')
743 call CheckDefFailure(['let var: sam'], 'E1010:')
744 call CheckDefFailure(['let var: vim'], 'E1010:')
Bram Moolenaara0a9f432020-04-28 21:29:34 +0200745
746 call CheckDefFailure(['let Ref: number', 'Ref()'], 'E1085:')
747 call CheckDefFailure(['let Ref: string', 'let res = Ref()'], 'E1085:')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100748endfunc
749
750func Test_const()
751 call CheckDefFailure(['const var = 234', 'var = 99'], 'E1018:')
752 call CheckDefFailure(['const one = 234', 'let one = 99'], 'E1017:')
753 call CheckDefFailure(['const two'], 'E1021:')
Bram Moolenaar9be61bb2020-03-30 22:51:24 +0200754 call CheckDefFailure(['const &option'], 'E996:')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100755endfunc
756
Bram Moolenaardf069ee2020-06-22 23:02:51 +0200757def Test_range_no_colon()
758 call CheckDefFailure(['%s/a/b/'], 'E1050:')
759 call CheckDefFailure(['+ s/a/b/'], 'E1050:')
760 call CheckDefFailure(['- s/a/b/'], 'E1050:')
761 call CheckDefFailure(['. s/a/b/'], 'E1050:')
762enddef
763
764
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100765def Test_block()
766 let outer = 1
767 {
768 let inner = 2
769 assert_equal(1, outer)
770 assert_equal(2, inner)
771 }
772 assert_equal(1, outer)
773enddef
774
775func Test_block_failure()
776 call CheckDefFailure(['{', 'let inner = 1', '}', 'echo inner'], 'E1001:')
Bram Moolenaar585fea72020-04-02 22:33:21 +0200777 call CheckDefFailure(['}'], 'E1025:')
778 call CheckDefFailure(['{', 'echo 1'], 'E1026:')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100779endfunc
780
Bram Moolenaard032f342020-07-18 18:13:02 +0200781func g:NoSuchFunc()
782 echo 'none'
783endfunc
784
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100785def Test_try_catch()
786 let l = []
Bram Moolenaar7a092242020-04-16 22:10:49 +0200787 try # comment
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100788 add(l, '1')
789 throw 'wrong'
790 add(l, '2')
Bram Moolenaar7a092242020-04-16 22:10:49 +0200791 catch # comment
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100792 add(l, v:exception)
Bram Moolenaar7a092242020-04-16 22:10:49 +0200793 finally # comment
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100794 add(l, '3')
Bram Moolenaar7a092242020-04-16 22:10:49 +0200795 endtry # comment
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100796 assert_equal(['1', 'wrong', '3'], l)
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200797
Bram Moolenaare8593122020-07-18 15:17:02 +0200798 l = []
799 try
800 try
801 add(l, '1')
802 throw 'wrong'
803 add(l, '2')
804 catch /right/
805 add(l, v:exception)
806 endtry
807 catch /wrong/
808 add(l, 'caught')
809 finally
810 add(l, 'finally')
811 endtry
812 assert_equal(['1', 'caught', 'finally'], l)
813
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200814 let n: number
815 try
816 n = l[3]
817 catch /E684:/
818 n = 99
819 endtry
820 assert_equal(99, n)
821
822 try
Bram Moolenaarcc673e72020-08-16 17:33:35 +0200823 # string slice returns a string, not a number
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200824 n = g:astring[3]
Bram Moolenaar56acb092020-08-16 14:48:19 +0200825 catch /E1029:/
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200826 n = 77
827 endtry
828 assert_equal(77, n)
829
830 try
831 n = l[g:astring]
Bram Moolenaar56acb092020-08-16 14:48:19 +0200832 catch /E1029:/
833 n = 88
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200834 endtry
Bram Moolenaar56acb092020-08-16 14:48:19 +0200835 assert_equal(88, n)
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200836
837 try
838 n = s:does_not_exist
839 catch /E121:/
Bram Moolenaarf0b9f432020-07-17 23:03:17 +0200840 n = 111
841 endtry
842 assert_equal(111, n)
843
844 try
845 n = g:does_not_exist
846 catch /E121:/
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200847 n = 121
848 endtry
849 assert_equal(121, n)
850
851 let d = #{one: 1}
852 try
853 n = d[g:astring]
854 catch /E716:/
855 n = 222
856 endtry
857 assert_equal(222, n)
Bram Moolenaarf0b9f432020-07-17 23:03:17 +0200858
859 try
860 n = -g:astring
861 catch /E39:/
862 n = 233
863 endtry
864 assert_equal(233, n)
865
866 try
867 n = +g:astring
868 catch /E1030:/
869 n = 244
870 endtry
871 assert_equal(244, n)
872
873 try
874 n = +g:alist
875 catch /E745:/
876 n = 255
877 endtry
878 assert_equal(255, n)
879
880 let nd: dict<any>
881 try
882 nd = {g:anumber: 1}
883 catch /E1029:/
884 n = 266
885 endtry
886 assert_equal(266, n)
887
888 try
889 [n] = [1, 2, 3]
890 catch /E1093:/
891 n = 277
892 endtry
893 assert_equal(277, n)
894
Bram Moolenaare8593122020-07-18 15:17:02 +0200895 try
896 &ts = g:astring
897 catch /E1029:/
898 n = 288
899 endtry
900 assert_equal(288, n)
901
902 try
903 &backspace = 'asdf'
904 catch /E474:/
905 n = 299
906 endtry
907 assert_equal(299, n)
908
909 l = [1]
910 try
911 l[3] = 3
912 catch /E684:/
913 n = 300
914 endtry
915 assert_equal(300, n)
916
917 try
Bram Moolenaare8593122020-07-18 15:17:02 +0200918 unlet g:does_not_exist
919 catch /E108:/
920 n = 322
921 endtry
922 assert_equal(322, n)
923
924 try
925 d = {'text': 1, g:astring: 2}
926 catch /E721:/
927 n = 333
928 endtry
929 assert_equal(333, n)
930
931 try
932 l = DeletedFunc()
933 catch /E933:/
934 n = 344
935 endtry
936 assert_equal(344, n)
Bram Moolenaard032f342020-07-18 18:13:02 +0200937
938 try
939 echo len(v:true)
940 catch /E701:/
941 n = 355
942 endtry
943 assert_equal(355, n)
944
945 let P = function('g:NoSuchFunc')
946 delfunc g:NoSuchFunc
947 try
948 echo P()
949 catch /E117:/
950 n = 366
951 endtry
952 assert_equal(366, n)
953
954 try
955 echo g:NoSuchFunc()
956 catch /E117:/
957 n = 377
958 endtry
959 assert_equal(377, n)
960
961 try
962 echo g:alist + 4
963 catch /E745:/
964 n = 388
965 endtry
966 assert_equal(388, n)
967
968 try
969 echo 4 + g:alist
970 catch /E745:/
971 n = 399
972 endtry
973 assert_equal(399, n)
974
975 try
976 echo g:alist.member
977 catch /E715:/
978 n = 400
979 endtry
980 assert_equal(400, n)
981
982 try
983 echo d.member
984 catch /E716:/
985 n = 411
986 endtry
987 assert_equal(411, n)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100988enddef
989
Bram Moolenaare8593122020-07-18 15:17:02 +0200990def DeletedFunc(): list<any>
991 return ['delete me']
992enddef
993defcompile
994delfunc DeletedFunc
995
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100996def ThrowFromDef()
Bram Moolenaara72cfb82020-04-23 17:07:30 +0200997 throw "getout" # comment
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100998enddef
999
1000func CatchInFunc()
1001 try
1002 call ThrowFromDef()
1003 catch
1004 let g:thrown_func = v:exception
1005 endtry
1006endfunc
1007
1008def CatchInDef()
1009 try
1010 ThrowFromDef()
1011 catch
1012 g:thrown_def = v:exception
1013 endtry
1014enddef
1015
Bram Moolenaarf575adf2020-02-20 20:41:06 +01001016def ReturnFinally(): string
1017 try
1018 return 'intry'
1019 finally
1020 g:in_finally = 'finally'
1021 endtry
1022 return 'end'
1023enddef
1024
Bram Moolenaar257cc5e2020-02-19 17:06:11 +01001025def Test_try_catch_nested()
1026 CatchInFunc()
1027 assert_equal('getout', g:thrown_func)
1028
1029 CatchInDef()
1030 assert_equal('getout', g:thrown_def)
Bram Moolenaarf575adf2020-02-20 20:41:06 +01001031
1032 assert_equal('intry', ReturnFinally())
1033 assert_equal('finally', g:in_finally)
1034enddef
1035
1036def Test_try_catch_match()
1037 let seq = 'a'
1038 try
1039 throw 'something'
1040 catch /nothing/
1041 seq ..= 'x'
1042 catch /some/
1043 seq ..= 'b'
1044 catch /asdf/
1045 seq ..= 'x'
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001046 catch ?a\?sdf?
1047 seq ..= 'y'
Bram Moolenaarf575adf2020-02-20 20:41:06 +01001048 finally
1049 seq ..= 'c'
1050 endtry
1051 assert_equal('abc', seq)
Bram Moolenaar257cc5e2020-02-19 17:06:11 +01001052enddef
1053
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001054def Test_try_catch_fails()
1055 call CheckDefFailure(['catch'], 'E603:')
Bram Moolenaar6b7a0a82020-07-08 18:38:08 +02001056 call CheckDefFailure(['try', 'echo 0', 'catch', 'catch'], 'E1033:')
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001057 call CheckDefFailure(['try', 'echo 0', 'catch /pat'], 'E1067:')
Bram Moolenaar585fea72020-04-02 22:33:21 +02001058 call CheckDefFailure(['finally'], 'E606:')
1059 call CheckDefFailure(['try', 'echo 0', 'finally', 'echo 1', 'finally'], 'E607:')
1060 call CheckDefFailure(['endtry'], 'E602:')
1061 call CheckDefFailure(['while 1', 'endtry'], 'E170:')
1062 call CheckDefFailure(['for i in range(5)', 'endtry'], 'E170:')
1063 call CheckDefFailure(['if 2', 'endtry'], 'E171:')
1064 call CheckDefFailure(['try', 'echo 1', 'endtry'], 'E1032:')
1065
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001066 call CheckDefFailure(['throw'], 'E1015:')
Bram Moolenaar585fea72020-04-02 22:33:21 +02001067 call CheckDefFailure(['throw xxx'], 'E1001:')
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001068enddef
1069
Bram Moolenaar006ad482020-06-30 20:55:15 +02001070def Test_throw_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001071 # only checks line continuation
Bram Moolenaar006ad482020-06-30 20:55:15 +02001072 let lines =<< trim END
1073 vim9script
1074 try
1075 throw 'one'
1076 .. 'two'
1077 catch
1078 assert_equal('onetwo', v:exception)
1079 endtry
1080 END
1081 CheckScriptSuccess(lines)
1082enddef
1083
Bram Moolenaared677f52020-08-12 16:38:10 +02001084def Test_error_in_nested_function()
1085 # an error in a nested :function aborts executin in the calling :def function
1086 let lines =<< trim END
1087 vim9script
1088 def Func()
1089 Error()
1090 g:test_var = 1
1091 enddef
1092 func Error() abort
1093 eval [][0]
1094 endfunc
1095 Func()
1096 END
1097 g:test_var = 0
1098 CheckScriptFailure(lines, 'E684:')
1099 assert_equal(0, g:test_var)
1100enddef
1101
Bram Moolenaar37c83712020-06-30 21:18:36 +02001102def Test_cexpr_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001103 # only checks line continuation
Bram Moolenaar37c83712020-06-30 21:18:36 +02001104 set errorformat=File\ %f\ line\ %l
1105 let lines =<< trim END
1106 vim9script
1107 cexpr 'File'
1108 .. ' someFile' ..
1109 ' line 19'
1110 assert_equal(19, getqflist()[0].lnum)
1111 END
1112 CheckScriptSuccess(lines)
1113 set errorformat&
1114enddef
1115
Bram Moolenaarc9edd6b2020-08-12 22:18:23 +02001116def Test_statusline_syntax()
1117 # legacy syntax is used for 'statusline'
1118 let lines =<< trim END
1119 vim9script
1120 func g:Status()
1121 return '%{"x" is# "x"}'
1122 endfunc
1123 set laststatus=2 statusline=%!Status()
1124 redrawstatus
1125 set laststatus statusline=
1126 END
1127 CheckScriptSuccess(lines)
1128enddef
1129
Bram Moolenaarb2097502020-07-19 17:17:02 +02001130def Test_list_vimscript()
1131 # checks line continuation and comments
1132 let lines =<< trim END
1133 vim9script
1134 let mylist = [
1135 'one',
1136 # comment
1137 'two', # empty line follows
1138
1139 'three',
1140 ]
1141 assert_equal(['one', 'two', 'three'], mylist)
1142 END
1143 CheckScriptSuccess(lines)
Bram Moolenaar66250c92020-08-20 15:02:42 +02001144
1145 # check all lines from heredoc are kept
1146 lines =<< trim END
1147 # comment 1
1148 two
1149 # comment 3
1150
1151 five
1152 # comment 6
1153 END
1154 assert_equal(['# comment 1', 'two', '# comment 3', '', 'five', '# comment 6'], lines)
Bram Moolenaarb2097502020-07-19 17:17:02 +02001155enddef
1156
Bram Moolenaar2a1381c2020-05-05 23:32:58 +02001157if has('channel')
1158 let someJob = test_null_job()
Bram Moolenaar40ee4662020-05-05 22:08:26 +02001159
Bram Moolenaar2a1381c2020-05-05 23:32:58 +02001160 def FuncWithError()
1161 echomsg g:someJob
1162 enddef
Bram Moolenaar40ee4662020-05-05 22:08:26 +02001163
Bram Moolenaar2a1381c2020-05-05 23:32:58 +02001164 func Test_convert_emsg_to_exception()
1165 try
1166 call FuncWithError()
1167 catch
1168 call assert_match('Vim:E908:', v:exception)
1169 endtry
1170 endfunc
1171endif
Bram Moolenaar40ee4662020-05-05 22:08:26 +02001172
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001173let s:export_script_lines =<< trim END
1174 vim9script
1175 let name: string = 'bob'
1176 def Concat(arg: string): string
1177 return name .. arg
1178 enddef
Bram Moolenaar227a69d2020-05-15 18:17:28 +02001179 g:result = Concat('bie')
1180 g:localname = name
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001181
1182 export const CONST = 1234
1183 export let exported = 9876
Bram Moolenaar6e587dc2020-02-06 13:15:52 +01001184 export let exp_name = 'John'
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001185 export def Exported(): string
1186 return 'Exported'
1187 enddef
1188END
1189
Bram Moolenaarb3ca9822020-08-09 14:43:58 +02001190def Undo_export_script_lines()
1191 unlet g:result
1192 unlet g:localname
1193enddef
1194
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001195def Test_vim9_import_export()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001196 let import_script_lines =<< trim END
1197 vim9script
1198 import {exported, Exported} from './Xexport.vim'
1199 g:imported = exported
Bram Moolenaar6e587dc2020-02-06 13:15:52 +01001200 exported += 3
1201 g:imported_added = exported
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001202 g:imported_func = Exported()
Bram Moolenaar6e587dc2020-02-06 13:15:52 +01001203
Bram Moolenaar40f4f7a2020-07-23 22:41:43 +02001204 def GetExported(): string
1205 let local_dict = #{ref: Exported}
1206 return local_dict.ref()
1207 enddef
1208 g:funcref_result = GetExported()
1209
Bram Moolenaar6e587dc2020-02-06 13:15:52 +01001210 import {exp_name} from './Xexport.vim'
1211 g:imported_name = exp_name
1212 exp_name ..= ' Doe'
1213 g:imported_name_appended = exp_name
Bram Moolenaar5381c7a2020-03-02 22:53:32 +01001214 g:imported_later = exported
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001215 END
1216
1217 writefile(import_script_lines, 'Ximport.vim')
1218 writefile(s:export_script_lines, 'Xexport.vim')
1219
1220 source Ximport.vim
1221
1222 assert_equal('bobbie', g:result)
1223 assert_equal('bob', g:localname)
1224 assert_equal(9876, g:imported)
Bram Moolenaar6e587dc2020-02-06 13:15:52 +01001225 assert_equal(9879, g:imported_added)
Bram Moolenaar5381c7a2020-03-02 22:53:32 +01001226 assert_equal(9879, g:imported_later)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001227 assert_equal('Exported', g:imported_func)
Bram Moolenaar40f4f7a2020-07-23 22:41:43 +02001228 assert_equal('Exported', g:funcref_result)
Bram Moolenaar6e587dc2020-02-06 13:15:52 +01001229 assert_equal('John', g:imported_name)
1230 assert_equal('John Doe', g:imported_name_appended)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001231 assert_false(exists('g:name'))
1232
Bram Moolenaarb3ca9822020-08-09 14:43:58 +02001233 Undo_export_script_lines()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001234 unlet g:imported
Bram Moolenaar6e587dc2020-02-06 13:15:52 +01001235 unlet g:imported_added
Bram Moolenaar5381c7a2020-03-02 22:53:32 +01001236 unlet g:imported_later
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001237 unlet g:imported_func
Bram Moolenaar6e587dc2020-02-06 13:15:52 +01001238 unlet g:imported_name g:imported_name_appended
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001239 delete('Ximport.vim')
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01001240
Bram Moolenaar1c991142020-07-04 13:15:31 +02001241 # similar, with line breaks
1242 let import_line_break_script_lines =<< trim END
1243 vim9script
1244 import {
1245 exported,
1246 Exported,
1247 }
1248 from
1249 './Xexport.vim'
1250 g:imported = exported
1251 exported += 5
1252 g:imported_added = exported
1253 g:imported_func = Exported()
1254 END
1255 writefile(import_line_break_script_lines, 'Ximport_lbr.vim')
1256 source Ximport_lbr.vim
1257
1258 assert_equal(9876, g:imported)
1259 assert_equal(9881, g:imported_added)
1260 assert_equal('Exported', g:imported_func)
1261
1262 # exported script not sourced again
1263 assert_false(exists('g:result'))
1264 unlet g:imported
1265 unlet g:imported_added
1266 unlet g:imported_func
1267 delete('Ximport_lbr.vim')
1268
1269 # import inside :def function
Bram Moolenaar5381c7a2020-03-02 22:53:32 +01001270 let import_in_def_lines =<< trim END
1271 vim9script
1272 def ImportInDef()
1273 import exported from './Xexport.vim'
1274 g:imported = exported
1275 exported += 7
1276 g:imported_added = exported
1277 enddef
1278 ImportInDef()
1279 END
1280 writefile(import_in_def_lines, 'Ximport2.vim')
1281 source Ximport2.vim
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001282 # TODO: this should be 9879
Bram Moolenaar5381c7a2020-03-02 22:53:32 +01001283 assert_equal(9876, g:imported)
1284 assert_equal(9883, g:imported_added)
1285 unlet g:imported
1286 unlet g:imported_added
1287 delete('Ximport2.vim')
1288
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01001289 let import_star_as_lines =<< trim END
1290 vim9script
1291 import * as Export from './Xexport.vim'
1292 def UseExport()
1293 g:imported = Export.exported
1294 enddef
1295 UseExport()
1296 END
1297 writefile(import_star_as_lines, 'Ximport.vim')
1298 source Ximport.vim
Bram Moolenaar5381c7a2020-03-02 22:53:32 +01001299 assert_equal(9883, g:imported)
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01001300
Bram Moolenaar599c89c2020-03-28 14:53:20 +01001301 let import_star_as_lines_no_dot =<< trim END
1302 vim9script
1303 import * as Export from './Xexport.vim'
1304 def Func()
1305 let dummy = 1
1306 let imported = Export + dummy
1307 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +02001308 defcompile
Bram Moolenaar599c89c2020-03-28 14:53:20 +01001309 END
1310 writefile(import_star_as_lines_no_dot, 'Ximport.vim')
1311 assert_fails('source Ximport.vim', 'E1060:')
1312
1313 let import_star_as_lines_dot_space =<< trim END
1314 vim9script
1315 import * as Export from './Xexport.vim'
1316 def Func()
1317 let imported = Export . exported
1318 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +02001319 defcompile
Bram Moolenaar599c89c2020-03-28 14:53:20 +01001320 END
1321 writefile(import_star_as_lines_dot_space, 'Ximport.vim')
1322 assert_fails('source Ximport.vim', 'E1074:')
1323
1324 let import_star_as_lines_missing_name =<< trim END
1325 vim9script
1326 import * as Export from './Xexport.vim'
1327 def Func()
1328 let imported = Export.
1329 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +02001330 defcompile
Bram Moolenaar599c89c2020-03-28 14:53:20 +01001331 END
1332 writefile(import_star_as_lines_missing_name, 'Ximport.vim')
1333 assert_fails('source Ximport.vim', 'E1048:')
1334
Bram Moolenaar1c991142020-07-04 13:15:31 +02001335 let import_star_as_lbr_lines =<< trim END
1336 vim9script
1337 import *
1338 as Export
1339 from
1340 './Xexport.vim'
1341 def UseExport()
1342 g:imported = Export.exported
1343 enddef
1344 UseExport()
1345 END
1346 writefile(import_star_as_lbr_lines, 'Ximport.vim')
1347 source Ximport.vim
1348 assert_equal(9883, g:imported)
1349
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01001350 let import_star_lines =<< trim END
1351 vim9script
1352 import * from './Xexport.vim'
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01001353 END
1354 writefile(import_star_lines, 'Ximport.vim')
1355 assert_fails('source Ximport.vim', 'E1045:')
1356
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001357 # try to import something that exists but is not exported
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001358 let import_not_exported_lines =<< trim END
1359 vim9script
1360 import name from './Xexport.vim'
1361 END
1362 writefile(import_not_exported_lines, 'Ximport.vim')
1363 assert_fails('source Ximport.vim', 'E1049:')
1364
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001365 # try to import something that is already defined
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001366 let import_already_defined =<< trim END
1367 vim9script
1368 let exported = 'something'
1369 import exported from './Xexport.vim'
1370 END
1371 writefile(import_already_defined, 'Ximport.vim')
1372 assert_fails('source Ximport.vim', 'E1073:')
1373
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001374 # try to import something that is already defined
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001375 import_already_defined =<< trim END
1376 vim9script
1377 let exported = 'something'
1378 import * as exported from './Xexport.vim'
1379 END
1380 writefile(import_already_defined, 'Ximport.vim')
1381 assert_fails('source Ximport.vim', 'E1073:')
1382
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001383 # try to import something that is already defined
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001384 import_already_defined =<< trim END
1385 vim9script
1386 let exported = 'something'
1387 import {exported} from './Xexport.vim'
1388 END
1389 writefile(import_already_defined, 'Ximport.vim')
1390 assert_fails('source Ximport.vim', 'E1073:')
1391
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001392 # import a very long name, requires making a copy
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001393 let import_long_name_lines =<< trim END
1394 vim9script
1395 import name012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789 from './Xexport.vim'
1396 END
1397 writefile(import_long_name_lines, 'Ximport.vim')
1398 assert_fails('source Ximport.vim', 'E1048:')
1399
1400 let import_no_from_lines =<< trim END
1401 vim9script
1402 import name './Xexport.vim'
1403 END
1404 writefile(import_no_from_lines, 'Ximport.vim')
1405 assert_fails('source Ximport.vim', 'E1070:')
1406
1407 let import_invalid_string_lines =<< trim END
1408 vim9script
1409 import name from Xexport.vim
1410 END
1411 writefile(import_invalid_string_lines, 'Ximport.vim')
1412 assert_fails('source Ximport.vim', 'E1071:')
1413
1414 let import_wrong_name_lines =<< trim END
1415 vim9script
1416 import name from './XnoExport.vim'
1417 END
1418 writefile(import_wrong_name_lines, 'Ximport.vim')
1419 assert_fails('source Ximport.vim', 'E1053:')
1420
1421 let import_missing_comma_lines =<< trim END
1422 vim9script
1423 import {exported name} from './Xexport.vim'
1424 END
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001425 writefile(import_missing_comma_lines, 'Ximport3.vim')
1426 assert_fails('source Ximport3.vim', 'E1046:')
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001427
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01001428 delete('Ximport.vim')
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001429 delete('Ximport3.vim')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001430 delete('Xexport.vim')
1431
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001432 # Check that in a Vim9 script 'cpo' is set to the Vim default.
Bram Moolenaar750802b2020-02-23 18:08:33 +01001433 set cpo&vi
1434 let cpo_before = &cpo
1435 let lines =<< trim END
1436 vim9script
1437 g:cpo_in_vim9script = &cpo
1438 END
1439 writefile(lines, 'Xvim9_script')
1440 source Xvim9_script
1441 assert_equal(cpo_before, &cpo)
1442 set cpo&vim
1443 assert_equal(&cpo, g:cpo_in_vim9script)
1444 delete('Xvim9_script')
1445enddef
1446
Bram Moolenaar803af682020-08-05 16:20:03 +02001447func g:Trigger()
1448 source Ximport.vim
1449 return "echo 'yes'\<CR>"
1450endfunc
1451
1452def Test_import_export_expr_map()
1453 # check that :import and :export work when buffer is locked
1454 let export_lines =<< trim END
1455 vim9script
1456 export def That(): string
1457 return 'yes'
1458 enddef
1459 END
1460 writefile(export_lines, 'Xexport_that.vim')
1461
1462 let import_lines =<< trim END
1463 vim9script
1464 import That from './Xexport_that.vim'
1465 assert_equal('yes', That())
1466 END
1467 writefile(import_lines, 'Ximport.vim')
1468
1469 nnoremap <expr> trigger g:Trigger()
1470 feedkeys('trigger', "xt")
1471
Bram Moolenaar730b2482020-08-09 13:02:10 +02001472 delete('Xexport_that.vim')
Bram Moolenaar803af682020-08-05 16:20:03 +02001473 delete('Ximport.vim')
1474 nunmap trigger
1475enddef
1476
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001477def Test_import_in_filetype()
1478 # check that :import works when the buffer is locked
1479 mkdir('ftplugin', 'p')
1480 let export_lines =<< trim END
1481 vim9script
1482 export let That = 'yes'
1483 END
Bram Moolenaar730b2482020-08-09 13:02:10 +02001484 writefile(export_lines, 'ftplugin/Xexport_ft.vim')
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001485
1486 let import_lines =<< trim END
1487 vim9script
Bram Moolenaar730b2482020-08-09 13:02:10 +02001488 import That from './Xexport_ft.vim'
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001489 assert_equal('yes', That)
1490 g:did_load_mytpe = 1
1491 END
1492 writefile(import_lines, 'ftplugin/qf.vim')
1493
1494 let save_rtp = &rtp
1495 &rtp = getcwd() .. ',' .. &rtp
1496
1497 filetype plugin on
1498 copen
1499 assert_equal(1, g:did_load_mytpe)
1500
1501 quit!
Bram Moolenaar730b2482020-08-09 13:02:10 +02001502 delete('Xexport_ft.vim')
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001503 delete('ftplugin', 'rf')
1504 &rtp = save_rtp
1505enddef
1506
Bram Moolenaarefa94442020-08-08 22:16:00 +02001507def Test_use_import_in_mapping()
1508 let lines =<< trim END
1509 vim9script
1510 export def Funcx()
1511 g:result = 42
1512 enddef
1513 END
1514 writefile(lines, 'XsomeExport.vim')
1515 lines =<< trim END
1516 vim9script
1517 import Funcx from './XsomeExport.vim'
Bram Moolenaarb3ca9822020-08-09 14:43:58 +02001518 nnoremap <F3> :call <sid>Funcx()<cr>
Bram Moolenaarefa94442020-08-08 22:16:00 +02001519 END
1520 writefile(lines, 'Xmapscript.vim')
1521
1522 source Xmapscript.vim
Bram Moolenaarb3ca9822020-08-09 14:43:58 +02001523 feedkeys("\<F3>", "xt")
Bram Moolenaarefa94442020-08-08 22:16:00 +02001524 assert_equal(42, g:result)
1525
1526 unlet g:result
1527 delete('XsomeExport.vim')
1528 delete('Xmapscript.vim')
Bram Moolenaarb3ca9822020-08-09 14:43:58 +02001529 nunmap <F3>
Bram Moolenaarefa94442020-08-08 22:16:00 +02001530enddef
1531
Bram Moolenaar750802b2020-02-23 18:08:33 +01001532def Test_vim9script_fails()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001533 CheckScriptFailure(['scriptversion 2', 'vim9script'], 'E1039:')
1534 CheckScriptFailure(['vim9script', 'scriptversion 2'], 'E1040:')
Bram Moolenaar750802b2020-02-23 18:08:33 +01001535 CheckScriptFailure(['export let some = 123'], 'E1042:')
Bram Moolenaar9721fb42020-06-11 23:10:46 +02001536 CheckScriptFailure(['import some from "./Xexport.vim"'], 'E1048:')
Bram Moolenaar9b7bf9e2020-07-11 22:14:59 +02001537 CheckScriptFailure(['vim9script', 'export let g:some'], 'E1022:')
Bram Moolenaar750802b2020-02-23 18:08:33 +01001538 CheckScriptFailure(['vim9script', 'export echo 134'], 'E1043:')
1539
Bram Moolenaar451c2e32020-08-15 16:33:28 +02001540 CheckScriptFailure(['vim9script', 'let str: string', 'str = 1234'], 'E1012:')
Bram Moolenaarc785b9a2020-06-19 18:34:15 +02001541 CheckScriptFailure(['vim9script', 'const str = "asdf"', 'str = "xxx"'], 'E46:')
1542
Bram Moolenaar750802b2020-02-23 18:08:33 +01001543 assert_fails('vim9script', 'E1038')
Bram Moolenaara26b9702020-04-18 19:53:28 +02001544 assert_fails('export something', 'E1043')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001545enddef
1546
Bram Moolenaarf7d267e2020-06-17 12:04:54 +02001547func Test_import_fails_without_script()
Bram Moolenaar101f4812020-06-16 23:18:51 +02001548 CheckRunVimInTerminal
1549
Bram Moolenaar9bb3eb32020-06-17 20:03:36 +02001550 " call indirectly to avoid compilation error for missing functions
Bram Moolenaarc620c052020-07-08 15:16:19 +02001551 call Run_Test_import_fails_on_command_line()
Bram Moolenaar9bb3eb32020-06-17 20:03:36 +02001552endfunc
1553
Bram Moolenaarc620c052020-07-08 15:16:19 +02001554def Run_Test_import_fails_on_command_line()
Bram Moolenaar101f4812020-06-16 23:18:51 +02001555 let export =<< trim END
1556 vim9script
1557 export def Foo(): number
1558 return 0
1559 enddef
1560 END
Bram Moolenaar730b2482020-08-09 13:02:10 +02001561 writefile(export, 'XexportCmd.vim')
Bram Moolenaar101f4812020-06-16 23:18:51 +02001562
Bram Moolenaar730b2482020-08-09 13:02:10 +02001563 let buf = RunVimInTerminal('-c "import Foo from ''./XexportCmd.vim''"', #{
Bram Moolenaar9bb3eb32020-06-17 20:03:36 +02001564 rows: 6, wait_for_ruler: 0})
1565 WaitForAssert({-> assert_match('^E1094:', term_getline(buf, 5))})
Bram Moolenaar101f4812020-06-16 23:18:51 +02001566
Bram Moolenaar730b2482020-08-09 13:02:10 +02001567 delete('XexportCmd.vim')
Bram Moolenaar9bb3eb32020-06-17 20:03:36 +02001568 StopVimInTerminal(buf)
1569enddef
Bram Moolenaar101f4812020-06-16 23:18:51 +02001570
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001571def Test_vim9script_reload_import()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001572 let lines =<< trim END
1573 vim9script
1574 const var = ''
1575 let valone = 1234
1576 def MyFunc(arg: string)
1577 valone = 5678
1578 enddef
1579 END
1580 let morelines =<< trim END
1581 let valtwo = 222
1582 export def GetValtwo(): number
1583 return valtwo
1584 enddef
1585 END
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001586 writefile(lines + morelines, 'Xreload.vim')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001587 source Xreload.vim
1588 source Xreload.vim
1589 source Xreload.vim
1590
1591 let testlines =<< trim END
1592 vim9script
1593 def TheFunc()
1594 import GetValtwo from './Xreload.vim'
1595 assert_equal(222, GetValtwo())
1596 enddef
1597 TheFunc()
1598 END
1599 writefile(testlines, 'Ximport.vim')
1600 source Ximport.vim
1601
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001602 # Test that when not using "morelines" GetValtwo() and valtwo are still
1603 # defined, because import doesn't reload a script.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001604 writefile(lines, 'Xreload.vim')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001605 source Ximport.vim
1606
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001607 # cannot declare a var twice
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001608 lines =<< trim END
1609 vim9script
1610 let valone = 1234
1611 let valone = 5678
1612 END
1613 writefile(lines, 'Xreload.vim')
1614 assert_fails('source Xreload.vim', 'E1041:')
1615
1616 delete('Xreload.vim')
1617 delete('Ximport.vim')
1618enddef
1619
Bram Moolenaarfe465a02020-07-07 22:50:12 +02001620" Not exported function that is referenced needs to be accessed by the
1621" script-local name.
1622def Test_vim9script_funcref()
1623 let sortlines =<< trim END
1624 vim9script
1625 def Compare(i1: number, i2: number): number
Bram Moolenaarbed36b92020-07-07 23:31:36 +02001626 return i2 - i1
Bram Moolenaarfe465a02020-07-07 22:50:12 +02001627 enddef
1628
1629 export def FastSort(): list<number>
1630 return range(5)->sort(Compare)
1631 enddef
1632 END
1633 writefile(sortlines, 'Xsort.vim')
1634
1635 let lines =<< trim END
1636 vim9script
1637 import FastSort from './Xsort.vim'
1638 def Test()
1639 g:result = FastSort()
1640 enddef
1641 Test()
1642 END
1643 writefile(lines, 'Xscript.vim')
1644
1645 source Xscript.vim
1646 assert_equal([4, 3, 2, 1, 0], g:result)
1647
1648 unlet g:result
1649 delete('Xsort.vim')
1650 delete('Xscript.vim')
1651enddef
1652
Bram Moolenaarc620c052020-07-08 15:16:19 +02001653" Check that when searcing for "FilterFunc" it doesn't find the import in the
1654" script where FastFilter() is called from.
1655def Test_vim9script_funcref_other_script()
1656 let filterLines =<< trim END
1657 vim9script
1658 export def FilterFunc(idx: number, val: number): bool
1659 return idx % 2 == 1
1660 enddef
1661 export def FastFilter(): list<number>
1662 return range(10)->filter('FilterFunc')
1663 enddef
1664 END
1665 writefile(filterLines, 'Xfilter.vim')
1666
1667 let lines =<< trim END
1668 vim9script
1669 import {FilterFunc, FastFilter} from './Xfilter.vim'
1670 def Test()
1671 let x: list<number> = FastFilter()
1672 enddef
1673 Test()
1674 END
1675 writefile(lines, 'Ximport.vim')
1676 assert_fails('source Ximport.vim', 'E121:')
1677
1678 delete('Xfilter.vim')
1679 delete('Ximport.vim')
1680enddef
1681
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001682def Test_vim9script_reload_delfunc()
1683 let first_lines =<< trim END
1684 vim9script
1685 def FuncYes(): string
1686 return 'yes'
1687 enddef
1688 END
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001689 let withno_lines =<< trim END
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001690 def FuncNo(): string
1691 return 'no'
1692 enddef
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001693 def g:DoCheck(no_exists: bool)
1694 assert_equal('yes', FuncYes())
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001695 assert_equal('no', FuncNo())
1696 enddef
1697 END
1698 let nono_lines =<< trim END
1699 def g:DoCheck(no_exists: bool)
1700 assert_equal('yes', FuncYes())
1701 assert_fails('call FuncNo()', 'E117:')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001702 enddef
1703 END
1704
1705 # FuncNo() is defined
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001706 writefile(first_lines + withno_lines, 'Xreloaded.vim')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001707 source Xreloaded.vim
1708 g:DoCheck(true)
1709
1710 # FuncNo() is not redefined
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001711 writefile(first_lines + nono_lines, 'Xreloaded.vim')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001712 source Xreloaded.vim
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001713 g:DoCheck()
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001714
1715 # FuncNo() is back
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001716 writefile(first_lines + withno_lines, 'Xreloaded.vim')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001717 source Xreloaded.vim
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001718 g:DoCheck()
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001719
1720 delete('Xreloaded.vim')
1721enddef
1722
Bram Moolenaar89483d42020-05-10 15:24:44 +02001723def Test_vim9script_reload_delvar()
1724 # write the script with a script-local variable
1725 let lines =<< trim END
1726 vim9script
1727 let var = 'string'
1728 END
1729 writefile(lines, 'XreloadVar.vim')
1730 source XreloadVar.vim
1731
1732 # now write the script using the same variable locally - works
1733 lines =<< trim END
1734 vim9script
1735 def Func()
1736 let var = 'string'
1737 enddef
1738 END
1739 writefile(lines, 'XreloadVar.vim')
1740 source XreloadVar.vim
1741
1742 delete('XreloadVar.vim')
1743enddef
1744
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001745def Test_import_absolute()
1746 let import_lines = [
Bram Moolenaare6085c52020-04-12 20:19:16 +02001747 'vim9script',
1748 'import exported from "' .. escape(getcwd(), '\') .. '/Xexport_abs.vim"',
1749 'def UseExported()',
1750 ' g:imported_abs = exported',
1751 ' exported = 8888',
1752 ' g:imported_after = exported',
1753 'enddef',
1754 'UseExported()',
1755 'g:import_disassembled = execute("disass UseExported")',
1756 ]
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001757 writefile(import_lines, 'Ximport_abs.vim')
1758 writefile(s:export_script_lines, 'Xexport_abs.vim')
1759
1760 source Ximport_abs.vim
1761
1762 assert_equal(9876, g:imported_abs)
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +01001763 assert_equal(8888, g:imported_after)
Bram Moolenaar675f7162020-04-12 22:53:54 +02001764 assert_match('<SNR>\d\+_UseExported.*' ..
1765 'g:imported_abs = exported.*' ..
1766 '0 LOADSCRIPT exported from .*Xexport_abs.vim.*' ..
1767 '1 STOREG g:imported_abs.*' ..
1768 'exported = 8888.*' ..
1769 '3 STORESCRIPT exported in .*Xexport_abs.vim.*' ..
1770 'g:imported_after = exported.*' ..
1771 '4 LOADSCRIPT exported from .*Xexport_abs.vim.*' ..
1772 '5 STOREG g:imported_after.*',
Bram Moolenaare6085c52020-04-12 20:19:16 +02001773 g:import_disassembled)
Bram Moolenaarb3ca9822020-08-09 14:43:58 +02001774
1775 Undo_export_script_lines()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001776 unlet g:imported_abs
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +01001777 unlet g:import_disassembled
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001778
1779 delete('Ximport_abs.vim')
1780 delete('Xexport_abs.vim')
1781enddef
1782
1783def Test_import_rtp()
1784 let import_lines = [
Bram Moolenaare6085c52020-04-12 20:19:16 +02001785 'vim9script',
1786 'import exported from "Xexport_rtp.vim"',
1787 'g:imported_rtp = exported',
1788 ]
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001789 writefile(import_lines, 'Ximport_rtp.vim')
1790 mkdir('import')
1791 writefile(s:export_script_lines, 'import/Xexport_rtp.vim')
1792
1793 let save_rtp = &rtp
1794 &rtp = getcwd()
1795 source Ximport_rtp.vim
1796 &rtp = save_rtp
1797
1798 assert_equal(9876, g:imported_rtp)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001799
Bram Moolenaarb3ca9822020-08-09 14:43:58 +02001800 Undo_export_script_lines()
1801 unlet g:imported_rtp
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001802 delete('Ximport_rtp.vim')
Bram Moolenaar89483d42020-05-10 15:24:44 +02001803 delete('import', 'rf')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001804enddef
1805
Bram Moolenaar25e0f582020-05-25 22:36:50 +02001806def Test_import_compile_error()
1807 let export_lines = [
1808 'vim9script',
1809 'export def ExpFunc(): string',
1810 ' return notDefined',
1811 'enddef',
1812 ]
1813 writefile(export_lines, 'Xexported.vim')
1814
1815 let import_lines = [
1816 'vim9script',
1817 'import ExpFunc from "./Xexported.vim"',
1818 'def ImpFunc()',
1819 ' echo ExpFunc()',
1820 'enddef',
1821 'defcompile',
1822 ]
1823 writefile(import_lines, 'Ximport.vim')
1824
1825 try
1826 source Ximport.vim
1827 catch /E1001/
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001828 # Error should be fore the Xexported.vim file.
Bram Moolenaar25e0f582020-05-25 22:36:50 +02001829 assert_match('E1001: variable not found: notDefined', v:exception)
1830 assert_match('function <SNR>\d\+_ImpFunc\[1\]..<SNR>\d\+_ExpFunc, line 1', v:throwpoint)
1831 endtry
1832
1833 delete('Xexported.vim')
1834 delete('Ximport.vim')
1835enddef
1836
Bram Moolenaarc4ce36d2020-08-14 17:08:15 +02001837def Test_func_redefine_error()
1838 let lines = [
1839 'vim9script',
1840 'def Func()',
1841 ' eval [][0]',
1842 'enddef',
1843 'Func()',
1844 ]
1845 writefile(lines, 'Xtestscript.vim')
1846
1847 for count in range(3)
1848 try
1849 source Xtestscript.vim
1850 catch /E684/
1851 # function name should contain <SNR> every time
1852 assert_match('E684: list index out of range', v:exception)
1853 assert_match('function <SNR>\d\+_Func, line 1', v:throwpoint)
1854 endtry
1855 endfor
1856
1857 delete('Xtestscript.vim')
1858enddef
1859
Bram Moolenaareef21022020-08-01 22:16:43 +02001860def Test_func_overrules_import_fails()
1861 let export_lines =<< trim END
1862 vim9script
1863 export def Func()
1864 echo 'imported'
1865 enddef
1866 END
1867 writefile(export_lines, 'XexportedFunc.vim')
1868
1869 let lines =<< trim END
1870 vim9script
1871 import Func from './XexportedFunc.vim'
1872 def Func()
1873 echo 'local to function'
1874 enddef
1875 END
1876 CheckScriptFailure(lines, 'E1073:')
1877
1878 lines =<< trim END
1879 vim9script
1880 import Func from './XexportedFunc.vim'
1881 def Outer()
1882 def Func()
1883 echo 'local to function'
1884 enddef
1885 enddef
1886 defcompile
1887 END
1888 CheckScriptFailure(lines, 'E1073:')
1889
1890 delete('XexportedFunc.vim')
1891enddef
1892
Bram Moolenaarb9a2cac2020-08-01 22:23:20 +02001893def Test_func_redefine_fails()
1894 let lines =<< trim END
1895 vim9script
1896 def Func()
1897 echo 'one'
1898 enddef
1899 def Func()
1900 echo 'two'
1901 enddef
1902 END
1903 CheckScriptFailure(lines, 'E1073:')
Bram Moolenaarfa211f32020-08-07 22:00:26 +02001904
1905 lines =<< trim END
1906 vim9script
1907 def Foo(): string
1908 return 'foo'
1909 enddef
1910 def Func()
1911 let Foo = {-> 'lambda'}
1912 enddef
1913 defcompile
1914 END
1915 CheckScriptFailure(lines, 'E1073:')
Bram Moolenaarb9a2cac2020-08-01 22:23:20 +02001916enddef
1917
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001918def Test_fixed_size_list()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001919 # will be allocated as one piece of memory, check that changes work
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001920 let l = [1, 2, 3, 4]
1921 l->remove(0)
1922 l->add(5)
1923 l->insert(99, 1)
Bram Moolenaar0f18b6d2020-02-02 17:22:27 +01001924 assert_equal([2, 99, 3, 4, 5], l)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001925enddef
1926
Bram Moolenaarae616492020-07-28 20:07:27 +02001927def Test_no_insert_xit()
Bram Moolenaarae616492020-07-28 20:07:27 +02001928 call CheckDefExecFailure(['a = 1'], 'E1100:')
Bram Moolenaarae616492020-07-28 20:07:27 +02001929 call CheckDefExecFailure(['c = 1'], 'E1100:')
Bram Moolenaarf5a48012020-08-01 17:00:03 +02001930 call CheckDefExecFailure(['i = 1'], 'E1100:')
1931 call CheckDefExecFailure(['t = 1'], 'E1100:')
1932 call CheckDefExecFailure(['x = 1'], 'E1100:')
Bram Moolenaarae616492020-07-28 20:07:27 +02001933
Bram Moolenaarae616492020-07-28 20:07:27 +02001934 CheckScriptFailure(['vim9script', 'a = 1'], 'E488:')
1935 CheckScriptFailure(['vim9script', 'a'], 'E1100:')
Bram Moolenaarae616492020-07-28 20:07:27 +02001936 CheckScriptFailure(['vim9script', 'c = 1'], 'E488:')
1937 CheckScriptFailure(['vim9script', 'c'], 'E1100:')
Bram Moolenaarf5a48012020-08-01 17:00:03 +02001938 CheckScriptFailure(['vim9script', 'i = 1'], 'E488:')
1939 CheckScriptFailure(['vim9script', 'i'], 'E1100:')
1940 CheckScriptFailure(['vim9script', 't'], 'E1100:')
1941 CheckScriptFailure(['vim9script', 't = 1'], 'E1100:')
1942 CheckScriptFailure(['vim9script', 'x = 1'], 'E1100:')
Bram Moolenaarae616492020-07-28 20:07:27 +02001943enddef
1944
Bram Moolenaar158906c2020-02-06 20:39:45 +01001945def IfElse(what: number): string
1946 let res = ''
1947 if what == 1
1948 res = "one"
1949 elseif what == 2
1950 res = "two"
Bram Moolenaara259d8d2020-01-31 20:10:50 +01001951 else
Bram Moolenaar158906c2020-02-06 20:39:45 +01001952 res = "three"
Bram Moolenaara259d8d2020-01-31 20:10:50 +01001953 endif
Bram Moolenaar158906c2020-02-06 20:39:45 +01001954 return res
Bram Moolenaara259d8d2020-01-31 20:10:50 +01001955enddef
1956
Bram Moolenaar158906c2020-02-06 20:39:45 +01001957def Test_if_elseif_else()
1958 assert_equal('one', IfElse(1))
1959 assert_equal('two', IfElse(2))
1960 assert_equal('three', IfElse(3))
Bram Moolenaar0f18b6d2020-02-02 17:22:27 +01001961enddef
1962
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001963def Test_if_elseif_else_fails()
1964 call CheckDefFailure(['elseif true'], 'E582:')
1965 call CheckDefFailure(['else'], 'E581:')
1966 call CheckDefFailure(['endif'], 'E580:')
1967 call CheckDefFailure(['if true', 'elseif xxx'], 'E1001:')
Bram Moolenaar585fea72020-04-02 22:33:21 +02001968 call CheckDefFailure(['if true', 'echo 1'], 'E171:')
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001969enddef
1970
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001971let g:bool_true = v:true
1972let g:bool_false = v:false
1973
1974def Test_if_const_expr()
1975 let res = false
1976 if true ? true : false
1977 res = true
1978 endif
1979 assert_equal(true, res)
1980
Bram Moolenaar585fea72020-04-02 22:33:21 +02001981 g:glob = 2
1982 if false
Bram Moolenaar67979662020-06-20 22:50:47 +02001983 execute('g:glob = 3')
Bram Moolenaar585fea72020-04-02 22:33:21 +02001984 endif
1985 assert_equal(2, g:glob)
1986 if true
Bram Moolenaar67979662020-06-20 22:50:47 +02001987 execute('g:glob = 3')
Bram Moolenaar585fea72020-04-02 22:33:21 +02001988 endif
1989 assert_equal(3, g:glob)
1990
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001991 res = false
1992 if g:bool_true ? true : false
1993 res = true
1994 endif
1995 assert_equal(true, res)
1996
1997 res = false
1998 if true ? g:bool_true : false
1999 res = true
2000 endif
2001 assert_equal(true, res)
2002
2003 res = false
2004 if true ? true : g:bool_false
2005 res = true
2006 endif
2007 assert_equal(true, res)
2008
2009 res = false
2010 if true ? false : true
2011 res = true
2012 endif
2013 assert_equal(false, res)
2014
2015 res = false
2016 if false ? false : true
2017 res = true
2018 endif
2019 assert_equal(true, res)
2020
2021 res = false
2022 if false ? true : false
2023 res = true
2024 endif
2025 assert_equal(false, res)
2026
2027 res = false
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02002028 if has('xyz') ? true : false
2029 res = true
2030 endif
2031 assert_equal(false, res)
2032
2033 res = false
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01002034 if true && true
2035 res = true
2036 endif
2037 assert_equal(true, res)
2038
2039 res = false
2040 if true && false
2041 res = true
2042 endif
2043 assert_equal(false, res)
2044
2045 res = false
2046 if g:bool_true && false
2047 res = true
2048 endif
2049 assert_equal(false, res)
2050
2051 res = false
2052 if true && g:bool_false
2053 res = true
2054 endif
2055 assert_equal(false, res)
2056
2057 res = false
2058 if false && false
2059 res = true
2060 endif
2061 assert_equal(false, res)
2062
2063 res = false
2064 if true || false
2065 res = true
2066 endif
2067 assert_equal(true, res)
2068
2069 res = false
2070 if g:bool_true || false
2071 res = true
2072 endif
2073 assert_equal(true, res)
2074
2075 res = false
2076 if true || g:bool_false
2077 res = true
2078 endif
2079 assert_equal(true, res)
2080
2081 res = false
2082 if false || false
2083 res = true
2084 endif
2085 assert_equal(false, res)
Bram Moolenaar80c34ca2020-04-01 23:05:18 +02002086enddef
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01002087
Bram Moolenaar80c34ca2020-04-01 23:05:18 +02002088def Test_if_const_expr_fails()
2089 call CheckDefFailure(['if "aaa" == "bbb'], 'E114:')
2090 call CheckDefFailure(["if 'aaa' == 'bbb"], 'E115:')
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02002091 call CheckDefFailure(["if has('aaa'"], 'E110:')
2092 call CheckDefFailure(["if has('aaa') ? true false"], 'E109:')
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01002093enddef
2094
Bram Moolenaar72abcf42020-06-18 18:26:24 +02002095def RunNested(i: number): number
2096 let x: number = 0
2097 if i % 2
2098 if 1
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002099 # comment
Bram Moolenaar72abcf42020-06-18 18:26:24 +02002100 else
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002101 # comment
Bram Moolenaar72abcf42020-06-18 18:26:24 +02002102 endif
2103 x += 1
2104 else
2105 x += 1000
2106 endif
2107 return x
2108enddef
2109
2110def Test_nested_if()
2111 assert_equal(1, RunNested(1))
2112 assert_equal(1000, RunNested(2))
2113enddef
2114
Bram Moolenaarad39c092020-02-26 18:23:43 +01002115def Test_execute_cmd()
2116 new
2117 setline(1, 'default')
2118 execute 'call setline(1, "execute-string")'
2119 assert_equal('execute-string', getline(1))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002120
2121 execute "call setline(1, 'execute-string')"
2122 assert_equal('execute-string', getline(1))
2123
Bram Moolenaarad39c092020-02-26 18:23:43 +01002124 let cmd1 = 'call setline(1,'
2125 let cmd2 = '"execute-var")'
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002126 execute cmd1 cmd2 # comment
Bram Moolenaarad39c092020-02-26 18:23:43 +01002127 assert_equal('execute-var', getline(1))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002128
Bram Moolenaarad39c092020-02-26 18:23:43 +01002129 execute cmd1 cmd2 '|call setline(1, "execute-var-string")'
2130 assert_equal('execute-var-string', getline(1))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002131
Bram Moolenaarad39c092020-02-26 18:23:43 +01002132 let cmd_first = 'call '
2133 let cmd_last = 'setline(1, "execute-var-var")'
2134 execute cmd_first .. cmd_last
2135 assert_equal('execute-var-var', getline(1))
2136 bwipe!
Bram Moolenaar585fea72020-04-02 22:33:21 +02002137
Bram Moolenaar2d6b20d2020-07-25 19:30:59 +02002138 let n = true
2139 execute 'echomsg' (n ? '"true"' : '"no"')
2140 assert_match('^true$', Screenline(&lines))
2141
Bram Moolenaare5abf7a2020-08-16 18:29:35 +02002142 echomsg [1, 2, 3] #{a: 1, b: 2}
2143 assert_match('^\[1, 2, 3\] {''a'': 1, ''b'': 2}$', Screenline(&lines))
2144
Bram Moolenaar585fea72020-04-02 22:33:21 +02002145 call CheckDefFailure(['execute xxx'], 'E1001:')
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002146 call CheckDefFailure(['execute "cmd"# comment'], 'E488:')
Bram Moolenaarad39c092020-02-26 18:23:43 +01002147enddef
2148
Bram Moolenaar47e880d2020-06-30 22:02:02 +02002149def Test_execute_cmd_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002150 # only checks line continuation
Bram Moolenaar47e880d2020-06-30 22:02:02 +02002151 let lines =<< trim END
2152 vim9script
2153 execute 'g:someVar'
2154 .. ' = ' ..
2155 '28'
2156 assert_equal(28, g:someVar)
2157 unlet g:someVar
2158 END
2159 CheckScriptSuccess(lines)
2160enddef
2161
Bram Moolenaarad39c092020-02-26 18:23:43 +01002162def Test_echo_cmd()
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002163 echo 'some' # comment
Bram Moolenaar585fea72020-04-02 22:33:21 +02002164 echon 'thing'
Bram Moolenaarad39c092020-02-26 18:23:43 +01002165 assert_match('^something$', Screenline(&lines))
2166
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002167 echo "some" # comment
2168 echon "thing"
2169 assert_match('^something$', Screenline(&lines))
2170
Bram Moolenaarad39c092020-02-26 18:23:43 +01002171 let str1 = 'some'
2172 let str2 = 'more'
2173 echo str1 str2
2174 assert_match('^some more$', Screenline(&lines))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002175
2176 call CheckDefFailure(['echo "xxx"# comment'], 'E488:')
Bram Moolenaarad39c092020-02-26 18:23:43 +01002177enddef
2178
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02002179def Test_echomsg_cmd()
2180 echomsg 'some' 'more' # comment
2181 assert_match('^some more$', Screenline(&lines))
2182 echo 'clear'
Bram Moolenaardf069ee2020-06-22 23:02:51 +02002183 :1messages
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02002184 assert_match('^some more$', Screenline(&lines))
2185
2186 call CheckDefFailure(['echomsg "xxx"# comment'], 'E488:')
2187enddef
2188
Bram Moolenaar47e880d2020-06-30 22:02:02 +02002189def Test_echomsg_cmd_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002190 # only checks line continuation
Bram Moolenaar47e880d2020-06-30 22:02:02 +02002191 let lines =<< trim END
2192 vim9script
2193 echomsg 'here'
2194 .. ' is ' ..
2195 'a message'
2196 assert_match('^here is a message$', Screenline(&lines))
2197 END
2198 CheckScriptSuccess(lines)
2199enddef
2200
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02002201def Test_echoerr_cmd()
Bram Moolenaar40ee4662020-05-05 22:08:26 +02002202 try
2203 echoerr 'something' 'wrong' # comment
2204 catch
2205 assert_match('something wrong', v:exception)
2206 endtry
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02002207enddef
2208
Bram Moolenaar47e880d2020-06-30 22:02:02 +02002209def Test_echoerr_cmd_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002210 # only checks line continuation
Bram Moolenaar47e880d2020-06-30 22:02:02 +02002211 let lines =<< trim END
2212 vim9script
2213 try
2214 echoerr 'this'
2215 .. ' is ' ..
2216 'wrong'
2217 catch
2218 assert_match('this is wrong', v:exception)
2219 endtry
2220 END
2221 CheckScriptSuccess(lines)
2222enddef
2223
Bram Moolenaar41fe0612020-03-01 16:22:40 +01002224def Test_for_outside_of_function()
2225 let lines =<< trim END
2226 vim9script
2227 new
2228 for var in range(0, 3)
2229 append(line('$'), var)
2230 endfor
2231 assert_equal(['', '0', '1', '2', '3'], getline(1, '$'))
2232 bwipe!
2233 END
2234 writefile(lines, 'Xvim9for.vim')
2235 source Xvim9for.vim
2236 delete('Xvim9for.vim')
2237enddef
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002238
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02002239def Test_for_loop()
2240 let result = ''
2241 for cnt in range(7)
2242 if cnt == 4
2243 break
2244 endif
2245 if cnt == 2
2246 continue
2247 endif
2248 result ..= cnt .. '_'
2249 endfor
2250 assert_equal('0_1_3_', result)
Bram Moolenaar0ad3e892020-07-05 21:38:11 +02002251
2252 let concat = ''
2253 for str in eval('["one", "two"]')
2254 concat ..= str
2255 endfor
2256 assert_equal('onetwo', concat)
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02002257enddef
2258
2259def Test_for_loop_fails()
Bram Moolenaar675f7162020-04-12 22:53:54 +02002260 CheckDefFailure(['for # in range(5)'], 'E690:')
2261 CheckDefFailure(['for i In range(5)'], 'E690:')
Bram Moolenaar451c2e32020-08-15 16:33:28 +02002262 CheckDefFailure(['let x = 5', 'for x in range(5)'], 'E1017:')
Bram Moolenaar822ba242020-05-24 23:00:18 +02002263 CheckScriptFailure(['def Func(arg: any)', 'for arg in range(5)', 'enddef', 'defcompile'], 'E1006:')
Bram Moolenaar451c2e32020-08-15 16:33:28 +02002264 CheckDefFailure(['for i in "text"'], 'E1012:')
Bram Moolenaar675f7162020-04-12 22:53:54 +02002265 CheckDefFailure(['for i in xxx'], 'E1001:')
2266 CheckDefFailure(['endfor'], 'E588:')
2267 CheckDefFailure(['for i in range(3)', 'echo 3'], 'E170:')
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02002268enddef
2269
Bram Moolenaard0df1aa2020-03-04 21:50:46 +01002270def Test_while_loop()
2271 let result = ''
2272 let cnt = 0
2273 while cnt < 555
2274 if cnt == 3
2275 break
2276 endif
2277 cnt += 1
2278 if cnt == 2
2279 continue
2280 endif
2281 result ..= cnt .. '_'
2282 endwhile
2283 assert_equal('1_3_', result)
2284enddef
2285
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02002286def Test_while_loop_fails()
Bram Moolenaar675f7162020-04-12 22:53:54 +02002287 CheckDefFailure(['while xxx'], 'E1001:')
2288 CheckDefFailure(['endwhile'], 'E588:')
2289 CheckDefFailure(['continue'], 'E586:')
2290 CheckDefFailure(['if true', 'continue'], 'E586:')
2291 CheckDefFailure(['break'], 'E587:')
2292 CheckDefFailure(['if true', 'break'], 'E587:')
2293 CheckDefFailure(['while 1', 'echo 3'], 'E170:')
Bram Moolenaarbd5da372020-03-31 23:13:10 +02002294enddef
2295
Bram Moolenaar9645e2d2020-03-20 20:48:49 +01002296def Test_interrupt_loop()
Bram Moolenaar97acfc72020-03-22 13:44:28 +01002297 let caught = false
Bram Moolenaar9645e2d2020-03-20 20:48:49 +01002298 let x = 0
Bram Moolenaar97acfc72020-03-22 13:44:28 +01002299 try
2300 while 1
2301 x += 1
2302 if x == 100
2303 feedkeys("\<C-C>", 'Lt')
2304 endif
2305 endwhile
2306 catch
2307 caught = true
2308 assert_equal(100, x)
2309 endtry
2310 assert_true(caught, 'should have caught an exception')
Bram Moolenaar9645e2d2020-03-20 20:48:49 +01002311enddef
Bram Moolenaar20431c92020-03-20 18:39:46 +01002312
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002313def Test_automatic_line_continuation()
2314 let mylist = [
2315 'one',
2316 'two',
2317 'three',
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002318 ] # comment
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002319 assert_equal(['one', 'two', 'three'], mylist)
2320
2321 let mydict = {
2322 'one': 1,
2323 'two': 2,
2324 'three':
2325 3,
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002326 } # comment
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002327 assert_equal({'one': 1, 'two': 2, 'three': 3}, mydict)
2328 mydict = #{
Bram Moolenaar2c330432020-04-13 14:41:35 +02002329 one: 1, # comment
2330 two: # comment
2331 2, # comment
2332 three: 3 # comment
2333 }
2334 assert_equal(#{one: 1, two: 2, three: 3}, mydict)
2335 mydict = #{
2336 one: 1,
2337 two:
2338 2,
2339 three: 3
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002340 }
2341 assert_equal(#{one: 1, two: 2, three: 3}, mydict)
Bram Moolenaare6085c52020-04-12 20:19:16 +02002342
2343 assert_equal(
2344 ['one', 'two', 'three'],
2345 split('one two three')
2346 )
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002347enddef
2348
Bram Moolenaar7a092242020-04-16 22:10:49 +02002349def Test_vim9_comment()
2350 CheckScriptSuccess([
2351 'vim9script',
2352 '# something',
2353 ])
2354 CheckScriptFailure([
2355 'vim9script',
2356 ':# something',
2357 ], 'E488:')
2358 CheckScriptFailure([
2359 '# something',
2360 ], 'E488:')
2361 CheckScriptFailure([
2362 ':# something',
2363 ], 'E488:')
2364
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02002365 { # block start
2366 } # block end
2367 CheckDefFailure([
2368 '{# comment',
2369 ], 'E488:')
2370 CheckDefFailure([
2371 '{',
2372 '}# comment',
2373 ], 'E488:')
2374
2375 echo "yes" # comment
2376 CheckDefFailure([
2377 'echo "yes"# comment',
2378 ], 'E488:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02002379 CheckScriptSuccess([
2380 'vim9script',
2381 'echo "yes" # something',
2382 ])
2383 CheckScriptFailure([
2384 'vim9script',
2385 'echo "yes"# something',
2386 ], 'E121:')
2387 CheckScriptFailure([
2388 'vim9script',
2389 'echo# something',
2390 ], 'E121:')
2391 CheckScriptFailure([
2392 'echo "yes" # something',
2393 ], 'E121:')
2394
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02002395 exe "echo" # comment
2396 CheckDefFailure([
2397 'exe "echo"# comment',
2398 ], 'E488:')
2399 CheckScriptSuccess([
2400 'vim9script',
2401 'exe "echo" # something',
2402 ])
2403 CheckScriptFailure([
2404 'vim9script',
2405 'exe "echo"# something',
2406 ], 'E121:')
2407 CheckDefFailure([
2408 'exe # comment',
2409 ], 'E1015:')
2410 CheckScriptFailure([
2411 'vim9script',
2412 'exe# something',
2413 ], 'E121:')
2414 CheckScriptFailure([
2415 'exe "echo" # something',
2416 ], 'E121:')
2417
Bram Moolenaar7a092242020-04-16 22:10:49 +02002418 CheckDefFailure([
2419 'try# comment',
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002420 ' echo "yes"',
Bram Moolenaar7a092242020-04-16 22:10:49 +02002421 'catch',
2422 'endtry',
2423 ], 'E488:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002424 CheckScriptFailure([
2425 'vim9script',
2426 'try# comment',
2427 'echo "yes"',
2428 ], 'E488:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02002429 CheckDefFailure([
2430 'try',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002431 ' throw#comment',
2432 'catch',
2433 'endtry',
2434 ], 'E1015:')
2435 CheckDefFailure([
2436 'try',
2437 ' throw "yes"#comment',
2438 'catch',
2439 'endtry',
2440 ], 'E488:')
2441 CheckDefFailure([
2442 'try',
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002443 ' echo "yes"',
Bram Moolenaar7a092242020-04-16 22:10:49 +02002444 'catch# comment',
2445 'endtry',
2446 ], 'E488:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002447 CheckScriptFailure([
2448 'vim9script',
2449 'try',
2450 ' echo "yes"',
2451 'catch# comment',
2452 'endtry',
2453 ], 'E654:')
2454 CheckDefFailure([
2455 'try',
2456 ' echo "yes"',
2457 'catch /pat/# comment',
2458 'endtry',
2459 ], 'E488:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02002460 CheckDefFailure([
2461 'try',
2462 'echo "yes"',
2463 'catch',
2464 'endtry# comment',
2465 ], 'E488:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002466 CheckScriptFailure([
2467 'vim9script',
2468 'try',
2469 ' echo "yes"',
2470 'catch',
2471 'endtry# comment',
Bram Moolenaar9b7bf9e2020-07-11 22:14:59 +02002472 ], 'E488:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002473
2474 CheckScriptSuccess([
2475 'vim9script',
2476 'hi # comment',
2477 ])
2478 CheckScriptFailure([
2479 'vim9script',
2480 'hi# comment',
2481 ], 'E416:')
Bram Moolenaar1966c242020-04-20 22:42:32 +02002482 CheckScriptSuccess([
2483 'vim9script',
2484 'hi Search # comment',
2485 ])
2486 CheckScriptFailure([
2487 'vim9script',
2488 'hi Search# comment',
2489 ], 'E416:')
2490 CheckScriptSuccess([
2491 'vim9script',
2492 'hi link This Search # comment',
2493 ])
2494 CheckScriptFailure([
2495 'vim9script',
2496 'hi link This That# comment',
2497 ], 'E413:')
2498 CheckScriptSuccess([
2499 'vim9script',
2500 'hi clear This # comment',
2501 'hi clear # comment',
2502 ])
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002503 # not tested, because it doesn't give an error but a warning:
2504 # hi clear This# comment',
Bram Moolenaar1966c242020-04-20 22:42:32 +02002505 CheckScriptFailure([
2506 'vim9script',
2507 'hi clear# comment',
2508 ], 'E416:')
2509
2510 CheckScriptSuccess([
2511 'vim9script',
2512 'hi Group term=bold',
2513 'match Group /todo/ # comment',
2514 ])
2515 CheckScriptFailure([
2516 'vim9script',
2517 'hi Group term=bold',
2518 'match Group /todo/# comment',
2519 ], 'E488:')
2520 CheckScriptSuccess([
2521 'vim9script',
2522 'match # comment',
2523 ])
2524 CheckScriptFailure([
2525 'vim9script',
2526 'match# comment',
2527 ], 'E475:')
2528 CheckScriptSuccess([
2529 'vim9script',
2530 'match none # comment',
2531 ])
2532 CheckScriptFailure([
2533 'vim9script',
2534 'match none# comment',
2535 ], 'E475:')
2536
2537 CheckScriptSuccess([
2538 'vim9script',
2539 'menutrans clear # comment',
2540 ])
2541 CheckScriptFailure([
2542 'vim9script',
2543 'menutrans clear# comment text',
2544 ], 'E474:')
2545
2546 CheckScriptSuccess([
2547 'vim9script',
2548 'syntax clear # comment',
2549 ])
2550 CheckScriptFailure([
2551 'vim9script',
2552 'syntax clear# comment text',
2553 ], 'E28:')
2554 CheckScriptSuccess([
2555 'vim9script',
2556 'syntax keyword Word some',
2557 'syntax clear Word # comment',
2558 ])
2559 CheckScriptFailure([
2560 'vim9script',
2561 'syntax keyword Word some',
2562 'syntax clear Word# comment text',
2563 ], 'E28:')
2564
2565 CheckScriptSuccess([
2566 'vim9script',
2567 'syntax list # comment',
2568 ])
2569 CheckScriptFailure([
2570 'vim9script',
2571 'syntax list# comment text',
2572 ], 'E28:')
2573
2574 CheckScriptSuccess([
2575 'vim9script',
2576 'syntax match Word /pat/ oneline # comment',
2577 ])
2578 CheckScriptFailure([
2579 'vim9script',
2580 'syntax match Word /pat/ oneline# comment',
2581 ], 'E475:')
2582
2583 CheckScriptSuccess([
2584 'vim9script',
2585 'syntax keyword Word word # comm[ent',
2586 ])
2587 CheckScriptFailure([
2588 'vim9script',
2589 'syntax keyword Word word# comm[ent',
2590 ], 'E789:')
2591
2592 CheckScriptSuccess([
2593 'vim9script',
2594 'syntax match Word /pat/ # comment',
2595 ])
2596 CheckScriptFailure([
2597 'vim9script',
2598 'syntax match Word /pat/# comment',
2599 ], 'E402:')
2600
2601 CheckScriptSuccess([
2602 'vim9script',
2603 'syntax match Word /pat/ contains=Something # comment',
2604 ])
2605 CheckScriptFailure([
2606 'vim9script',
2607 'syntax match Word /pat/ contains=Something# comment',
2608 ], 'E475:')
2609 CheckScriptFailure([
2610 'vim9script',
2611 'syntax match Word /pat/ contains= # comment',
2612 ], 'E406:')
2613 CheckScriptFailure([
2614 'vim9script',
2615 'syntax match Word /pat/ contains=# comment',
2616 ], 'E475:')
2617
2618 CheckScriptSuccess([
2619 'vim9script',
2620 'syntax region Word start=/pat/ end=/pat/ # comment',
2621 ])
2622 CheckScriptFailure([
2623 'vim9script',
2624 'syntax region Word start=/pat/ end=/pat/# comment',
Bram Moolenaard032f342020-07-18 18:13:02 +02002625 ], 'E402:')
Bram Moolenaar1966c242020-04-20 22:42:32 +02002626
2627 CheckScriptSuccess([
2628 'vim9script',
2629 'syntax sync # comment',
2630 ])
2631 CheckScriptFailure([
2632 'vim9script',
2633 'syntax sync# comment',
2634 ], 'E404:')
2635 CheckScriptSuccess([
2636 'vim9script',
2637 'syntax sync ccomment # comment',
2638 ])
2639 CheckScriptFailure([
2640 'vim9script',
2641 'syntax sync ccomment# comment',
2642 ], 'E404:')
2643
2644 CheckScriptSuccess([
2645 'vim9script',
2646 'syntax cluster Some contains=Word # comment',
2647 ])
2648 CheckScriptFailure([
2649 'vim9script',
2650 'syntax cluster Some contains=Word# comment',
2651 ], 'E475:')
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002652
2653 CheckScriptSuccess([
2654 'vim9script',
2655 'command Echo echo # comment',
2656 'command Echo # comment',
2657 ])
2658 CheckScriptFailure([
2659 'vim9script',
2660 'command Echo echo# comment',
2661 'Echo',
2662 ], 'E121:')
2663 CheckScriptFailure([
2664 'vim9script',
2665 'command Echo# comment',
2666 ], 'E182:')
2667 CheckScriptFailure([
2668 'vim9script',
2669 'command Echo echo',
2670 'command Echo# comment',
2671 ], 'E182:')
2672
2673 CheckScriptSuccess([
2674 'vim9script',
2675 'function # comment',
2676 ])
2677 CheckScriptFailure([
2678 'vim9script',
Bram Moolenaar98981072020-07-29 14:40:25 +02002679 'function " comment',
2680 ], 'E129:')
2681 CheckScriptFailure([
2682 'vim9script',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002683 'function# comment',
2684 ], 'E129:')
2685 CheckScriptSuccess([
2686 'vim9script',
2687 'function CheckScriptSuccess # comment',
2688 ])
2689 CheckScriptFailure([
2690 'vim9script',
2691 'function CheckScriptSuccess# comment',
2692 ], 'E488:')
2693
2694 CheckScriptSuccess([
2695 'vim9script',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02002696 'func g:DeleteMeA()',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002697 'endfunc',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02002698 'delfunction g:DeleteMeA # comment',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002699 ])
2700 CheckScriptFailure([
2701 'vim9script',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02002702 'func g:DeleteMeB()',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002703 'endfunc',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02002704 'delfunction g:DeleteMeB# comment',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002705 ], 'E488:')
2706
2707 CheckScriptSuccess([
2708 'vim9script',
2709 'call execute("ls") # comment',
2710 ])
2711 CheckScriptFailure([
2712 'vim9script',
2713 'call execute("ls")# comment',
2714 ], 'E488:')
Bram Moolenaare7e48382020-07-22 18:17:08 +02002715
2716 CheckScriptFailure([
2717 'def Test() " comment',
2718 'enddef',
2719 ], 'E488:')
2720 CheckScriptFailure([
2721 'vim9script',
2722 'def Test() " comment',
2723 'enddef',
2724 ], 'E488:')
2725
2726 CheckScriptSuccess([
2727 'func Test() " comment',
2728 'endfunc',
2729 ])
Bram Moolenaar98981072020-07-29 14:40:25 +02002730 CheckScriptSuccess([
Bram Moolenaare7e48382020-07-22 18:17:08 +02002731 'vim9script',
2732 'func Test() " comment',
2733 'endfunc',
Bram Moolenaar98981072020-07-29 14:40:25 +02002734 ])
Bram Moolenaare7e48382020-07-22 18:17:08 +02002735
2736 CheckScriptSuccess([
2737 'def Test() # comment',
2738 'enddef',
2739 ])
2740 CheckScriptFailure([
2741 'func Test() # comment',
2742 'endfunc',
2743 ], 'E488:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002744enddef
2745
2746def Test_vim9_comment_gui()
2747 CheckCanRunGui
2748
2749 CheckScriptFailure([
2750 'vim9script',
2751 'gui#comment'
2752 ], 'E499:')
2753 CheckScriptFailure([
2754 'vim9script',
2755 'gui -f#comment'
2756 ], 'E499:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02002757enddef
2758
Bram Moolenaara26b9702020-04-18 19:53:28 +02002759def Test_vim9_comment_not_compiled()
Bram Moolenaar67979662020-06-20 22:50:47 +02002760 au TabEnter *.vim g:entered = 1
2761 au TabEnter *.x g:entered = 2
Bram Moolenaara26b9702020-04-18 19:53:28 +02002762
2763 edit test.vim
2764 doautocmd TabEnter #comment
2765 assert_equal(1, g:entered)
2766
2767 doautocmd TabEnter f.x
2768 assert_equal(2, g:entered)
2769
2770 g:entered = 0
2771 doautocmd TabEnter f.x #comment
2772 assert_equal(2, g:entered)
2773
2774 assert_fails('doautocmd Syntax#comment', 'E216:')
2775
2776 au! TabEnter
2777 unlet g:entered
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02002778
2779 CheckScriptSuccess([
2780 'vim9script',
Bram Moolenaar67979662020-06-20 22:50:47 +02002781 'g:var = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02002782 'b:var = 456',
2783 'w:var = 777',
2784 't:var = 888',
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02002785 'unlet g:var w:var # something',
2786 ])
2787
2788 CheckScriptFailure([
2789 'vim9script',
2790 'let g:var = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02002791 ], 'E1016: Cannot declare a global variable:')
2792
2793 CheckScriptFailure([
2794 'vim9script',
2795 'let b:var = 123',
2796 ], 'E1016: Cannot declare a buffer variable:')
2797
2798 CheckScriptFailure([
2799 'vim9script',
2800 'let w:var = 123',
2801 ], 'E1016: Cannot declare a window variable:')
2802
2803 CheckScriptFailure([
2804 'vim9script',
2805 'let t:var = 123',
2806 ], 'E1016: Cannot declare a tab variable:')
2807
2808 CheckScriptFailure([
2809 'vim9script',
2810 'let v:version = 123',
2811 ], 'E1016: Cannot declare a v: variable:')
2812
2813 CheckScriptFailure([
2814 'vim9script',
2815 'let $VARIABLE = "text"',
2816 ], 'E1016: Cannot declare an environment variable:')
Bram Moolenaar67979662020-06-20 22:50:47 +02002817
2818 CheckScriptFailure([
2819 'vim9script',
2820 'g:var = 123',
Bram Moolenaar32e35112020-05-14 22:41:15 +02002821 'unlet g:var# comment1',
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02002822 ], 'E108:')
2823
2824 CheckScriptFailure([
2825 'let g:var = 123',
2826 'unlet g:var # something',
2827 ], 'E488:')
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002828
2829 CheckScriptSuccess([
2830 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02002831 'if 1 # comment2',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002832 ' echo "yes"',
2833 'elseif 2 #comment',
2834 ' echo "no"',
2835 'endif',
2836 ])
2837
2838 CheckScriptFailure([
2839 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02002840 'if 1# comment3',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002841 ' echo "yes"',
2842 'endif',
2843 ], 'E15:')
2844
2845 CheckScriptFailure([
2846 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02002847 'if 0 # comment4',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002848 ' echo "yes"',
2849 'elseif 2#comment',
2850 ' echo "no"',
2851 'endif',
2852 ], 'E15:')
2853
2854 CheckScriptSuccess([
2855 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02002856 'let v = 1 # comment5',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002857 ])
2858
2859 CheckScriptFailure([
2860 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02002861 'let v = 1# comment6',
2862 ], 'E15:')
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002863
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002864 CheckScriptSuccess([
2865 'vim9script',
2866 'new'
2867 'call setline(1, ["# define pat", "last"])',
Bram Moolenaardf069ee2020-06-22 23:02:51 +02002868 ':$',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002869 'dsearch /pat/ #comment',
2870 'bwipe!',
2871 ])
2872
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002873 CheckScriptFailure([
2874 'vim9script',
2875 'new'
2876 'call setline(1, ["# define pat", "last"])',
2877 ':$',
2878 'dsearch /pat/#comment',
2879 'bwipe!',
2880 ], 'E488:')
2881
2882 CheckScriptFailure([
2883 'vim9script',
2884 'func! SomeFunc()',
2885 ], 'E477:')
Bram Moolenaara26b9702020-04-18 19:53:28 +02002886enddef
2887
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02002888def Test_finish()
2889 let lines =<< trim END
2890 vim9script
Bram Moolenaar67979662020-06-20 22:50:47 +02002891 g:res = 'one'
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02002892 if v:false | finish | endif
Bram Moolenaar67979662020-06-20 22:50:47 +02002893 g:res = 'two'
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02002894 finish
Bram Moolenaar67979662020-06-20 22:50:47 +02002895 g:res = 'three'
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02002896 END
2897 writefile(lines, 'Xfinished')
2898 source Xfinished
2899 assert_equal('two', g:res)
2900
2901 unlet g:res
2902 delete('Xfinished')
2903enddef
2904
Bram Moolenaar32e35112020-05-14 22:41:15 +02002905def Test_let_func_call()
2906 let lines =<< trim END
2907 vim9script
2908 func GetValue()
2909 if exists('g:count')
2910 let g:count += 1
2911 else
2912 let g:count = 1
2913 endif
2914 return 'this'
2915 endfunc
2916 let val: string = GetValue()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002917 # env var is always a string
Bram Moolenaardf671b42020-05-16 22:33:33 +02002918 let env = $TERM
Bram Moolenaar32e35112020-05-14 22:41:15 +02002919 END
2920 writefile(lines, 'Xfinished')
2921 source Xfinished
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002922 # GetValue() is not called during discovery phase
Bram Moolenaar32e35112020-05-14 22:41:15 +02002923 assert_equal(1, g:count)
2924
2925 unlet g:count
2926 delete('Xfinished')
2927enddef
2928
2929def Test_let_missing_type()
2930 let lines =<< trim END
2931 vim9script
Bram Moolenaardf671b42020-05-16 22:33:33 +02002932 let var = g:unknown
Bram Moolenaar227a69d2020-05-15 18:17:28 +02002933 END
Bram Moolenaar822ba242020-05-24 23:00:18 +02002934 CheckScriptFailure(lines, 'E121:')
Bram Moolenaar227a69d2020-05-15 18:17:28 +02002935
2936 lines =<< trim END
2937 vim9script
2938 let nr: number = 123
2939 let var = nr
2940 END
Bram Moolenaar822ba242020-05-24 23:00:18 +02002941 CheckScriptSuccess(lines)
Bram Moolenaar32e35112020-05-14 22:41:15 +02002942enddef
2943
Bram Moolenaarc82a5b52020-06-13 18:09:19 +02002944def Test_let_declaration()
2945 let lines =<< trim END
2946 vim9script
2947 let var: string
2948 g:var_uninit = var
2949 var = 'text'
2950 g:var_test = var
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002951 # prefixing s: is optional
Bram Moolenaar984dddb2020-06-14 12:50:24 +02002952 s:var = 'prefixed'
2953 g:var_prefixed = s:var
2954
2955 let s:other: number
2956 other = 1234
2957 g:other_var = other
Bram Moolenaar53b29e42020-08-15 14:31:20 +02002958
2959 # type is inferred
2960 s:dict = {'a': 222}
2961 def GetDictVal(key: any)
2962 g:dict_val = s:dict[key]
2963 enddef
2964 GetDictVal('a')
Bram Moolenaarc82a5b52020-06-13 18:09:19 +02002965 END
2966 CheckScriptSuccess(lines)
2967 assert_equal('', g:var_uninit)
2968 assert_equal('text', g:var_test)
Bram Moolenaar984dddb2020-06-14 12:50:24 +02002969 assert_equal('prefixed', g:var_prefixed)
2970 assert_equal(1234, g:other_var)
Bram Moolenaar53b29e42020-08-15 14:31:20 +02002971 assert_equal(222, g:dict_val)
Bram Moolenaarc82a5b52020-06-13 18:09:19 +02002972
2973 unlet g:var_uninit
2974 unlet g:var_test
Bram Moolenaar984dddb2020-06-14 12:50:24 +02002975 unlet g:var_prefixed
2976 unlet g:other_var
Bram Moolenaarc82a5b52020-06-13 18:09:19 +02002977enddef
2978
Bram Moolenaarc5b1c202020-06-18 22:43:27 +02002979def Test_let_declaration_fails()
2980 let lines =<< trim END
2981 vim9script
2982 const var: string
2983 END
2984 CheckScriptFailure(lines, 'E1021:')
2985
2986 lines =<< trim END
2987 vim9script
2988 let 9var: string
2989 END
2990 CheckScriptFailure(lines, 'E475:')
2991enddef
2992
Bram Moolenaar34db91f2020-06-13 19:00:10 +02002993def Test_let_type_check()
2994 let lines =<< trim END
2995 vim9script
2996 let var: string
2997 var = 1234
2998 END
Bram Moolenaar451c2e32020-08-15 16:33:28 +02002999 CheckScriptFailure(lines, 'E1012:')
Bram Moolenaar984dddb2020-06-14 12:50:24 +02003000
3001 lines =<< trim END
3002 vim9script
3003 let var:string
3004 END
3005 CheckScriptFailure(lines, 'E1069:')
Bram Moolenaarc5b1c202020-06-18 22:43:27 +02003006
3007 lines =<< trim END
3008 vim9script
3009 let var: asdf
3010 END
3011 CheckScriptFailure(lines, 'E1010:')
Bram Moolenaara71e2632020-08-05 15:11:03 +02003012
3013 lines =<< trim END
3014 vim9script
3015 let s:l: list<number>
3016 s:l = []
3017 END
3018 CheckScriptSuccess(lines)
3019
3020 lines =<< trim END
3021 vim9script
3022 let s:d: dict<number>
3023 s:d = {}
3024 END
3025 CheckScriptSuccess(lines)
Bram Moolenaar34db91f2020-06-13 19:00:10 +02003026enddef
3027
Bram Moolenaara5d00772020-05-14 23:20:55 +02003028def Test_forward_declaration()
3029 let lines =<< trim END
3030 vim9script
Bram Moolenaara5d00772020-05-14 23:20:55 +02003031 def GetValue(): string
3032 return theVal
3033 enddef
3034 let theVal = 'something'
Bram Moolenaar822ba242020-05-24 23:00:18 +02003035 g:initVal = GetValue()
Bram Moolenaara5d00772020-05-14 23:20:55 +02003036 theVal = 'else'
3037 g:laterVal = GetValue()
3038 END
3039 writefile(lines, 'Xforward')
3040 source Xforward
3041 assert_equal('something', g:initVal)
3042 assert_equal('else', g:laterVal)
3043
3044 unlet g:initVal
3045 unlet g:laterVal
3046 delete('Xforward')
3047enddef
3048
Bram Moolenaar9721fb42020-06-11 23:10:46 +02003049def Test_source_vim9_from_legacy()
3050 let legacy_lines =<< trim END
3051 source Xvim9_script.vim
3052
3053 call assert_false(exists('local'))
3054 call assert_false(exists('exported'))
3055 call assert_false(exists('s:exported'))
3056 call assert_equal('global', global)
3057 call assert_equal('global', g:global)
3058
3059 " imported variable becomes script-local
3060 import exported from './Xvim9_script.vim'
3061 call assert_equal('exported', s:exported)
3062 call assert_false(exists('exported'))
3063
3064 " imported function becomes script-local
3065 import GetText from './Xvim9_script.vim'
3066 call assert_equal('text', s:GetText())
3067 call assert_false(exists('*GetText'))
3068 END
3069 writefile(legacy_lines, 'Xlegacy_script.vim')
3070
3071 let vim9_lines =<< trim END
3072 vim9script
3073 let local = 'local'
3074 g:global = 'global'
3075 export let exported = 'exported'
3076 export def GetText(): string
3077 return 'text'
3078 enddef
3079 END
3080 writefile(vim9_lines, 'Xvim9_script.vim')
3081
3082 source Xlegacy_script.vim
3083
3084 assert_equal('global', g:global)
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02003085 unlet g:global
Bram Moolenaar9721fb42020-06-11 23:10:46 +02003086
3087 delete('Xlegacy_script.vim')
3088 delete('Xvim9_script.vim')
3089enddef
Bram Moolenaara5d00772020-05-14 23:20:55 +02003090
Bram Moolenaar7d699702020-08-14 20:52:28 +02003091func Test_vim9script_not_global()
3092 " check that items defined in Vim9 script are script-local, not global
3093 let vim9lines =<< trim END
3094 vim9script
3095 let var = 'local'
3096 func TheFunc()
3097 echo 'local'
3098 endfunc
3099 def DefFunc()
3100 echo 'local'
3101 enddef
3102 END
3103 call writefile(vim9lines, 'Xvim9script.vim')
3104 source Xvim9script.vim
3105 try
3106 echo g:var
3107 assert_report('did not fail')
3108 catch /E121:/
3109 " caught
3110 endtry
3111 try
3112 call TheFunc()
3113 assert_report('did not fail')
3114 catch /E117:/
3115 " caught
3116 endtry
3117 try
3118 call DefFunc()
3119 assert_report('did not fail')
3120 catch /E117:/
3121 " caught
3122 endtry
3123
3124 call delete('Xvim9script.vium')
3125endfunc
3126
Bram Moolenaareeb27bf2020-07-04 17:39:10 +02003127def Test_vim9_copen()
3128 # this was giving an error for setting w:quickfix_title
3129 copen
3130 quit
3131enddef
3132
Bram Moolenaar2d6b20d2020-07-25 19:30:59 +02003133" test using a vim9script that is auto-loaded from an autocmd
3134def Test_vim9_autoload()
3135 let lines =<< trim END
3136 vim9script
3137 def foo#test()
3138 echomsg getreg('"')
3139 enddef
3140 END
3141
3142 mkdir('Xdir/autoload', 'p')
3143 writefile(lines, 'Xdir/autoload/foo.vim')
3144 let save_rtp = &rtp
3145 exe 'set rtp^=' .. getcwd() .. '/Xdir'
3146 augroup test
3147 autocmd TextYankPost * call foo#test()
3148 augroup END
3149
3150 normal Y
3151
3152 augroup test
3153 autocmd!
3154 augroup END
3155 delete('Xdir', 'rf')
3156 &rtp = save_rtp
3157enddef
3158
Bram Moolenaar3896a102020-08-09 14:33:55 +02003159def Test_cmdline_win()
3160 # if the Vim syntax highlighting uses Vim9 constructs they can be used from
3161 # the command line window.
3162 mkdir('rtp/syntax', 'p')
3163 let export_lines =<< trim END
3164 vim9script
3165 export let That = 'yes'
3166 END
3167 writefile(export_lines, 'rtp/syntax/Xexport.vim')
3168 let import_lines =<< trim END
3169 vim9script
3170 import That from './Xexport.vim'
3171 END
3172 writefile(import_lines, 'rtp/syntax/vim.vim')
3173 let save_rtp = &rtp
3174 &rtp = getcwd() .. '/rtp' .. ',' .. &rtp
3175 syntax on
3176 augroup CmdWin
3177 autocmd CmdwinEnter * g:got_there = 'yes'
3178 augroup END
3179 # this will open and also close the cmdline window
3180 feedkeys('q:', 'xt')
3181 assert_equal('yes', g:got_there)
3182
3183 augroup CmdWin
3184 au!
3185 augroup END
3186 &rtp = save_rtp
3187 delete('rtp', 'rf')
3188enddef
3189
Bram Moolenaar585fea72020-04-02 22:33:21 +02003190" Keep this last, it messes up highlighting.
3191def Test_substitute_cmd()
3192 new
3193 setline(1, 'something')
3194 :substitute(some(other(
3195 assert_equal('otherthing', getline(1))
3196 bwipe!
3197
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02003198 # also when the context is Vim9 script
Bram Moolenaar585fea72020-04-02 22:33:21 +02003199 let lines =<< trim END
3200 vim9script
3201 new
3202 setline(1, 'something')
3203 :substitute(some(other(
3204 assert_equal('otherthing', getline(1))
3205 bwipe!
3206 END
3207 writefile(lines, 'Xvim9lines')
3208 source Xvim9lines
3209
3210 delete('Xvim9lines')
3211enddef
3212
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003213" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker