blob: ea976c52c9a1a3ad542732702d3f0f4fcca42f9c [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 Moolenaarad39c092020-02-26 18:23:43 +01004source view_util.vim
Bram Moolenaarcfe435d2020-04-25 20:02:55 +02005source vim9.vim
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006
7def Test_syntax()
8 let var = 234
9 let other: list<string> = ['asdf']
10enddef
11
Bram Moolenaar6e587dc2020-02-06 13:15:52 +010012let s:appendToMe = 'xxx'
13let s:addToMe = 111
Bram Moolenaar401d9ff2020-02-19 18:14:44 +010014let g:existing = 'yes'
Bram Moolenaara8c17702020-04-01 21:17:24 +020015let g:inc_counter = 1
16let $SOME_ENV_VAR = 'some'
Bram Moolenaara6e67e42020-05-15 23:36:40 +020017let g:alist = [7]
18let g:astring = 'text'
Bram Moolenaar6e587dc2020-02-06 13:15:52 +010019
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010020def Test_assignment()
21 let bool1: bool = true
22 assert_equal(v:true, bool1)
23 let bool2: bool = false
24 assert_equal(v:false, bool2)
25
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +020026 call CheckDefFailure(['let x:string'], 'E1069:')
27 call CheckDefFailure(['let x:string = "x"'], 'E1069:')
Bram Moolenaar1cc2a942020-05-10 19:10:31 +020028 call CheckDefFailure(['let a:string = "x"'], 'E1069:')
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +020029
Bram Moolenaar9be61bb2020-03-30 22:51:24 +020030 let a: number = 6
31 assert_equal(6, a)
32
Bram Moolenaar42a480b2020-02-29 23:23:47 +010033 if has('channel')
34 let chan1: channel
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +010035 let job1: job
Bram Moolenaarf51cb4e2020-03-01 17:55:14 +010036 let job2: job = job_start('willfail')
Bram Moolenaar42a480b2020-02-29 23:23:47 +010037 endif
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +010038 if has('float')
39 let float1: float = 3.4
40 endif
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +020041 let Funky1: func
42 let Funky2: func = function('len')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +020043 let Party2: func = funcref('g:Test_syntax')
Bram Moolenaar42a480b2020-02-29 23:23:47 +010044
Bram Moolenaar401d9ff2020-02-19 18:14:44 +010045 g:newvar = 'new'
46 assert_equal('new', g:newvar)
47
48 assert_equal('yes', g:existing)
49 g:existing = 'no'
50 assert_equal('no', g:existing)
51
Bram Moolenaarb283a8a2020-02-02 22:24:04 +010052 v:char = 'abc'
Bram Moolenaar6e587dc2020-02-06 13:15:52 +010053 assert_equal('abc', v:char)
Bram Moolenaarb283a8a2020-02-02 22:24:04 +010054
55 $ENVVAR = 'foobar'
Bram Moolenaar6e587dc2020-02-06 13:15:52 +010056 assert_equal('foobar', $ENVVAR)
Bram Moolenaarb283a8a2020-02-02 22:24:04 +010057 $ENVVAR = ''
Bram Moolenaar6e587dc2020-02-06 13:15:52 +010058
Bram Moolenaarfd1823e2020-02-19 20:23:11 +010059 s:appendToMe ..= 'yyy'
60 assert_equal('xxxyyy', s:appendToMe)
61 s:addToMe += 222
62 assert_equal(333, s:addToMe)
Bram Moolenaar0bbf7222020-02-19 22:31:48 +010063 s:newVar = 'new'
64 assert_equal('new', s:newVar)
Bram Moolenaara8c17702020-04-01 21:17:24 +020065
66 set ts=7
67 &ts += 1
68 assert_equal(8, &ts)
Bram Moolenaar80c34ca2020-04-01 23:05:18 +020069 &ts -= 3
70 assert_equal(5, &ts)
71 &ts *= 2
72 assert_equal(10, &ts)
73 &ts /= 3
74 assert_equal(3, &ts)
75 set ts=10
76 &ts %= 4
77 assert_equal(2, &ts)
Bram Moolenaara8c17702020-04-01 21:17:24 +020078 call CheckDefFailure(['&notex += 3'], 'E113:')
79 call CheckDefFailure(['&ts ..= "xxx"'], 'E1019:')
Bram Moolenaara6e67e42020-05-15 23:36:40 +020080 call CheckDefFailure(['&ts = [7]'], 'E1013:')
81 call CheckDefExecFailure(['&ts = g:alist'], 'E1029: Expected number but got list')
82 call CheckDefFailure(['&ts = "xx"'], 'E1013:')
83 call CheckDefExecFailure(['&ts = g:astring'], 'E1029: Expected number but got string')
Bram Moolenaara8c17702020-04-01 21:17:24 +020084 call CheckDefFailure(['&path += 3'], 'E1013:')
Bram Moolenaara6e67e42020-05-15 23:36:40 +020085 call CheckDefExecFailure(['&bs = "asdf"'], 'E474:')
Bram Moolenaarcb711ab2020-04-16 13:00:29 +020086 # test freeing ISN_STOREOPT
Bram Moolenaar585fea72020-04-02 22:33:21 +020087 call CheckDefFailure(['&ts = 3', 'let asdf'], 'E1022:')
Bram Moolenaar80c34ca2020-04-01 23:05:18 +020088 &ts = 8
Bram Moolenaara8c17702020-04-01 21:17:24 +020089
90 g:inc_counter += 1
91 assert_equal(2, g:inc_counter)
92
93 $SOME_ENV_VAR ..= 'more'
94 assert_equal('somemore', $SOME_ENV_VAR)
95 call CheckDefFailure(['$SOME_ENV_VAR += "more"'], 'E1013:')
96 call CheckDefFailure(['$SOME_ENV_VAR += 123'], 'E1013:')
97
98 @a = 'areg'
99 @a ..= 'add'
100 assert_equal('aregadd', @a)
101 call CheckDefFailure(['@a += "more"'], 'E1013:')
102 call CheckDefFailure(['@a += 123'], 'E1013:')
Bram Moolenaare69f6d02020-04-01 22:11:01 +0200103
104 v:errmsg = 'none'
105 v:errmsg ..= 'again'
106 assert_equal('noneagain', v:errmsg)
107 call CheckDefFailure(['v:errmsg += "more"'], 'E1013:')
108 call CheckDefFailure(['v:errmsg += 123'], 'E1013:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200109enddef
110
Bram Moolenaar84370082020-05-18 14:20:36 +0200111def Test_assignment_list()
112 let list1: list<bool> = [false, true, false]
113 let list2: list<number> = [1, 2, 3]
114 let list3: list<string> = ['sdf', 'asdf']
115 let list4: list<any> = ['yes', true, 1234]
116 let list5: list<blob> = [0z01, 0z02]
117
118 let listS: list<string> = []
119 let listN: list<number> = []
120
121 assert_equal([1, 2, 3], list2)
122 list2[-1] = 99
123 assert_equal([1, 2, 99], list2)
124 list2[-2] = 88
125 assert_equal([1, 88, 99], list2)
126 list2[-3] = 77
127 assert_equal([77, 88, 99], list2)
128 call CheckDefExecFailure(['let ll = [1, 2, 3]', 'll[-4] = 6'], 'E684:')
129
130 # type becomes list<any>
131 let somelist = rand() > 0 ? [1, 2, 3] : ['a', 'b', 'c']
132enddef
133
134def Test_assignment_dict()
135 let dict1: dict<bool> = #{one: false, two: true}
136 let dict2: dict<number> = #{one: 1, two: 2}
137 let dict3: dict<string> = #{key: 'value'}
138 let dict4: dict<any> = #{one: 1, two: '2'}
Bram Moolenaar74fae512020-05-21 21:50:58 +0200139 let dict5: dict<blob> = #{one: 0z01, two: 0z02}
Bram Moolenaar84370082020-05-18 14:20:36 +0200140
141 call CheckDefExecFailure(['let dd = {}', 'dd[""] = 6'], 'E713:')
142
143 # type becomes dict<any>
144 let somedict = rand() > 0 ? #{a: 1, b: 2} : #{a: 'a', b: 'b'}
145enddef
146
Bram Moolenaard3aac292020-04-19 14:32:17 +0200147def Test_assignment_local()
148 " Test in a separated file in order not to the current buffer/window/tab is
149 " changed.
150 let script_lines: list<string> =<< trim END
151 let b:existing = 'yes'
152 let w:existing = 'yes'
153 let t:existing = 'yes'
154
155 def Test_assignment_local_internal()
156 b:newvar = 'new'
157 assert_equal('new', b:newvar)
158 assert_equal('yes', b:existing)
159 b:existing = 'no'
160 assert_equal('no', b:existing)
Bram Moolenaar396f3132020-05-09 18:44:56 +0200161 b:existing ..= 'NO'
162 assert_equal('noNO', b:existing)
Bram Moolenaard3aac292020-04-19 14:32:17 +0200163
164 w:newvar = 'new'
165 assert_equal('new', w:newvar)
166 assert_equal('yes', w:existing)
167 w:existing = 'no'
168 assert_equal('no', w:existing)
Bram Moolenaar396f3132020-05-09 18:44:56 +0200169 w:existing ..= 'NO'
170 assert_equal('noNO', w:existing)
Bram Moolenaard3aac292020-04-19 14:32:17 +0200171
172 t:newvar = 'new'
173 assert_equal('new', t:newvar)
174 assert_equal('yes', t:existing)
175 t:existing = 'no'
176 assert_equal('no', t:existing)
Bram Moolenaar396f3132020-05-09 18:44:56 +0200177 t:existing ..= 'NO'
178 assert_equal('noNO', t:existing)
Bram Moolenaard3aac292020-04-19 14:32:17 +0200179 enddef
180 call Test_assignment_local_internal()
181 END
182 call CheckScriptSuccess(script_lines)
183enddef
184
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200185def Test_assignment_default()
Bram Moolenaare69f6d02020-04-01 22:11:01 +0200186
Bram Moolenaarcb711ab2020-04-16 13:00:29 +0200187 # Test default values.
Bram Moolenaare69f6d02020-04-01 22:11:01 +0200188 let thebool: bool
189 assert_equal(v:false, thebool)
190
191 let thenumber: number
192 assert_equal(0, thenumber)
193
194 if has('float')
195 let thefloat: float
196 assert_equal(0.0, thefloat)
197 endif
198
199 let thestring: string
200 assert_equal('', thestring)
201
202 let theblob: blob
203 assert_equal(0z, theblob)
204
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200205 let Thefunc: func
206 assert_equal(test_null_function(), Thefunc)
Bram Moolenaare69f6d02020-04-01 22:11:01 +0200207
Bram Moolenaare69f6d02020-04-01 22:11:01 +0200208 let thelist: list<any>
209 assert_equal([], thelist)
210
211 let thedict: dict<any>
212 assert_equal({}, thedict)
213
Bram Moolenaar2c869de2020-04-02 19:12:08 +0200214 if has('channel')
215 let thejob: job
216 assert_equal(test_null_job(), thejob)
Bram Moolenaare69f6d02020-04-01 22:11:01 +0200217
Bram Moolenaar2c869de2020-04-02 19:12:08 +0200218 let thechannel: channel
219 assert_equal(test_null_channel(), thechannel)
220 endif
Bram Moolenaar585fea72020-04-02 22:33:21 +0200221
222 let nr = 1234 | nr = 5678
223 assert_equal(5678, nr)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100224enddef
225
Bram Moolenaarcab27672020-04-09 20:10:55 +0200226def Mess(): string
227 v:foldstart = 123
228 return 'xxx'
229enddef
230
Bram Moolenaard72c1bf2020-04-19 16:28:59 +0200231def Test_assignment_failure()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100232 call CheckDefFailure(['let var=234'], 'E1004:')
233 call CheckDefFailure(['let var =234'], 'E1004:')
234 call CheckDefFailure(['let var= 234'], 'E1004:')
235
236 call CheckDefFailure(['let true = 1'], 'E1034:')
237 call CheckDefFailure(['let false = 1'], 'E1034:')
238
Bram Moolenaar9be61bb2020-03-30 22:51:24 +0200239 call CheckDefFailure(['let [a; b; c] = g:list'], 'E452:')
240
Bram Moolenaare69f6d02020-04-01 22:11:01 +0200241 call CheckDefFailure(['let somevar'], "E1022:")
Bram Moolenaar9be61bb2020-03-30 22:51:24 +0200242 call CheckDefFailure(['let &option'], 'E1052:')
243 call CheckDefFailure(['&g:option = 5'], 'E113:')
244
245 call CheckDefFailure(['let $VAR = 5'], 'E1065:')
246
247 call CheckDefFailure(['let @~ = 5'], 'E354:')
248 call CheckDefFailure(['let @a = 5'], 'E1066:')
249
250 call CheckDefFailure(['let g:var = 5'], 'E1016:')
Bram Moolenaard3aac292020-04-19 14:32:17 +0200251 call CheckDefFailure(['let w:var = 5'], 'E1079:')
252 call CheckDefFailure(['let b:var = 5'], 'E1078:')
253 call CheckDefFailure(['let t:var = 5'], 'E1080:')
Bram Moolenaar9be61bb2020-03-30 22:51:24 +0200254
255 call CheckDefFailure(['let anr = 4', 'anr ..= "text"'], 'E1019:')
256 call CheckDefFailure(['let xnr += 4'], 'E1020:')
257
Bram Moolenaar822ba242020-05-24 23:00:18 +0200258 call CheckScriptFailure(['vim9script', 'def Func()', 'let dummy = s:notfound', 'enddef', 'defcompile'], 'E1050:')
Bram Moolenaar33fa29c2020-03-28 19:41:33 +0100259
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100260 call CheckDefFailure(['let var: list<string> = [123]'], 'expected list<string> but got list<number>')
261 call CheckDefFailure(['let var: list<number> = ["xx"]'], 'expected list<number> but got list<string>')
262
263 call CheckDefFailure(['let var: dict<string> = #{key: 123}'], 'expected dict<string> but got dict<number>')
264 call CheckDefFailure(['let var: dict<number> = #{key: "xx"}'], 'expected dict<number> but got dict<string>')
265
266 call CheckDefFailure(['let var = feedkeys("0")'], 'E1031:')
267 call CheckDefFailure(['let var: number = feedkeys("0")'], 'expected number but got void')
Bram Moolenaar42a480b2020-02-29 23:23:47 +0100268
Bram Moolenaard77a8522020-04-03 21:59:57 +0200269 call CheckDefFailure(['let var: dict <number>'], 'E1068:')
Bram Moolenaar42a480b2020-02-29 23:23:47 +0100270 call CheckDefFailure(['let var: dict<number'], 'E1009:')
Bram Moolenaarcab27672020-04-09 20:10:55 +0200271
272 call assert_fails('s/^/\=Mess()/n', 'E794:')
273 call CheckDefFailure(['let var: dict<number'], 'E1009:')
Bram Moolenaard72c1bf2020-04-19 16:28:59 +0200274enddef
275
276def Test_unlet()
277 g:somevar = 'yes'
278 assert_true(exists('g:somevar'))
279 unlet g:somevar
280 assert_false(exists('g:somevar'))
281 unlet! g:somevar
282
283 call CheckScriptFailure([
284 'vim9script',
285 'let svar = 123',
286 'unlet svar',
287 ], 'E1081:')
288 call CheckScriptFailure([
289 'vim9script',
290 'let svar = 123',
291 'unlet s:svar',
292 ], 'E1081:')
293 call CheckScriptFailure([
294 'vim9script',
295 'let svar = 123',
296 'def Func()',
297 ' unlet svar',
298 'enddef',
Bram Moolenaar822ba242020-05-24 23:00:18 +0200299 'defcompile',
Bram Moolenaard72c1bf2020-04-19 16:28:59 +0200300 ], 'E1081:')
301 call CheckScriptFailure([
302 'vim9script',
303 'let svar = 123',
304 'def Func()',
305 ' unlet s:svar',
306 'enddef',
Bram Moolenaar822ba242020-05-24 23:00:18 +0200307 'defcompile',
Bram Moolenaard72c1bf2020-04-19 16:28:59 +0200308 ], 'E1081:')
Bram Moolenaar7bdaea62020-04-19 18:27:26 +0200309
310 $ENVVAR = 'foobar'
311 assert_equal('foobar', $ENVVAR)
312 unlet $ENVVAR
313 assert_equal('', $ENVVAR)
Bram Moolenaard72c1bf2020-04-19 16:28:59 +0200314enddef
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100315
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200316def Test_delfunction()
317 " Check function is defined in script namespace
318 CheckScriptSuccess([
319 'vim9script',
320 'func CheckMe()',
321 ' return 123',
322 'endfunc',
323 'assert_equal(123, s:CheckMe())',
324 ])
325
326 " Check function in script namespace cannot be deleted
327 CheckScriptFailure([
328 'vim9script',
329 'func DeleteMe1()',
330 'endfunc',
331 'delfunction DeleteMe1',
332 ], 'E1084:')
333 CheckScriptFailure([
334 'vim9script',
335 'func DeleteMe2()',
336 'endfunc',
337 'def DoThat()',
338 ' delfunction DeleteMe2',
339 'enddef',
340 'DoThat()',
341 ], 'E1084:')
342 CheckScriptFailure([
343 'vim9script',
344 'def DeleteMe3()',
345 'enddef',
346 'delfunction DeleteMe3',
347 ], 'E1084:')
348 CheckScriptFailure([
349 'vim9script',
350 'def DeleteMe4()',
351 'enddef',
352 'def DoThat()',
353 ' delfunction DeleteMe4',
354 'enddef',
355 'DoThat()',
356 ], 'E1084:')
357enddef
358
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100359func Test_wrong_type()
360 call CheckDefFailure(['let var: list<nothing>'], 'E1010:')
361 call CheckDefFailure(['let var: list<list<nothing>>'], 'E1010:')
362 call CheckDefFailure(['let var: dict<nothing>'], 'E1010:')
363 call CheckDefFailure(['let var: dict<dict<nothing>>'], 'E1010:')
364
365 call CheckDefFailure(['let var: dict<number'], 'E1009:')
366 call CheckDefFailure(['let var: dict<list<number>'], 'E1009:')
Bram Moolenaar42a480b2020-02-29 23:23:47 +0100367
368 call CheckDefFailure(['let var: ally'], 'E1010:')
369 call CheckDefFailure(['let var: bram'], 'E1010:')
370 call CheckDefFailure(['let var: cathy'], 'E1010:')
371 call CheckDefFailure(['let var: dom'], 'E1010:')
372 call CheckDefFailure(['let var: freddy'], 'E1010:')
373 call CheckDefFailure(['let var: john'], 'E1010:')
374 call CheckDefFailure(['let var: larry'], 'E1010:')
375 call CheckDefFailure(['let var: ned'], 'E1010:')
376 call CheckDefFailure(['let var: pam'], 'E1010:')
377 call CheckDefFailure(['let var: sam'], 'E1010:')
378 call CheckDefFailure(['let var: vim'], 'E1010:')
Bram Moolenaara0a9f432020-04-28 21:29:34 +0200379
380 call CheckDefFailure(['let Ref: number', 'Ref()'], 'E1085:')
381 call CheckDefFailure(['let Ref: string', 'let res = Ref()'], 'E1085:')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100382endfunc
383
384func Test_const()
385 call CheckDefFailure(['const var = 234', 'var = 99'], 'E1018:')
386 call CheckDefFailure(['const one = 234', 'let one = 99'], 'E1017:')
387 call CheckDefFailure(['const two'], 'E1021:')
Bram Moolenaar9be61bb2020-03-30 22:51:24 +0200388 call CheckDefFailure(['const &option'], 'E996:')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100389endfunc
390
391def Test_block()
392 let outer = 1
393 {
394 let inner = 2
395 assert_equal(1, outer)
396 assert_equal(2, inner)
397 }
398 assert_equal(1, outer)
399enddef
400
401func Test_block_failure()
402 call CheckDefFailure(['{', 'let inner = 1', '}', 'echo inner'], 'E1001:')
Bram Moolenaar585fea72020-04-02 22:33:21 +0200403 call CheckDefFailure(['}'], 'E1025:')
404 call CheckDefFailure(['{', 'echo 1'], 'E1026:')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100405endfunc
406
Bram Moolenaar585fea72020-04-02 22:33:21 +0200407def Test_cmd_modifier()
408 tab echo '0'
409 call CheckDefFailure(['5tab echo 3'], 'E16:')
410enddef
411
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100412def Test_try_catch()
413 let l = []
Bram Moolenaar7a092242020-04-16 22:10:49 +0200414 try # comment
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100415 add(l, '1')
416 throw 'wrong'
417 add(l, '2')
Bram Moolenaar7a092242020-04-16 22:10:49 +0200418 catch # comment
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100419 add(l, v:exception)
Bram Moolenaar7a092242020-04-16 22:10:49 +0200420 finally # comment
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100421 add(l, '3')
Bram Moolenaar7a092242020-04-16 22:10:49 +0200422 endtry # comment
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100423 assert_equal(['1', 'wrong', '3'], l)
424enddef
425
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100426def ThrowFromDef()
Bram Moolenaara72cfb82020-04-23 17:07:30 +0200427 throw "getout" # comment
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100428enddef
429
430func CatchInFunc()
431 try
432 call ThrowFromDef()
433 catch
434 let g:thrown_func = v:exception
435 endtry
436endfunc
437
438def CatchInDef()
439 try
440 ThrowFromDef()
441 catch
442 g:thrown_def = v:exception
443 endtry
444enddef
445
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100446def ReturnFinally(): string
447 try
448 return 'intry'
449 finally
450 g:in_finally = 'finally'
451 endtry
452 return 'end'
453enddef
454
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100455def Test_try_catch_nested()
456 CatchInFunc()
457 assert_equal('getout', g:thrown_func)
458
459 CatchInDef()
460 assert_equal('getout', g:thrown_def)
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100461
462 assert_equal('intry', ReturnFinally())
463 assert_equal('finally', g:in_finally)
464enddef
465
466def Test_try_catch_match()
467 let seq = 'a'
468 try
469 throw 'something'
470 catch /nothing/
471 seq ..= 'x'
472 catch /some/
473 seq ..= 'b'
474 catch /asdf/
475 seq ..= 'x'
Bram Moolenaare8c4abb2020-04-02 21:13:25 +0200476 catch ?a\?sdf?
477 seq ..= 'y'
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100478 finally
479 seq ..= 'c'
480 endtry
481 assert_equal('abc', seq)
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100482enddef
483
Bram Moolenaare8c4abb2020-04-02 21:13:25 +0200484def Test_try_catch_fails()
485 call CheckDefFailure(['catch'], 'E603:')
486 call CheckDefFailure(['try', 'echo 0', 'catch','catch'], 'E1033:')
487 call CheckDefFailure(['try', 'echo 0', 'catch /pat'], 'E1067:')
Bram Moolenaar585fea72020-04-02 22:33:21 +0200488 call CheckDefFailure(['finally'], 'E606:')
489 call CheckDefFailure(['try', 'echo 0', 'finally', 'echo 1', 'finally'], 'E607:')
490 call CheckDefFailure(['endtry'], 'E602:')
491 call CheckDefFailure(['while 1', 'endtry'], 'E170:')
492 call CheckDefFailure(['for i in range(5)', 'endtry'], 'E170:')
493 call CheckDefFailure(['if 2', 'endtry'], 'E171:')
494 call CheckDefFailure(['try', 'echo 1', 'endtry'], 'E1032:')
495
Bram Moolenaara72cfb82020-04-23 17:07:30 +0200496 call CheckDefFailure(['throw'], 'E1015:')
Bram Moolenaar585fea72020-04-02 22:33:21 +0200497 call CheckDefFailure(['throw xxx'], 'E1001:')
Bram Moolenaare8c4abb2020-04-02 21:13:25 +0200498enddef
499
Bram Moolenaar2a1381c2020-05-05 23:32:58 +0200500if has('channel')
501 let someJob = test_null_job()
Bram Moolenaar40ee4662020-05-05 22:08:26 +0200502
Bram Moolenaar2a1381c2020-05-05 23:32:58 +0200503 def FuncWithError()
504 echomsg g:someJob
505 enddef
Bram Moolenaar40ee4662020-05-05 22:08:26 +0200506
Bram Moolenaar2a1381c2020-05-05 23:32:58 +0200507 func Test_convert_emsg_to_exception()
508 try
509 call FuncWithError()
510 catch
511 call assert_match('Vim:E908:', v:exception)
512 endtry
513 endfunc
514endif
Bram Moolenaar40ee4662020-05-05 22:08:26 +0200515
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100516let s:export_script_lines =<< trim END
517 vim9script
518 let name: string = 'bob'
519 def Concat(arg: string): string
520 return name .. arg
521 enddef
Bram Moolenaar227a69d2020-05-15 18:17:28 +0200522 g:result = Concat('bie')
523 g:localname = name
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100524
525 export const CONST = 1234
526 export let exported = 9876
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100527 export let exp_name = 'John'
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100528 export def Exported(): string
529 return 'Exported'
530 enddef
531END
532
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100533def Test_vim9_import_export()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100534 let import_script_lines =<< trim END
535 vim9script
536 import {exported, Exported} from './Xexport.vim'
537 g:imported = exported
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100538 exported += 3
539 g:imported_added = exported
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100540 g:imported_func = Exported()
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100541
542 import {exp_name} from './Xexport.vim'
543 g:imported_name = exp_name
544 exp_name ..= ' Doe'
545 g:imported_name_appended = exp_name
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100546 g:imported_later = exported
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100547 END
548
549 writefile(import_script_lines, 'Ximport.vim')
550 writefile(s:export_script_lines, 'Xexport.vim')
551
552 source Ximport.vim
553
554 assert_equal('bobbie', g:result)
555 assert_equal('bob', g:localname)
556 assert_equal(9876, g:imported)
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100557 assert_equal(9879, g:imported_added)
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100558 assert_equal(9879, g:imported_later)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100559 assert_equal('Exported', g:imported_func)
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100560 assert_equal('John', g:imported_name)
561 assert_equal('John Doe', g:imported_name_appended)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100562 assert_false(exists('g:name'))
563
564 unlet g:result
565 unlet g:localname
566 unlet g:imported
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100567 unlet g:imported_added
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100568 unlet g:imported_later
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100569 unlet g:imported_func
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100570 unlet g:imported_name g:imported_name_appended
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100571 delete('Ximport.vim')
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100572
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100573 let import_in_def_lines =<< trim END
574 vim9script
575 def ImportInDef()
576 import exported from './Xexport.vim'
577 g:imported = exported
578 exported += 7
579 g:imported_added = exported
580 enddef
581 ImportInDef()
582 END
583 writefile(import_in_def_lines, 'Ximport2.vim')
584 source Ximport2.vim
585 " TODO: this should be 9879
586 assert_equal(9876, g:imported)
587 assert_equal(9883, g:imported_added)
588 unlet g:imported
589 unlet g:imported_added
590 delete('Ximport2.vim')
591
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100592 let import_star_as_lines =<< trim END
593 vim9script
594 import * as Export from './Xexport.vim'
595 def UseExport()
596 g:imported = Export.exported
597 enddef
598 UseExport()
599 END
600 writefile(import_star_as_lines, 'Ximport.vim')
601 source Ximport.vim
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100602 assert_equal(9883, g:imported)
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100603
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100604 let import_star_as_lines_no_dot =<< trim END
605 vim9script
606 import * as Export from './Xexport.vim'
607 def Func()
608 let dummy = 1
609 let imported = Export + dummy
610 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +0200611 defcompile
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100612 END
613 writefile(import_star_as_lines_no_dot, 'Ximport.vim')
614 assert_fails('source Ximport.vim', 'E1060:')
615
616 let import_star_as_lines_dot_space =<< trim END
617 vim9script
618 import * as Export from './Xexport.vim'
619 def Func()
620 let imported = Export . exported
621 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +0200622 defcompile
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100623 END
624 writefile(import_star_as_lines_dot_space, 'Ximport.vim')
625 assert_fails('source Ximport.vim', 'E1074:')
626
627 let import_star_as_lines_missing_name =<< trim END
628 vim9script
629 import * as Export from './Xexport.vim'
630 def Func()
631 let imported = Export.
632 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +0200633 defcompile
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100634 END
635 writefile(import_star_as_lines_missing_name, 'Ximport.vim')
636 assert_fails('source Ximport.vim', 'E1048:')
637
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100638 let import_star_lines =<< trim END
639 vim9script
640 import * from './Xexport.vim'
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100641 END
642 writefile(import_star_lines, 'Ximport.vim')
643 assert_fails('source Ximport.vim', 'E1045:')
644
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +0100645 " try to import something that exists but is not exported
646 let import_not_exported_lines =<< trim END
647 vim9script
648 import name from './Xexport.vim'
649 END
650 writefile(import_not_exported_lines, 'Ximport.vim')
651 assert_fails('source Ximport.vim', 'E1049:')
652
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100653 " try to import something that is already defined
654 let import_already_defined =<< trim END
655 vim9script
656 let exported = 'something'
657 import exported from './Xexport.vim'
658 END
659 writefile(import_already_defined, 'Ximport.vim')
660 assert_fails('source Ximport.vim', 'E1073:')
661
662 " try to import something that is already defined
663 import_already_defined =<< trim END
664 vim9script
665 let exported = 'something'
666 import * as exported from './Xexport.vim'
667 END
668 writefile(import_already_defined, 'Ximport.vim')
669 assert_fails('source Ximport.vim', 'E1073:')
670
671 " try to import something that is already defined
672 import_already_defined =<< trim END
673 vim9script
674 let exported = 'something'
675 import {exported} from './Xexport.vim'
676 END
677 writefile(import_already_defined, 'Ximport.vim')
678 assert_fails('source Ximport.vim', 'E1073:')
679
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +0100680 " import a very long name, requires making a copy
681 let import_long_name_lines =<< trim END
682 vim9script
683 import name012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789 from './Xexport.vim'
684 END
685 writefile(import_long_name_lines, 'Ximport.vim')
686 assert_fails('source Ximport.vim', 'E1048:')
687
688 let import_no_from_lines =<< trim END
689 vim9script
690 import name './Xexport.vim'
691 END
692 writefile(import_no_from_lines, 'Ximport.vim')
693 assert_fails('source Ximport.vim', 'E1070:')
694
695 let import_invalid_string_lines =<< trim END
696 vim9script
697 import name from Xexport.vim
698 END
699 writefile(import_invalid_string_lines, 'Ximport.vim')
700 assert_fails('source Ximport.vim', 'E1071:')
701
702 let import_wrong_name_lines =<< trim END
703 vim9script
704 import name from './XnoExport.vim'
705 END
706 writefile(import_wrong_name_lines, 'Ximport.vim')
707 assert_fails('source Ximport.vim', 'E1053:')
708
709 let import_missing_comma_lines =<< trim END
710 vim9script
711 import {exported name} from './Xexport.vim'
712 END
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100713 writefile(import_missing_comma_lines, 'Ximport3.vim')
714 assert_fails('source Ximport3.vim', 'E1046:')
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +0100715
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100716 delete('Ximport.vim')
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100717 delete('Ximport3.vim')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100718 delete('Xexport.vim')
719
Bram Moolenaar750802b2020-02-23 18:08:33 +0100720 " Check that in a Vim9 script 'cpo' is set to the Vim default.
721 set cpo&vi
722 let cpo_before = &cpo
723 let lines =<< trim END
724 vim9script
725 g:cpo_in_vim9script = &cpo
726 END
727 writefile(lines, 'Xvim9_script')
728 source Xvim9_script
729 assert_equal(cpo_before, &cpo)
730 set cpo&vim
731 assert_equal(&cpo, g:cpo_in_vim9script)
732 delete('Xvim9_script')
733enddef
734
735def Test_vim9script_fails()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100736 CheckScriptFailure(['scriptversion 2', 'vim9script'], 'E1039:')
737 CheckScriptFailure(['vim9script', 'scriptversion 2'], 'E1040:')
Bram Moolenaar750802b2020-02-23 18:08:33 +0100738 CheckScriptFailure(['export let some = 123'], 'E1042:')
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100739 CheckScriptFailure(['import some from "./Xexport.vim"'], 'E1042:')
Bram Moolenaar750802b2020-02-23 18:08:33 +0100740 CheckScriptFailure(['vim9script', 'export let g:some'], 'E1044:')
741 CheckScriptFailure(['vim9script', 'export echo 134'], 'E1043:')
742
743 assert_fails('vim9script', 'E1038')
Bram Moolenaara26b9702020-04-18 19:53:28 +0200744 assert_fails('export something', 'E1043')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100745enddef
746
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200747def Test_vim9script_reload_import()
Bram Moolenaar822ba242020-05-24 23:00:18 +0200748 " TODO: make it work to compile when not in the script context anymore
749 return
750
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100751 let lines =<< trim END
752 vim9script
753 const var = ''
754 let valone = 1234
755 def MyFunc(arg: string)
756 valone = 5678
757 enddef
758 END
759 let morelines =<< trim END
760 let valtwo = 222
761 export def GetValtwo(): number
762 return valtwo
763 enddef
764 END
Bram Moolenaar03afdcf2020-04-27 23:39:30 +0200765 writefile(lines + morelines, 'Xreload.vim')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100766 source Xreload.vim
767 source Xreload.vim
768 source Xreload.vim
769
770 let testlines =<< trim END
771 vim9script
772 def TheFunc()
773 import GetValtwo from './Xreload.vim'
774 assert_equal(222, GetValtwo())
775 enddef
776 TheFunc()
777 END
778 writefile(testlines, 'Ximport.vim')
779 source Ximport.vim
780
Bram Moolenaar03afdcf2020-04-27 23:39:30 +0200781 " Test that when not using "morelines" GetValtwo() and valtwo are still
782 " defined, because import doesn't reload a script.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100783 writefile(lines, 'Xreload.vim')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100784 source Ximport.vim
785
786 " cannot declare a var twice
787 lines =<< trim END
788 vim9script
789 let valone = 1234
790 let valone = 5678
791 END
792 writefile(lines, 'Xreload.vim')
793 assert_fails('source Xreload.vim', 'E1041:')
794
795 delete('Xreload.vim')
796 delete('Ximport.vim')
797enddef
798
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200799def Test_vim9script_reload_delfunc()
Bram Moolenaar822ba242020-05-24 23:00:18 +0200800 " TODO: make it work to compile when not in the script context anymore
801 return
802
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200803 let first_lines =<< trim END
804 vim9script
805 def FuncYes(): string
806 return 'yes'
807 enddef
808 END
Bram Moolenaar03afdcf2020-04-27 23:39:30 +0200809 let withno_lines =<< trim END
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200810 def FuncNo(): string
811 return 'no'
812 enddef
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200813 def g:DoCheck(no_exists: bool)
814 assert_equal('yes', FuncYes())
Bram Moolenaar03afdcf2020-04-27 23:39:30 +0200815 assert_equal('no', FuncNo())
816 enddef
817 END
818 let nono_lines =<< trim END
819 def g:DoCheck(no_exists: bool)
820 assert_equal('yes', FuncYes())
821 assert_fails('call FuncNo()', 'E117:')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200822 enddef
823 END
824
825 # FuncNo() is defined
Bram Moolenaar03afdcf2020-04-27 23:39:30 +0200826 writefile(first_lines + withno_lines, 'Xreloaded.vim')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200827 source Xreloaded.vim
828 g:DoCheck(true)
829
830 # FuncNo() is not redefined
Bram Moolenaar03afdcf2020-04-27 23:39:30 +0200831 writefile(first_lines + nono_lines, 'Xreloaded.vim')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200832 source Xreloaded.vim
Bram Moolenaar03afdcf2020-04-27 23:39:30 +0200833 g:DoCheck()
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200834
835 # FuncNo() is back
Bram Moolenaar03afdcf2020-04-27 23:39:30 +0200836 writefile(first_lines + withno_lines, 'Xreloaded.vim')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200837 source Xreloaded.vim
Bram Moolenaar03afdcf2020-04-27 23:39:30 +0200838 g:DoCheck()
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200839
840 delete('Xreloaded.vim')
841enddef
842
Bram Moolenaar89483d42020-05-10 15:24:44 +0200843def Test_vim9script_reload_delvar()
844 # write the script with a script-local variable
845 let lines =<< trim END
846 vim9script
847 let var = 'string'
848 END
849 writefile(lines, 'XreloadVar.vim')
850 source XreloadVar.vim
851
852 # now write the script using the same variable locally - works
853 lines =<< trim END
854 vim9script
855 def Func()
856 let var = 'string'
857 enddef
858 END
859 writefile(lines, 'XreloadVar.vim')
860 source XreloadVar.vim
861
862 delete('XreloadVar.vim')
863enddef
864
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100865def Test_import_absolute()
866 let import_lines = [
Bram Moolenaare6085c52020-04-12 20:19:16 +0200867 'vim9script',
868 'import exported from "' .. escape(getcwd(), '\') .. '/Xexport_abs.vim"',
869 'def UseExported()',
870 ' g:imported_abs = exported',
871 ' exported = 8888',
872 ' g:imported_after = exported',
873 'enddef',
874 'UseExported()',
875 'g:import_disassembled = execute("disass UseExported")',
876 ]
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100877 writefile(import_lines, 'Ximport_abs.vim')
878 writefile(s:export_script_lines, 'Xexport_abs.vim')
879
880 source Ximport_abs.vim
881
882 assert_equal(9876, g:imported_abs)
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +0100883 assert_equal(8888, g:imported_after)
Bram Moolenaar675f7162020-04-12 22:53:54 +0200884 assert_match('<SNR>\d\+_UseExported.*' ..
885 'g:imported_abs = exported.*' ..
886 '0 LOADSCRIPT exported from .*Xexport_abs.vim.*' ..
887 '1 STOREG g:imported_abs.*' ..
888 'exported = 8888.*' ..
889 '3 STORESCRIPT exported in .*Xexport_abs.vim.*' ..
890 'g:imported_after = exported.*' ..
891 '4 LOADSCRIPT exported from .*Xexport_abs.vim.*' ..
892 '5 STOREG g:imported_after.*',
Bram Moolenaare6085c52020-04-12 20:19:16 +0200893 g:import_disassembled)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100894 unlet g:imported_abs
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +0100895 unlet g:import_disassembled
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100896
897 delete('Ximport_abs.vim')
898 delete('Xexport_abs.vim')
899enddef
900
901def Test_import_rtp()
902 let import_lines = [
Bram Moolenaare6085c52020-04-12 20:19:16 +0200903 'vim9script',
904 'import exported from "Xexport_rtp.vim"',
905 'g:imported_rtp = exported',
906 ]
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100907 writefile(import_lines, 'Ximport_rtp.vim')
908 mkdir('import')
909 writefile(s:export_script_lines, 'import/Xexport_rtp.vim')
910
911 let save_rtp = &rtp
912 &rtp = getcwd()
913 source Ximport_rtp.vim
914 &rtp = save_rtp
915
916 assert_equal(9876, g:imported_rtp)
917 unlet g:imported_rtp
918
919 delete('Ximport_rtp.vim')
Bram Moolenaar89483d42020-05-10 15:24:44 +0200920 delete('import', 'rf')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100921enddef
922
923def Test_fixed_size_list()
924 " will be allocated as one piece of memory, check that changes work
925 let l = [1, 2, 3, 4]
926 l->remove(0)
927 l->add(5)
928 l->insert(99, 1)
Bram Moolenaar0f18b6d2020-02-02 17:22:27 +0100929 assert_equal([2, 99, 3, 4, 5], l)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100930enddef
931
Bram Moolenaar158906c2020-02-06 20:39:45 +0100932def IfElse(what: number): string
933 let res = ''
934 if what == 1
935 res = "one"
936 elseif what == 2
937 res = "two"
Bram Moolenaara259d8d2020-01-31 20:10:50 +0100938 else
Bram Moolenaar158906c2020-02-06 20:39:45 +0100939 res = "three"
Bram Moolenaara259d8d2020-01-31 20:10:50 +0100940 endif
Bram Moolenaar158906c2020-02-06 20:39:45 +0100941 return res
Bram Moolenaara259d8d2020-01-31 20:10:50 +0100942enddef
943
Bram Moolenaar158906c2020-02-06 20:39:45 +0100944def Test_if_elseif_else()
945 assert_equal('one', IfElse(1))
946 assert_equal('two', IfElse(2))
947 assert_equal('three', IfElse(3))
Bram Moolenaar0f18b6d2020-02-02 17:22:27 +0100948enddef
949
Bram Moolenaare8c4abb2020-04-02 21:13:25 +0200950def Test_if_elseif_else_fails()
951 call CheckDefFailure(['elseif true'], 'E582:')
952 call CheckDefFailure(['else'], 'E581:')
953 call CheckDefFailure(['endif'], 'E580:')
954 call CheckDefFailure(['if true', 'elseif xxx'], 'E1001:')
Bram Moolenaar585fea72020-04-02 22:33:21 +0200955 call CheckDefFailure(['if true', 'echo 1'], 'E171:')
Bram Moolenaare8c4abb2020-04-02 21:13:25 +0200956enddef
957
Bram Moolenaar6d69bf62020-03-03 19:02:12 +0100958let g:bool_true = v:true
959let g:bool_false = v:false
960
961def Test_if_const_expr()
962 let res = false
963 if true ? true : false
964 res = true
965 endif
966 assert_equal(true, res)
967
Bram Moolenaar585fea72020-04-02 22:33:21 +0200968 g:glob = 2
969 if false
970 execute('let g:glob = 3')
971 endif
972 assert_equal(2, g:glob)
973 if true
974 execute('let g:glob = 3')
975 endif
976 assert_equal(3, g:glob)
977
Bram Moolenaar6d69bf62020-03-03 19:02:12 +0100978 res = false
979 if g:bool_true ? true : false
980 res = true
981 endif
982 assert_equal(true, res)
983
984 res = false
985 if true ? g:bool_true : false
986 res = true
987 endif
988 assert_equal(true, res)
989
990 res = false
991 if true ? true : g:bool_false
992 res = true
993 endif
994 assert_equal(true, res)
995
996 res = false
997 if true ? false : true
998 res = true
999 endif
1000 assert_equal(false, res)
1001
1002 res = false
1003 if false ? false : true
1004 res = true
1005 endif
1006 assert_equal(true, res)
1007
1008 res = false
1009 if false ? true : false
1010 res = true
1011 endif
1012 assert_equal(false, res)
1013
1014 res = false
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001015 if has('xyz') ? true : false
1016 res = true
1017 endif
1018 assert_equal(false, res)
1019
1020 res = false
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001021 if true && true
1022 res = true
1023 endif
1024 assert_equal(true, res)
1025
1026 res = false
1027 if true && false
1028 res = true
1029 endif
1030 assert_equal(false, res)
1031
1032 res = false
1033 if g:bool_true && false
1034 res = true
1035 endif
1036 assert_equal(false, res)
1037
1038 res = false
1039 if true && g:bool_false
1040 res = true
1041 endif
1042 assert_equal(false, res)
1043
1044 res = false
1045 if false && false
1046 res = true
1047 endif
1048 assert_equal(false, res)
1049
1050 res = false
1051 if true || false
1052 res = true
1053 endif
1054 assert_equal(true, res)
1055
1056 res = false
1057 if g:bool_true || false
1058 res = true
1059 endif
1060 assert_equal(true, res)
1061
1062 res = false
1063 if true || g:bool_false
1064 res = true
1065 endif
1066 assert_equal(true, res)
1067
1068 res = false
1069 if false || false
1070 res = true
1071 endif
1072 assert_equal(false, res)
Bram Moolenaar80c34ca2020-04-01 23:05:18 +02001073enddef
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001074
Bram Moolenaar80c34ca2020-04-01 23:05:18 +02001075def Test_if_const_expr_fails()
1076 call CheckDefFailure(['if "aaa" == "bbb'], 'E114:')
1077 call CheckDefFailure(["if 'aaa' == 'bbb"], 'E115:')
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001078 call CheckDefFailure(["if has('aaa'"], 'E110:')
1079 call CheckDefFailure(["if has('aaa') ? true false"], 'E109:')
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001080enddef
1081
Bram Moolenaarad39c092020-02-26 18:23:43 +01001082def Test_execute_cmd()
1083 new
1084 setline(1, 'default')
1085 execute 'call setline(1, "execute-string")'
1086 assert_equal('execute-string', getline(1))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001087
1088 execute "call setline(1, 'execute-string')"
1089 assert_equal('execute-string', getline(1))
1090
Bram Moolenaarad39c092020-02-26 18:23:43 +01001091 let cmd1 = 'call setline(1,'
1092 let cmd2 = '"execute-var")'
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001093 execute cmd1 cmd2 # comment
Bram Moolenaarad39c092020-02-26 18:23:43 +01001094 assert_equal('execute-var', getline(1))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001095
Bram Moolenaarad39c092020-02-26 18:23:43 +01001096 execute cmd1 cmd2 '|call setline(1, "execute-var-string")'
1097 assert_equal('execute-var-string', getline(1))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001098
Bram Moolenaarad39c092020-02-26 18:23:43 +01001099 let cmd_first = 'call '
1100 let cmd_last = 'setline(1, "execute-var-var")'
1101 execute cmd_first .. cmd_last
1102 assert_equal('execute-var-var', getline(1))
1103 bwipe!
Bram Moolenaar585fea72020-04-02 22:33:21 +02001104
1105 call CheckDefFailure(['execute xxx'], 'E1001:')
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001106 call CheckDefFailure(['execute "cmd"# comment'], 'E488:')
Bram Moolenaarad39c092020-02-26 18:23:43 +01001107enddef
1108
1109def Test_echo_cmd()
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001110 echo 'some' # comment
Bram Moolenaar585fea72020-04-02 22:33:21 +02001111 echon 'thing'
Bram Moolenaarad39c092020-02-26 18:23:43 +01001112 assert_match('^something$', Screenline(&lines))
1113
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001114 echo "some" # comment
1115 echon "thing"
1116 assert_match('^something$', Screenline(&lines))
1117
Bram Moolenaarad39c092020-02-26 18:23:43 +01001118 let str1 = 'some'
1119 let str2 = 'more'
1120 echo str1 str2
1121 assert_match('^some more$', Screenline(&lines))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001122
1123 call CheckDefFailure(['echo "xxx"# comment'], 'E488:')
Bram Moolenaarad39c092020-02-26 18:23:43 +01001124enddef
1125
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001126def Test_echomsg_cmd()
1127 echomsg 'some' 'more' # comment
1128 assert_match('^some more$', Screenline(&lines))
1129 echo 'clear'
1130 1messages
1131 assert_match('^some more$', Screenline(&lines))
1132
1133 call CheckDefFailure(['echomsg "xxx"# comment'], 'E488:')
1134enddef
1135
1136def Test_echoerr_cmd()
Bram Moolenaar40ee4662020-05-05 22:08:26 +02001137 try
1138 echoerr 'something' 'wrong' # comment
1139 catch
1140 assert_match('something wrong', v:exception)
1141 endtry
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001142enddef
1143
Bram Moolenaar41fe0612020-03-01 16:22:40 +01001144def Test_for_outside_of_function()
1145 let lines =<< trim END
1146 vim9script
1147 new
1148 for var in range(0, 3)
1149 append(line('$'), var)
1150 endfor
1151 assert_equal(['', '0', '1', '2', '3'], getline(1, '$'))
1152 bwipe!
1153 END
1154 writefile(lines, 'Xvim9for.vim')
1155 source Xvim9for.vim
1156 delete('Xvim9for.vim')
1157enddef
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001158
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001159def Test_for_loop()
1160 let result = ''
1161 for cnt in range(7)
1162 if cnt == 4
1163 break
1164 endif
1165 if cnt == 2
1166 continue
1167 endif
1168 result ..= cnt .. '_'
1169 endfor
1170 assert_equal('0_1_3_', result)
1171enddef
1172
1173def Test_for_loop_fails()
Bram Moolenaar675f7162020-04-12 22:53:54 +02001174 CheckDefFailure(['for # in range(5)'], 'E690:')
1175 CheckDefFailure(['for i In range(5)'], 'E690:')
1176 CheckDefFailure(['let x = 5', 'for x in range(5)'], 'E1023:')
Bram Moolenaar822ba242020-05-24 23:00:18 +02001177 CheckScriptFailure(['def Func(arg: any)', 'for arg in range(5)', 'enddef', 'defcompile'], 'E1006:')
Bram Moolenaar675f7162020-04-12 22:53:54 +02001178 CheckDefFailure(['for i in "text"'], 'E1024:')
1179 CheckDefFailure(['for i in xxx'], 'E1001:')
1180 CheckDefFailure(['endfor'], 'E588:')
1181 CheckDefFailure(['for i in range(3)', 'echo 3'], 'E170:')
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001182enddef
1183
Bram Moolenaard0df1aa2020-03-04 21:50:46 +01001184def Test_while_loop()
1185 let result = ''
1186 let cnt = 0
1187 while cnt < 555
1188 if cnt == 3
1189 break
1190 endif
1191 cnt += 1
1192 if cnt == 2
1193 continue
1194 endif
1195 result ..= cnt .. '_'
1196 endwhile
1197 assert_equal('1_3_', result)
1198enddef
1199
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001200def Test_while_loop_fails()
Bram Moolenaar675f7162020-04-12 22:53:54 +02001201 CheckDefFailure(['while xxx'], 'E1001:')
1202 CheckDefFailure(['endwhile'], 'E588:')
1203 CheckDefFailure(['continue'], 'E586:')
1204 CheckDefFailure(['if true', 'continue'], 'E586:')
1205 CheckDefFailure(['break'], 'E587:')
1206 CheckDefFailure(['if true', 'break'], 'E587:')
1207 CheckDefFailure(['while 1', 'echo 3'], 'E170:')
Bram Moolenaarbd5da372020-03-31 23:13:10 +02001208enddef
1209
Bram Moolenaar9645e2d2020-03-20 20:48:49 +01001210def Test_interrupt_loop()
Bram Moolenaar97acfc72020-03-22 13:44:28 +01001211 let caught = false
Bram Moolenaar9645e2d2020-03-20 20:48:49 +01001212 let x = 0
Bram Moolenaar97acfc72020-03-22 13:44:28 +01001213 try
1214 while 1
1215 x += 1
1216 if x == 100
1217 feedkeys("\<C-C>", 'Lt')
1218 endif
1219 endwhile
1220 catch
1221 caught = true
1222 assert_equal(100, x)
1223 endtry
1224 assert_true(caught, 'should have caught an exception')
Bram Moolenaar9645e2d2020-03-20 20:48:49 +01001225enddef
Bram Moolenaar20431c92020-03-20 18:39:46 +01001226
Bram Moolenaar4fdae992020-04-12 16:38:57 +02001227def Test_automatic_line_continuation()
1228 let mylist = [
1229 'one',
1230 'two',
1231 'three',
1232 ] " comment
1233 assert_equal(['one', 'two', 'three'], mylist)
1234
1235 let mydict = {
1236 'one': 1,
1237 'two': 2,
1238 'three':
1239 3,
1240 } " comment
1241 assert_equal({'one': 1, 'two': 2, 'three': 3}, mydict)
1242 mydict = #{
Bram Moolenaar2c330432020-04-13 14:41:35 +02001243 one: 1, # comment
1244 two: # comment
1245 2, # comment
1246 three: 3 # comment
1247 }
1248 assert_equal(#{one: 1, two: 2, three: 3}, mydict)
1249 mydict = #{
1250 one: 1,
1251 two:
1252 2,
1253 three: 3
Bram Moolenaar4fdae992020-04-12 16:38:57 +02001254 }
1255 assert_equal(#{one: 1, two: 2, three: 3}, mydict)
Bram Moolenaare6085c52020-04-12 20:19:16 +02001256
1257 assert_equal(
1258 ['one', 'two', 'three'],
1259 split('one two three')
1260 )
Bram Moolenaar4fdae992020-04-12 16:38:57 +02001261enddef
1262
Bram Moolenaar7a092242020-04-16 22:10:49 +02001263def Test_vim9_comment()
1264 CheckScriptSuccess([
1265 'vim9script',
1266 '# something',
1267 ])
1268 CheckScriptFailure([
1269 'vim9script',
1270 ':# something',
1271 ], 'E488:')
1272 CheckScriptFailure([
1273 '# something',
1274 ], 'E488:')
1275 CheckScriptFailure([
1276 ':# something',
1277 ], 'E488:')
1278
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02001279 { # block start
1280 } # block end
1281 CheckDefFailure([
1282 '{# comment',
1283 ], 'E488:')
1284 CheckDefFailure([
1285 '{',
1286 '}# comment',
1287 ], 'E488:')
1288
1289 echo "yes" # comment
1290 CheckDefFailure([
1291 'echo "yes"# comment',
1292 ], 'E488:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02001293 CheckScriptSuccess([
1294 'vim9script',
1295 'echo "yes" # something',
1296 ])
1297 CheckScriptFailure([
1298 'vim9script',
1299 'echo "yes"# something',
1300 ], 'E121:')
1301 CheckScriptFailure([
1302 'vim9script',
1303 'echo# something',
1304 ], 'E121:')
1305 CheckScriptFailure([
1306 'echo "yes" # something',
1307 ], 'E121:')
1308
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02001309 exe "echo" # comment
1310 CheckDefFailure([
1311 'exe "echo"# comment',
1312 ], 'E488:')
1313 CheckScriptSuccess([
1314 'vim9script',
1315 'exe "echo" # something',
1316 ])
1317 CheckScriptFailure([
1318 'vim9script',
1319 'exe "echo"# something',
1320 ], 'E121:')
1321 CheckDefFailure([
1322 'exe # comment',
1323 ], 'E1015:')
1324 CheckScriptFailure([
1325 'vim9script',
1326 'exe# something',
1327 ], 'E121:')
1328 CheckScriptFailure([
1329 'exe "echo" # something',
1330 ], 'E121:')
1331
Bram Moolenaar7a092242020-04-16 22:10:49 +02001332 CheckDefFailure([
1333 'try# comment',
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02001334 ' echo "yes"',
Bram Moolenaar7a092242020-04-16 22:10:49 +02001335 'catch',
1336 'endtry',
1337 ], 'E488:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02001338 CheckScriptFailure([
1339 'vim9script',
1340 'try# comment',
1341 'echo "yes"',
1342 ], 'E488:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02001343 CheckDefFailure([
1344 'try',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001345 ' throw#comment',
1346 'catch',
1347 'endtry',
1348 ], 'E1015:')
1349 CheckDefFailure([
1350 'try',
1351 ' throw "yes"#comment',
1352 'catch',
1353 'endtry',
1354 ], 'E488:')
1355 CheckDefFailure([
1356 'try',
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02001357 ' echo "yes"',
Bram Moolenaar7a092242020-04-16 22:10:49 +02001358 'catch# comment',
1359 'endtry',
1360 ], 'E488:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02001361 CheckScriptFailure([
1362 'vim9script',
1363 'try',
1364 ' echo "yes"',
1365 'catch# comment',
1366 'endtry',
1367 ], 'E654:')
1368 CheckDefFailure([
1369 'try',
1370 ' echo "yes"',
1371 'catch /pat/# comment',
1372 'endtry',
1373 ], 'E488:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02001374 CheckDefFailure([
1375 'try',
1376 'echo "yes"',
1377 'catch',
1378 'endtry# comment',
1379 ], 'E488:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02001380 CheckScriptFailure([
1381 'vim9script',
1382 'try',
1383 ' echo "yes"',
1384 'catch',
1385 'endtry# comment',
1386 ], 'E600:')
1387
1388 CheckScriptSuccess([
1389 'vim9script',
1390 'hi # comment',
1391 ])
1392 CheckScriptFailure([
1393 'vim9script',
1394 'hi# comment',
1395 ], 'E416:')
Bram Moolenaar1966c242020-04-20 22:42:32 +02001396 CheckScriptSuccess([
1397 'vim9script',
1398 'hi Search # comment',
1399 ])
1400 CheckScriptFailure([
1401 'vim9script',
1402 'hi Search# comment',
1403 ], 'E416:')
1404 CheckScriptSuccess([
1405 'vim9script',
1406 'hi link This Search # comment',
1407 ])
1408 CheckScriptFailure([
1409 'vim9script',
1410 'hi link This That# comment',
1411 ], 'E413:')
1412 CheckScriptSuccess([
1413 'vim9script',
1414 'hi clear This # comment',
1415 'hi clear # comment',
1416 ])
1417 " not tested, because it doesn't give an error but a warning:
1418 " hi clear This# comment',
1419 CheckScriptFailure([
1420 'vim9script',
1421 'hi clear# comment',
1422 ], 'E416:')
1423
1424 CheckScriptSuccess([
1425 'vim9script',
1426 'hi Group term=bold',
1427 'match Group /todo/ # comment',
1428 ])
1429 CheckScriptFailure([
1430 'vim9script',
1431 'hi Group term=bold',
1432 'match Group /todo/# comment',
1433 ], 'E488:')
1434 CheckScriptSuccess([
1435 'vim9script',
1436 'match # comment',
1437 ])
1438 CheckScriptFailure([
1439 'vim9script',
1440 'match# comment',
1441 ], 'E475:')
1442 CheckScriptSuccess([
1443 'vim9script',
1444 'match none # comment',
1445 ])
1446 CheckScriptFailure([
1447 'vim9script',
1448 'match none# comment',
1449 ], 'E475:')
1450
1451 CheckScriptSuccess([
1452 'vim9script',
1453 'menutrans clear # comment',
1454 ])
1455 CheckScriptFailure([
1456 'vim9script',
1457 'menutrans clear# comment text',
1458 ], 'E474:')
1459
1460 CheckScriptSuccess([
1461 'vim9script',
1462 'syntax clear # comment',
1463 ])
1464 CheckScriptFailure([
1465 'vim9script',
1466 'syntax clear# comment text',
1467 ], 'E28:')
1468 CheckScriptSuccess([
1469 'vim9script',
1470 'syntax keyword Word some',
1471 'syntax clear Word # comment',
1472 ])
1473 CheckScriptFailure([
1474 'vim9script',
1475 'syntax keyword Word some',
1476 'syntax clear Word# comment text',
1477 ], 'E28:')
1478
1479 CheckScriptSuccess([
1480 'vim9script',
1481 'syntax list # comment',
1482 ])
1483 CheckScriptFailure([
1484 'vim9script',
1485 'syntax list# comment text',
1486 ], 'E28:')
1487
1488 CheckScriptSuccess([
1489 'vim9script',
1490 'syntax match Word /pat/ oneline # comment',
1491 ])
1492 CheckScriptFailure([
1493 'vim9script',
1494 'syntax match Word /pat/ oneline# comment',
1495 ], 'E475:')
1496
1497 CheckScriptSuccess([
1498 'vim9script',
1499 'syntax keyword Word word # comm[ent',
1500 ])
1501 CheckScriptFailure([
1502 'vim9script',
1503 'syntax keyword Word word# comm[ent',
1504 ], 'E789:')
1505
1506 CheckScriptSuccess([
1507 'vim9script',
1508 'syntax match Word /pat/ # comment',
1509 ])
1510 CheckScriptFailure([
1511 'vim9script',
1512 'syntax match Word /pat/# comment',
1513 ], 'E402:')
1514
1515 CheckScriptSuccess([
1516 'vim9script',
1517 'syntax match Word /pat/ contains=Something # comment',
1518 ])
1519 CheckScriptFailure([
1520 'vim9script',
1521 'syntax match Word /pat/ contains=Something# comment',
1522 ], 'E475:')
1523 CheckScriptFailure([
1524 'vim9script',
1525 'syntax match Word /pat/ contains= # comment',
1526 ], 'E406:')
1527 CheckScriptFailure([
1528 'vim9script',
1529 'syntax match Word /pat/ contains=# comment',
1530 ], 'E475:')
1531
1532 CheckScriptSuccess([
1533 'vim9script',
1534 'syntax region Word start=/pat/ end=/pat/ # comment',
1535 ])
1536 CheckScriptFailure([
1537 'vim9script',
1538 'syntax region Word start=/pat/ end=/pat/# comment',
1539 ], 'E475:')
1540
1541 CheckScriptSuccess([
1542 'vim9script',
1543 'syntax sync # comment',
1544 ])
1545 CheckScriptFailure([
1546 'vim9script',
1547 'syntax sync# comment',
1548 ], 'E404:')
1549 CheckScriptSuccess([
1550 'vim9script',
1551 'syntax sync ccomment # comment',
1552 ])
1553 CheckScriptFailure([
1554 'vim9script',
1555 'syntax sync ccomment# comment',
1556 ], 'E404:')
1557
1558 CheckScriptSuccess([
1559 'vim9script',
1560 'syntax cluster Some contains=Word # comment',
1561 ])
1562 CheckScriptFailure([
1563 'vim9script',
1564 'syntax cluster Some contains=Word# comment',
1565 ], 'E475:')
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001566
1567 CheckScriptSuccess([
1568 'vim9script',
1569 'command Echo echo # comment',
1570 'command Echo # comment',
1571 ])
1572 CheckScriptFailure([
1573 'vim9script',
1574 'command Echo echo# comment',
1575 'Echo',
1576 ], 'E121:')
1577 CheckScriptFailure([
1578 'vim9script',
1579 'command Echo# comment',
1580 ], 'E182:')
1581 CheckScriptFailure([
1582 'vim9script',
1583 'command Echo echo',
1584 'command Echo# comment',
1585 ], 'E182:')
1586
1587 CheckScriptSuccess([
1588 'vim9script',
1589 'function # comment',
1590 ])
1591 CheckScriptFailure([
1592 'vim9script',
1593 'function# comment',
1594 ], 'E129:')
1595 CheckScriptSuccess([
1596 'vim9script',
1597 'function CheckScriptSuccess # comment',
1598 ])
1599 CheckScriptFailure([
1600 'vim9script',
1601 'function CheckScriptSuccess# comment',
1602 ], 'E488:')
1603
1604 CheckScriptSuccess([
1605 'vim9script',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001606 'func g:DeleteMeA()',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001607 'endfunc',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001608 'delfunction g:DeleteMeA # comment',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001609 ])
1610 CheckScriptFailure([
1611 'vim9script',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001612 'func g:DeleteMeB()',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001613 'endfunc',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001614 'delfunction g:DeleteMeB# comment',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001615 ], 'E488:')
1616
1617 CheckScriptSuccess([
1618 'vim9script',
1619 'call execute("ls") # comment',
1620 ])
1621 CheckScriptFailure([
1622 'vim9script',
1623 'call execute("ls")# comment',
1624 ], 'E488:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02001625enddef
1626
1627def Test_vim9_comment_gui()
1628 CheckCanRunGui
1629
1630 CheckScriptFailure([
1631 'vim9script',
1632 'gui#comment'
1633 ], 'E499:')
1634 CheckScriptFailure([
1635 'vim9script',
1636 'gui -f#comment'
1637 ], 'E499:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02001638enddef
1639
Bram Moolenaara26b9702020-04-18 19:53:28 +02001640def Test_vim9_comment_not_compiled()
1641 au TabEnter *.vim let g:entered = 1
1642 au TabEnter *.x let g:entered = 2
1643
1644 edit test.vim
1645 doautocmd TabEnter #comment
1646 assert_equal(1, g:entered)
1647
1648 doautocmd TabEnter f.x
1649 assert_equal(2, g:entered)
1650
1651 g:entered = 0
1652 doautocmd TabEnter f.x #comment
1653 assert_equal(2, g:entered)
1654
1655 assert_fails('doautocmd Syntax#comment', 'E216:')
1656
1657 au! TabEnter
1658 unlet g:entered
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02001659
1660 CheckScriptSuccess([
1661 'vim9script',
1662 'let g:var = 123',
1663 'let w:var = 777',
1664 'unlet g:var w:var # something',
1665 ])
1666
1667 CheckScriptFailure([
1668 'vim9script',
1669 'let g:var = 123',
Bram Moolenaar32e35112020-05-14 22:41:15 +02001670 'unlet g:var# comment1',
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02001671 ], 'E108:')
1672
1673 CheckScriptFailure([
1674 'let g:var = 123',
1675 'unlet g:var # something',
1676 ], 'E488:')
Bram Moolenaarfaac4102020-04-20 17:46:14 +02001677
1678 CheckScriptSuccess([
1679 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02001680 'if 1 # comment2',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02001681 ' echo "yes"',
1682 'elseif 2 #comment',
1683 ' echo "no"',
1684 'endif',
1685 ])
1686
1687 CheckScriptFailure([
1688 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02001689 'if 1# comment3',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02001690 ' echo "yes"',
1691 'endif',
1692 ], 'E15:')
1693
1694 CheckScriptFailure([
1695 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02001696 'if 0 # comment4',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02001697 ' echo "yes"',
1698 'elseif 2#comment',
1699 ' echo "no"',
1700 'endif',
1701 ], 'E15:')
1702
1703 CheckScriptSuccess([
1704 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02001705 'let v = 1 # comment5',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02001706 ])
1707
1708 CheckScriptFailure([
1709 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02001710 'let v = 1# comment6',
1711 ], 'E15:')
Bram Moolenaarfaac4102020-04-20 17:46:14 +02001712
Bram Moolenaarfaac4102020-04-20 17:46:14 +02001713 CheckScriptSuccess([
1714 'vim9script',
1715 'new'
1716 'call setline(1, ["# define pat", "last"])',
1717 '$',
1718 'dsearch /pat/ #comment',
1719 'bwipe!',
1720 ])
1721
1722 CheckScriptFailure([
1723 'vim9script',
1724 'new'
1725 'call setline(1, ["# define pat", "last"])',
1726 '$',
1727 'dsearch /pat/#comment',
1728 'bwipe!',
1729 ], 'E488:')
Bram Moolenaar74fae512020-05-21 21:50:58 +02001730
1731 CheckScriptFailure([
1732 'vim9script',
1733 'func! SomeFunc()',
1734 ], 'E477:')
Bram Moolenaara26b9702020-04-18 19:53:28 +02001735enddef
1736
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02001737def Test_finish()
1738 let lines =<< trim END
1739 vim9script
1740 let g:res = 'one'
1741 if v:false | finish | endif
1742 let g:res = 'two'
1743 finish
1744 let g:res = 'three'
1745 END
1746 writefile(lines, 'Xfinished')
1747 source Xfinished
1748 assert_equal('two', g:res)
1749
1750 unlet g:res
1751 delete('Xfinished')
1752enddef
1753
Bram Moolenaar32e35112020-05-14 22:41:15 +02001754def Test_let_func_call()
1755 let lines =<< trim END
1756 vim9script
1757 func GetValue()
1758 if exists('g:count')
1759 let g:count += 1
1760 else
1761 let g:count = 1
1762 endif
1763 return 'this'
1764 endfunc
1765 let val: string = GetValue()
Bram Moolenaardf671b42020-05-16 22:33:33 +02001766 " env var is always a string
1767 let env = $TERM
Bram Moolenaar32e35112020-05-14 22:41:15 +02001768 END
1769 writefile(lines, 'Xfinished')
1770 source Xfinished
Bram Moolenaara5d00772020-05-14 23:20:55 +02001771 " GetValue() is not called during discovery phase
Bram Moolenaar32e35112020-05-14 22:41:15 +02001772 assert_equal(1, g:count)
1773
1774 unlet g:count
1775 delete('Xfinished')
1776enddef
1777
1778def Test_let_missing_type()
1779 let lines =<< trim END
1780 vim9script
Bram Moolenaardf671b42020-05-16 22:33:33 +02001781 let var = g:unknown
Bram Moolenaar227a69d2020-05-15 18:17:28 +02001782 END
Bram Moolenaar822ba242020-05-24 23:00:18 +02001783 CheckScriptFailure(lines, 'E121:')
Bram Moolenaar227a69d2020-05-15 18:17:28 +02001784
1785 lines =<< trim END
1786 vim9script
1787 let nr: number = 123
1788 let var = nr
1789 END
Bram Moolenaar822ba242020-05-24 23:00:18 +02001790 CheckScriptSuccess(lines)
Bram Moolenaar32e35112020-05-14 22:41:15 +02001791enddef
1792
Bram Moolenaara5d00772020-05-14 23:20:55 +02001793def Test_forward_declaration()
1794 let lines =<< trim END
1795 vim9script
Bram Moolenaara5d00772020-05-14 23:20:55 +02001796 def GetValue(): string
1797 return theVal
1798 enddef
1799 let theVal = 'something'
Bram Moolenaar822ba242020-05-24 23:00:18 +02001800 g:initVal = GetValue()
Bram Moolenaara5d00772020-05-14 23:20:55 +02001801 theVal = 'else'
1802 g:laterVal = GetValue()
1803 END
1804 writefile(lines, 'Xforward')
1805 source Xforward
1806 assert_equal('something', g:initVal)
1807 assert_equal('else', g:laterVal)
1808
1809 unlet g:initVal
1810 unlet g:laterVal
1811 delete('Xforward')
1812enddef
1813
1814
Bram Moolenaar585fea72020-04-02 22:33:21 +02001815" Keep this last, it messes up highlighting.
1816def Test_substitute_cmd()
1817 new
1818 setline(1, 'something')
1819 :substitute(some(other(
1820 assert_equal('otherthing', getline(1))
1821 bwipe!
1822
1823 " also when the context is Vim9 script
1824 let lines =<< trim END
1825 vim9script
1826 new
1827 setline(1, 'something')
1828 :substitute(some(other(
1829 assert_equal('otherthing', getline(1))
1830 bwipe!
1831 END
1832 writefile(lines, 'Xvim9lines')
1833 source Xvim9lines
1834
1835 delete('Xvim9lines')
1836enddef
1837
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001838" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker