blob: fc2c38046fc6aafef99cc379629862e581efe97f [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
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200116 # single character variable declarations work
Bram Moolenaar3b74b6b2020-06-19 19:01:43 +0200117 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
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200125 # script-local variables can be used without s: prefix
Bram Moolenaar3b74b6b2020-06-19 19:01:43 +0200126 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 Moolenaarf5be8cd2020-07-17 20:36:00 +0200178 # overwrite
Bram Moolenaarc785b9a2020-06-19 18:34:15 +0200179 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()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200188 # Test in a separated file in order not to the current buffer/window/tab is
189 # changed.
Bram Moolenaard3aac292020-04-19 14:32:17 +0200190 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')
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200262 # check with non-null job and channel, types must match
Bram Moolenaarc785b9a2020-06-19 18:34:15 +0200263 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 Moolenaar9b7bf9e2020-07-11 22:14:59 +0200308 call CheckDefFailure(['[a; b; c] = g:list'], 'E452:')
Bram Moolenaar9af78762020-06-16 11:34:42 +0200309 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()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200397 # Check function is defined in script namespace
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200398 CheckScriptSuccess([
399 'vim9script',
400 'func CheckMe()',
401 ' return 123',
402 'endfunc',
403 'assert_equal(123, s:CheckMe())',
404 ])
405
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200406 # Check function in script namespace cannot be deleted
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200407 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)
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200512
513 let n: number
514 try
515 n = l[3]
516 catch /E684:/
517 n = 99
518 endtry
519 assert_equal(99, n)
520
521 try
522 n = g:astring[3]
523 catch /E714:/
524 n = 77
525 endtry
526 assert_equal(77, n)
527
528 try
529 n = l[g:astring]
530 catch /E39:/
531 n = 77
532 endtry
533 assert_equal(77, n)
534
535 try
536 n = s:does_not_exist
537 catch /E121:/
538 n = 121
539 endtry
540 assert_equal(121, n)
541
542 let d = #{one: 1}
543 try
544 n = d[g:astring]
545 catch /E716:/
546 n = 222
547 endtry
548 assert_equal(222, n)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100549enddef
550
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100551def ThrowFromDef()
Bram Moolenaara72cfb82020-04-23 17:07:30 +0200552 throw "getout" # comment
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100553enddef
554
555func CatchInFunc()
556 try
557 call ThrowFromDef()
558 catch
559 let g:thrown_func = v:exception
560 endtry
561endfunc
562
563def CatchInDef()
564 try
565 ThrowFromDef()
566 catch
567 g:thrown_def = v:exception
568 endtry
569enddef
570
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100571def ReturnFinally(): string
572 try
573 return 'intry'
574 finally
575 g:in_finally = 'finally'
576 endtry
577 return 'end'
578enddef
579
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100580def Test_try_catch_nested()
581 CatchInFunc()
582 assert_equal('getout', g:thrown_func)
583
584 CatchInDef()
585 assert_equal('getout', g:thrown_def)
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100586
587 assert_equal('intry', ReturnFinally())
588 assert_equal('finally', g:in_finally)
589enddef
590
591def Test_try_catch_match()
592 let seq = 'a'
593 try
594 throw 'something'
595 catch /nothing/
596 seq ..= 'x'
597 catch /some/
598 seq ..= 'b'
599 catch /asdf/
600 seq ..= 'x'
Bram Moolenaare8c4abb2020-04-02 21:13:25 +0200601 catch ?a\?sdf?
602 seq ..= 'y'
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100603 finally
604 seq ..= 'c'
605 endtry
606 assert_equal('abc', seq)
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100607enddef
608
Bram Moolenaare8c4abb2020-04-02 21:13:25 +0200609def Test_try_catch_fails()
610 call CheckDefFailure(['catch'], 'E603:')
Bram Moolenaar6b7a0a82020-07-08 18:38:08 +0200611 call CheckDefFailure(['try', 'echo 0', 'catch', 'catch'], 'E1033:')
Bram Moolenaare8c4abb2020-04-02 21:13:25 +0200612 call CheckDefFailure(['try', 'echo 0', 'catch /pat'], 'E1067:')
Bram Moolenaar585fea72020-04-02 22:33:21 +0200613 call CheckDefFailure(['finally'], 'E606:')
614 call CheckDefFailure(['try', 'echo 0', 'finally', 'echo 1', 'finally'], 'E607:')
615 call CheckDefFailure(['endtry'], 'E602:')
616 call CheckDefFailure(['while 1', 'endtry'], 'E170:')
617 call CheckDefFailure(['for i in range(5)', 'endtry'], 'E170:')
618 call CheckDefFailure(['if 2', 'endtry'], 'E171:')
619 call CheckDefFailure(['try', 'echo 1', 'endtry'], 'E1032:')
620
Bram Moolenaara72cfb82020-04-23 17:07:30 +0200621 call CheckDefFailure(['throw'], 'E1015:')
Bram Moolenaar585fea72020-04-02 22:33:21 +0200622 call CheckDefFailure(['throw xxx'], 'E1001:')
Bram Moolenaare8c4abb2020-04-02 21:13:25 +0200623enddef
624
Bram Moolenaar006ad482020-06-30 20:55:15 +0200625def Test_throw_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200626 # only checks line continuation
Bram Moolenaar006ad482020-06-30 20:55:15 +0200627 let lines =<< trim END
628 vim9script
629 try
630 throw 'one'
631 .. 'two'
632 catch
633 assert_equal('onetwo', v:exception)
634 endtry
635 END
636 CheckScriptSuccess(lines)
637enddef
638
Bram Moolenaar37c83712020-06-30 21:18:36 +0200639def Test_cexpr_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200640 # only checks line continuation
Bram Moolenaar37c83712020-06-30 21:18:36 +0200641 set errorformat=File\ %f\ line\ %l
642 let lines =<< trim END
643 vim9script
644 cexpr 'File'
645 .. ' someFile' ..
646 ' line 19'
647 assert_equal(19, getqflist()[0].lnum)
648 END
649 CheckScriptSuccess(lines)
650 set errorformat&
651enddef
652
Bram Moolenaar2a1381c2020-05-05 23:32:58 +0200653if has('channel')
654 let someJob = test_null_job()
Bram Moolenaar40ee4662020-05-05 22:08:26 +0200655
Bram Moolenaar2a1381c2020-05-05 23:32:58 +0200656 def FuncWithError()
657 echomsg g:someJob
658 enddef
Bram Moolenaar40ee4662020-05-05 22:08:26 +0200659
Bram Moolenaar2a1381c2020-05-05 23:32:58 +0200660 func Test_convert_emsg_to_exception()
661 try
662 call FuncWithError()
663 catch
664 call assert_match('Vim:E908:', v:exception)
665 endtry
666 endfunc
667endif
Bram Moolenaar40ee4662020-05-05 22:08:26 +0200668
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100669let s:export_script_lines =<< trim END
670 vim9script
671 let name: string = 'bob'
672 def Concat(arg: string): string
673 return name .. arg
674 enddef
Bram Moolenaar227a69d2020-05-15 18:17:28 +0200675 g:result = Concat('bie')
676 g:localname = name
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100677
678 export const CONST = 1234
679 export let exported = 9876
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100680 export let exp_name = 'John'
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100681 export def Exported(): string
682 return 'Exported'
683 enddef
684END
685
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100686def Test_vim9_import_export()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100687 let import_script_lines =<< trim END
688 vim9script
689 import {exported, Exported} from './Xexport.vim'
690 g:imported = exported
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100691 exported += 3
692 g:imported_added = exported
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100693 g:imported_func = Exported()
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100694
695 import {exp_name} from './Xexport.vim'
696 g:imported_name = exp_name
697 exp_name ..= ' Doe'
698 g:imported_name_appended = exp_name
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100699 g:imported_later = exported
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100700 END
701
702 writefile(import_script_lines, 'Ximport.vim')
703 writefile(s:export_script_lines, 'Xexport.vim')
704
705 source Ximport.vim
706
707 assert_equal('bobbie', g:result)
708 assert_equal('bob', g:localname)
709 assert_equal(9876, g:imported)
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100710 assert_equal(9879, g:imported_added)
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100711 assert_equal(9879, g:imported_later)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100712 assert_equal('Exported', g:imported_func)
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100713 assert_equal('John', g:imported_name)
714 assert_equal('John Doe', g:imported_name_appended)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100715 assert_false(exists('g:name'))
716
717 unlet g:result
718 unlet g:localname
719 unlet g:imported
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100720 unlet g:imported_added
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100721 unlet g:imported_later
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100722 unlet g:imported_func
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100723 unlet g:imported_name g:imported_name_appended
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100724 delete('Ximport.vim')
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100725
Bram Moolenaar1c991142020-07-04 13:15:31 +0200726 # similar, with line breaks
727 let import_line_break_script_lines =<< trim END
728 vim9script
729 import {
730 exported,
731 Exported,
732 }
733 from
734 './Xexport.vim'
735 g:imported = exported
736 exported += 5
737 g:imported_added = exported
738 g:imported_func = Exported()
739 END
740 writefile(import_line_break_script_lines, 'Ximport_lbr.vim')
741 source Ximport_lbr.vim
742
743 assert_equal(9876, g:imported)
744 assert_equal(9881, g:imported_added)
745 assert_equal('Exported', g:imported_func)
746
747 # exported script not sourced again
748 assert_false(exists('g:result'))
749 unlet g:imported
750 unlet g:imported_added
751 unlet g:imported_func
752 delete('Ximport_lbr.vim')
753
754 # import inside :def function
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100755 let import_in_def_lines =<< trim END
756 vim9script
757 def ImportInDef()
758 import exported from './Xexport.vim'
759 g:imported = exported
760 exported += 7
761 g:imported_added = exported
762 enddef
763 ImportInDef()
764 END
765 writefile(import_in_def_lines, 'Ximport2.vim')
766 source Ximport2.vim
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200767 # TODO: this should be 9879
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100768 assert_equal(9876, g:imported)
769 assert_equal(9883, g:imported_added)
770 unlet g:imported
771 unlet g:imported_added
772 delete('Ximport2.vim')
773
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100774 let import_star_as_lines =<< trim END
775 vim9script
776 import * as Export from './Xexport.vim'
777 def UseExport()
778 g:imported = Export.exported
779 enddef
780 UseExport()
781 END
782 writefile(import_star_as_lines, 'Ximport.vim')
783 source Ximport.vim
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100784 assert_equal(9883, g:imported)
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100785
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100786 let import_star_as_lines_no_dot =<< trim END
787 vim9script
788 import * as Export from './Xexport.vim'
789 def Func()
790 let dummy = 1
791 let imported = Export + dummy
792 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +0200793 defcompile
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100794 END
795 writefile(import_star_as_lines_no_dot, 'Ximport.vim')
796 assert_fails('source Ximport.vim', 'E1060:')
797
798 let import_star_as_lines_dot_space =<< trim END
799 vim9script
800 import * as Export from './Xexport.vim'
801 def Func()
802 let imported = Export . exported
803 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +0200804 defcompile
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100805 END
806 writefile(import_star_as_lines_dot_space, 'Ximport.vim')
807 assert_fails('source Ximport.vim', 'E1074:')
808
809 let import_star_as_lines_missing_name =<< trim END
810 vim9script
811 import * as Export from './Xexport.vim'
812 def Func()
813 let imported = Export.
814 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +0200815 defcompile
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100816 END
817 writefile(import_star_as_lines_missing_name, 'Ximport.vim')
818 assert_fails('source Ximport.vim', 'E1048:')
819
Bram Moolenaar1c991142020-07-04 13:15:31 +0200820 let import_star_as_lbr_lines =<< trim END
821 vim9script
822 import *
823 as Export
824 from
825 './Xexport.vim'
826 def UseExport()
827 g:imported = Export.exported
828 enddef
829 UseExport()
830 END
831 writefile(import_star_as_lbr_lines, 'Ximport.vim')
832 source Ximport.vim
833 assert_equal(9883, g:imported)
834
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100835 let import_star_lines =<< trim END
836 vim9script
837 import * from './Xexport.vim'
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100838 END
839 writefile(import_star_lines, 'Ximport.vim')
840 assert_fails('source Ximport.vim', 'E1045:')
841
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200842 # try to import something that exists but is not exported
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +0100843 let import_not_exported_lines =<< trim END
844 vim9script
845 import name from './Xexport.vim'
846 END
847 writefile(import_not_exported_lines, 'Ximport.vim')
848 assert_fails('source Ximport.vim', 'E1049:')
849
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200850 # try to import something that is already defined
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100851 let import_already_defined =<< trim END
852 vim9script
853 let exported = 'something'
854 import exported from './Xexport.vim'
855 END
856 writefile(import_already_defined, 'Ximport.vim')
857 assert_fails('source Ximport.vim', 'E1073:')
858
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200859 # try to import something that is already defined
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100860 import_already_defined =<< trim END
861 vim9script
862 let exported = 'something'
863 import * as exported from './Xexport.vim'
864 END
865 writefile(import_already_defined, 'Ximport.vim')
866 assert_fails('source Ximport.vim', 'E1073:')
867
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200868 # try to import something that is already defined
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100869 import_already_defined =<< trim END
870 vim9script
871 let exported = 'something'
872 import {exported} from './Xexport.vim'
873 END
874 writefile(import_already_defined, 'Ximport.vim')
875 assert_fails('source Ximport.vim', 'E1073:')
876
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200877 # import a very long name, requires making a copy
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +0100878 let import_long_name_lines =<< trim END
879 vim9script
880 import name012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789 from './Xexport.vim'
881 END
882 writefile(import_long_name_lines, 'Ximport.vim')
883 assert_fails('source Ximport.vim', 'E1048:')
884
885 let import_no_from_lines =<< trim END
886 vim9script
887 import name './Xexport.vim'
888 END
889 writefile(import_no_from_lines, 'Ximport.vim')
890 assert_fails('source Ximport.vim', 'E1070:')
891
892 let import_invalid_string_lines =<< trim END
893 vim9script
894 import name from Xexport.vim
895 END
896 writefile(import_invalid_string_lines, 'Ximport.vim')
897 assert_fails('source Ximport.vim', 'E1071:')
898
899 let import_wrong_name_lines =<< trim END
900 vim9script
901 import name from './XnoExport.vim'
902 END
903 writefile(import_wrong_name_lines, 'Ximport.vim')
904 assert_fails('source Ximport.vim', 'E1053:')
905
906 let import_missing_comma_lines =<< trim END
907 vim9script
908 import {exported name} from './Xexport.vim'
909 END
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100910 writefile(import_missing_comma_lines, 'Ximport3.vim')
911 assert_fails('source Ximport3.vim', 'E1046:')
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +0100912
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100913 delete('Ximport.vim')
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100914 delete('Ximport3.vim')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100915 delete('Xexport.vim')
916
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200917 # Check that in a Vim9 script 'cpo' is set to the Vim default.
Bram Moolenaar750802b2020-02-23 18:08:33 +0100918 set cpo&vi
919 let cpo_before = &cpo
920 let lines =<< trim END
921 vim9script
922 g:cpo_in_vim9script = &cpo
923 END
924 writefile(lines, 'Xvim9_script')
925 source Xvim9_script
926 assert_equal(cpo_before, &cpo)
927 set cpo&vim
928 assert_equal(&cpo, g:cpo_in_vim9script)
929 delete('Xvim9_script')
930enddef
931
932def Test_vim9script_fails()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100933 CheckScriptFailure(['scriptversion 2', 'vim9script'], 'E1039:')
934 CheckScriptFailure(['vim9script', 'scriptversion 2'], 'E1040:')
Bram Moolenaar750802b2020-02-23 18:08:33 +0100935 CheckScriptFailure(['export let some = 123'], 'E1042:')
Bram Moolenaar9721fb42020-06-11 23:10:46 +0200936 CheckScriptFailure(['import some from "./Xexport.vim"'], 'E1048:')
Bram Moolenaar9b7bf9e2020-07-11 22:14:59 +0200937 CheckScriptFailure(['vim9script', 'export let g:some'], 'E1022:')
Bram Moolenaar750802b2020-02-23 18:08:33 +0100938 CheckScriptFailure(['vim9script', 'export echo 134'], 'E1043:')
939
Bram Moolenaarc785b9a2020-06-19 18:34:15 +0200940 CheckScriptFailure(['vim9script', 'let str: string', 'str = 1234'], 'E1013:')
941 CheckScriptFailure(['vim9script', 'const str = "asdf"', 'str = "xxx"'], 'E46:')
942
Bram Moolenaar750802b2020-02-23 18:08:33 +0100943 assert_fails('vim9script', 'E1038')
Bram Moolenaara26b9702020-04-18 19:53:28 +0200944 assert_fails('export something', 'E1043')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100945enddef
946
Bram Moolenaarf7d267e2020-06-17 12:04:54 +0200947func Test_import_fails_without_script()
Bram Moolenaar101f4812020-06-16 23:18:51 +0200948 CheckRunVimInTerminal
949
Bram Moolenaar9bb3eb32020-06-17 20:03:36 +0200950 " call indirectly to avoid compilation error for missing functions
Bram Moolenaarc620c052020-07-08 15:16:19 +0200951 call Run_Test_import_fails_on_command_line()
Bram Moolenaar9bb3eb32020-06-17 20:03:36 +0200952endfunc
953
Bram Moolenaarc620c052020-07-08 15:16:19 +0200954def Run_Test_import_fails_on_command_line()
Bram Moolenaar101f4812020-06-16 23:18:51 +0200955 let export =<< trim END
956 vim9script
957 export def Foo(): number
958 return 0
959 enddef
960 END
Bram Moolenaar9bb3eb32020-06-17 20:03:36 +0200961 writefile(export, 'Xexport.vim')
Bram Moolenaar101f4812020-06-16 23:18:51 +0200962
Bram Moolenaar9bb3eb32020-06-17 20:03:36 +0200963 let buf = RunVimInTerminal('-c "import Foo from ''./Xexport.vim''"', #{
964 rows: 6, wait_for_ruler: 0})
965 WaitForAssert({-> assert_match('^E1094:', term_getline(buf, 5))})
Bram Moolenaar101f4812020-06-16 23:18:51 +0200966
Bram Moolenaar9bb3eb32020-06-17 20:03:36 +0200967 delete('Xexport.vim')
968 StopVimInTerminal(buf)
969enddef
Bram Moolenaar101f4812020-06-16 23:18:51 +0200970
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200971def Test_vim9script_reload_import()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100972 let lines =<< trim END
973 vim9script
974 const var = ''
975 let valone = 1234
976 def MyFunc(arg: string)
977 valone = 5678
978 enddef
979 END
980 let morelines =<< trim END
981 let valtwo = 222
982 export def GetValtwo(): number
983 return valtwo
984 enddef
985 END
Bram Moolenaar03afdcf2020-04-27 23:39:30 +0200986 writefile(lines + morelines, 'Xreload.vim')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100987 source Xreload.vim
988 source Xreload.vim
989 source Xreload.vim
990
991 let testlines =<< trim END
992 vim9script
993 def TheFunc()
994 import GetValtwo from './Xreload.vim'
995 assert_equal(222, GetValtwo())
996 enddef
997 TheFunc()
998 END
999 writefile(testlines, 'Ximport.vim')
1000 source Ximport.vim
1001
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001002 # Test that when not using "morelines" GetValtwo() and valtwo are still
1003 # defined, because import doesn't reload a script.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001004 writefile(lines, 'Xreload.vim')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001005 source Ximport.vim
1006
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001007 # cannot declare a var twice
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001008 lines =<< trim END
1009 vim9script
1010 let valone = 1234
1011 let valone = 5678
1012 END
1013 writefile(lines, 'Xreload.vim')
1014 assert_fails('source Xreload.vim', 'E1041:')
1015
1016 delete('Xreload.vim')
1017 delete('Ximport.vim')
1018enddef
1019
Bram Moolenaarfe465a02020-07-07 22:50:12 +02001020" Not exported function that is referenced needs to be accessed by the
1021" script-local name.
1022def Test_vim9script_funcref()
1023 let sortlines =<< trim END
1024 vim9script
1025 def Compare(i1: number, i2: number): number
Bram Moolenaarbed36b92020-07-07 23:31:36 +02001026 return i2 - i1
Bram Moolenaarfe465a02020-07-07 22:50:12 +02001027 enddef
1028
1029 export def FastSort(): list<number>
1030 return range(5)->sort(Compare)
1031 enddef
1032 END
1033 writefile(sortlines, 'Xsort.vim')
1034
1035 let lines =<< trim END
1036 vim9script
1037 import FastSort from './Xsort.vim'
1038 def Test()
1039 g:result = FastSort()
1040 enddef
1041 Test()
1042 END
1043 writefile(lines, 'Xscript.vim')
1044
1045 source Xscript.vim
1046 assert_equal([4, 3, 2, 1, 0], g:result)
1047
1048 unlet g:result
1049 delete('Xsort.vim')
1050 delete('Xscript.vim')
1051enddef
1052
Bram Moolenaarc620c052020-07-08 15:16:19 +02001053" Check that when searcing for "FilterFunc" it doesn't find the import in the
1054" script where FastFilter() is called from.
1055def Test_vim9script_funcref_other_script()
1056 let filterLines =<< trim END
1057 vim9script
1058 export def FilterFunc(idx: number, val: number): bool
1059 return idx % 2 == 1
1060 enddef
1061 export def FastFilter(): list<number>
1062 return range(10)->filter('FilterFunc')
1063 enddef
1064 END
1065 writefile(filterLines, 'Xfilter.vim')
1066
1067 let lines =<< trim END
1068 vim9script
1069 import {FilterFunc, FastFilter} from './Xfilter.vim'
1070 def Test()
1071 let x: list<number> = FastFilter()
1072 enddef
1073 Test()
1074 END
1075 writefile(lines, 'Ximport.vim')
1076 assert_fails('source Ximport.vim', 'E121:')
1077
1078 delete('Xfilter.vim')
1079 delete('Ximport.vim')
1080enddef
1081
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001082def Test_vim9script_reload_delfunc()
1083 let first_lines =<< trim END
1084 vim9script
1085 def FuncYes(): string
1086 return 'yes'
1087 enddef
1088 END
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001089 let withno_lines =<< trim END
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001090 def FuncNo(): string
1091 return 'no'
1092 enddef
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001093 def g:DoCheck(no_exists: bool)
1094 assert_equal('yes', FuncYes())
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001095 assert_equal('no', FuncNo())
1096 enddef
1097 END
1098 let nono_lines =<< trim END
1099 def g:DoCheck(no_exists: bool)
1100 assert_equal('yes', FuncYes())
1101 assert_fails('call FuncNo()', 'E117:')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001102 enddef
1103 END
1104
1105 # FuncNo() is defined
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001106 writefile(first_lines + withno_lines, 'Xreloaded.vim')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001107 source Xreloaded.vim
1108 g:DoCheck(true)
1109
1110 # FuncNo() is not redefined
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001111 writefile(first_lines + nono_lines, 'Xreloaded.vim')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001112 source Xreloaded.vim
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001113 g:DoCheck()
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001114
1115 # FuncNo() is back
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001116 writefile(first_lines + withno_lines, 'Xreloaded.vim')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001117 source Xreloaded.vim
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001118 g:DoCheck()
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001119
1120 delete('Xreloaded.vim')
1121enddef
1122
Bram Moolenaar89483d42020-05-10 15:24:44 +02001123def Test_vim9script_reload_delvar()
1124 # write the script with a script-local variable
1125 let lines =<< trim END
1126 vim9script
1127 let var = 'string'
1128 END
1129 writefile(lines, 'XreloadVar.vim')
1130 source XreloadVar.vim
1131
1132 # now write the script using the same variable locally - works
1133 lines =<< trim END
1134 vim9script
1135 def Func()
1136 let var = 'string'
1137 enddef
1138 END
1139 writefile(lines, 'XreloadVar.vim')
1140 source XreloadVar.vim
1141
1142 delete('XreloadVar.vim')
1143enddef
1144
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001145def Test_import_absolute()
1146 let import_lines = [
Bram Moolenaare6085c52020-04-12 20:19:16 +02001147 'vim9script',
1148 'import exported from "' .. escape(getcwd(), '\') .. '/Xexport_abs.vim"',
1149 'def UseExported()',
1150 ' g:imported_abs = exported',
1151 ' exported = 8888',
1152 ' g:imported_after = exported',
1153 'enddef',
1154 'UseExported()',
1155 'g:import_disassembled = execute("disass UseExported")',
1156 ]
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001157 writefile(import_lines, 'Ximport_abs.vim')
1158 writefile(s:export_script_lines, 'Xexport_abs.vim')
1159
1160 source Ximport_abs.vim
1161
1162 assert_equal(9876, g:imported_abs)
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +01001163 assert_equal(8888, g:imported_after)
Bram Moolenaar675f7162020-04-12 22:53:54 +02001164 assert_match('<SNR>\d\+_UseExported.*' ..
1165 'g:imported_abs = exported.*' ..
1166 '0 LOADSCRIPT exported from .*Xexport_abs.vim.*' ..
1167 '1 STOREG g:imported_abs.*' ..
1168 'exported = 8888.*' ..
1169 '3 STORESCRIPT exported in .*Xexport_abs.vim.*' ..
1170 'g:imported_after = exported.*' ..
1171 '4 LOADSCRIPT exported from .*Xexport_abs.vim.*' ..
1172 '5 STOREG g:imported_after.*',
Bram Moolenaare6085c52020-04-12 20:19:16 +02001173 g:import_disassembled)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001174 unlet g:imported_abs
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +01001175 unlet g:import_disassembled
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001176
1177 delete('Ximport_abs.vim')
1178 delete('Xexport_abs.vim')
1179enddef
1180
1181def Test_import_rtp()
1182 let import_lines = [
Bram Moolenaare6085c52020-04-12 20:19:16 +02001183 'vim9script',
1184 'import exported from "Xexport_rtp.vim"',
1185 'g:imported_rtp = exported',
1186 ]
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001187 writefile(import_lines, 'Ximport_rtp.vim')
1188 mkdir('import')
1189 writefile(s:export_script_lines, 'import/Xexport_rtp.vim')
1190
1191 let save_rtp = &rtp
1192 &rtp = getcwd()
1193 source Ximport_rtp.vim
1194 &rtp = save_rtp
1195
1196 assert_equal(9876, g:imported_rtp)
1197 unlet g:imported_rtp
1198
1199 delete('Ximport_rtp.vim')
Bram Moolenaar89483d42020-05-10 15:24:44 +02001200 delete('import', 'rf')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001201enddef
1202
Bram Moolenaar25e0f582020-05-25 22:36:50 +02001203def Test_import_compile_error()
1204 let export_lines = [
1205 'vim9script',
1206 'export def ExpFunc(): string',
1207 ' return notDefined',
1208 'enddef',
1209 ]
1210 writefile(export_lines, 'Xexported.vim')
1211
1212 let import_lines = [
1213 'vim9script',
1214 'import ExpFunc from "./Xexported.vim"',
1215 'def ImpFunc()',
1216 ' echo ExpFunc()',
1217 'enddef',
1218 'defcompile',
1219 ]
1220 writefile(import_lines, 'Ximport.vim')
1221
1222 try
1223 source Ximport.vim
1224 catch /E1001/
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001225 # Error should be fore the Xexported.vim file.
Bram Moolenaar25e0f582020-05-25 22:36:50 +02001226 assert_match('E1001: variable not found: notDefined', v:exception)
1227 assert_match('function <SNR>\d\+_ImpFunc\[1\]..<SNR>\d\+_ExpFunc, line 1', v:throwpoint)
1228 endtry
1229
1230 delete('Xexported.vim')
1231 delete('Ximport.vim')
1232enddef
1233
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001234def Test_fixed_size_list()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001235 # will be allocated as one piece of memory, check that changes work
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001236 let l = [1, 2, 3, 4]
1237 l->remove(0)
1238 l->add(5)
1239 l->insert(99, 1)
Bram Moolenaar0f18b6d2020-02-02 17:22:27 +01001240 assert_equal([2, 99, 3, 4, 5], l)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001241enddef
1242
Bram Moolenaar158906c2020-02-06 20:39:45 +01001243def IfElse(what: number): string
1244 let res = ''
1245 if what == 1
1246 res = "one"
1247 elseif what == 2
1248 res = "two"
Bram Moolenaara259d8d2020-01-31 20:10:50 +01001249 else
Bram Moolenaar158906c2020-02-06 20:39:45 +01001250 res = "three"
Bram Moolenaara259d8d2020-01-31 20:10:50 +01001251 endif
Bram Moolenaar158906c2020-02-06 20:39:45 +01001252 return res
Bram Moolenaara259d8d2020-01-31 20:10:50 +01001253enddef
1254
Bram Moolenaar158906c2020-02-06 20:39:45 +01001255def Test_if_elseif_else()
1256 assert_equal('one', IfElse(1))
1257 assert_equal('two', IfElse(2))
1258 assert_equal('three', IfElse(3))
Bram Moolenaar0f18b6d2020-02-02 17:22:27 +01001259enddef
1260
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001261def Test_if_elseif_else_fails()
1262 call CheckDefFailure(['elseif true'], 'E582:')
1263 call CheckDefFailure(['else'], 'E581:')
1264 call CheckDefFailure(['endif'], 'E580:')
1265 call CheckDefFailure(['if true', 'elseif xxx'], 'E1001:')
Bram Moolenaar585fea72020-04-02 22:33:21 +02001266 call CheckDefFailure(['if true', 'echo 1'], 'E171:')
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001267enddef
1268
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001269let g:bool_true = v:true
1270let g:bool_false = v:false
1271
1272def Test_if_const_expr()
1273 let res = false
1274 if true ? true : false
1275 res = true
1276 endif
1277 assert_equal(true, res)
1278
Bram Moolenaar585fea72020-04-02 22:33:21 +02001279 g:glob = 2
1280 if false
Bram Moolenaar67979662020-06-20 22:50:47 +02001281 execute('g:glob = 3')
Bram Moolenaar585fea72020-04-02 22:33:21 +02001282 endif
1283 assert_equal(2, g:glob)
1284 if true
Bram Moolenaar67979662020-06-20 22:50:47 +02001285 execute('g:glob = 3')
Bram Moolenaar585fea72020-04-02 22:33:21 +02001286 endif
1287 assert_equal(3, g:glob)
1288
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001289 res = false
1290 if g:bool_true ? true : false
1291 res = true
1292 endif
1293 assert_equal(true, res)
1294
1295 res = false
1296 if true ? g:bool_true : false
1297 res = true
1298 endif
1299 assert_equal(true, res)
1300
1301 res = false
1302 if true ? true : g:bool_false
1303 res = true
1304 endif
1305 assert_equal(true, res)
1306
1307 res = false
1308 if true ? false : true
1309 res = true
1310 endif
1311 assert_equal(false, res)
1312
1313 res = false
1314 if false ? false : true
1315 res = true
1316 endif
1317 assert_equal(true, res)
1318
1319 res = false
1320 if false ? true : false
1321 res = true
1322 endif
1323 assert_equal(false, res)
1324
1325 res = false
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001326 if has('xyz') ? true : false
1327 res = true
1328 endif
1329 assert_equal(false, res)
1330
1331 res = false
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001332 if true && true
1333 res = true
1334 endif
1335 assert_equal(true, res)
1336
1337 res = false
1338 if true && false
1339 res = true
1340 endif
1341 assert_equal(false, res)
1342
1343 res = false
1344 if g:bool_true && false
1345 res = true
1346 endif
1347 assert_equal(false, res)
1348
1349 res = false
1350 if true && g:bool_false
1351 res = true
1352 endif
1353 assert_equal(false, res)
1354
1355 res = false
1356 if false && false
1357 res = true
1358 endif
1359 assert_equal(false, res)
1360
1361 res = false
1362 if true || false
1363 res = true
1364 endif
1365 assert_equal(true, res)
1366
1367 res = false
1368 if g:bool_true || false
1369 res = true
1370 endif
1371 assert_equal(true, res)
1372
1373 res = false
1374 if true || g:bool_false
1375 res = true
1376 endif
1377 assert_equal(true, res)
1378
1379 res = false
1380 if false || false
1381 res = true
1382 endif
1383 assert_equal(false, res)
Bram Moolenaar80c34ca2020-04-01 23:05:18 +02001384enddef
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001385
Bram Moolenaar80c34ca2020-04-01 23:05:18 +02001386def Test_if_const_expr_fails()
1387 call CheckDefFailure(['if "aaa" == "bbb'], 'E114:')
1388 call CheckDefFailure(["if 'aaa' == 'bbb"], 'E115:')
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001389 call CheckDefFailure(["if has('aaa'"], 'E110:')
1390 call CheckDefFailure(["if has('aaa') ? true false"], 'E109:')
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001391enddef
1392
Bram Moolenaar72abcf42020-06-18 18:26:24 +02001393def RunNested(i: number): number
1394 let x: number = 0
1395 if i % 2
1396 if 1
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001397 # comment
Bram Moolenaar72abcf42020-06-18 18:26:24 +02001398 else
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001399 # comment
Bram Moolenaar72abcf42020-06-18 18:26:24 +02001400 endif
1401 x += 1
1402 else
1403 x += 1000
1404 endif
1405 return x
1406enddef
1407
1408def Test_nested_if()
1409 assert_equal(1, RunNested(1))
1410 assert_equal(1000, RunNested(2))
1411enddef
1412
Bram Moolenaarad39c092020-02-26 18:23:43 +01001413def Test_execute_cmd()
1414 new
1415 setline(1, 'default')
1416 execute 'call setline(1, "execute-string")'
1417 assert_equal('execute-string', getline(1))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001418
1419 execute "call setline(1, 'execute-string')"
1420 assert_equal('execute-string', getline(1))
1421
Bram Moolenaarad39c092020-02-26 18:23:43 +01001422 let cmd1 = 'call setline(1,'
1423 let cmd2 = '"execute-var")'
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001424 execute cmd1 cmd2 # comment
Bram Moolenaarad39c092020-02-26 18:23:43 +01001425 assert_equal('execute-var', getline(1))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001426
Bram Moolenaarad39c092020-02-26 18:23:43 +01001427 execute cmd1 cmd2 '|call setline(1, "execute-var-string")'
1428 assert_equal('execute-var-string', getline(1))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001429
Bram Moolenaarad39c092020-02-26 18:23:43 +01001430 let cmd_first = 'call '
1431 let cmd_last = 'setline(1, "execute-var-var")'
1432 execute cmd_first .. cmd_last
1433 assert_equal('execute-var-var', getline(1))
1434 bwipe!
Bram Moolenaar585fea72020-04-02 22:33:21 +02001435
1436 call CheckDefFailure(['execute xxx'], 'E1001:')
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001437 call CheckDefFailure(['execute "cmd"# comment'], 'E488:')
Bram Moolenaarad39c092020-02-26 18:23:43 +01001438enddef
1439
Bram Moolenaar47e880d2020-06-30 22:02:02 +02001440def Test_execute_cmd_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001441 # only checks line continuation
Bram Moolenaar47e880d2020-06-30 22:02:02 +02001442 let lines =<< trim END
1443 vim9script
1444 execute 'g:someVar'
1445 .. ' = ' ..
1446 '28'
1447 assert_equal(28, g:someVar)
1448 unlet g:someVar
1449 END
1450 CheckScriptSuccess(lines)
1451enddef
1452
Bram Moolenaarad39c092020-02-26 18:23:43 +01001453def Test_echo_cmd()
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001454 echo 'some' # comment
Bram Moolenaar585fea72020-04-02 22:33:21 +02001455 echon 'thing'
Bram Moolenaarad39c092020-02-26 18:23:43 +01001456 assert_match('^something$', Screenline(&lines))
1457
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001458 echo "some" # comment
1459 echon "thing"
1460 assert_match('^something$', Screenline(&lines))
1461
Bram Moolenaarad39c092020-02-26 18:23:43 +01001462 let str1 = 'some'
1463 let str2 = 'more'
1464 echo str1 str2
1465 assert_match('^some more$', Screenline(&lines))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001466
1467 call CheckDefFailure(['echo "xxx"# comment'], 'E488:')
Bram Moolenaarad39c092020-02-26 18:23:43 +01001468enddef
1469
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001470def Test_echomsg_cmd()
1471 echomsg 'some' 'more' # comment
1472 assert_match('^some more$', Screenline(&lines))
1473 echo 'clear'
Bram Moolenaardf069ee2020-06-22 23:02:51 +02001474 :1messages
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001475 assert_match('^some more$', Screenline(&lines))
1476
1477 call CheckDefFailure(['echomsg "xxx"# comment'], 'E488:')
1478enddef
1479
Bram Moolenaar47e880d2020-06-30 22:02:02 +02001480def Test_echomsg_cmd_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001481 # only checks line continuation
Bram Moolenaar47e880d2020-06-30 22:02:02 +02001482 let lines =<< trim END
1483 vim9script
1484 echomsg 'here'
1485 .. ' is ' ..
1486 'a message'
1487 assert_match('^here is a message$', Screenline(&lines))
1488 END
1489 CheckScriptSuccess(lines)
1490enddef
1491
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001492def Test_echoerr_cmd()
Bram Moolenaar40ee4662020-05-05 22:08:26 +02001493 try
1494 echoerr 'something' 'wrong' # comment
1495 catch
1496 assert_match('something wrong', v:exception)
1497 endtry
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001498enddef
1499
Bram Moolenaar47e880d2020-06-30 22:02:02 +02001500def Test_echoerr_cmd_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001501 # only checks line continuation
Bram Moolenaar47e880d2020-06-30 22:02:02 +02001502 let lines =<< trim END
1503 vim9script
1504 try
1505 echoerr 'this'
1506 .. ' is ' ..
1507 'wrong'
1508 catch
1509 assert_match('this is wrong', v:exception)
1510 endtry
1511 END
1512 CheckScriptSuccess(lines)
1513enddef
1514
Bram Moolenaar41fe0612020-03-01 16:22:40 +01001515def Test_for_outside_of_function()
1516 let lines =<< trim END
1517 vim9script
1518 new
1519 for var in range(0, 3)
1520 append(line('$'), var)
1521 endfor
1522 assert_equal(['', '0', '1', '2', '3'], getline(1, '$'))
1523 bwipe!
1524 END
1525 writefile(lines, 'Xvim9for.vim')
1526 source Xvim9for.vim
1527 delete('Xvim9for.vim')
1528enddef
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001529
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001530def Test_for_loop()
1531 let result = ''
1532 for cnt in range(7)
1533 if cnt == 4
1534 break
1535 endif
1536 if cnt == 2
1537 continue
1538 endif
1539 result ..= cnt .. '_'
1540 endfor
1541 assert_equal('0_1_3_', result)
Bram Moolenaar0ad3e892020-07-05 21:38:11 +02001542
1543 let concat = ''
1544 for str in eval('["one", "two"]')
1545 concat ..= str
1546 endfor
1547 assert_equal('onetwo', concat)
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001548enddef
1549
1550def Test_for_loop_fails()
Bram Moolenaar675f7162020-04-12 22:53:54 +02001551 CheckDefFailure(['for # in range(5)'], 'E690:')
1552 CheckDefFailure(['for i In range(5)'], 'E690:')
1553 CheckDefFailure(['let x = 5', 'for x in range(5)'], 'E1023:')
Bram Moolenaar822ba242020-05-24 23:00:18 +02001554 CheckScriptFailure(['def Func(arg: any)', 'for arg in range(5)', 'enddef', 'defcompile'], 'E1006:')
Bram Moolenaar0ad3e892020-07-05 21:38:11 +02001555 CheckDefFailure(['for i in "text"'], 'E1013:')
Bram Moolenaar675f7162020-04-12 22:53:54 +02001556 CheckDefFailure(['for i in xxx'], 'E1001:')
1557 CheckDefFailure(['endfor'], 'E588:')
1558 CheckDefFailure(['for i in range(3)', 'echo 3'], 'E170:')
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001559enddef
1560
Bram Moolenaard0df1aa2020-03-04 21:50:46 +01001561def Test_while_loop()
1562 let result = ''
1563 let cnt = 0
1564 while cnt < 555
1565 if cnt == 3
1566 break
1567 endif
1568 cnt += 1
1569 if cnt == 2
1570 continue
1571 endif
1572 result ..= cnt .. '_'
1573 endwhile
1574 assert_equal('1_3_', result)
1575enddef
1576
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001577def Test_while_loop_fails()
Bram Moolenaar675f7162020-04-12 22:53:54 +02001578 CheckDefFailure(['while xxx'], 'E1001:')
1579 CheckDefFailure(['endwhile'], 'E588:')
1580 CheckDefFailure(['continue'], 'E586:')
1581 CheckDefFailure(['if true', 'continue'], 'E586:')
1582 CheckDefFailure(['break'], 'E587:')
1583 CheckDefFailure(['if true', 'break'], 'E587:')
1584 CheckDefFailure(['while 1', 'echo 3'], 'E170:')
Bram Moolenaarbd5da372020-03-31 23:13:10 +02001585enddef
1586
Bram Moolenaar9645e2d2020-03-20 20:48:49 +01001587def Test_interrupt_loop()
Bram Moolenaar97acfc72020-03-22 13:44:28 +01001588 let caught = false
Bram Moolenaar9645e2d2020-03-20 20:48:49 +01001589 let x = 0
Bram Moolenaar97acfc72020-03-22 13:44:28 +01001590 try
1591 while 1
1592 x += 1
1593 if x == 100
1594 feedkeys("\<C-C>", 'Lt')
1595 endif
1596 endwhile
1597 catch
1598 caught = true
1599 assert_equal(100, x)
1600 endtry
1601 assert_true(caught, 'should have caught an exception')
Bram Moolenaar9645e2d2020-03-20 20:48:49 +01001602enddef
Bram Moolenaar20431c92020-03-20 18:39:46 +01001603
Bram Moolenaar4fdae992020-04-12 16:38:57 +02001604def Test_automatic_line_continuation()
1605 let mylist = [
1606 'one',
1607 'two',
1608 'three',
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001609 ] # comment
Bram Moolenaar4fdae992020-04-12 16:38:57 +02001610 assert_equal(['one', 'two', 'three'], mylist)
1611
1612 let mydict = {
1613 'one': 1,
1614 'two': 2,
1615 'three':
1616 3,
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001617 } # comment
Bram Moolenaar4fdae992020-04-12 16:38:57 +02001618 assert_equal({'one': 1, 'two': 2, 'three': 3}, mydict)
1619 mydict = #{
Bram Moolenaar2c330432020-04-13 14:41:35 +02001620 one: 1, # comment
1621 two: # comment
1622 2, # comment
1623 three: 3 # comment
1624 }
1625 assert_equal(#{one: 1, two: 2, three: 3}, mydict)
1626 mydict = #{
1627 one: 1,
1628 two:
1629 2,
1630 three: 3
Bram Moolenaar4fdae992020-04-12 16:38:57 +02001631 }
1632 assert_equal(#{one: 1, two: 2, three: 3}, mydict)
Bram Moolenaare6085c52020-04-12 20:19:16 +02001633
1634 assert_equal(
1635 ['one', 'two', 'three'],
1636 split('one two three')
1637 )
Bram Moolenaar4fdae992020-04-12 16:38:57 +02001638enddef
1639
Bram Moolenaar7a092242020-04-16 22:10:49 +02001640def Test_vim9_comment()
1641 CheckScriptSuccess([
1642 'vim9script',
1643 '# something',
1644 ])
1645 CheckScriptFailure([
1646 'vim9script',
1647 ':# something',
1648 ], 'E488:')
1649 CheckScriptFailure([
1650 '# something',
1651 ], 'E488:')
1652 CheckScriptFailure([
1653 ':# something',
1654 ], 'E488:')
1655
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02001656 { # block start
1657 } # block end
1658 CheckDefFailure([
1659 '{# comment',
1660 ], 'E488:')
1661 CheckDefFailure([
1662 '{',
1663 '}# comment',
1664 ], 'E488:')
1665
1666 echo "yes" # comment
1667 CheckDefFailure([
1668 'echo "yes"# comment',
1669 ], 'E488:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02001670 CheckScriptSuccess([
1671 'vim9script',
1672 'echo "yes" # something',
1673 ])
1674 CheckScriptFailure([
1675 'vim9script',
1676 'echo "yes"# something',
1677 ], 'E121:')
1678 CheckScriptFailure([
1679 'vim9script',
1680 'echo# something',
1681 ], 'E121:')
1682 CheckScriptFailure([
1683 'echo "yes" # something',
1684 ], 'E121:')
1685
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02001686 exe "echo" # comment
1687 CheckDefFailure([
1688 'exe "echo"# comment',
1689 ], 'E488:')
1690 CheckScriptSuccess([
1691 'vim9script',
1692 'exe "echo" # something',
1693 ])
1694 CheckScriptFailure([
1695 'vim9script',
1696 'exe "echo"# something',
1697 ], 'E121:')
1698 CheckDefFailure([
1699 'exe # comment',
1700 ], 'E1015:')
1701 CheckScriptFailure([
1702 'vim9script',
1703 'exe# something',
1704 ], 'E121:')
1705 CheckScriptFailure([
1706 'exe "echo" # something',
1707 ], 'E121:')
1708
Bram Moolenaar7a092242020-04-16 22:10:49 +02001709 CheckDefFailure([
1710 'try# comment',
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02001711 ' echo "yes"',
Bram Moolenaar7a092242020-04-16 22:10:49 +02001712 'catch',
1713 'endtry',
1714 ], 'E488:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02001715 CheckScriptFailure([
1716 'vim9script',
1717 'try# comment',
1718 'echo "yes"',
1719 ], 'E488:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02001720 CheckDefFailure([
1721 'try',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001722 ' throw#comment',
1723 'catch',
1724 'endtry',
1725 ], 'E1015:')
1726 CheckDefFailure([
1727 'try',
1728 ' throw "yes"#comment',
1729 'catch',
1730 'endtry',
1731 ], 'E488:')
1732 CheckDefFailure([
1733 'try',
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02001734 ' echo "yes"',
Bram Moolenaar7a092242020-04-16 22:10:49 +02001735 'catch# comment',
1736 'endtry',
1737 ], 'E488:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02001738 CheckScriptFailure([
1739 'vim9script',
1740 'try',
1741 ' echo "yes"',
1742 'catch# comment',
1743 'endtry',
1744 ], 'E654:')
1745 CheckDefFailure([
1746 'try',
1747 ' echo "yes"',
1748 'catch /pat/# comment',
1749 'endtry',
1750 ], 'E488:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02001751 CheckDefFailure([
1752 'try',
1753 'echo "yes"',
1754 'catch',
1755 'endtry# comment',
1756 ], 'E488:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02001757 CheckScriptFailure([
1758 'vim9script',
1759 'try',
1760 ' echo "yes"',
1761 'catch',
1762 'endtry# comment',
Bram Moolenaar9b7bf9e2020-07-11 22:14:59 +02001763 ], 'E488:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02001764
1765 CheckScriptSuccess([
1766 'vim9script',
1767 'hi # comment',
1768 ])
1769 CheckScriptFailure([
1770 'vim9script',
1771 'hi# comment',
1772 ], 'E416:')
Bram Moolenaar1966c242020-04-20 22:42:32 +02001773 CheckScriptSuccess([
1774 'vim9script',
1775 'hi Search # comment',
1776 ])
1777 CheckScriptFailure([
1778 'vim9script',
1779 'hi Search# comment',
1780 ], 'E416:')
1781 CheckScriptSuccess([
1782 'vim9script',
1783 'hi link This Search # comment',
1784 ])
1785 CheckScriptFailure([
1786 'vim9script',
1787 'hi link This That# comment',
1788 ], 'E413:')
1789 CheckScriptSuccess([
1790 'vim9script',
1791 'hi clear This # comment',
1792 'hi clear # comment',
1793 ])
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001794 # not tested, because it doesn't give an error but a warning:
1795 # hi clear This# comment',
Bram Moolenaar1966c242020-04-20 22:42:32 +02001796 CheckScriptFailure([
1797 'vim9script',
1798 'hi clear# comment',
1799 ], 'E416:')
1800
1801 CheckScriptSuccess([
1802 'vim9script',
1803 'hi Group term=bold',
1804 'match Group /todo/ # comment',
1805 ])
1806 CheckScriptFailure([
1807 'vim9script',
1808 'hi Group term=bold',
1809 'match Group /todo/# comment',
1810 ], 'E488:')
1811 CheckScriptSuccess([
1812 'vim9script',
1813 'match # comment',
1814 ])
1815 CheckScriptFailure([
1816 'vim9script',
1817 'match# comment',
1818 ], 'E475:')
1819 CheckScriptSuccess([
1820 'vim9script',
1821 'match none # comment',
1822 ])
1823 CheckScriptFailure([
1824 'vim9script',
1825 'match none# comment',
1826 ], 'E475:')
1827
1828 CheckScriptSuccess([
1829 'vim9script',
1830 'menutrans clear # comment',
1831 ])
1832 CheckScriptFailure([
1833 'vim9script',
1834 'menutrans clear# comment text',
1835 ], 'E474:')
1836
1837 CheckScriptSuccess([
1838 'vim9script',
1839 'syntax clear # comment',
1840 ])
1841 CheckScriptFailure([
1842 'vim9script',
1843 'syntax clear# comment text',
1844 ], 'E28:')
1845 CheckScriptSuccess([
1846 'vim9script',
1847 'syntax keyword Word some',
1848 'syntax clear Word # comment',
1849 ])
1850 CheckScriptFailure([
1851 'vim9script',
1852 'syntax keyword Word some',
1853 'syntax clear Word# comment text',
1854 ], 'E28:')
1855
1856 CheckScriptSuccess([
1857 'vim9script',
1858 'syntax list # comment',
1859 ])
1860 CheckScriptFailure([
1861 'vim9script',
1862 'syntax list# comment text',
1863 ], 'E28:')
1864
1865 CheckScriptSuccess([
1866 'vim9script',
1867 'syntax match Word /pat/ oneline # comment',
1868 ])
1869 CheckScriptFailure([
1870 'vim9script',
1871 'syntax match Word /pat/ oneline# comment',
1872 ], 'E475:')
1873
1874 CheckScriptSuccess([
1875 'vim9script',
1876 'syntax keyword Word word # comm[ent',
1877 ])
1878 CheckScriptFailure([
1879 'vim9script',
1880 'syntax keyword Word word# comm[ent',
1881 ], 'E789:')
1882
1883 CheckScriptSuccess([
1884 'vim9script',
1885 'syntax match Word /pat/ # comment',
1886 ])
1887 CheckScriptFailure([
1888 'vim9script',
1889 'syntax match Word /pat/# comment',
1890 ], 'E402:')
1891
1892 CheckScriptSuccess([
1893 'vim9script',
1894 'syntax match Word /pat/ contains=Something # comment',
1895 ])
1896 CheckScriptFailure([
1897 'vim9script',
1898 'syntax match Word /pat/ contains=Something# comment',
1899 ], 'E475:')
1900 CheckScriptFailure([
1901 'vim9script',
1902 'syntax match Word /pat/ contains= # comment',
1903 ], 'E406:')
1904 CheckScriptFailure([
1905 'vim9script',
1906 'syntax match Word /pat/ contains=# comment',
1907 ], 'E475:')
1908
1909 CheckScriptSuccess([
1910 'vim9script',
1911 'syntax region Word start=/pat/ end=/pat/ # comment',
1912 ])
1913 CheckScriptFailure([
1914 'vim9script',
1915 'syntax region Word start=/pat/ end=/pat/# comment',
1916 ], 'E475:')
1917
1918 CheckScriptSuccess([
1919 'vim9script',
1920 'syntax sync # comment',
1921 ])
1922 CheckScriptFailure([
1923 'vim9script',
1924 'syntax sync# comment',
1925 ], 'E404:')
1926 CheckScriptSuccess([
1927 'vim9script',
1928 'syntax sync ccomment # comment',
1929 ])
1930 CheckScriptFailure([
1931 'vim9script',
1932 'syntax sync ccomment# comment',
1933 ], 'E404:')
1934
1935 CheckScriptSuccess([
1936 'vim9script',
1937 'syntax cluster Some contains=Word # comment',
1938 ])
1939 CheckScriptFailure([
1940 'vim9script',
1941 'syntax cluster Some contains=Word# comment',
1942 ], 'E475:')
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001943
1944 CheckScriptSuccess([
1945 'vim9script',
1946 'command Echo echo # comment',
1947 'command Echo # comment',
1948 ])
1949 CheckScriptFailure([
1950 'vim9script',
1951 'command Echo echo# comment',
1952 'Echo',
1953 ], 'E121:')
1954 CheckScriptFailure([
1955 'vim9script',
1956 'command Echo# comment',
1957 ], 'E182:')
1958 CheckScriptFailure([
1959 'vim9script',
1960 'command Echo echo',
1961 'command Echo# comment',
1962 ], 'E182:')
1963
1964 CheckScriptSuccess([
1965 'vim9script',
1966 'function # comment',
1967 ])
1968 CheckScriptFailure([
1969 'vim9script',
1970 'function# comment',
1971 ], 'E129:')
1972 CheckScriptSuccess([
1973 'vim9script',
1974 'function CheckScriptSuccess # comment',
1975 ])
1976 CheckScriptFailure([
1977 'vim9script',
1978 'function CheckScriptSuccess# comment',
1979 ], 'E488:')
1980
1981 CheckScriptSuccess([
1982 'vim9script',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001983 'func g:DeleteMeA()',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001984 'endfunc',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001985 'delfunction g:DeleteMeA # comment',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001986 ])
1987 CheckScriptFailure([
1988 'vim9script',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001989 'func g:DeleteMeB()',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001990 'endfunc',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001991 'delfunction g:DeleteMeB# comment',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001992 ], 'E488:')
1993
1994 CheckScriptSuccess([
1995 'vim9script',
1996 'call execute("ls") # comment',
1997 ])
1998 CheckScriptFailure([
1999 'vim9script',
2000 'call execute("ls")# comment',
2001 ], 'E488:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002002enddef
2003
2004def Test_vim9_comment_gui()
2005 CheckCanRunGui
2006
2007 CheckScriptFailure([
2008 'vim9script',
2009 'gui#comment'
2010 ], 'E499:')
2011 CheckScriptFailure([
2012 'vim9script',
2013 'gui -f#comment'
2014 ], 'E499:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02002015enddef
2016
Bram Moolenaara26b9702020-04-18 19:53:28 +02002017def Test_vim9_comment_not_compiled()
Bram Moolenaar67979662020-06-20 22:50:47 +02002018 au TabEnter *.vim g:entered = 1
2019 au TabEnter *.x g:entered = 2
Bram Moolenaara26b9702020-04-18 19:53:28 +02002020
2021 edit test.vim
2022 doautocmd TabEnter #comment
2023 assert_equal(1, g:entered)
2024
2025 doautocmd TabEnter f.x
2026 assert_equal(2, g:entered)
2027
2028 g:entered = 0
2029 doautocmd TabEnter f.x #comment
2030 assert_equal(2, g:entered)
2031
2032 assert_fails('doautocmd Syntax#comment', 'E216:')
2033
2034 au! TabEnter
2035 unlet g:entered
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02002036
2037 CheckScriptSuccess([
2038 'vim9script',
Bram Moolenaar67979662020-06-20 22:50:47 +02002039 'g:var = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02002040 'b:var = 456',
2041 'w:var = 777',
2042 't:var = 888',
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02002043 'unlet g:var w:var # something',
2044 ])
2045
2046 CheckScriptFailure([
2047 'vim9script',
2048 'let g:var = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02002049 ], 'E1016: Cannot declare a global variable:')
2050
2051 CheckScriptFailure([
2052 'vim9script',
2053 'let b:var = 123',
2054 ], 'E1016: Cannot declare a buffer variable:')
2055
2056 CheckScriptFailure([
2057 'vim9script',
2058 'let w:var = 123',
2059 ], 'E1016: Cannot declare a window variable:')
2060
2061 CheckScriptFailure([
2062 'vim9script',
2063 'let t:var = 123',
2064 ], 'E1016: Cannot declare a tab variable:')
2065
2066 CheckScriptFailure([
2067 'vim9script',
2068 'let v:version = 123',
2069 ], 'E1016: Cannot declare a v: variable:')
2070
2071 CheckScriptFailure([
2072 'vim9script',
2073 'let $VARIABLE = "text"',
2074 ], 'E1016: Cannot declare an environment variable:')
Bram Moolenaar67979662020-06-20 22:50:47 +02002075
2076 CheckScriptFailure([
2077 'vim9script',
2078 'g:var = 123',
Bram Moolenaar32e35112020-05-14 22:41:15 +02002079 'unlet g:var# comment1',
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02002080 ], 'E108:')
2081
2082 CheckScriptFailure([
2083 'let g:var = 123',
2084 'unlet g:var # something',
2085 ], 'E488:')
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002086
2087 CheckScriptSuccess([
2088 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02002089 'if 1 # comment2',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002090 ' echo "yes"',
2091 'elseif 2 #comment',
2092 ' echo "no"',
2093 'endif',
2094 ])
2095
2096 CheckScriptFailure([
2097 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02002098 'if 1# comment3',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002099 ' echo "yes"',
2100 'endif',
2101 ], 'E15:')
2102
2103 CheckScriptFailure([
2104 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02002105 'if 0 # comment4',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002106 ' echo "yes"',
2107 'elseif 2#comment',
2108 ' echo "no"',
2109 'endif',
2110 ], 'E15:')
2111
2112 CheckScriptSuccess([
2113 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02002114 'let v = 1 # comment5',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002115 ])
2116
2117 CheckScriptFailure([
2118 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02002119 'let v = 1# comment6',
2120 ], 'E15:')
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002121
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002122 CheckScriptSuccess([
2123 'vim9script',
2124 'new'
2125 'call setline(1, ["# define pat", "last"])',
Bram Moolenaardf069ee2020-06-22 23:02:51 +02002126 ':$',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002127 'dsearch /pat/ #comment',
2128 'bwipe!',
2129 ])
2130
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002131 CheckScriptFailure([
2132 'vim9script',
2133 'new'
2134 'call setline(1, ["# define pat", "last"])',
2135 ':$',
2136 'dsearch /pat/#comment',
2137 'bwipe!',
2138 ], 'E488:')
2139
2140 CheckScriptFailure([
2141 'vim9script',
2142 'func! SomeFunc()',
2143 ], 'E477:')
Bram Moolenaara26b9702020-04-18 19:53:28 +02002144enddef
2145
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02002146def Test_finish()
2147 let lines =<< trim END
2148 vim9script
Bram Moolenaar67979662020-06-20 22:50:47 +02002149 g:res = 'one'
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02002150 if v:false | finish | endif
Bram Moolenaar67979662020-06-20 22:50:47 +02002151 g:res = 'two'
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02002152 finish
Bram Moolenaar67979662020-06-20 22:50:47 +02002153 g:res = 'three'
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02002154 END
2155 writefile(lines, 'Xfinished')
2156 source Xfinished
2157 assert_equal('two', g:res)
2158
2159 unlet g:res
2160 delete('Xfinished')
2161enddef
2162
Bram Moolenaar32e35112020-05-14 22:41:15 +02002163def Test_let_func_call()
2164 let lines =<< trim END
2165 vim9script
2166 func GetValue()
2167 if exists('g:count')
2168 let g:count += 1
2169 else
2170 let g:count = 1
2171 endif
2172 return 'this'
2173 endfunc
2174 let val: string = GetValue()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002175 # env var is always a string
Bram Moolenaardf671b42020-05-16 22:33:33 +02002176 let env = $TERM
Bram Moolenaar32e35112020-05-14 22:41:15 +02002177 END
2178 writefile(lines, 'Xfinished')
2179 source Xfinished
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002180 # GetValue() is not called during discovery phase
Bram Moolenaar32e35112020-05-14 22:41:15 +02002181 assert_equal(1, g:count)
2182
2183 unlet g:count
2184 delete('Xfinished')
2185enddef
2186
2187def Test_let_missing_type()
2188 let lines =<< trim END
2189 vim9script
Bram Moolenaardf671b42020-05-16 22:33:33 +02002190 let var = g:unknown
Bram Moolenaar227a69d2020-05-15 18:17:28 +02002191 END
Bram Moolenaar822ba242020-05-24 23:00:18 +02002192 CheckScriptFailure(lines, 'E121:')
Bram Moolenaar227a69d2020-05-15 18:17:28 +02002193
2194 lines =<< trim END
2195 vim9script
2196 let nr: number = 123
2197 let var = nr
2198 END
Bram Moolenaar822ba242020-05-24 23:00:18 +02002199 CheckScriptSuccess(lines)
Bram Moolenaar32e35112020-05-14 22:41:15 +02002200enddef
2201
Bram Moolenaarc82a5b52020-06-13 18:09:19 +02002202def Test_let_declaration()
2203 let lines =<< trim END
2204 vim9script
2205 let var: string
2206 g:var_uninit = var
2207 var = 'text'
2208 g:var_test = var
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002209 # prefixing s: is optional
Bram Moolenaar984dddb2020-06-14 12:50:24 +02002210 s:var = 'prefixed'
2211 g:var_prefixed = s:var
2212
2213 let s:other: number
2214 other = 1234
2215 g:other_var = other
Bram Moolenaarc82a5b52020-06-13 18:09:19 +02002216 END
2217 CheckScriptSuccess(lines)
2218 assert_equal('', g:var_uninit)
2219 assert_equal('text', g:var_test)
Bram Moolenaar984dddb2020-06-14 12:50:24 +02002220 assert_equal('prefixed', g:var_prefixed)
2221 assert_equal(1234, g:other_var)
Bram Moolenaarc82a5b52020-06-13 18:09:19 +02002222
2223 unlet g:var_uninit
2224 unlet g:var_test
Bram Moolenaar984dddb2020-06-14 12:50:24 +02002225 unlet g:var_prefixed
2226 unlet g:other_var
Bram Moolenaarc82a5b52020-06-13 18:09:19 +02002227enddef
2228
Bram Moolenaarc5b1c202020-06-18 22:43:27 +02002229def Test_let_declaration_fails()
2230 let lines =<< trim END
2231 vim9script
2232 const var: string
2233 END
2234 CheckScriptFailure(lines, 'E1021:')
2235
2236 lines =<< trim END
2237 vim9script
2238 let 9var: string
2239 END
2240 CheckScriptFailure(lines, 'E475:')
2241enddef
2242
Bram Moolenaar34db91f2020-06-13 19:00:10 +02002243def Test_let_type_check()
2244 let lines =<< trim END
2245 vim9script
2246 let var: string
2247 var = 1234
2248 END
2249 CheckScriptFailure(lines, 'E1013:')
Bram Moolenaar984dddb2020-06-14 12:50:24 +02002250
2251 lines =<< trim END
2252 vim9script
2253 let var:string
2254 END
2255 CheckScriptFailure(lines, 'E1069:')
Bram Moolenaarc5b1c202020-06-18 22:43:27 +02002256
2257 lines =<< trim END
2258 vim9script
2259 let var: asdf
2260 END
2261 CheckScriptFailure(lines, 'E1010:')
Bram Moolenaar34db91f2020-06-13 19:00:10 +02002262enddef
2263
Bram Moolenaara5d00772020-05-14 23:20:55 +02002264def Test_forward_declaration()
2265 let lines =<< trim END
2266 vim9script
Bram Moolenaara5d00772020-05-14 23:20:55 +02002267 def GetValue(): string
2268 return theVal
2269 enddef
2270 let theVal = 'something'
Bram Moolenaar822ba242020-05-24 23:00:18 +02002271 g:initVal = GetValue()
Bram Moolenaara5d00772020-05-14 23:20:55 +02002272 theVal = 'else'
2273 g:laterVal = GetValue()
2274 END
2275 writefile(lines, 'Xforward')
2276 source Xforward
2277 assert_equal('something', g:initVal)
2278 assert_equal('else', g:laterVal)
2279
2280 unlet g:initVal
2281 unlet g:laterVal
2282 delete('Xforward')
2283enddef
2284
Bram Moolenaar9721fb42020-06-11 23:10:46 +02002285def Test_source_vim9_from_legacy()
2286 let legacy_lines =<< trim END
2287 source Xvim9_script.vim
2288
2289 call assert_false(exists('local'))
2290 call assert_false(exists('exported'))
2291 call assert_false(exists('s:exported'))
2292 call assert_equal('global', global)
2293 call assert_equal('global', g:global)
2294
2295 " imported variable becomes script-local
2296 import exported from './Xvim9_script.vim'
2297 call assert_equal('exported', s:exported)
2298 call assert_false(exists('exported'))
2299
2300 " imported function becomes script-local
2301 import GetText from './Xvim9_script.vim'
2302 call assert_equal('text', s:GetText())
2303 call assert_false(exists('*GetText'))
2304 END
2305 writefile(legacy_lines, 'Xlegacy_script.vim')
2306
2307 let vim9_lines =<< trim END
2308 vim9script
2309 let local = 'local'
2310 g:global = 'global'
2311 export let exported = 'exported'
2312 export def GetText(): string
2313 return 'text'
2314 enddef
2315 END
2316 writefile(vim9_lines, 'Xvim9_script.vim')
2317
2318 source Xlegacy_script.vim
2319
2320 assert_equal('global', g:global)
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002321 unlet g:global
Bram Moolenaar9721fb42020-06-11 23:10:46 +02002322
2323 delete('Xlegacy_script.vim')
2324 delete('Xvim9_script.vim')
2325enddef
Bram Moolenaara5d00772020-05-14 23:20:55 +02002326
Bram Moolenaareeb27bf2020-07-04 17:39:10 +02002327def Test_vim9_copen()
2328 # this was giving an error for setting w:quickfix_title
2329 copen
2330 quit
2331enddef
2332
Bram Moolenaar585fea72020-04-02 22:33:21 +02002333" Keep this last, it messes up highlighting.
2334def Test_substitute_cmd()
2335 new
2336 setline(1, 'something')
2337 :substitute(some(other(
2338 assert_equal('otherthing', getline(1))
2339 bwipe!
2340
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002341 # also when the context is Vim9 script
Bram Moolenaar585fea72020-04-02 22:33:21 +02002342 let lines =<< trim END
2343 vim9script
2344 new
2345 setline(1, 'something')
2346 :substitute(some(other(
2347 assert_equal('otherthing', getline(1))
2348 bwipe!
2349 END
2350 writefile(lines, 'Xvim9lines')
2351 source Xvim9lines
2352
2353 delete('Xvim9lines')
2354enddef
2355
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002356" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker