blob: 031b31917c41c15f867c4154d0911c7c970422a2 [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 Moolenaar6e587dc2020-02-06 13:15:52 +010020
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010021def Test_assignment()
22 let bool1: bool = true
23 assert_equal(v:true, bool1)
24 let bool2: bool = false
25 assert_equal(v:false, bool2)
26
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +020027 call CheckDefFailure(['let x:string'], 'E1069:')
28 call CheckDefFailure(['let x:string = "x"'], 'E1069:')
Bram Moolenaar1cc2a942020-05-10 19:10:31 +020029 call CheckDefFailure(['let a:string = "x"'], 'E1069:')
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +020030
Bram Moolenaar9be61bb2020-03-30 22:51:24 +020031 let a: number = 6
32 assert_equal(6, a)
33
Bram Moolenaar42a480b2020-02-29 23:23:47 +010034 if has('channel')
35 let chan1: channel
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +010036 let job1: job
Bram Moolenaarf51cb4e2020-03-01 17:55:14 +010037 let job2: job = job_start('willfail')
Bram Moolenaar42a480b2020-02-29 23:23:47 +010038 endif
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +010039 if has('float')
40 let float1: float = 3.4
41 endif
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +020042 let Funky1: func
43 let Funky2: func = function('len')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +020044 let Party2: func = funcref('g:Test_syntax')
Bram Moolenaar42a480b2020-02-29 23:23:47 +010045
Bram Moolenaar401d9ff2020-02-19 18:14:44 +010046 g:newvar = 'new'
47 assert_equal('new', g:newvar)
48
49 assert_equal('yes', g:existing)
50 g:existing = 'no'
51 assert_equal('no', g:existing)
52
Bram Moolenaarb283a8a2020-02-02 22:24:04 +010053 v:char = 'abc'
Bram Moolenaar6e587dc2020-02-06 13:15:52 +010054 assert_equal('abc', v:char)
Bram Moolenaarb283a8a2020-02-02 22:24:04 +010055
56 $ENVVAR = 'foobar'
Bram Moolenaar6e587dc2020-02-06 13:15:52 +010057 assert_equal('foobar', $ENVVAR)
Bram Moolenaarb283a8a2020-02-02 22:24:04 +010058 $ENVVAR = ''
Bram Moolenaar6e587dc2020-02-06 13:15:52 +010059
Bram Moolenaarfd1823e2020-02-19 20:23:11 +010060 s:appendToMe ..= 'yyy'
61 assert_equal('xxxyyy', s:appendToMe)
62 s:addToMe += 222
63 assert_equal(333, s:addToMe)
Bram Moolenaar0bbf7222020-02-19 22:31:48 +010064 s:newVar = 'new'
65 assert_equal('new', s:newVar)
Bram Moolenaara8c17702020-04-01 21:17:24 +020066
67 set ts=7
68 &ts += 1
69 assert_equal(8, &ts)
Bram Moolenaar80c34ca2020-04-01 23:05:18 +020070 &ts -= 3
71 assert_equal(5, &ts)
72 &ts *= 2
73 assert_equal(10, &ts)
74 &ts /= 3
75 assert_equal(3, &ts)
76 set ts=10
77 &ts %= 4
78 assert_equal(2, &ts)
Bram Moolenaara8c17702020-04-01 21:17:24 +020079 call CheckDefFailure(['&notex += 3'], 'E113:')
80 call CheckDefFailure(['&ts ..= "xxx"'], 'E1019:')
Bram Moolenaara6e67e42020-05-15 23:36:40 +020081 call CheckDefFailure(['&ts = [7]'], 'E1013:')
82 call CheckDefExecFailure(['&ts = g:alist'], 'E1029: Expected number but got list')
83 call CheckDefFailure(['&ts = "xx"'], 'E1013:')
84 call CheckDefExecFailure(['&ts = g:astring'], 'E1029: Expected number but got string')
Bram Moolenaara8c17702020-04-01 21:17:24 +020085 call CheckDefFailure(['&path += 3'], 'E1013:')
Bram Moolenaara6e67e42020-05-15 23:36:40 +020086 call CheckDefExecFailure(['&bs = "asdf"'], 'E474:')
Bram Moolenaarcb711ab2020-04-16 13:00:29 +020087 # test freeing ISN_STOREOPT
Bram Moolenaar585fea72020-04-02 22:33:21 +020088 call CheckDefFailure(['&ts = 3', 'let asdf'], 'E1022:')
Bram Moolenaar80c34ca2020-04-01 23:05:18 +020089 &ts = 8
Bram Moolenaara8c17702020-04-01 21:17:24 +020090
91 g:inc_counter += 1
92 assert_equal(2, g:inc_counter)
93
94 $SOME_ENV_VAR ..= 'more'
95 assert_equal('somemore', $SOME_ENV_VAR)
96 call CheckDefFailure(['$SOME_ENV_VAR += "more"'], 'E1013:')
97 call CheckDefFailure(['$SOME_ENV_VAR += 123'], 'E1013:')
98
99 @a = 'areg'
100 @a ..= 'add'
101 assert_equal('aregadd', @a)
102 call CheckDefFailure(['@a += "more"'], 'E1013:')
103 call CheckDefFailure(['@a += 123'], 'E1013:')
Bram Moolenaare69f6d02020-04-01 22:11:01 +0200104
105 v:errmsg = 'none'
106 v:errmsg ..= 'again'
107 assert_equal('noneagain', v:errmsg)
108 call CheckDefFailure(['v:errmsg += "more"'], 'E1013:')
109 call CheckDefFailure(['v:errmsg += 123'], 'E1013:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200110enddef
111
Bram Moolenaar3b74b6b2020-06-19 19:01:43 +0200112def Test_vim9_single_char_vars()
113 let lines =<< trim END
114 vim9script
115
116 " single character variable declarations work
117 let a: string
118 let b: number
119 let l: list<any>
120 let s: string
121 let t: number
122 let v: number
123 let w: number
124
125 " script-local variables can be used without s: prefix
126 a = 'script-a'
127 b = 111
128 l = [1, 2, 3]
129 s = 'script-s'
130 t = 222
131 v = 333
132 w = 444
133
134 assert_equal('script-a', a)
135 assert_equal(111, b)
136 assert_equal([1, 2, 3], l)
137 assert_equal('script-s', s)
138 assert_equal(222, t)
139 assert_equal(333, v)
140 assert_equal(444, w)
141 END
142 writefile(lines, 'Xsinglechar')
143 source Xsinglechar
144 delete('Xsinglechar')
145enddef
146
Bram Moolenaar84370082020-05-18 14:20:36 +0200147def Test_assignment_list()
148 let list1: list<bool> = [false, true, false]
149 let list2: list<number> = [1, 2, 3]
150 let list3: list<string> = ['sdf', 'asdf']
151 let list4: list<any> = ['yes', true, 1234]
152 let list5: list<blob> = [0z01, 0z02]
153
154 let listS: list<string> = []
155 let listN: list<number> = []
156
157 assert_equal([1, 2, 3], list2)
158 list2[-1] = 99
159 assert_equal([1, 2, 99], list2)
160 list2[-2] = 88
161 assert_equal([1, 88, 99], list2)
162 list2[-3] = 77
163 assert_equal([77, 88, 99], list2)
164 call CheckDefExecFailure(['let ll = [1, 2, 3]', 'll[-4] = 6'], 'E684:')
Bram Moolenaarc5b1c202020-06-18 22:43:27 +0200165 call CheckDefExecFailure(['let [v1, v2] = [1, 2]'], 'E1092:')
Bram Moolenaar84370082020-05-18 14:20:36 +0200166
167 # type becomes list<any>
168 let somelist = rand() > 0 ? [1, 2, 3] : ['a', 'b', 'c']
169enddef
170
171def Test_assignment_dict()
172 let dict1: dict<bool> = #{one: false, two: true}
173 let dict2: dict<number> = #{one: 1, two: 2}
174 let dict3: dict<string> = #{key: 'value'}
175 let dict4: dict<any> = #{one: 1, two: '2'}
Bram Moolenaar74fae512020-05-21 21:50:58 +0200176 let dict5: dict<blob> = #{one: 0z01, two: 0z02}
Bram Moolenaar84370082020-05-18 14:20:36 +0200177
Bram Moolenaarc785b9a2020-06-19 18:34:15 +0200178 " overwrite
179 dict3['key'] = 'another'
180
Bram Moolenaar84370082020-05-18 14:20:36 +0200181 call CheckDefExecFailure(['let dd = {}', 'dd[""] = 6'], 'E713:')
182
183 # type becomes dict<any>
184 let somedict = rand() > 0 ? #{a: 1, b: 2} : #{a: 'a', b: 'b'}
185enddef
186
Bram Moolenaard3aac292020-04-19 14:32:17 +0200187def Test_assignment_local()
188 " Test in a separated file in order not to the current buffer/window/tab is
189 " changed.
190 let script_lines: list<string> =<< trim END
191 let b:existing = 'yes'
192 let w:existing = 'yes'
193 let t:existing = 'yes'
194
195 def Test_assignment_local_internal()
196 b:newvar = 'new'
197 assert_equal('new', b:newvar)
198 assert_equal('yes', b:existing)
199 b:existing = 'no'
200 assert_equal('no', b:existing)
Bram Moolenaar396f3132020-05-09 18:44:56 +0200201 b:existing ..= 'NO'
202 assert_equal('noNO', b:existing)
Bram Moolenaard3aac292020-04-19 14:32:17 +0200203
204 w:newvar = 'new'
205 assert_equal('new', w:newvar)
206 assert_equal('yes', w:existing)
207 w:existing = 'no'
208 assert_equal('no', w:existing)
Bram Moolenaar396f3132020-05-09 18:44:56 +0200209 w:existing ..= 'NO'
210 assert_equal('noNO', w:existing)
Bram Moolenaard3aac292020-04-19 14:32:17 +0200211
212 t:newvar = 'new'
213 assert_equal('new', t:newvar)
214 assert_equal('yes', t:existing)
215 t:existing = 'no'
216 assert_equal('no', t:existing)
Bram Moolenaar396f3132020-05-09 18:44:56 +0200217 t:existing ..= 'NO'
218 assert_equal('noNO', t:existing)
Bram Moolenaard3aac292020-04-19 14:32:17 +0200219 enddef
220 call Test_assignment_local_internal()
221 END
222 call CheckScriptSuccess(script_lines)
223enddef
224
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200225def Test_assignment_default()
Bram Moolenaare69f6d02020-04-01 22:11:01 +0200226
Bram Moolenaarcb711ab2020-04-16 13:00:29 +0200227 # Test default values.
Bram Moolenaare69f6d02020-04-01 22:11:01 +0200228 let thebool: bool
229 assert_equal(v:false, thebool)
230
231 let thenumber: number
232 assert_equal(0, thenumber)
233
234 if has('float')
235 let thefloat: float
236 assert_equal(0.0, thefloat)
237 endif
238
239 let thestring: string
240 assert_equal('', thestring)
241
242 let theblob: blob
243 assert_equal(0z, theblob)
244
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200245 let Thefunc: func
246 assert_equal(test_null_function(), Thefunc)
Bram Moolenaare69f6d02020-04-01 22:11:01 +0200247
Bram Moolenaare69f6d02020-04-01 22:11:01 +0200248 let thelist: list<any>
249 assert_equal([], thelist)
250
251 let thedict: dict<any>
252 assert_equal({}, thedict)
253
Bram Moolenaar2c869de2020-04-02 19:12:08 +0200254 if has('channel')
255 let thejob: job
256 assert_equal(test_null_job(), thejob)
Bram Moolenaare69f6d02020-04-01 22:11:01 +0200257
Bram Moolenaar2c869de2020-04-02 19:12:08 +0200258 let thechannel: channel
259 assert_equal(test_null_channel(), thechannel)
Bram Moolenaarc785b9a2020-06-19 18:34:15 +0200260
261 if has('unix') && executable('cat')
262 " check with non-null job and channel, types must match
263 thejob = job_start("cat ", #{})
264 thechannel = job_getchannel(thejob)
265 job_stop(thejob, 'kill')
266 endif
Bram Moolenaar2c869de2020-04-02 19:12:08 +0200267 endif
Bram Moolenaar585fea72020-04-02 22:33:21 +0200268
269 let nr = 1234 | nr = 5678
270 assert_equal(5678, nr)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100271enddef
272
Bram Moolenaar47a519a2020-06-14 23:05:10 +0200273def Test_assignment_var_list()
274 let v1: string
275 let v2: string
Bram Moolenaar9af78762020-06-16 11:34:42 +0200276 let vrem: list<string>
277 [v1] = ['aaa']
278 assert_equal('aaa', v1)
279
Bram Moolenaar47a519a2020-06-14 23:05:10 +0200280 [v1, v2] = ['one', 'two']
281 assert_equal('one', v1)
282 assert_equal('two', v2)
Bram Moolenaar9af78762020-06-16 11:34:42 +0200283
284 [v1, v2; vrem] = ['one', 'two']
285 assert_equal('one', v1)
286 assert_equal('two', v2)
287 assert_equal([], vrem)
288
289 [v1, v2; vrem] = ['one', 'two', 'three']
290 assert_equal('one', v1)
291 assert_equal('two', v2)
292 assert_equal(['three'], vrem)
Bram Moolenaar47a519a2020-06-14 23:05:10 +0200293enddef
294
Bram Moolenaarcab27672020-04-09 20:10:55 +0200295def Mess(): string
296 v:foldstart = 123
297 return 'xxx'
298enddef
299
Bram Moolenaard72c1bf2020-04-19 16:28:59 +0200300def Test_assignment_failure()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100301 call CheckDefFailure(['let var=234'], 'E1004:')
302 call CheckDefFailure(['let var =234'], 'E1004:')
303 call CheckDefFailure(['let var= 234'], 'E1004:')
304
305 call CheckDefFailure(['let true = 1'], 'E1034:')
306 call CheckDefFailure(['let false = 1'], 'E1034:')
307
Bram Moolenaar9af78762020-06-16 11:34:42 +0200308 call CheckDefFailure(['[a; b; c] = g:list'], 'E452:')
309 call CheckDefExecFailure(['let a: number',
310 '[a] = test_null_list()'], 'E1093:')
311 call CheckDefExecFailure(['let a: number',
312 '[a] = []'], 'E1093:')
313 call CheckDefExecFailure(['let x: number',
314 'let y: number',
315 '[x, y] = [1]'], 'E1093:')
316 call CheckDefExecFailure(['let x: number',
317 'let y: number',
318 'let z: list<number>',
319 '[x, y; z] = [1]'], 'E1093:')
Bram Moolenaar9be61bb2020-03-30 22:51:24 +0200320
Bram Moolenaare69f6d02020-04-01 22:11:01 +0200321 call CheckDefFailure(['let somevar'], "E1022:")
Bram Moolenaar9be61bb2020-03-30 22:51:24 +0200322 call CheckDefFailure(['let &option'], 'E1052:')
323 call CheckDefFailure(['&g:option = 5'], 'E113:')
324
Bram Moolenaare55b1c02020-06-21 15:52:59 +0200325 call CheckDefFailure(['let $VAR = 5'], 'E1016: Cannot declare an environment variable:')
Bram Moolenaar9be61bb2020-03-30 22:51:24 +0200326
327 call CheckDefFailure(['let @~ = 5'], 'E354:')
328 call CheckDefFailure(['let @a = 5'], 'E1066:')
329
Bram Moolenaare55b1c02020-06-21 15:52:59 +0200330 call CheckDefFailure(['let g:var = 5'], 'E1016: Cannot declare a global variable:')
331 call CheckDefFailure(['let w:var = 5'], 'E1016: Cannot declare a window variable:')
332 call CheckDefFailure(['let b:var = 5'], 'E1016: Cannot declare a buffer variable:')
333 call CheckDefFailure(['let t:var = 5'], 'E1016: Cannot declare a tab variable:')
Bram Moolenaar9be61bb2020-03-30 22:51:24 +0200334
335 call CheckDefFailure(['let anr = 4', 'anr ..= "text"'], 'E1019:')
336 call CheckDefFailure(['let xnr += 4'], 'E1020:')
337
Bram Moolenaar822ba242020-05-24 23:00:18 +0200338 call CheckScriptFailure(['vim9script', 'def Func()', 'let dummy = s:notfound', 'enddef', 'defcompile'], 'E1050:')
Bram Moolenaar33fa29c2020-03-28 19:41:33 +0100339
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100340 call CheckDefFailure(['let var: list<string> = [123]'], 'expected list<string> but got list<number>')
341 call CheckDefFailure(['let var: list<number> = ["xx"]'], 'expected list<number> but got list<string>')
342
343 call CheckDefFailure(['let var: dict<string> = #{key: 123}'], 'expected dict<string> but got dict<number>')
344 call CheckDefFailure(['let var: dict<number> = #{key: "xx"}'], 'expected dict<number> but got dict<string>')
345
346 call CheckDefFailure(['let var = feedkeys("0")'], 'E1031:')
347 call CheckDefFailure(['let var: number = feedkeys("0")'], 'expected number but got void')
Bram Moolenaar42a480b2020-02-29 23:23:47 +0100348
Bram Moolenaard77a8522020-04-03 21:59:57 +0200349 call CheckDefFailure(['let var: dict <number>'], 'E1068:')
Bram Moolenaar42a480b2020-02-29 23:23:47 +0100350 call CheckDefFailure(['let var: dict<number'], 'E1009:')
Bram Moolenaarcab27672020-04-09 20:10:55 +0200351
352 call assert_fails('s/^/\=Mess()/n', 'E794:')
353 call CheckDefFailure(['let var: dict<number'], 'E1009:')
Bram Moolenaard72c1bf2020-04-19 16:28:59 +0200354enddef
355
356def Test_unlet()
357 g:somevar = 'yes'
358 assert_true(exists('g:somevar'))
359 unlet g:somevar
360 assert_false(exists('g:somevar'))
361 unlet! g:somevar
362
363 call CheckScriptFailure([
364 'vim9script',
365 'let svar = 123',
366 'unlet svar',
367 ], 'E1081:')
368 call CheckScriptFailure([
369 'vim9script',
370 'let svar = 123',
371 'unlet s:svar',
372 ], 'E1081:')
373 call CheckScriptFailure([
374 'vim9script',
375 'let svar = 123',
376 'def Func()',
377 ' unlet svar',
378 'enddef',
Bram Moolenaar822ba242020-05-24 23:00:18 +0200379 'defcompile',
Bram Moolenaard72c1bf2020-04-19 16:28:59 +0200380 ], 'E1081:')
381 call CheckScriptFailure([
382 'vim9script',
383 'let svar = 123',
384 'def Func()',
385 ' unlet s:svar',
386 'enddef',
Bram Moolenaar822ba242020-05-24 23:00:18 +0200387 'defcompile',
Bram Moolenaard72c1bf2020-04-19 16:28:59 +0200388 ], 'E1081:')
Bram Moolenaar7bdaea62020-04-19 18:27:26 +0200389
390 $ENVVAR = 'foobar'
391 assert_equal('foobar', $ENVVAR)
392 unlet $ENVVAR
393 assert_equal('', $ENVVAR)
Bram Moolenaard72c1bf2020-04-19 16:28:59 +0200394enddef
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100395
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200396def Test_delfunction()
397 " Check function is defined in script namespace
398 CheckScriptSuccess([
399 'vim9script',
400 'func CheckMe()',
401 ' return 123',
402 'endfunc',
403 'assert_equal(123, s:CheckMe())',
404 ])
405
406 " Check function in script namespace cannot be deleted
407 CheckScriptFailure([
408 'vim9script',
409 'func DeleteMe1()',
410 'endfunc',
411 'delfunction DeleteMe1',
412 ], 'E1084:')
413 CheckScriptFailure([
414 'vim9script',
415 'func DeleteMe2()',
416 'endfunc',
417 'def DoThat()',
418 ' delfunction DeleteMe2',
419 'enddef',
420 'DoThat()',
421 ], 'E1084:')
422 CheckScriptFailure([
423 'vim9script',
424 'def DeleteMe3()',
425 'enddef',
426 'delfunction DeleteMe3',
427 ], 'E1084:')
428 CheckScriptFailure([
429 'vim9script',
430 'def DeleteMe4()',
431 'enddef',
432 'def DoThat()',
433 ' delfunction DeleteMe4',
434 'enddef',
435 'DoThat()',
436 ], 'E1084:')
437enddef
438
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100439func Test_wrong_type()
440 call CheckDefFailure(['let var: list<nothing>'], 'E1010:')
441 call CheckDefFailure(['let var: list<list<nothing>>'], 'E1010:')
442 call CheckDefFailure(['let var: dict<nothing>'], 'E1010:')
443 call CheckDefFailure(['let var: dict<dict<nothing>>'], 'E1010:')
444
445 call CheckDefFailure(['let var: dict<number'], 'E1009:')
446 call CheckDefFailure(['let var: dict<list<number>'], 'E1009:')
Bram Moolenaar42a480b2020-02-29 23:23:47 +0100447
448 call CheckDefFailure(['let var: ally'], 'E1010:')
449 call CheckDefFailure(['let var: bram'], 'E1010:')
450 call CheckDefFailure(['let var: cathy'], 'E1010:')
451 call CheckDefFailure(['let var: dom'], 'E1010:')
452 call CheckDefFailure(['let var: freddy'], 'E1010:')
453 call CheckDefFailure(['let var: john'], 'E1010:')
454 call CheckDefFailure(['let var: larry'], 'E1010:')
455 call CheckDefFailure(['let var: ned'], 'E1010:')
456 call CheckDefFailure(['let var: pam'], 'E1010:')
457 call CheckDefFailure(['let var: sam'], 'E1010:')
458 call CheckDefFailure(['let var: vim'], 'E1010:')
Bram Moolenaara0a9f432020-04-28 21:29:34 +0200459
460 call CheckDefFailure(['let Ref: number', 'Ref()'], 'E1085:')
461 call CheckDefFailure(['let Ref: string', 'let res = Ref()'], 'E1085:')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100462endfunc
463
464func Test_const()
465 call CheckDefFailure(['const var = 234', 'var = 99'], 'E1018:')
466 call CheckDefFailure(['const one = 234', 'let one = 99'], 'E1017:')
467 call CheckDefFailure(['const two'], 'E1021:')
Bram Moolenaar9be61bb2020-03-30 22:51:24 +0200468 call CheckDefFailure(['const &option'], 'E996:')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100469endfunc
470
Bram Moolenaardf069ee2020-06-22 23:02:51 +0200471def Test_range_no_colon()
472 call CheckDefFailure(['%s/a/b/'], 'E1050:')
473 call CheckDefFailure(['+ s/a/b/'], 'E1050:')
474 call CheckDefFailure(['- s/a/b/'], 'E1050:')
475 call CheckDefFailure(['. s/a/b/'], 'E1050:')
476enddef
477
478
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100479def Test_block()
480 let outer = 1
481 {
482 let inner = 2
483 assert_equal(1, outer)
484 assert_equal(2, inner)
485 }
486 assert_equal(1, outer)
487enddef
488
489func Test_block_failure()
490 call CheckDefFailure(['{', 'let inner = 1', '}', 'echo inner'], 'E1001:')
Bram Moolenaar585fea72020-04-02 22:33:21 +0200491 call CheckDefFailure(['}'], 'E1025:')
492 call CheckDefFailure(['{', 'echo 1'], 'E1026:')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100493endfunc
494
Bram Moolenaar585fea72020-04-02 22:33:21 +0200495def Test_cmd_modifier()
496 tab echo '0'
497 call CheckDefFailure(['5tab echo 3'], 'E16:')
498enddef
499
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100500def Test_try_catch()
501 let l = []
Bram Moolenaar7a092242020-04-16 22:10:49 +0200502 try # comment
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100503 add(l, '1')
504 throw 'wrong'
505 add(l, '2')
Bram Moolenaar7a092242020-04-16 22:10:49 +0200506 catch # comment
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100507 add(l, v:exception)
Bram Moolenaar7a092242020-04-16 22:10:49 +0200508 finally # comment
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100509 add(l, '3')
Bram Moolenaar7a092242020-04-16 22:10:49 +0200510 endtry # comment
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100511 assert_equal(['1', 'wrong', '3'], l)
512enddef
513
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100514def ThrowFromDef()
Bram Moolenaara72cfb82020-04-23 17:07:30 +0200515 throw "getout" # comment
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100516enddef
517
518func CatchInFunc()
519 try
520 call ThrowFromDef()
521 catch
522 let g:thrown_func = v:exception
523 endtry
524endfunc
525
526def CatchInDef()
527 try
528 ThrowFromDef()
529 catch
530 g:thrown_def = v:exception
531 endtry
532enddef
533
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100534def ReturnFinally(): string
535 try
536 return 'intry'
537 finally
538 g:in_finally = 'finally'
539 endtry
540 return 'end'
541enddef
542
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100543def Test_try_catch_nested()
544 CatchInFunc()
545 assert_equal('getout', g:thrown_func)
546
547 CatchInDef()
548 assert_equal('getout', g:thrown_def)
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100549
550 assert_equal('intry', ReturnFinally())
551 assert_equal('finally', g:in_finally)
552enddef
553
554def Test_try_catch_match()
555 let seq = 'a'
556 try
557 throw 'something'
558 catch /nothing/
559 seq ..= 'x'
560 catch /some/
561 seq ..= 'b'
562 catch /asdf/
563 seq ..= 'x'
Bram Moolenaare8c4abb2020-04-02 21:13:25 +0200564 catch ?a\?sdf?
565 seq ..= 'y'
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100566 finally
567 seq ..= 'c'
568 endtry
569 assert_equal('abc', seq)
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100570enddef
571
Bram Moolenaare8c4abb2020-04-02 21:13:25 +0200572def Test_try_catch_fails()
573 call CheckDefFailure(['catch'], 'E603:')
574 call CheckDefFailure(['try', 'echo 0', 'catch','catch'], 'E1033:')
575 call CheckDefFailure(['try', 'echo 0', 'catch /pat'], 'E1067:')
Bram Moolenaar585fea72020-04-02 22:33:21 +0200576 call CheckDefFailure(['finally'], 'E606:')
577 call CheckDefFailure(['try', 'echo 0', 'finally', 'echo 1', 'finally'], 'E607:')
578 call CheckDefFailure(['endtry'], 'E602:')
579 call CheckDefFailure(['while 1', 'endtry'], 'E170:')
580 call CheckDefFailure(['for i in range(5)', 'endtry'], 'E170:')
581 call CheckDefFailure(['if 2', 'endtry'], 'E171:')
582 call CheckDefFailure(['try', 'echo 1', 'endtry'], 'E1032:')
583
Bram Moolenaara72cfb82020-04-23 17:07:30 +0200584 call CheckDefFailure(['throw'], 'E1015:')
Bram Moolenaar585fea72020-04-02 22:33:21 +0200585 call CheckDefFailure(['throw xxx'], 'E1001:')
Bram Moolenaare8c4abb2020-04-02 21:13:25 +0200586enddef
587
Bram Moolenaar006ad482020-06-30 20:55:15 +0200588def Test_throw_vimscript()
589 " only checks line continuation
590 let lines =<< trim END
591 vim9script
592 try
593 throw 'one'
594 .. 'two'
595 catch
596 assert_equal('onetwo', v:exception)
597 endtry
598 END
599 CheckScriptSuccess(lines)
600enddef
601
Bram Moolenaar2a1381c2020-05-05 23:32:58 +0200602if has('channel')
603 let someJob = test_null_job()
Bram Moolenaar40ee4662020-05-05 22:08:26 +0200604
Bram Moolenaar2a1381c2020-05-05 23:32:58 +0200605 def FuncWithError()
606 echomsg g:someJob
607 enddef
Bram Moolenaar40ee4662020-05-05 22:08:26 +0200608
Bram Moolenaar2a1381c2020-05-05 23:32:58 +0200609 func Test_convert_emsg_to_exception()
610 try
611 call FuncWithError()
612 catch
613 call assert_match('Vim:E908:', v:exception)
614 endtry
615 endfunc
616endif
Bram Moolenaar40ee4662020-05-05 22:08:26 +0200617
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100618let s:export_script_lines =<< trim END
619 vim9script
620 let name: string = 'bob'
621 def Concat(arg: string): string
622 return name .. arg
623 enddef
Bram Moolenaar227a69d2020-05-15 18:17:28 +0200624 g:result = Concat('bie')
625 g:localname = name
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100626
627 export const CONST = 1234
628 export let exported = 9876
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100629 export let exp_name = 'John'
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100630 export def Exported(): string
631 return 'Exported'
632 enddef
633END
634
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100635def Test_vim9_import_export()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100636 let import_script_lines =<< trim END
637 vim9script
638 import {exported, Exported} from './Xexport.vim'
639 g:imported = exported
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100640 exported += 3
641 g:imported_added = exported
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100642 g:imported_func = Exported()
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100643
644 import {exp_name} from './Xexport.vim'
645 g:imported_name = exp_name
646 exp_name ..= ' Doe'
647 g:imported_name_appended = exp_name
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100648 g:imported_later = exported
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100649 END
650
651 writefile(import_script_lines, 'Ximport.vim')
652 writefile(s:export_script_lines, 'Xexport.vim')
653
654 source Ximport.vim
655
656 assert_equal('bobbie', g:result)
657 assert_equal('bob', g:localname)
658 assert_equal(9876, g:imported)
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100659 assert_equal(9879, g:imported_added)
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100660 assert_equal(9879, g:imported_later)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100661 assert_equal('Exported', g:imported_func)
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100662 assert_equal('John', g:imported_name)
663 assert_equal('John Doe', g:imported_name_appended)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100664 assert_false(exists('g:name'))
665
666 unlet g:result
667 unlet g:localname
668 unlet g:imported
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100669 unlet g:imported_added
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100670 unlet g:imported_later
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100671 unlet g:imported_func
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100672 unlet g:imported_name g:imported_name_appended
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100673 delete('Ximport.vim')
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100674
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100675 let import_in_def_lines =<< trim END
676 vim9script
677 def ImportInDef()
678 import exported from './Xexport.vim'
679 g:imported = exported
680 exported += 7
681 g:imported_added = exported
682 enddef
683 ImportInDef()
684 END
685 writefile(import_in_def_lines, 'Ximport2.vim')
686 source Ximport2.vim
687 " TODO: this should be 9879
688 assert_equal(9876, g:imported)
689 assert_equal(9883, g:imported_added)
690 unlet g:imported
691 unlet g:imported_added
692 delete('Ximport2.vim')
693
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100694 let import_star_as_lines =<< trim END
695 vim9script
696 import * as Export from './Xexport.vim'
697 def UseExport()
698 g:imported = Export.exported
699 enddef
700 UseExport()
701 END
702 writefile(import_star_as_lines, 'Ximport.vim')
703 source Ximport.vim
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100704 assert_equal(9883, g:imported)
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100705
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100706 let import_star_as_lines_no_dot =<< trim END
707 vim9script
708 import * as Export from './Xexport.vim'
709 def Func()
710 let dummy = 1
711 let imported = Export + dummy
712 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +0200713 defcompile
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100714 END
715 writefile(import_star_as_lines_no_dot, 'Ximport.vim')
716 assert_fails('source Ximport.vim', 'E1060:')
717
718 let import_star_as_lines_dot_space =<< trim END
719 vim9script
720 import * as Export from './Xexport.vim'
721 def Func()
722 let imported = Export . exported
723 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +0200724 defcompile
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100725 END
726 writefile(import_star_as_lines_dot_space, 'Ximport.vim')
727 assert_fails('source Ximport.vim', 'E1074:')
728
729 let import_star_as_lines_missing_name =<< trim END
730 vim9script
731 import * as Export from './Xexport.vim'
732 def Func()
733 let imported = Export.
734 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +0200735 defcompile
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100736 END
737 writefile(import_star_as_lines_missing_name, 'Ximport.vim')
738 assert_fails('source Ximport.vim', 'E1048:')
739
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100740 let import_star_lines =<< trim END
741 vim9script
742 import * from './Xexport.vim'
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100743 END
744 writefile(import_star_lines, 'Ximport.vim')
745 assert_fails('source Ximport.vim', 'E1045:')
746
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +0100747 " try to import something that exists but is not exported
748 let import_not_exported_lines =<< trim END
749 vim9script
750 import name from './Xexport.vim'
751 END
752 writefile(import_not_exported_lines, 'Ximport.vim')
753 assert_fails('source Ximport.vim', 'E1049:')
754
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100755 " try to import something that is already defined
756 let import_already_defined =<< trim END
757 vim9script
758 let exported = 'something'
759 import exported from './Xexport.vim'
760 END
761 writefile(import_already_defined, 'Ximport.vim')
762 assert_fails('source Ximport.vim', 'E1073:')
763
764 " try to import something that is already defined
765 import_already_defined =<< trim END
766 vim9script
767 let exported = 'something'
768 import * as exported from './Xexport.vim'
769 END
770 writefile(import_already_defined, 'Ximport.vim')
771 assert_fails('source Ximport.vim', 'E1073:')
772
773 " try to import something that is already defined
774 import_already_defined =<< trim END
775 vim9script
776 let exported = 'something'
777 import {exported} from './Xexport.vim'
778 END
779 writefile(import_already_defined, 'Ximport.vim')
780 assert_fails('source Ximport.vim', 'E1073:')
781
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +0100782 " import a very long name, requires making a copy
783 let import_long_name_lines =<< trim END
784 vim9script
785 import name012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789 from './Xexport.vim'
786 END
787 writefile(import_long_name_lines, 'Ximport.vim')
788 assert_fails('source Ximport.vim', 'E1048:')
789
790 let import_no_from_lines =<< trim END
791 vim9script
792 import name './Xexport.vim'
793 END
794 writefile(import_no_from_lines, 'Ximport.vim')
795 assert_fails('source Ximport.vim', 'E1070:')
796
797 let import_invalid_string_lines =<< trim END
798 vim9script
799 import name from Xexport.vim
800 END
801 writefile(import_invalid_string_lines, 'Ximport.vim')
802 assert_fails('source Ximport.vim', 'E1071:')
803
804 let import_wrong_name_lines =<< trim END
805 vim9script
806 import name from './XnoExport.vim'
807 END
808 writefile(import_wrong_name_lines, 'Ximport.vim')
809 assert_fails('source Ximport.vim', 'E1053:')
810
811 let import_missing_comma_lines =<< trim END
812 vim9script
813 import {exported name} from './Xexport.vim'
814 END
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100815 writefile(import_missing_comma_lines, 'Ximport3.vim')
816 assert_fails('source Ximport3.vim', 'E1046:')
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +0100817
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100818 delete('Ximport.vim')
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100819 delete('Ximport3.vim')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100820 delete('Xexport.vim')
821
Bram Moolenaar750802b2020-02-23 18:08:33 +0100822 " Check that in a Vim9 script 'cpo' is set to the Vim default.
823 set cpo&vi
824 let cpo_before = &cpo
825 let lines =<< trim END
826 vim9script
827 g:cpo_in_vim9script = &cpo
828 END
829 writefile(lines, 'Xvim9_script')
830 source Xvim9_script
831 assert_equal(cpo_before, &cpo)
832 set cpo&vim
833 assert_equal(&cpo, g:cpo_in_vim9script)
834 delete('Xvim9_script')
835enddef
836
837def Test_vim9script_fails()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100838 CheckScriptFailure(['scriptversion 2', 'vim9script'], 'E1039:')
839 CheckScriptFailure(['vim9script', 'scriptversion 2'], 'E1040:')
Bram Moolenaar750802b2020-02-23 18:08:33 +0100840 CheckScriptFailure(['export let some = 123'], 'E1042:')
Bram Moolenaar9721fb42020-06-11 23:10:46 +0200841 CheckScriptFailure(['import some from "./Xexport.vim"'], 'E1048:')
Bram Moolenaar750802b2020-02-23 18:08:33 +0100842 CheckScriptFailure(['vim9script', 'export let g:some'], 'E1044:')
843 CheckScriptFailure(['vim9script', 'export echo 134'], 'E1043:')
844
Bram Moolenaarc785b9a2020-06-19 18:34:15 +0200845 CheckScriptFailure(['vim9script', 'let str: string', 'str = 1234'], 'E1013:')
846 CheckScriptFailure(['vim9script', 'const str = "asdf"', 'str = "xxx"'], 'E46:')
847
Bram Moolenaar750802b2020-02-23 18:08:33 +0100848 assert_fails('vim9script', 'E1038')
Bram Moolenaara26b9702020-04-18 19:53:28 +0200849 assert_fails('export something', 'E1043')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100850enddef
851
Bram Moolenaarf7d267e2020-06-17 12:04:54 +0200852func Test_import_fails_without_script()
Bram Moolenaar101f4812020-06-16 23:18:51 +0200853 CheckRunVimInTerminal
854
Bram Moolenaar9bb3eb32020-06-17 20:03:36 +0200855 " call indirectly to avoid compilation error for missing functions
856 call Run_Test_import_fails_without_script()
857endfunc
858
859def Run_Test_import_fails_without_script()
Bram Moolenaar101f4812020-06-16 23:18:51 +0200860 let export =<< trim END
861 vim9script
862 export def Foo(): number
863 return 0
864 enddef
865 END
Bram Moolenaar9bb3eb32020-06-17 20:03:36 +0200866 writefile(export, 'Xexport.vim')
Bram Moolenaar101f4812020-06-16 23:18:51 +0200867
Bram Moolenaar9bb3eb32020-06-17 20:03:36 +0200868 let buf = RunVimInTerminal('-c "import Foo from ''./Xexport.vim''"', #{
869 rows: 6, wait_for_ruler: 0})
870 WaitForAssert({-> assert_match('^E1094:', term_getline(buf, 5))})
Bram Moolenaar101f4812020-06-16 23:18:51 +0200871
Bram Moolenaar9bb3eb32020-06-17 20:03:36 +0200872 delete('Xexport.vim')
873 StopVimInTerminal(buf)
874enddef
Bram Moolenaar101f4812020-06-16 23:18:51 +0200875
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200876def Test_vim9script_reload_import()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100877 let lines =<< trim END
878 vim9script
879 const var = ''
880 let valone = 1234
881 def MyFunc(arg: string)
882 valone = 5678
883 enddef
884 END
885 let morelines =<< trim END
886 let valtwo = 222
887 export def GetValtwo(): number
888 return valtwo
889 enddef
890 END
Bram Moolenaar03afdcf2020-04-27 23:39:30 +0200891 writefile(lines + morelines, 'Xreload.vim')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100892 source Xreload.vim
893 source Xreload.vim
894 source Xreload.vim
895
896 let testlines =<< trim END
897 vim9script
898 def TheFunc()
899 import GetValtwo from './Xreload.vim'
900 assert_equal(222, GetValtwo())
901 enddef
902 TheFunc()
903 END
904 writefile(testlines, 'Ximport.vim')
905 source Ximport.vim
906
Bram Moolenaar03afdcf2020-04-27 23:39:30 +0200907 " Test that when not using "morelines" GetValtwo() and valtwo are still
908 " defined, because import doesn't reload a script.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100909 writefile(lines, 'Xreload.vim')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100910 source Ximport.vim
911
912 " cannot declare a var twice
913 lines =<< trim END
914 vim9script
915 let valone = 1234
916 let valone = 5678
917 END
918 writefile(lines, 'Xreload.vim')
919 assert_fails('source Xreload.vim', 'E1041:')
920
921 delete('Xreload.vim')
922 delete('Ximport.vim')
923enddef
924
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200925def Test_vim9script_reload_delfunc()
926 let first_lines =<< trim END
927 vim9script
928 def FuncYes(): string
929 return 'yes'
930 enddef
931 END
Bram Moolenaar03afdcf2020-04-27 23:39:30 +0200932 let withno_lines =<< trim END
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200933 def FuncNo(): string
934 return 'no'
935 enddef
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200936 def g:DoCheck(no_exists: bool)
937 assert_equal('yes', FuncYes())
Bram Moolenaar03afdcf2020-04-27 23:39:30 +0200938 assert_equal('no', FuncNo())
939 enddef
940 END
941 let nono_lines =<< trim END
942 def g:DoCheck(no_exists: bool)
943 assert_equal('yes', FuncYes())
944 assert_fails('call FuncNo()', 'E117:')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200945 enddef
946 END
947
948 # FuncNo() is defined
Bram Moolenaar03afdcf2020-04-27 23:39:30 +0200949 writefile(first_lines + withno_lines, 'Xreloaded.vim')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200950 source Xreloaded.vim
951 g:DoCheck(true)
952
953 # FuncNo() is not redefined
Bram Moolenaar03afdcf2020-04-27 23:39:30 +0200954 writefile(first_lines + nono_lines, 'Xreloaded.vim')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200955 source Xreloaded.vim
Bram Moolenaar03afdcf2020-04-27 23:39:30 +0200956 g:DoCheck()
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200957
958 # FuncNo() is back
Bram Moolenaar03afdcf2020-04-27 23:39:30 +0200959 writefile(first_lines + withno_lines, 'Xreloaded.vim')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200960 source Xreloaded.vim
Bram Moolenaar03afdcf2020-04-27 23:39:30 +0200961 g:DoCheck()
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200962
963 delete('Xreloaded.vim')
964enddef
965
Bram Moolenaar89483d42020-05-10 15:24:44 +0200966def Test_vim9script_reload_delvar()
967 # write the script with a script-local variable
968 let lines =<< trim END
969 vim9script
970 let var = 'string'
971 END
972 writefile(lines, 'XreloadVar.vim')
973 source XreloadVar.vim
974
975 # now write the script using the same variable locally - works
976 lines =<< trim END
977 vim9script
978 def Func()
979 let var = 'string'
980 enddef
981 END
982 writefile(lines, 'XreloadVar.vim')
983 source XreloadVar.vim
984
985 delete('XreloadVar.vim')
986enddef
987
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100988def Test_import_absolute()
989 let import_lines = [
Bram Moolenaare6085c52020-04-12 20:19:16 +0200990 'vim9script',
991 'import exported from "' .. escape(getcwd(), '\') .. '/Xexport_abs.vim"',
992 'def UseExported()',
993 ' g:imported_abs = exported',
994 ' exported = 8888',
995 ' g:imported_after = exported',
996 'enddef',
997 'UseExported()',
998 'g:import_disassembled = execute("disass UseExported")',
999 ]
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001000 writefile(import_lines, 'Ximport_abs.vim')
1001 writefile(s:export_script_lines, 'Xexport_abs.vim')
1002
1003 source Ximport_abs.vim
1004
1005 assert_equal(9876, g:imported_abs)
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +01001006 assert_equal(8888, g:imported_after)
Bram Moolenaar675f7162020-04-12 22:53:54 +02001007 assert_match('<SNR>\d\+_UseExported.*' ..
1008 'g:imported_abs = exported.*' ..
1009 '0 LOADSCRIPT exported from .*Xexport_abs.vim.*' ..
1010 '1 STOREG g:imported_abs.*' ..
1011 'exported = 8888.*' ..
1012 '3 STORESCRIPT exported in .*Xexport_abs.vim.*' ..
1013 'g:imported_after = exported.*' ..
1014 '4 LOADSCRIPT exported from .*Xexport_abs.vim.*' ..
1015 '5 STOREG g:imported_after.*',
Bram Moolenaare6085c52020-04-12 20:19:16 +02001016 g:import_disassembled)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001017 unlet g:imported_abs
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +01001018 unlet g:import_disassembled
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001019
1020 delete('Ximport_abs.vim')
1021 delete('Xexport_abs.vim')
1022enddef
1023
1024def Test_import_rtp()
1025 let import_lines = [
Bram Moolenaare6085c52020-04-12 20:19:16 +02001026 'vim9script',
1027 'import exported from "Xexport_rtp.vim"',
1028 'g:imported_rtp = exported',
1029 ]
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001030 writefile(import_lines, 'Ximport_rtp.vim')
1031 mkdir('import')
1032 writefile(s:export_script_lines, 'import/Xexport_rtp.vim')
1033
1034 let save_rtp = &rtp
1035 &rtp = getcwd()
1036 source Ximport_rtp.vim
1037 &rtp = save_rtp
1038
1039 assert_equal(9876, g:imported_rtp)
1040 unlet g:imported_rtp
1041
1042 delete('Ximport_rtp.vim')
Bram Moolenaar89483d42020-05-10 15:24:44 +02001043 delete('import', 'rf')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001044enddef
1045
Bram Moolenaar25e0f582020-05-25 22:36:50 +02001046def Test_import_compile_error()
1047 let export_lines = [
1048 'vim9script',
1049 'export def ExpFunc(): string',
1050 ' return notDefined',
1051 'enddef',
1052 ]
1053 writefile(export_lines, 'Xexported.vim')
1054
1055 let import_lines = [
1056 'vim9script',
1057 'import ExpFunc from "./Xexported.vim"',
1058 'def ImpFunc()',
1059 ' echo ExpFunc()',
1060 'enddef',
1061 'defcompile',
1062 ]
1063 writefile(import_lines, 'Ximport.vim')
1064
1065 try
1066 source Ximport.vim
1067 catch /E1001/
1068 " Error should be fore the Xexported.vim file.
1069 assert_match('E1001: variable not found: notDefined', v:exception)
1070 assert_match('function <SNR>\d\+_ImpFunc\[1\]..<SNR>\d\+_ExpFunc, line 1', v:throwpoint)
1071 endtry
1072
1073 delete('Xexported.vim')
1074 delete('Ximport.vim')
1075enddef
1076
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001077def Test_fixed_size_list()
1078 " will be allocated as one piece of memory, check that changes work
1079 let l = [1, 2, 3, 4]
1080 l->remove(0)
1081 l->add(5)
1082 l->insert(99, 1)
Bram Moolenaar0f18b6d2020-02-02 17:22:27 +01001083 assert_equal([2, 99, 3, 4, 5], l)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001084enddef
1085
Bram Moolenaar158906c2020-02-06 20:39:45 +01001086def IfElse(what: number): string
1087 let res = ''
1088 if what == 1
1089 res = "one"
1090 elseif what == 2
1091 res = "two"
Bram Moolenaara259d8d2020-01-31 20:10:50 +01001092 else
Bram Moolenaar158906c2020-02-06 20:39:45 +01001093 res = "three"
Bram Moolenaara259d8d2020-01-31 20:10:50 +01001094 endif
Bram Moolenaar158906c2020-02-06 20:39:45 +01001095 return res
Bram Moolenaara259d8d2020-01-31 20:10:50 +01001096enddef
1097
Bram Moolenaar158906c2020-02-06 20:39:45 +01001098def Test_if_elseif_else()
1099 assert_equal('one', IfElse(1))
1100 assert_equal('two', IfElse(2))
1101 assert_equal('three', IfElse(3))
Bram Moolenaar0f18b6d2020-02-02 17:22:27 +01001102enddef
1103
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001104def Test_if_elseif_else_fails()
1105 call CheckDefFailure(['elseif true'], 'E582:')
1106 call CheckDefFailure(['else'], 'E581:')
1107 call CheckDefFailure(['endif'], 'E580:')
1108 call CheckDefFailure(['if true', 'elseif xxx'], 'E1001:')
Bram Moolenaar585fea72020-04-02 22:33:21 +02001109 call CheckDefFailure(['if true', 'echo 1'], 'E171:')
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001110enddef
1111
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001112let g:bool_true = v:true
1113let g:bool_false = v:false
1114
1115def Test_if_const_expr()
1116 let res = false
1117 if true ? true : false
1118 res = true
1119 endif
1120 assert_equal(true, res)
1121
Bram Moolenaar585fea72020-04-02 22:33:21 +02001122 g:glob = 2
1123 if false
Bram Moolenaar67979662020-06-20 22:50:47 +02001124 execute('g:glob = 3')
Bram Moolenaar585fea72020-04-02 22:33:21 +02001125 endif
1126 assert_equal(2, g:glob)
1127 if true
Bram Moolenaar67979662020-06-20 22:50:47 +02001128 execute('g:glob = 3')
Bram Moolenaar585fea72020-04-02 22:33:21 +02001129 endif
1130 assert_equal(3, g:glob)
1131
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001132 res = false
1133 if g:bool_true ? true : false
1134 res = true
1135 endif
1136 assert_equal(true, res)
1137
1138 res = false
1139 if true ? g:bool_true : false
1140 res = true
1141 endif
1142 assert_equal(true, res)
1143
1144 res = false
1145 if true ? true : g:bool_false
1146 res = true
1147 endif
1148 assert_equal(true, res)
1149
1150 res = false
1151 if true ? false : true
1152 res = true
1153 endif
1154 assert_equal(false, res)
1155
1156 res = false
1157 if false ? false : true
1158 res = true
1159 endif
1160 assert_equal(true, res)
1161
1162 res = false
1163 if false ? true : false
1164 res = true
1165 endif
1166 assert_equal(false, res)
1167
1168 res = false
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001169 if has('xyz') ? true : false
1170 res = true
1171 endif
1172 assert_equal(false, res)
1173
1174 res = false
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001175 if true && true
1176 res = true
1177 endif
1178 assert_equal(true, res)
1179
1180 res = false
1181 if true && false
1182 res = true
1183 endif
1184 assert_equal(false, res)
1185
1186 res = false
1187 if g:bool_true && false
1188 res = true
1189 endif
1190 assert_equal(false, res)
1191
1192 res = false
1193 if true && g:bool_false
1194 res = true
1195 endif
1196 assert_equal(false, res)
1197
1198 res = false
1199 if false && false
1200 res = true
1201 endif
1202 assert_equal(false, res)
1203
1204 res = false
1205 if true || false
1206 res = true
1207 endif
1208 assert_equal(true, res)
1209
1210 res = false
1211 if g:bool_true || false
1212 res = true
1213 endif
1214 assert_equal(true, res)
1215
1216 res = false
1217 if true || g:bool_false
1218 res = true
1219 endif
1220 assert_equal(true, res)
1221
1222 res = false
1223 if false || false
1224 res = true
1225 endif
1226 assert_equal(false, res)
Bram Moolenaar80c34ca2020-04-01 23:05:18 +02001227enddef
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001228
Bram Moolenaar80c34ca2020-04-01 23:05:18 +02001229def Test_if_const_expr_fails()
1230 call CheckDefFailure(['if "aaa" == "bbb'], 'E114:')
1231 call CheckDefFailure(["if 'aaa' == 'bbb"], 'E115:')
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001232 call CheckDefFailure(["if has('aaa'"], 'E110:')
1233 call CheckDefFailure(["if has('aaa') ? true false"], 'E109:')
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001234enddef
1235
Bram Moolenaar72abcf42020-06-18 18:26:24 +02001236def RunNested(i: number): number
1237 let x: number = 0
1238 if i % 2
1239 if 1
1240 " comment
1241 else
1242 " comment
1243 endif
1244 x += 1
1245 else
1246 x += 1000
1247 endif
1248 return x
1249enddef
1250
1251def Test_nested_if()
1252 assert_equal(1, RunNested(1))
1253 assert_equal(1000, RunNested(2))
1254enddef
1255
Bram Moolenaarad39c092020-02-26 18:23:43 +01001256def Test_execute_cmd()
1257 new
1258 setline(1, 'default')
1259 execute 'call setline(1, "execute-string")'
1260 assert_equal('execute-string', getline(1))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001261
1262 execute "call setline(1, 'execute-string')"
1263 assert_equal('execute-string', getline(1))
1264
Bram Moolenaarad39c092020-02-26 18:23:43 +01001265 let cmd1 = 'call setline(1,'
1266 let cmd2 = '"execute-var")'
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001267 execute cmd1 cmd2 # comment
Bram Moolenaarad39c092020-02-26 18:23:43 +01001268 assert_equal('execute-var', getline(1))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001269
Bram Moolenaarad39c092020-02-26 18:23:43 +01001270 execute cmd1 cmd2 '|call setline(1, "execute-var-string")'
1271 assert_equal('execute-var-string', getline(1))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001272
Bram Moolenaarad39c092020-02-26 18:23:43 +01001273 let cmd_first = 'call '
1274 let cmd_last = 'setline(1, "execute-var-var")'
1275 execute cmd_first .. cmd_last
1276 assert_equal('execute-var-var', getline(1))
1277 bwipe!
Bram Moolenaar585fea72020-04-02 22:33:21 +02001278
1279 call CheckDefFailure(['execute xxx'], 'E1001:')
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001280 call CheckDefFailure(['execute "cmd"# comment'], 'E488:')
Bram Moolenaarad39c092020-02-26 18:23:43 +01001281enddef
1282
1283def Test_echo_cmd()
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001284 echo 'some' # comment
Bram Moolenaar585fea72020-04-02 22:33:21 +02001285 echon 'thing'
Bram Moolenaarad39c092020-02-26 18:23:43 +01001286 assert_match('^something$', Screenline(&lines))
1287
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001288 echo "some" # comment
1289 echon "thing"
1290 assert_match('^something$', Screenline(&lines))
1291
Bram Moolenaarad39c092020-02-26 18:23:43 +01001292 let str1 = 'some'
1293 let str2 = 'more'
1294 echo str1 str2
1295 assert_match('^some more$', Screenline(&lines))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001296
1297 call CheckDefFailure(['echo "xxx"# comment'], 'E488:')
Bram Moolenaarad39c092020-02-26 18:23:43 +01001298enddef
1299
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001300def Test_echomsg_cmd()
1301 echomsg 'some' 'more' # comment
1302 assert_match('^some more$', Screenline(&lines))
1303 echo 'clear'
Bram Moolenaardf069ee2020-06-22 23:02:51 +02001304 :1messages
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001305 assert_match('^some more$', Screenline(&lines))
1306
1307 call CheckDefFailure(['echomsg "xxx"# comment'], 'E488:')
1308enddef
1309
1310def Test_echoerr_cmd()
Bram Moolenaar40ee4662020-05-05 22:08:26 +02001311 try
1312 echoerr 'something' 'wrong' # comment
1313 catch
1314 assert_match('something wrong', v:exception)
1315 endtry
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001316enddef
1317
Bram Moolenaar41fe0612020-03-01 16:22:40 +01001318def Test_for_outside_of_function()
1319 let lines =<< trim END
1320 vim9script
1321 new
1322 for var in range(0, 3)
1323 append(line('$'), var)
1324 endfor
1325 assert_equal(['', '0', '1', '2', '3'], getline(1, '$'))
1326 bwipe!
1327 END
1328 writefile(lines, 'Xvim9for.vim')
1329 source Xvim9for.vim
1330 delete('Xvim9for.vim')
1331enddef
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001332
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001333def Test_for_loop()
1334 let result = ''
1335 for cnt in range(7)
1336 if cnt == 4
1337 break
1338 endif
1339 if cnt == 2
1340 continue
1341 endif
1342 result ..= cnt .. '_'
1343 endfor
1344 assert_equal('0_1_3_', result)
1345enddef
1346
1347def Test_for_loop_fails()
Bram Moolenaar675f7162020-04-12 22:53:54 +02001348 CheckDefFailure(['for # in range(5)'], 'E690:')
1349 CheckDefFailure(['for i In range(5)'], 'E690:')
1350 CheckDefFailure(['let x = 5', 'for x in range(5)'], 'E1023:')
Bram Moolenaar822ba242020-05-24 23:00:18 +02001351 CheckScriptFailure(['def Func(arg: any)', 'for arg in range(5)', 'enddef', 'defcompile'], 'E1006:')
Bram Moolenaar675f7162020-04-12 22:53:54 +02001352 CheckDefFailure(['for i in "text"'], 'E1024:')
1353 CheckDefFailure(['for i in xxx'], 'E1001:')
1354 CheckDefFailure(['endfor'], 'E588:')
1355 CheckDefFailure(['for i in range(3)', 'echo 3'], 'E170:')
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001356enddef
1357
Bram Moolenaard0df1aa2020-03-04 21:50:46 +01001358def Test_while_loop()
1359 let result = ''
1360 let cnt = 0
1361 while cnt < 555
1362 if cnt == 3
1363 break
1364 endif
1365 cnt += 1
1366 if cnt == 2
1367 continue
1368 endif
1369 result ..= cnt .. '_'
1370 endwhile
1371 assert_equal('1_3_', result)
1372enddef
1373
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001374def Test_while_loop_fails()
Bram Moolenaar675f7162020-04-12 22:53:54 +02001375 CheckDefFailure(['while xxx'], 'E1001:')
1376 CheckDefFailure(['endwhile'], 'E588:')
1377 CheckDefFailure(['continue'], 'E586:')
1378 CheckDefFailure(['if true', 'continue'], 'E586:')
1379 CheckDefFailure(['break'], 'E587:')
1380 CheckDefFailure(['if true', 'break'], 'E587:')
1381 CheckDefFailure(['while 1', 'echo 3'], 'E170:')
Bram Moolenaarbd5da372020-03-31 23:13:10 +02001382enddef
1383
Bram Moolenaar9645e2d2020-03-20 20:48:49 +01001384def Test_interrupt_loop()
Bram Moolenaar97acfc72020-03-22 13:44:28 +01001385 let caught = false
Bram Moolenaar9645e2d2020-03-20 20:48:49 +01001386 let x = 0
Bram Moolenaar97acfc72020-03-22 13:44:28 +01001387 try
1388 while 1
1389 x += 1
1390 if x == 100
1391 feedkeys("\<C-C>", 'Lt')
1392 endif
1393 endwhile
1394 catch
1395 caught = true
1396 assert_equal(100, x)
1397 endtry
1398 assert_true(caught, 'should have caught an exception')
Bram Moolenaar9645e2d2020-03-20 20:48:49 +01001399enddef
Bram Moolenaar20431c92020-03-20 18:39:46 +01001400
Bram Moolenaar4fdae992020-04-12 16:38:57 +02001401def Test_automatic_line_continuation()
1402 let mylist = [
1403 'one',
1404 'two',
1405 'three',
1406 ] " comment
1407 assert_equal(['one', 'two', 'three'], mylist)
1408
1409 let mydict = {
1410 'one': 1,
1411 'two': 2,
1412 'three':
1413 3,
1414 } " comment
1415 assert_equal({'one': 1, 'two': 2, 'three': 3}, mydict)
1416 mydict = #{
Bram Moolenaar2c330432020-04-13 14:41:35 +02001417 one: 1, # comment
1418 two: # comment
1419 2, # comment
1420 three: 3 # comment
1421 }
1422 assert_equal(#{one: 1, two: 2, three: 3}, mydict)
1423 mydict = #{
1424 one: 1,
1425 two:
1426 2,
1427 three: 3
Bram Moolenaar4fdae992020-04-12 16:38:57 +02001428 }
1429 assert_equal(#{one: 1, two: 2, three: 3}, mydict)
Bram Moolenaare6085c52020-04-12 20:19:16 +02001430
1431 assert_equal(
1432 ['one', 'two', 'three'],
1433 split('one two three')
1434 )
Bram Moolenaar4fdae992020-04-12 16:38:57 +02001435enddef
1436
Bram Moolenaar7a092242020-04-16 22:10:49 +02001437def Test_vim9_comment()
1438 CheckScriptSuccess([
1439 'vim9script',
1440 '# something',
1441 ])
1442 CheckScriptFailure([
1443 'vim9script',
1444 ':# something',
1445 ], 'E488:')
1446 CheckScriptFailure([
1447 '# something',
1448 ], 'E488:')
1449 CheckScriptFailure([
1450 ':# something',
1451 ], 'E488:')
1452
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02001453 { # block start
1454 } # block end
1455 CheckDefFailure([
1456 '{# comment',
1457 ], 'E488:')
1458 CheckDefFailure([
1459 '{',
1460 '}# comment',
1461 ], 'E488:')
1462
1463 echo "yes" # comment
1464 CheckDefFailure([
1465 'echo "yes"# comment',
1466 ], 'E488:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02001467 CheckScriptSuccess([
1468 'vim9script',
1469 'echo "yes" # something',
1470 ])
1471 CheckScriptFailure([
1472 'vim9script',
1473 'echo "yes"# something',
1474 ], 'E121:')
1475 CheckScriptFailure([
1476 'vim9script',
1477 'echo# something',
1478 ], 'E121:')
1479 CheckScriptFailure([
1480 'echo "yes" # something',
1481 ], 'E121:')
1482
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02001483 exe "echo" # comment
1484 CheckDefFailure([
1485 'exe "echo"# comment',
1486 ], 'E488:')
1487 CheckScriptSuccess([
1488 'vim9script',
1489 'exe "echo" # something',
1490 ])
1491 CheckScriptFailure([
1492 'vim9script',
1493 'exe "echo"# something',
1494 ], 'E121:')
1495 CheckDefFailure([
1496 'exe # comment',
1497 ], 'E1015:')
1498 CheckScriptFailure([
1499 'vim9script',
1500 'exe# something',
1501 ], 'E121:')
1502 CheckScriptFailure([
1503 'exe "echo" # something',
1504 ], 'E121:')
1505
Bram Moolenaar7a092242020-04-16 22:10:49 +02001506 CheckDefFailure([
1507 'try# comment',
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02001508 ' echo "yes"',
Bram Moolenaar7a092242020-04-16 22:10:49 +02001509 'catch',
1510 'endtry',
1511 ], 'E488:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02001512 CheckScriptFailure([
1513 'vim9script',
1514 'try# comment',
1515 'echo "yes"',
1516 ], 'E488:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02001517 CheckDefFailure([
1518 'try',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001519 ' throw#comment',
1520 'catch',
1521 'endtry',
1522 ], 'E1015:')
1523 CheckDefFailure([
1524 'try',
1525 ' throw "yes"#comment',
1526 'catch',
1527 'endtry',
1528 ], 'E488:')
1529 CheckDefFailure([
1530 'try',
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02001531 ' echo "yes"',
Bram Moolenaar7a092242020-04-16 22:10:49 +02001532 'catch# comment',
1533 'endtry',
1534 ], 'E488:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02001535 CheckScriptFailure([
1536 'vim9script',
1537 'try',
1538 ' echo "yes"',
1539 'catch# comment',
1540 'endtry',
1541 ], 'E654:')
1542 CheckDefFailure([
1543 'try',
1544 ' echo "yes"',
1545 'catch /pat/# comment',
1546 'endtry',
1547 ], 'E488:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02001548 CheckDefFailure([
1549 'try',
1550 'echo "yes"',
1551 'catch',
1552 'endtry# comment',
1553 ], 'E488:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02001554 CheckScriptFailure([
1555 'vim9script',
1556 'try',
1557 ' echo "yes"',
1558 'catch',
1559 'endtry# comment',
1560 ], 'E600:')
1561
1562 CheckScriptSuccess([
1563 'vim9script',
1564 'hi # comment',
1565 ])
1566 CheckScriptFailure([
1567 'vim9script',
1568 'hi# comment',
1569 ], 'E416:')
Bram Moolenaar1966c242020-04-20 22:42:32 +02001570 CheckScriptSuccess([
1571 'vim9script',
1572 'hi Search # comment',
1573 ])
1574 CheckScriptFailure([
1575 'vim9script',
1576 'hi Search# comment',
1577 ], 'E416:')
1578 CheckScriptSuccess([
1579 'vim9script',
1580 'hi link This Search # comment',
1581 ])
1582 CheckScriptFailure([
1583 'vim9script',
1584 'hi link This That# comment',
1585 ], 'E413:')
1586 CheckScriptSuccess([
1587 'vim9script',
1588 'hi clear This # comment',
1589 'hi clear # comment',
1590 ])
1591 " not tested, because it doesn't give an error but a warning:
1592 " hi clear This# comment',
1593 CheckScriptFailure([
1594 'vim9script',
1595 'hi clear# comment',
1596 ], 'E416:')
1597
1598 CheckScriptSuccess([
1599 'vim9script',
1600 'hi Group term=bold',
1601 'match Group /todo/ # comment',
1602 ])
1603 CheckScriptFailure([
1604 'vim9script',
1605 'hi Group term=bold',
1606 'match Group /todo/# comment',
1607 ], 'E488:')
1608 CheckScriptSuccess([
1609 'vim9script',
1610 'match # comment',
1611 ])
1612 CheckScriptFailure([
1613 'vim9script',
1614 'match# comment',
1615 ], 'E475:')
1616 CheckScriptSuccess([
1617 'vim9script',
1618 'match none # comment',
1619 ])
1620 CheckScriptFailure([
1621 'vim9script',
1622 'match none# comment',
1623 ], 'E475:')
1624
1625 CheckScriptSuccess([
1626 'vim9script',
1627 'menutrans clear # comment',
1628 ])
1629 CheckScriptFailure([
1630 'vim9script',
1631 'menutrans clear# comment text',
1632 ], 'E474:')
1633
1634 CheckScriptSuccess([
1635 'vim9script',
1636 'syntax clear # comment',
1637 ])
1638 CheckScriptFailure([
1639 'vim9script',
1640 'syntax clear# comment text',
1641 ], 'E28:')
1642 CheckScriptSuccess([
1643 'vim9script',
1644 'syntax keyword Word some',
1645 'syntax clear Word # comment',
1646 ])
1647 CheckScriptFailure([
1648 'vim9script',
1649 'syntax keyword Word some',
1650 'syntax clear Word# comment text',
1651 ], 'E28:')
1652
1653 CheckScriptSuccess([
1654 'vim9script',
1655 'syntax list # comment',
1656 ])
1657 CheckScriptFailure([
1658 'vim9script',
1659 'syntax list# comment text',
1660 ], 'E28:')
1661
1662 CheckScriptSuccess([
1663 'vim9script',
1664 'syntax match Word /pat/ oneline # comment',
1665 ])
1666 CheckScriptFailure([
1667 'vim9script',
1668 'syntax match Word /pat/ oneline# comment',
1669 ], 'E475:')
1670
1671 CheckScriptSuccess([
1672 'vim9script',
1673 'syntax keyword Word word # comm[ent',
1674 ])
1675 CheckScriptFailure([
1676 'vim9script',
1677 'syntax keyword Word word# comm[ent',
1678 ], 'E789:')
1679
1680 CheckScriptSuccess([
1681 'vim9script',
1682 'syntax match Word /pat/ # comment',
1683 ])
1684 CheckScriptFailure([
1685 'vim9script',
1686 'syntax match Word /pat/# comment',
1687 ], 'E402:')
1688
1689 CheckScriptSuccess([
1690 'vim9script',
1691 'syntax match Word /pat/ contains=Something # comment',
1692 ])
1693 CheckScriptFailure([
1694 'vim9script',
1695 'syntax match Word /pat/ contains=Something# comment',
1696 ], 'E475:')
1697 CheckScriptFailure([
1698 'vim9script',
1699 'syntax match Word /pat/ contains= # comment',
1700 ], 'E406:')
1701 CheckScriptFailure([
1702 'vim9script',
1703 'syntax match Word /pat/ contains=# comment',
1704 ], 'E475:')
1705
1706 CheckScriptSuccess([
1707 'vim9script',
1708 'syntax region Word start=/pat/ end=/pat/ # comment',
1709 ])
1710 CheckScriptFailure([
1711 'vim9script',
1712 'syntax region Word start=/pat/ end=/pat/# comment',
1713 ], 'E475:')
1714
1715 CheckScriptSuccess([
1716 'vim9script',
1717 'syntax sync # comment',
1718 ])
1719 CheckScriptFailure([
1720 'vim9script',
1721 'syntax sync# comment',
1722 ], 'E404:')
1723 CheckScriptSuccess([
1724 'vim9script',
1725 'syntax sync ccomment # comment',
1726 ])
1727 CheckScriptFailure([
1728 'vim9script',
1729 'syntax sync ccomment# comment',
1730 ], 'E404:')
1731
1732 CheckScriptSuccess([
1733 'vim9script',
1734 'syntax cluster Some contains=Word # comment',
1735 ])
1736 CheckScriptFailure([
1737 'vim9script',
1738 'syntax cluster Some contains=Word# comment',
1739 ], 'E475:')
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001740
1741 CheckScriptSuccess([
1742 'vim9script',
1743 'command Echo echo # comment',
1744 'command Echo # comment',
1745 ])
1746 CheckScriptFailure([
1747 'vim9script',
1748 'command Echo echo# comment',
1749 'Echo',
1750 ], 'E121:')
1751 CheckScriptFailure([
1752 'vim9script',
1753 'command Echo# comment',
1754 ], 'E182:')
1755 CheckScriptFailure([
1756 'vim9script',
1757 'command Echo echo',
1758 'command Echo# comment',
1759 ], 'E182:')
1760
1761 CheckScriptSuccess([
1762 'vim9script',
1763 'function # comment',
1764 ])
1765 CheckScriptFailure([
1766 'vim9script',
1767 'function# comment',
1768 ], 'E129:')
1769 CheckScriptSuccess([
1770 'vim9script',
1771 'function CheckScriptSuccess # comment',
1772 ])
1773 CheckScriptFailure([
1774 'vim9script',
1775 'function CheckScriptSuccess# comment',
1776 ], 'E488:')
1777
1778 CheckScriptSuccess([
1779 'vim9script',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001780 'func g:DeleteMeA()',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001781 'endfunc',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001782 'delfunction g:DeleteMeA # comment',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001783 ])
1784 CheckScriptFailure([
1785 'vim9script',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001786 'func g:DeleteMeB()',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001787 'endfunc',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001788 'delfunction g:DeleteMeB# comment',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001789 ], 'E488:')
1790
1791 CheckScriptSuccess([
1792 'vim9script',
1793 'call execute("ls") # comment',
1794 ])
1795 CheckScriptFailure([
1796 'vim9script',
1797 'call execute("ls")# comment',
1798 ], 'E488:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02001799enddef
1800
1801def Test_vim9_comment_gui()
1802 CheckCanRunGui
1803
1804 CheckScriptFailure([
1805 'vim9script',
1806 'gui#comment'
1807 ], 'E499:')
1808 CheckScriptFailure([
1809 'vim9script',
1810 'gui -f#comment'
1811 ], 'E499:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02001812enddef
1813
Bram Moolenaara26b9702020-04-18 19:53:28 +02001814def Test_vim9_comment_not_compiled()
Bram Moolenaar67979662020-06-20 22:50:47 +02001815 au TabEnter *.vim g:entered = 1
1816 au TabEnter *.x g:entered = 2
Bram Moolenaara26b9702020-04-18 19:53:28 +02001817
1818 edit test.vim
1819 doautocmd TabEnter #comment
1820 assert_equal(1, g:entered)
1821
1822 doautocmd TabEnter f.x
1823 assert_equal(2, g:entered)
1824
1825 g:entered = 0
1826 doautocmd TabEnter f.x #comment
1827 assert_equal(2, g:entered)
1828
1829 assert_fails('doautocmd Syntax#comment', 'E216:')
1830
1831 au! TabEnter
1832 unlet g:entered
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02001833
1834 CheckScriptSuccess([
1835 'vim9script',
Bram Moolenaar67979662020-06-20 22:50:47 +02001836 'g:var = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02001837 'b:var = 456',
1838 'w:var = 777',
1839 't:var = 888',
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02001840 'unlet g:var w:var # something',
1841 ])
1842
1843 CheckScriptFailure([
1844 'vim9script',
1845 'let g:var = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02001846 ], 'E1016: Cannot declare a global variable:')
1847
1848 CheckScriptFailure([
1849 'vim9script',
1850 'let b:var = 123',
1851 ], 'E1016: Cannot declare a buffer variable:')
1852
1853 CheckScriptFailure([
1854 'vim9script',
1855 'let w:var = 123',
1856 ], 'E1016: Cannot declare a window variable:')
1857
1858 CheckScriptFailure([
1859 'vim9script',
1860 'let t:var = 123',
1861 ], 'E1016: Cannot declare a tab variable:')
1862
1863 CheckScriptFailure([
1864 'vim9script',
1865 'let v:version = 123',
1866 ], 'E1016: Cannot declare a v: variable:')
1867
1868 CheckScriptFailure([
1869 'vim9script',
1870 'let $VARIABLE = "text"',
1871 ], 'E1016: Cannot declare an environment variable:')
Bram Moolenaar67979662020-06-20 22:50:47 +02001872
1873 CheckScriptFailure([
1874 'vim9script',
1875 'g:var = 123',
Bram Moolenaar32e35112020-05-14 22:41:15 +02001876 'unlet g:var# comment1',
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02001877 ], 'E108:')
1878
1879 CheckScriptFailure([
1880 'let g:var = 123',
1881 'unlet g:var # something',
1882 ], 'E488:')
Bram Moolenaarfaac4102020-04-20 17:46:14 +02001883
1884 CheckScriptSuccess([
1885 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02001886 'if 1 # comment2',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02001887 ' echo "yes"',
1888 'elseif 2 #comment',
1889 ' echo "no"',
1890 'endif',
1891 ])
1892
1893 CheckScriptFailure([
1894 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02001895 'if 1# comment3',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02001896 ' echo "yes"',
1897 'endif',
1898 ], 'E15:')
1899
1900 CheckScriptFailure([
1901 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02001902 'if 0 # comment4',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02001903 ' echo "yes"',
1904 'elseif 2#comment',
1905 ' echo "no"',
1906 'endif',
1907 ], 'E15:')
1908
1909 CheckScriptSuccess([
1910 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02001911 'let v = 1 # comment5',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02001912 ])
1913
1914 CheckScriptFailure([
1915 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02001916 'let v = 1# comment6',
1917 ], 'E15:')
Bram Moolenaarfaac4102020-04-20 17:46:14 +02001918
Bram Moolenaarfaac4102020-04-20 17:46:14 +02001919 CheckScriptSuccess([
1920 'vim9script',
1921 'new'
1922 'call setline(1, ["# define pat", "last"])',
Bram Moolenaardf069ee2020-06-22 23:02:51 +02001923 ':$',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02001924 'dsearch /pat/ #comment',
1925 'bwipe!',
1926 ])
1927
1928 CheckScriptFailure([
1929 'vim9script',
1930 'new'
1931 'call setline(1, ["# define pat", "last"])',
Bram Moolenaardf069ee2020-06-22 23:02:51 +02001932 ':$',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02001933 'dsearch /pat/#comment',
1934 'bwipe!',
1935 ], 'E488:')
Bram Moolenaar74fae512020-05-21 21:50:58 +02001936
1937 CheckScriptFailure([
1938 'vim9script',
1939 'func! SomeFunc()',
1940 ], 'E477:')
Bram Moolenaara26b9702020-04-18 19:53:28 +02001941enddef
1942
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02001943def Test_finish()
1944 let lines =<< trim END
1945 vim9script
Bram Moolenaar67979662020-06-20 22:50:47 +02001946 g:res = 'one'
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02001947 if v:false | finish | endif
Bram Moolenaar67979662020-06-20 22:50:47 +02001948 g:res = 'two'
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02001949 finish
Bram Moolenaar67979662020-06-20 22:50:47 +02001950 g:res = 'three'
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02001951 END
1952 writefile(lines, 'Xfinished')
1953 source Xfinished
1954 assert_equal('two', g:res)
1955
1956 unlet g:res
1957 delete('Xfinished')
1958enddef
1959
Bram Moolenaar32e35112020-05-14 22:41:15 +02001960def Test_let_func_call()
1961 let lines =<< trim END
1962 vim9script
1963 func GetValue()
1964 if exists('g:count')
1965 let g:count += 1
1966 else
1967 let g:count = 1
1968 endif
1969 return 'this'
1970 endfunc
1971 let val: string = GetValue()
Bram Moolenaardf671b42020-05-16 22:33:33 +02001972 " env var is always a string
1973 let env = $TERM
Bram Moolenaar32e35112020-05-14 22:41:15 +02001974 END
1975 writefile(lines, 'Xfinished')
1976 source Xfinished
Bram Moolenaara5d00772020-05-14 23:20:55 +02001977 " GetValue() is not called during discovery phase
Bram Moolenaar32e35112020-05-14 22:41:15 +02001978 assert_equal(1, g:count)
1979
1980 unlet g:count
1981 delete('Xfinished')
1982enddef
1983
1984def Test_let_missing_type()
1985 let lines =<< trim END
1986 vim9script
Bram Moolenaardf671b42020-05-16 22:33:33 +02001987 let var = g:unknown
Bram Moolenaar227a69d2020-05-15 18:17:28 +02001988 END
Bram Moolenaar822ba242020-05-24 23:00:18 +02001989 CheckScriptFailure(lines, 'E121:')
Bram Moolenaar227a69d2020-05-15 18:17:28 +02001990
1991 lines =<< trim END
1992 vim9script
1993 let nr: number = 123
1994 let var = nr
1995 END
Bram Moolenaar822ba242020-05-24 23:00:18 +02001996 CheckScriptSuccess(lines)
Bram Moolenaar32e35112020-05-14 22:41:15 +02001997enddef
1998
Bram Moolenaarc82a5b52020-06-13 18:09:19 +02001999def Test_let_declaration()
2000 let lines =<< trim END
2001 vim9script
2002 let var: string
2003 g:var_uninit = var
2004 var = 'text'
2005 g:var_test = var
Bram Moolenaar984dddb2020-06-14 12:50:24 +02002006 " prefixing s: is optional
2007 s:var = 'prefixed'
2008 g:var_prefixed = s:var
2009
2010 let s:other: number
2011 other = 1234
2012 g:other_var = other
Bram Moolenaarc82a5b52020-06-13 18:09:19 +02002013 END
2014 CheckScriptSuccess(lines)
2015 assert_equal('', g:var_uninit)
2016 assert_equal('text', g:var_test)
Bram Moolenaar984dddb2020-06-14 12:50:24 +02002017 assert_equal('prefixed', g:var_prefixed)
2018 assert_equal(1234, g:other_var)
Bram Moolenaarc82a5b52020-06-13 18:09:19 +02002019
2020 unlet g:var_uninit
2021 unlet g:var_test
Bram Moolenaar984dddb2020-06-14 12:50:24 +02002022 unlet g:var_prefixed
2023 unlet g:other_var
Bram Moolenaarc82a5b52020-06-13 18:09:19 +02002024enddef
2025
Bram Moolenaarc5b1c202020-06-18 22:43:27 +02002026def Test_let_declaration_fails()
2027 let lines =<< trim END
2028 vim9script
2029 const var: string
2030 END
2031 CheckScriptFailure(lines, 'E1021:')
2032
2033 lines =<< trim END
2034 vim9script
2035 let 9var: string
2036 END
2037 CheckScriptFailure(lines, 'E475:')
2038enddef
2039
Bram Moolenaar34db91f2020-06-13 19:00:10 +02002040def Test_let_type_check()
2041 let lines =<< trim END
2042 vim9script
2043 let var: string
2044 var = 1234
2045 END
2046 CheckScriptFailure(lines, 'E1013:')
Bram Moolenaar984dddb2020-06-14 12:50:24 +02002047
2048 lines =<< trim END
2049 vim9script
2050 let var:string
2051 END
2052 CheckScriptFailure(lines, 'E1069:')
Bram Moolenaarc5b1c202020-06-18 22:43:27 +02002053
2054 lines =<< trim END
2055 vim9script
2056 let var: asdf
2057 END
2058 CheckScriptFailure(lines, 'E1010:')
Bram Moolenaar34db91f2020-06-13 19:00:10 +02002059enddef
2060
Bram Moolenaara5d00772020-05-14 23:20:55 +02002061def Test_forward_declaration()
2062 let lines =<< trim END
2063 vim9script
Bram Moolenaara5d00772020-05-14 23:20:55 +02002064 def GetValue(): string
2065 return theVal
2066 enddef
2067 let theVal = 'something'
Bram Moolenaar822ba242020-05-24 23:00:18 +02002068 g:initVal = GetValue()
Bram Moolenaara5d00772020-05-14 23:20:55 +02002069 theVal = 'else'
2070 g:laterVal = GetValue()
2071 END
2072 writefile(lines, 'Xforward')
2073 source Xforward
2074 assert_equal('something', g:initVal)
2075 assert_equal('else', g:laterVal)
2076
2077 unlet g:initVal
2078 unlet g:laterVal
2079 delete('Xforward')
2080enddef
2081
Bram Moolenaar9721fb42020-06-11 23:10:46 +02002082def Test_source_vim9_from_legacy()
2083 let legacy_lines =<< trim END
2084 source Xvim9_script.vim
2085
2086 call assert_false(exists('local'))
2087 call assert_false(exists('exported'))
2088 call assert_false(exists('s:exported'))
2089 call assert_equal('global', global)
2090 call assert_equal('global', g:global)
2091
2092 " imported variable becomes script-local
2093 import exported from './Xvim9_script.vim'
2094 call assert_equal('exported', s:exported)
2095 call assert_false(exists('exported'))
2096
2097 " imported function becomes script-local
2098 import GetText from './Xvim9_script.vim'
2099 call assert_equal('text', s:GetText())
2100 call assert_false(exists('*GetText'))
2101 END
2102 writefile(legacy_lines, 'Xlegacy_script.vim')
2103
2104 let vim9_lines =<< trim END
2105 vim9script
2106 let local = 'local'
2107 g:global = 'global'
2108 export let exported = 'exported'
2109 export def GetText(): string
2110 return 'text'
2111 enddef
2112 END
2113 writefile(vim9_lines, 'Xvim9_script.vim')
2114
2115 source Xlegacy_script.vim
2116
2117 assert_equal('global', g:global)
2118" unlet g:global
2119
2120 delete('Xlegacy_script.vim')
2121 delete('Xvim9_script.vim')
2122enddef
Bram Moolenaara5d00772020-05-14 23:20:55 +02002123
Bram Moolenaar585fea72020-04-02 22:33:21 +02002124" Keep this last, it messes up highlighting.
2125def Test_substitute_cmd()
2126 new
2127 setline(1, 'something')
2128 :substitute(some(other(
2129 assert_equal('otherthing', getline(1))
2130 bwipe!
2131
2132 " also when the context is Vim9 script
2133 let lines =<< trim END
2134 vim9script
2135 new
2136 setline(1, 'something')
2137 :substitute(some(other(
2138 assert_equal('otherthing', getline(1))
2139 bwipe!
2140 END
2141 writefile(lines, 'Xvim9lines')
2142 source Xvim9lines
2143
2144 delete('Xvim9lines')
2145enddef
2146
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002147" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker