blob: 379245f397f229e3fa77c34d69b7cdf7094ffa85 [file] [log] [blame]
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001" Test various aspects of the Vim9 script language.
2
Bram Moolenaar673660a2020-01-26 16:50:05 +01003source check.vim
Bram Moolenaar101f4812020-06-16 23:18:51 +02004source term_util.vim
Bram Moolenaarad39c092020-02-26 18:23:43 +01005source view_util.vim
Bram Moolenaarcfe435d2020-04-25 20:02:55 +02006source vim9.vim
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01007
8def Test_syntax()
9 let var = 234
10 let other: list<string> = ['asdf']
11enddef
12
Bram Moolenaar6e587dc2020-02-06 13:15:52 +010013let s:appendToMe = 'xxx'
14let s:addToMe = 111
Bram Moolenaar401d9ff2020-02-19 18:14:44 +010015let g:existing = 'yes'
Bram Moolenaara8c17702020-04-01 21:17:24 +020016let g:inc_counter = 1
17let $SOME_ENV_VAR = 'some'
Bram Moolenaara6e67e42020-05-15 23:36:40 +020018let g:alist = [7]
19let g:astring = 'text'
Bram Moolenaarf0b9f432020-07-17 23:03:17 +020020let g:anumber = 123
Bram Moolenaar6e587dc2020-02-06 13:15:52 +010021
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010022def Test_assignment()
23 let bool1: bool = true
24 assert_equal(v:true, bool1)
25 let bool2: bool = false
26 assert_equal(v:false, bool2)
27
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +020028 call CheckDefFailure(['let x:string'], 'E1069:')
29 call CheckDefFailure(['let x:string = "x"'], 'E1069:')
Bram Moolenaar1cc2a942020-05-10 19:10:31 +020030 call CheckDefFailure(['let a:string = "x"'], 'E1069:')
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +020031
Bram Moolenaar4cdb13c2020-07-22 21:45:14 +020032 let nr: number = 1234
33 call CheckDefFailure(['let nr: number = "asdf"'], 'E1013:')
34
Bram Moolenaarb2097502020-07-19 17:17:02 +020035 let a: number = 6 #comment
Bram Moolenaar9be61bb2020-03-30 22:51:24 +020036 assert_equal(6, a)
37
Bram Moolenaar42a480b2020-02-29 23:23:47 +010038 if has('channel')
39 let chan1: channel
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +010040 let job1: job
Bram Moolenaarf51cb4e2020-03-01 17:55:14 +010041 let job2: job = job_start('willfail')
Bram Moolenaar42a480b2020-02-29 23:23:47 +010042 endif
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +010043 if has('float')
44 let float1: float = 3.4
45 endif
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +020046 let Funky1: func
47 let Funky2: func = function('len')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +020048 let Party2: func = funcref('g:Test_syntax')
Bram Moolenaar42a480b2020-02-29 23:23:47 +010049
Bram Moolenaarb2097502020-07-19 17:17:02 +020050 g:newvar = 'new' #comment
Bram Moolenaar401d9ff2020-02-19 18:14:44 +010051 assert_equal('new', g:newvar)
52
53 assert_equal('yes', g:existing)
54 g:existing = 'no'
55 assert_equal('no', g:existing)
56
Bram Moolenaarb283a8a2020-02-02 22:24:04 +010057 v:char = 'abc'
Bram Moolenaar6e587dc2020-02-06 13:15:52 +010058 assert_equal('abc', v:char)
Bram Moolenaarb283a8a2020-02-02 22:24:04 +010059
60 $ENVVAR = 'foobar'
Bram Moolenaar6e587dc2020-02-06 13:15:52 +010061 assert_equal('foobar', $ENVVAR)
Bram Moolenaarb283a8a2020-02-02 22:24:04 +010062 $ENVVAR = ''
Bram Moolenaar6e587dc2020-02-06 13:15:52 +010063
Bram Moolenaarfd1823e2020-02-19 20:23:11 +010064 s:appendToMe ..= 'yyy'
65 assert_equal('xxxyyy', s:appendToMe)
66 s:addToMe += 222
67 assert_equal(333, s:addToMe)
Bram Moolenaar0bbf7222020-02-19 22:31:48 +010068 s:newVar = 'new'
69 assert_equal('new', s:newVar)
Bram Moolenaara8c17702020-04-01 21:17:24 +020070
71 set ts=7
72 &ts += 1
73 assert_equal(8, &ts)
Bram Moolenaar80c34ca2020-04-01 23:05:18 +020074 &ts -= 3
75 assert_equal(5, &ts)
76 &ts *= 2
77 assert_equal(10, &ts)
78 &ts /= 3
79 assert_equal(3, &ts)
80 set ts=10
81 &ts %= 4
82 assert_equal(2, &ts)
Bram Moolenaara8c17702020-04-01 21:17:24 +020083 call CheckDefFailure(['&notex += 3'], 'E113:')
84 call CheckDefFailure(['&ts ..= "xxx"'], 'E1019:')
Bram Moolenaara6e67e42020-05-15 23:36:40 +020085 call CheckDefFailure(['&ts = [7]'], 'E1013:')
86 call CheckDefExecFailure(['&ts = g:alist'], 'E1029: Expected number but got list')
87 call CheckDefFailure(['&ts = "xx"'], 'E1013:')
88 call CheckDefExecFailure(['&ts = g:astring'], 'E1029: Expected number but got string')
Bram Moolenaara8c17702020-04-01 21:17:24 +020089 call CheckDefFailure(['&path += 3'], 'E1013:')
Bram Moolenaara6e67e42020-05-15 23:36:40 +020090 call CheckDefExecFailure(['&bs = "asdf"'], 'E474:')
Bram Moolenaarcb711ab2020-04-16 13:00:29 +020091 # test freeing ISN_STOREOPT
Bram Moolenaar585fea72020-04-02 22:33:21 +020092 call CheckDefFailure(['&ts = 3', 'let asdf'], 'E1022:')
Bram Moolenaar80c34ca2020-04-01 23:05:18 +020093 &ts = 8
Bram Moolenaara8c17702020-04-01 21:17:24 +020094
95 g:inc_counter += 1
96 assert_equal(2, g:inc_counter)
97
98 $SOME_ENV_VAR ..= 'more'
99 assert_equal('somemore', $SOME_ENV_VAR)
100 call CheckDefFailure(['$SOME_ENV_VAR += "more"'], 'E1013:')
101 call CheckDefFailure(['$SOME_ENV_VAR += 123'], 'E1013:')
102
103 @a = 'areg'
104 @a ..= 'add'
105 assert_equal('aregadd', @a)
106 call CheckDefFailure(['@a += "more"'], 'E1013:')
107 call CheckDefFailure(['@a += 123'], 'E1013:')
Bram Moolenaare69f6d02020-04-01 22:11:01 +0200108
109 v:errmsg = 'none'
110 v:errmsg ..= 'again'
111 assert_equal('noneagain', v:errmsg)
112 call CheckDefFailure(['v:errmsg += "more"'], 'E1013:')
113 call CheckDefFailure(['v:errmsg += 123'], 'E1013:')
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200114enddef
115
Bram Moolenaar3b74b6b2020-06-19 19:01:43 +0200116def Test_vim9_single_char_vars()
117 let lines =<< trim END
118 vim9script
119
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200120 # single character variable declarations work
Bram Moolenaar3b74b6b2020-06-19 19:01:43 +0200121 let a: string
122 let b: number
123 let l: list<any>
124 let s: string
125 let t: number
126 let v: number
127 let w: number
128
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200129 # script-local variables can be used without s: prefix
Bram Moolenaar3b74b6b2020-06-19 19:01:43 +0200130 a = 'script-a'
131 b = 111
132 l = [1, 2, 3]
133 s = 'script-s'
134 t = 222
135 v = 333
136 w = 444
137
138 assert_equal('script-a', a)
139 assert_equal(111, b)
140 assert_equal([1, 2, 3], l)
141 assert_equal('script-s', s)
142 assert_equal(222, t)
143 assert_equal(333, v)
144 assert_equal(444, w)
145 END
146 writefile(lines, 'Xsinglechar')
147 source Xsinglechar
148 delete('Xsinglechar')
149enddef
150
Bram Moolenaar84370082020-05-18 14:20:36 +0200151def Test_assignment_list()
152 let list1: list<bool> = [false, true, false]
153 let list2: list<number> = [1, 2, 3]
154 let list3: list<string> = ['sdf', 'asdf']
155 let list4: list<any> = ['yes', true, 1234]
156 let list5: list<blob> = [0z01, 0z02]
157
158 let listS: list<string> = []
159 let listN: list<number> = []
160
161 assert_equal([1, 2, 3], list2)
162 list2[-1] = 99
163 assert_equal([1, 2, 99], list2)
164 list2[-2] = 88
165 assert_equal([1, 88, 99], list2)
166 list2[-3] = 77
167 assert_equal([77, 88, 99], list2)
168 call CheckDefExecFailure(['let ll = [1, 2, 3]', 'll[-4] = 6'], 'E684:')
Bram Moolenaarc5b1c202020-06-18 22:43:27 +0200169 call CheckDefExecFailure(['let [v1, v2] = [1, 2]'], 'E1092:')
Bram Moolenaar84370082020-05-18 14:20:36 +0200170
171 # type becomes list<any>
172 let somelist = rand() > 0 ? [1, 2, 3] : ['a', 'b', 'c']
173enddef
174
Bram Moolenaarb31be3f2020-07-20 22:37:44 +0200175def Test_assignment_list_vim9script()
176 let lines =<< trim END
177 vim9script
178 let v1: number
179 let v2: number
180 let v3: number
181 [v1, v2, v3] = [1, 2, 3]
182 assert_equal([1, 2, 3], [v1, v2, v3])
183 END
184 call CheckScriptSuccess(lines)
185enddef
186
Bram Moolenaar84370082020-05-18 14:20:36 +0200187def Test_assignment_dict()
188 let dict1: dict<bool> = #{one: false, two: true}
189 let dict2: dict<number> = #{one: 1, two: 2}
190 let dict3: dict<string> = #{key: 'value'}
191 let dict4: dict<any> = #{one: 1, two: '2'}
Bram Moolenaar74fae512020-05-21 21:50:58 +0200192 let dict5: dict<blob> = #{one: 0z01, two: 0z02}
Bram Moolenaar84370082020-05-18 14:20:36 +0200193
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200194 # overwrite
Bram Moolenaarc785b9a2020-06-19 18:34:15 +0200195 dict3['key'] = 'another'
196
Bram Moolenaar84370082020-05-18 14:20:36 +0200197 call CheckDefExecFailure(['let dd = {}', 'dd[""] = 6'], 'E713:')
198
199 # type becomes dict<any>
200 let somedict = rand() > 0 ? #{a: 1, b: 2} : #{a: 'a', b: 'b'}
201enddef
202
Bram Moolenaard3aac292020-04-19 14:32:17 +0200203def Test_assignment_local()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200204 # Test in a separated file in order not to the current buffer/window/tab is
205 # changed.
Bram Moolenaard3aac292020-04-19 14:32:17 +0200206 let script_lines: list<string> =<< trim END
207 let b:existing = 'yes'
208 let w:existing = 'yes'
209 let t:existing = 'yes'
210
211 def Test_assignment_local_internal()
212 b:newvar = 'new'
213 assert_equal('new', b:newvar)
214 assert_equal('yes', b:existing)
215 b:existing = 'no'
216 assert_equal('no', b:existing)
Bram Moolenaar396f3132020-05-09 18:44:56 +0200217 b:existing ..= 'NO'
218 assert_equal('noNO', b:existing)
Bram Moolenaard3aac292020-04-19 14:32:17 +0200219
220 w:newvar = 'new'
221 assert_equal('new', w:newvar)
222 assert_equal('yes', w:existing)
223 w:existing = 'no'
224 assert_equal('no', w:existing)
Bram Moolenaar396f3132020-05-09 18:44:56 +0200225 w:existing ..= 'NO'
226 assert_equal('noNO', w:existing)
Bram Moolenaard3aac292020-04-19 14:32:17 +0200227
228 t:newvar = 'new'
229 assert_equal('new', t:newvar)
230 assert_equal('yes', t:existing)
231 t:existing = 'no'
232 assert_equal('no', t:existing)
Bram Moolenaar396f3132020-05-09 18:44:56 +0200233 t:existing ..= 'NO'
234 assert_equal('noNO', t:existing)
Bram Moolenaard3aac292020-04-19 14:32:17 +0200235 enddef
236 call Test_assignment_local_internal()
237 END
238 call CheckScriptSuccess(script_lines)
239enddef
240
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200241def Test_assignment_default()
Bram Moolenaare69f6d02020-04-01 22:11:01 +0200242
Bram Moolenaarcb711ab2020-04-16 13:00:29 +0200243 # Test default values.
Bram Moolenaare69f6d02020-04-01 22:11:01 +0200244 let thebool: bool
245 assert_equal(v:false, thebool)
246
247 let thenumber: number
248 assert_equal(0, thenumber)
249
250 if has('float')
251 let thefloat: float
252 assert_equal(0.0, thefloat)
253 endif
254
255 let thestring: string
256 assert_equal('', thestring)
257
258 let theblob: blob
259 assert_equal(0z, theblob)
260
Bram Moolenaar5deeb3f2020-04-05 17:08:17 +0200261 let Thefunc: func
262 assert_equal(test_null_function(), Thefunc)
Bram Moolenaare69f6d02020-04-01 22:11:01 +0200263
Bram Moolenaare69f6d02020-04-01 22:11:01 +0200264 let thelist: list<any>
265 assert_equal([], thelist)
266
267 let thedict: dict<any>
268 assert_equal({}, thedict)
269
Bram Moolenaar2c869de2020-04-02 19:12:08 +0200270 if has('channel')
271 let thejob: job
272 assert_equal(test_null_job(), thejob)
Bram Moolenaare69f6d02020-04-01 22:11:01 +0200273
Bram Moolenaar2c869de2020-04-02 19:12:08 +0200274 let thechannel: channel
275 assert_equal(test_null_channel(), thechannel)
Bram Moolenaarc785b9a2020-06-19 18:34:15 +0200276
277 if has('unix') && executable('cat')
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200278 # check with non-null job and channel, types must match
Bram Moolenaarc785b9a2020-06-19 18:34:15 +0200279 thejob = job_start("cat ", #{})
280 thechannel = job_getchannel(thejob)
281 job_stop(thejob, 'kill')
282 endif
Bram Moolenaar2c869de2020-04-02 19:12:08 +0200283 endif
Bram Moolenaar585fea72020-04-02 22:33:21 +0200284
285 let nr = 1234 | nr = 5678
286 assert_equal(5678, nr)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100287enddef
288
Bram Moolenaar47a519a2020-06-14 23:05:10 +0200289def Test_assignment_var_list()
290 let v1: string
291 let v2: string
Bram Moolenaar9af78762020-06-16 11:34:42 +0200292 let vrem: list<string>
293 [v1] = ['aaa']
294 assert_equal('aaa', v1)
295
Bram Moolenaar47a519a2020-06-14 23:05:10 +0200296 [v1, v2] = ['one', 'two']
297 assert_equal('one', v1)
298 assert_equal('two', v2)
Bram Moolenaar9af78762020-06-16 11:34:42 +0200299
300 [v1, v2; vrem] = ['one', 'two']
301 assert_equal('one', v1)
302 assert_equal('two', v2)
303 assert_equal([], vrem)
304
305 [v1, v2; vrem] = ['one', 'two', 'three']
306 assert_equal('one', v1)
307 assert_equal('two', v2)
308 assert_equal(['three'], vrem)
Bram Moolenaar47a519a2020-06-14 23:05:10 +0200309enddef
310
Bram Moolenaarcab27672020-04-09 20:10:55 +0200311def Mess(): string
312 v:foldstart = 123
313 return 'xxx'
314enddef
315
Bram Moolenaard72c1bf2020-04-19 16:28:59 +0200316def Test_assignment_failure()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100317 call CheckDefFailure(['let var=234'], 'E1004:')
318 call CheckDefFailure(['let var =234'], 'E1004:')
319 call CheckDefFailure(['let var= 234'], 'E1004:')
320
Bram Moolenaar63be3d42020-07-23 13:11:37 +0200321 call CheckScriptFailure(['vim9script', 'let var=234'], 'E1004:')
322 call CheckScriptFailure(['vim9script', 'let var=234'], "before and after '='")
323 call CheckScriptFailure(['vim9script', 'let var =234'], 'E1004:')
324 call CheckScriptFailure(['vim9script', 'let var= 234'], 'E1004:')
325 call CheckScriptFailure(['vim9script', 'let var = 234', 'var+=234'], 'E1004:')
326 call CheckScriptFailure(['vim9script', 'let var = 234', 'var+=234'], "before and after '+='")
327 call CheckScriptFailure(['vim9script', 'let var = "x"', 'var..="y"'], 'E1004:')
328 call CheckScriptFailure(['vim9script', 'let var = "x"', 'var..="y"'], "before and after '..='")
329
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100330 call CheckDefFailure(['let true = 1'], 'E1034:')
331 call CheckDefFailure(['let false = 1'], 'E1034:')
332
Bram Moolenaar9b7bf9e2020-07-11 22:14:59 +0200333 call CheckDefFailure(['[a; b; c] = g:list'], 'E452:')
Bram Moolenaar9af78762020-06-16 11:34:42 +0200334 call CheckDefExecFailure(['let a: number',
335 '[a] = test_null_list()'], 'E1093:')
336 call CheckDefExecFailure(['let a: number',
337 '[a] = []'], 'E1093:')
338 call CheckDefExecFailure(['let x: number',
339 'let y: number',
340 '[x, y] = [1]'], 'E1093:')
341 call CheckDefExecFailure(['let x: number',
342 'let y: number',
343 'let z: list<number>',
344 '[x, y; z] = [1]'], 'E1093:')
Bram Moolenaar9be61bb2020-03-30 22:51:24 +0200345
Bram Moolenaare69f6d02020-04-01 22:11:01 +0200346 call CheckDefFailure(['let somevar'], "E1022:")
Bram Moolenaar9be61bb2020-03-30 22:51:24 +0200347 call CheckDefFailure(['let &option'], 'E1052:')
348 call CheckDefFailure(['&g:option = 5'], 'E113:')
349
Bram Moolenaare55b1c02020-06-21 15:52:59 +0200350 call CheckDefFailure(['let $VAR = 5'], 'E1016: Cannot declare an environment variable:')
Bram Moolenaar9be61bb2020-03-30 22:51:24 +0200351
352 call CheckDefFailure(['let @~ = 5'], 'E354:')
353 call CheckDefFailure(['let @a = 5'], 'E1066:')
354
Bram Moolenaare55b1c02020-06-21 15:52:59 +0200355 call CheckDefFailure(['let g:var = 5'], 'E1016: Cannot declare a global variable:')
356 call CheckDefFailure(['let w:var = 5'], 'E1016: Cannot declare a window variable:')
357 call CheckDefFailure(['let b:var = 5'], 'E1016: Cannot declare a buffer variable:')
358 call CheckDefFailure(['let t:var = 5'], 'E1016: Cannot declare a tab variable:')
Bram Moolenaar9be61bb2020-03-30 22:51:24 +0200359
360 call CheckDefFailure(['let anr = 4', 'anr ..= "text"'], 'E1019:')
361 call CheckDefFailure(['let xnr += 4'], 'E1020:')
362
Bram Moolenaar822ba242020-05-24 23:00:18 +0200363 call CheckScriptFailure(['vim9script', 'def Func()', 'let dummy = s:notfound', 'enddef', 'defcompile'], 'E1050:')
Bram Moolenaar33fa29c2020-03-28 19:41:33 +0100364
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100365 call CheckDefFailure(['let var: list<string> = [123]'], 'expected list<string> but got list<number>')
366 call CheckDefFailure(['let var: list<number> = ["xx"]'], 'expected list<number> but got list<string>')
367
368 call CheckDefFailure(['let var: dict<string> = #{key: 123}'], 'expected dict<string> but got dict<number>')
369 call CheckDefFailure(['let var: dict<number> = #{key: "xx"}'], 'expected dict<number> but got dict<string>')
370
371 call CheckDefFailure(['let var = feedkeys("0")'], 'E1031:')
372 call CheckDefFailure(['let var: number = feedkeys("0")'], 'expected number but got void')
Bram Moolenaar42a480b2020-02-29 23:23:47 +0100373
Bram Moolenaard77a8522020-04-03 21:59:57 +0200374 call CheckDefFailure(['let var: dict <number>'], 'E1068:')
Bram Moolenaar42a480b2020-02-29 23:23:47 +0100375 call CheckDefFailure(['let var: dict<number'], 'E1009:')
Bram Moolenaarcab27672020-04-09 20:10:55 +0200376
377 call assert_fails('s/^/\=Mess()/n', 'E794:')
378 call CheckDefFailure(['let var: dict<number'], 'E1009:')
Bram Moolenaar43e969d2020-07-23 21:14:43 +0200379
380 call CheckDefFailure(['w:foo: number = 10'],
381 'E488: Trailing characters: : number = 1')
382 call CheckDefFailure(['t:foo: bool = true'],
383 'E488: Trailing characters: : bool = true')
384 call CheckDefFailure(['b:foo: string = "x"'],
385 'E488: Trailing characters: : string = "x"')
386 call CheckDefFailure(['g:foo: number = 123'],
387 'E488: Trailing characters: : number = 123')
Bram Moolenaard72c1bf2020-04-19 16:28:59 +0200388enddef
389
390def Test_unlet()
391 g:somevar = 'yes'
392 assert_true(exists('g:somevar'))
393 unlet g:somevar
394 assert_false(exists('g:somevar'))
395 unlet! g:somevar
396
397 call CheckScriptFailure([
398 'vim9script',
399 'let svar = 123',
400 'unlet svar',
401 ], 'E1081:')
402 call CheckScriptFailure([
403 'vim9script',
404 'let svar = 123',
405 'unlet s:svar',
406 ], 'E1081:')
407 call CheckScriptFailure([
408 'vim9script',
409 'let svar = 123',
410 'def Func()',
411 ' unlet svar',
412 'enddef',
Bram Moolenaar822ba242020-05-24 23:00:18 +0200413 'defcompile',
Bram Moolenaard72c1bf2020-04-19 16:28:59 +0200414 ], 'E1081:')
415 call CheckScriptFailure([
416 'vim9script',
417 'let svar = 123',
418 'def Func()',
419 ' unlet s:svar',
420 'enddef',
Bram Moolenaar822ba242020-05-24 23:00:18 +0200421 'defcompile',
Bram Moolenaard72c1bf2020-04-19 16:28:59 +0200422 ], 'E1081:')
Bram Moolenaar7bdaea62020-04-19 18:27:26 +0200423
424 $ENVVAR = 'foobar'
425 assert_equal('foobar', $ENVVAR)
426 unlet $ENVVAR
427 assert_equal('', $ENVVAR)
Bram Moolenaard72c1bf2020-04-19 16:28:59 +0200428enddef
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100429
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200430def Test_delfunction()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200431 # Check function is defined in script namespace
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200432 CheckScriptSuccess([
433 'vim9script',
434 'func CheckMe()',
435 ' return 123',
436 'endfunc',
437 'assert_equal(123, s:CheckMe())',
438 ])
439
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200440 # Check function in script namespace cannot be deleted
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200441 CheckScriptFailure([
442 'vim9script',
443 'func DeleteMe1()',
444 'endfunc',
445 'delfunction DeleteMe1',
446 ], 'E1084:')
447 CheckScriptFailure([
448 'vim9script',
449 'func DeleteMe2()',
450 'endfunc',
451 'def DoThat()',
452 ' delfunction DeleteMe2',
453 'enddef',
454 'DoThat()',
455 ], 'E1084:')
456 CheckScriptFailure([
457 'vim9script',
458 'def DeleteMe3()',
459 'enddef',
460 'delfunction DeleteMe3',
461 ], 'E1084:')
462 CheckScriptFailure([
463 'vim9script',
464 'def DeleteMe4()',
465 'enddef',
466 'def DoThat()',
467 ' delfunction DeleteMe4',
468 'enddef',
469 'DoThat()',
470 ], 'E1084:')
Bram Moolenaar925e9fd2020-07-25 15:41:11 +0200471
472 # Check that global :def function can be replaced and deleted
473 let lines =<< trim END
474 vim9script
475 def g:Global(): string
476 return "yes"
477 enddef
478 assert_equal("yes", g:Global())
479 def! g:Global(): string
480 return "no"
481 enddef
482 assert_equal("no", g:Global())
483 delfunc g:Global
484 assert_false(exists('*g:Global'))
485 END
486 CheckScriptSuccess(lines)
487
488 # Check that global function can be replaced by a :def function and deleted
489 lines =<< trim END
490 vim9script
491 func g:Global()
492 return "yes"
493 endfunc
494 assert_equal("yes", g:Global())
495 def! g:Global(): string
496 return "no"
497 enddef
498 assert_equal("no", g:Global())
499 delfunc g:Global
500 assert_false(exists('*g:Global'))
501 END
502 CheckScriptSuccess(lines)
503
504 # Check that global :def function can be replaced by a function and deleted
505 lines =<< trim END
506 vim9script
507 def g:Global(): string
508 return "yes"
509 enddef
510 assert_equal("yes", g:Global())
511 func! g:Global()
512 return "no"
513 endfunc
514 assert_equal("no", g:Global())
515 delfunc g:Global
516 assert_false(exists('*g:Global'))
517 END
518 CheckScriptSuccess(lines)
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200519enddef
520
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100521func Test_wrong_type()
522 call CheckDefFailure(['let var: list<nothing>'], 'E1010:')
523 call CheckDefFailure(['let var: list<list<nothing>>'], 'E1010:')
524 call CheckDefFailure(['let var: dict<nothing>'], 'E1010:')
525 call CheckDefFailure(['let var: dict<dict<nothing>>'], 'E1010:')
526
527 call CheckDefFailure(['let var: dict<number'], 'E1009:')
528 call CheckDefFailure(['let var: dict<list<number>'], 'E1009:')
Bram Moolenaar42a480b2020-02-29 23:23:47 +0100529
530 call CheckDefFailure(['let var: ally'], 'E1010:')
531 call CheckDefFailure(['let var: bram'], 'E1010:')
532 call CheckDefFailure(['let var: cathy'], 'E1010:')
533 call CheckDefFailure(['let var: dom'], 'E1010:')
534 call CheckDefFailure(['let var: freddy'], 'E1010:')
535 call CheckDefFailure(['let var: john'], 'E1010:')
536 call CheckDefFailure(['let var: larry'], 'E1010:')
537 call CheckDefFailure(['let var: ned'], 'E1010:')
538 call CheckDefFailure(['let var: pam'], 'E1010:')
539 call CheckDefFailure(['let var: sam'], 'E1010:')
540 call CheckDefFailure(['let var: vim'], 'E1010:')
Bram Moolenaara0a9f432020-04-28 21:29:34 +0200541
542 call CheckDefFailure(['let Ref: number', 'Ref()'], 'E1085:')
543 call CheckDefFailure(['let Ref: string', 'let res = Ref()'], 'E1085:')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100544endfunc
545
546func Test_const()
547 call CheckDefFailure(['const var = 234', 'var = 99'], 'E1018:')
548 call CheckDefFailure(['const one = 234', 'let one = 99'], 'E1017:')
549 call CheckDefFailure(['const two'], 'E1021:')
Bram Moolenaar9be61bb2020-03-30 22:51:24 +0200550 call CheckDefFailure(['const &option'], 'E996:')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100551endfunc
552
Bram Moolenaardf069ee2020-06-22 23:02:51 +0200553def Test_range_no_colon()
554 call CheckDefFailure(['%s/a/b/'], 'E1050:')
555 call CheckDefFailure(['+ s/a/b/'], 'E1050:')
556 call CheckDefFailure(['- s/a/b/'], 'E1050:')
557 call CheckDefFailure(['. s/a/b/'], 'E1050:')
558enddef
559
560
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100561def Test_block()
562 let outer = 1
563 {
564 let inner = 2
565 assert_equal(1, outer)
566 assert_equal(2, inner)
567 }
568 assert_equal(1, outer)
569enddef
570
571func Test_block_failure()
572 call CheckDefFailure(['{', 'let inner = 1', '}', 'echo inner'], 'E1001:')
Bram Moolenaar585fea72020-04-02 22:33:21 +0200573 call CheckDefFailure(['}'], 'E1025:')
574 call CheckDefFailure(['{', 'echo 1'], 'E1026:')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100575endfunc
576
Bram Moolenaar585fea72020-04-02 22:33:21 +0200577def Test_cmd_modifier()
578 tab echo '0'
579 call CheckDefFailure(['5tab echo 3'], 'E16:')
580enddef
581
Bram Moolenaard032f342020-07-18 18:13:02 +0200582func g:NoSuchFunc()
583 echo 'none'
584endfunc
585
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100586def Test_try_catch()
587 let l = []
Bram Moolenaar7a092242020-04-16 22:10:49 +0200588 try # comment
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100589 add(l, '1')
590 throw 'wrong'
591 add(l, '2')
Bram Moolenaar7a092242020-04-16 22:10:49 +0200592 catch # comment
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100593 add(l, v:exception)
Bram Moolenaar7a092242020-04-16 22:10:49 +0200594 finally # comment
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100595 add(l, '3')
Bram Moolenaar7a092242020-04-16 22:10:49 +0200596 endtry # comment
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100597 assert_equal(['1', 'wrong', '3'], l)
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200598
Bram Moolenaare8593122020-07-18 15:17:02 +0200599 l = []
600 try
601 try
602 add(l, '1')
603 throw 'wrong'
604 add(l, '2')
605 catch /right/
606 add(l, v:exception)
607 endtry
608 catch /wrong/
609 add(l, 'caught')
610 finally
611 add(l, 'finally')
612 endtry
613 assert_equal(['1', 'caught', 'finally'], l)
614
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200615 let n: number
616 try
617 n = l[3]
618 catch /E684:/
619 n = 99
620 endtry
621 assert_equal(99, n)
622
623 try
624 n = g:astring[3]
625 catch /E714:/
626 n = 77
627 endtry
628 assert_equal(77, n)
629
630 try
631 n = l[g:astring]
632 catch /E39:/
633 n = 77
634 endtry
635 assert_equal(77, n)
636
637 try
638 n = s:does_not_exist
639 catch /E121:/
Bram Moolenaarf0b9f432020-07-17 23:03:17 +0200640 n = 111
641 endtry
642 assert_equal(111, n)
643
644 try
645 n = g:does_not_exist
646 catch /E121:/
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200647 n = 121
648 endtry
649 assert_equal(121, n)
650
651 let d = #{one: 1}
652 try
653 n = d[g:astring]
654 catch /E716:/
655 n = 222
656 endtry
657 assert_equal(222, n)
Bram Moolenaarf0b9f432020-07-17 23:03:17 +0200658
659 try
660 n = -g:astring
661 catch /E39:/
662 n = 233
663 endtry
664 assert_equal(233, n)
665
666 try
667 n = +g:astring
668 catch /E1030:/
669 n = 244
670 endtry
671 assert_equal(244, n)
672
673 try
674 n = +g:alist
675 catch /E745:/
676 n = 255
677 endtry
678 assert_equal(255, n)
679
680 let nd: dict<any>
681 try
682 nd = {g:anumber: 1}
683 catch /E1029:/
684 n = 266
685 endtry
686 assert_equal(266, n)
687
688 try
689 [n] = [1, 2, 3]
690 catch /E1093:/
691 n = 277
692 endtry
693 assert_equal(277, n)
694
Bram Moolenaare8593122020-07-18 15:17:02 +0200695 try
696 &ts = g:astring
697 catch /E1029:/
698 n = 288
699 endtry
700 assert_equal(288, n)
701
702 try
703 &backspace = 'asdf'
704 catch /E474:/
705 n = 299
706 endtry
707 assert_equal(299, n)
708
709 l = [1]
710 try
711 l[3] = 3
712 catch /E684:/
713 n = 300
714 endtry
715 assert_equal(300, n)
716
717 try
718 d[''] = 3
719 catch /E713:/
720 n = 311
721 endtry
722 assert_equal(311, n)
723
724 try
725 unlet g:does_not_exist
726 catch /E108:/
727 n = 322
728 endtry
729 assert_equal(322, n)
730
731 try
732 d = {'text': 1, g:astring: 2}
733 catch /E721:/
734 n = 333
735 endtry
736 assert_equal(333, n)
737
738 try
739 l = DeletedFunc()
740 catch /E933:/
741 n = 344
742 endtry
743 assert_equal(344, n)
Bram Moolenaard032f342020-07-18 18:13:02 +0200744
745 try
746 echo len(v:true)
747 catch /E701:/
748 n = 355
749 endtry
750 assert_equal(355, n)
751
752 let P = function('g:NoSuchFunc')
753 delfunc g:NoSuchFunc
754 try
755 echo P()
756 catch /E117:/
757 n = 366
758 endtry
759 assert_equal(366, n)
760
761 try
762 echo g:NoSuchFunc()
763 catch /E117:/
764 n = 377
765 endtry
766 assert_equal(377, n)
767
768 try
769 echo g:alist + 4
770 catch /E745:/
771 n = 388
772 endtry
773 assert_equal(388, n)
774
775 try
776 echo 4 + g:alist
777 catch /E745:/
778 n = 399
779 endtry
780 assert_equal(399, n)
781
782 try
783 echo g:alist.member
784 catch /E715:/
785 n = 400
786 endtry
787 assert_equal(400, n)
788
789 try
790 echo d.member
791 catch /E716:/
792 n = 411
793 endtry
794 assert_equal(411, n)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100795enddef
796
Bram Moolenaare8593122020-07-18 15:17:02 +0200797def DeletedFunc(): list<any>
798 return ['delete me']
799enddef
800defcompile
801delfunc DeletedFunc
802
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100803def ThrowFromDef()
Bram Moolenaara72cfb82020-04-23 17:07:30 +0200804 throw "getout" # comment
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100805enddef
806
807func CatchInFunc()
808 try
809 call ThrowFromDef()
810 catch
811 let g:thrown_func = v:exception
812 endtry
813endfunc
814
815def CatchInDef()
816 try
817 ThrowFromDef()
818 catch
819 g:thrown_def = v:exception
820 endtry
821enddef
822
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100823def ReturnFinally(): string
824 try
825 return 'intry'
826 finally
827 g:in_finally = 'finally'
828 endtry
829 return 'end'
830enddef
831
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100832def Test_try_catch_nested()
833 CatchInFunc()
834 assert_equal('getout', g:thrown_func)
835
836 CatchInDef()
837 assert_equal('getout', g:thrown_def)
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100838
839 assert_equal('intry', ReturnFinally())
840 assert_equal('finally', g:in_finally)
841enddef
842
843def Test_try_catch_match()
844 let seq = 'a'
845 try
846 throw 'something'
847 catch /nothing/
848 seq ..= 'x'
849 catch /some/
850 seq ..= 'b'
851 catch /asdf/
852 seq ..= 'x'
Bram Moolenaare8c4abb2020-04-02 21:13:25 +0200853 catch ?a\?sdf?
854 seq ..= 'y'
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100855 finally
856 seq ..= 'c'
857 endtry
858 assert_equal('abc', seq)
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100859enddef
860
Bram Moolenaare8c4abb2020-04-02 21:13:25 +0200861def Test_try_catch_fails()
862 call CheckDefFailure(['catch'], 'E603:')
Bram Moolenaar6b7a0a82020-07-08 18:38:08 +0200863 call CheckDefFailure(['try', 'echo 0', 'catch', 'catch'], 'E1033:')
Bram Moolenaare8c4abb2020-04-02 21:13:25 +0200864 call CheckDefFailure(['try', 'echo 0', 'catch /pat'], 'E1067:')
Bram Moolenaar585fea72020-04-02 22:33:21 +0200865 call CheckDefFailure(['finally'], 'E606:')
866 call CheckDefFailure(['try', 'echo 0', 'finally', 'echo 1', 'finally'], 'E607:')
867 call CheckDefFailure(['endtry'], 'E602:')
868 call CheckDefFailure(['while 1', 'endtry'], 'E170:')
869 call CheckDefFailure(['for i in range(5)', 'endtry'], 'E170:')
870 call CheckDefFailure(['if 2', 'endtry'], 'E171:')
871 call CheckDefFailure(['try', 'echo 1', 'endtry'], 'E1032:')
872
Bram Moolenaara72cfb82020-04-23 17:07:30 +0200873 call CheckDefFailure(['throw'], 'E1015:')
Bram Moolenaar585fea72020-04-02 22:33:21 +0200874 call CheckDefFailure(['throw xxx'], 'E1001:')
Bram Moolenaare8c4abb2020-04-02 21:13:25 +0200875enddef
876
Bram Moolenaar006ad482020-06-30 20:55:15 +0200877def Test_throw_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200878 # only checks line continuation
Bram Moolenaar006ad482020-06-30 20:55:15 +0200879 let lines =<< trim END
880 vim9script
881 try
882 throw 'one'
883 .. 'two'
884 catch
885 assert_equal('onetwo', v:exception)
886 endtry
887 END
888 CheckScriptSuccess(lines)
889enddef
890
Bram Moolenaar37c83712020-06-30 21:18:36 +0200891def Test_cexpr_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200892 # only checks line continuation
Bram Moolenaar37c83712020-06-30 21:18:36 +0200893 set errorformat=File\ %f\ line\ %l
894 let lines =<< trim END
895 vim9script
896 cexpr 'File'
897 .. ' someFile' ..
898 ' line 19'
899 assert_equal(19, getqflist()[0].lnum)
900 END
901 CheckScriptSuccess(lines)
902 set errorformat&
903enddef
904
Bram Moolenaarb2097502020-07-19 17:17:02 +0200905def Test_list_vimscript()
906 # checks line continuation and comments
907 let lines =<< trim END
908 vim9script
909 let mylist = [
910 'one',
911 # comment
912 'two', # empty line follows
913
914 'three',
915 ]
916 assert_equal(['one', 'two', 'three'], mylist)
917 END
918 CheckScriptSuccess(lines)
919enddef
920
Bram Moolenaar2a1381c2020-05-05 23:32:58 +0200921if has('channel')
922 let someJob = test_null_job()
Bram Moolenaar40ee4662020-05-05 22:08:26 +0200923
Bram Moolenaar2a1381c2020-05-05 23:32:58 +0200924 def FuncWithError()
925 echomsg g:someJob
926 enddef
Bram Moolenaar40ee4662020-05-05 22:08:26 +0200927
Bram Moolenaar2a1381c2020-05-05 23:32:58 +0200928 func Test_convert_emsg_to_exception()
929 try
930 call FuncWithError()
931 catch
932 call assert_match('Vim:E908:', v:exception)
933 endtry
934 endfunc
935endif
Bram Moolenaar40ee4662020-05-05 22:08:26 +0200936
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100937let s:export_script_lines =<< trim END
938 vim9script
939 let name: string = 'bob'
940 def Concat(arg: string): string
941 return name .. arg
942 enddef
Bram Moolenaar227a69d2020-05-15 18:17:28 +0200943 g:result = Concat('bie')
944 g:localname = name
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100945
946 export const CONST = 1234
947 export let exported = 9876
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100948 export let exp_name = 'John'
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100949 export def Exported(): string
950 return 'Exported'
951 enddef
952END
953
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100954def Test_vim9_import_export()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100955 let import_script_lines =<< trim END
956 vim9script
957 import {exported, Exported} from './Xexport.vim'
958 g:imported = exported
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100959 exported += 3
960 g:imported_added = exported
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100961 g:imported_func = Exported()
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100962
Bram Moolenaar40f4f7a2020-07-23 22:41:43 +0200963 def GetExported(): string
964 let local_dict = #{ref: Exported}
965 return local_dict.ref()
966 enddef
967 g:funcref_result = GetExported()
968
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100969 import {exp_name} from './Xexport.vim'
970 g:imported_name = exp_name
971 exp_name ..= ' Doe'
972 g:imported_name_appended = exp_name
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100973 g:imported_later = exported
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100974 END
975
976 writefile(import_script_lines, 'Ximport.vim')
977 writefile(s:export_script_lines, 'Xexport.vim')
978
979 source Ximport.vim
980
981 assert_equal('bobbie', g:result)
982 assert_equal('bob', g:localname)
983 assert_equal(9876, g:imported)
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100984 assert_equal(9879, g:imported_added)
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100985 assert_equal(9879, g:imported_later)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100986 assert_equal('Exported', g:imported_func)
Bram Moolenaar40f4f7a2020-07-23 22:41:43 +0200987 assert_equal('Exported', g:funcref_result)
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100988 assert_equal('John', g:imported_name)
989 assert_equal('John Doe', g:imported_name_appended)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100990 assert_false(exists('g:name'))
991
992 unlet g:result
993 unlet g:localname
994 unlet g:imported
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100995 unlet g:imported_added
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100996 unlet g:imported_later
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100997 unlet g:imported_func
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100998 unlet g:imported_name g:imported_name_appended
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100999 delete('Ximport.vim')
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01001000
Bram Moolenaar1c991142020-07-04 13:15:31 +02001001 # similar, with line breaks
1002 let import_line_break_script_lines =<< trim END
1003 vim9script
1004 import {
1005 exported,
1006 Exported,
1007 }
1008 from
1009 './Xexport.vim'
1010 g:imported = exported
1011 exported += 5
1012 g:imported_added = exported
1013 g:imported_func = Exported()
1014 END
1015 writefile(import_line_break_script_lines, 'Ximport_lbr.vim')
1016 source Ximport_lbr.vim
1017
1018 assert_equal(9876, g:imported)
1019 assert_equal(9881, g:imported_added)
1020 assert_equal('Exported', g:imported_func)
1021
1022 # exported script not sourced again
1023 assert_false(exists('g:result'))
1024 unlet g:imported
1025 unlet g:imported_added
1026 unlet g:imported_func
1027 delete('Ximport_lbr.vim')
1028
1029 # import inside :def function
Bram Moolenaar5381c7a2020-03-02 22:53:32 +01001030 let import_in_def_lines =<< trim END
1031 vim9script
1032 def ImportInDef()
1033 import exported from './Xexport.vim'
1034 g:imported = exported
1035 exported += 7
1036 g:imported_added = exported
1037 enddef
1038 ImportInDef()
1039 END
1040 writefile(import_in_def_lines, 'Ximport2.vim')
1041 source Ximport2.vim
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001042 # TODO: this should be 9879
Bram Moolenaar5381c7a2020-03-02 22:53:32 +01001043 assert_equal(9876, g:imported)
1044 assert_equal(9883, g:imported_added)
1045 unlet g:imported
1046 unlet g:imported_added
1047 delete('Ximport2.vim')
1048
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01001049 let import_star_as_lines =<< trim END
1050 vim9script
1051 import * as Export from './Xexport.vim'
1052 def UseExport()
1053 g:imported = Export.exported
1054 enddef
1055 UseExport()
1056 END
1057 writefile(import_star_as_lines, 'Ximport.vim')
1058 source Ximport.vim
Bram Moolenaar5381c7a2020-03-02 22:53:32 +01001059 assert_equal(9883, g:imported)
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01001060
Bram Moolenaar599c89c2020-03-28 14:53:20 +01001061 let import_star_as_lines_no_dot =<< trim END
1062 vim9script
1063 import * as Export from './Xexport.vim'
1064 def Func()
1065 let dummy = 1
1066 let imported = Export + dummy
1067 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +02001068 defcompile
Bram Moolenaar599c89c2020-03-28 14:53:20 +01001069 END
1070 writefile(import_star_as_lines_no_dot, 'Ximport.vim')
1071 assert_fails('source Ximport.vim', 'E1060:')
1072
1073 let import_star_as_lines_dot_space =<< trim END
1074 vim9script
1075 import * as Export from './Xexport.vim'
1076 def Func()
1077 let imported = Export . exported
1078 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +02001079 defcompile
Bram Moolenaar599c89c2020-03-28 14:53:20 +01001080 END
1081 writefile(import_star_as_lines_dot_space, 'Ximport.vim')
1082 assert_fails('source Ximport.vim', 'E1074:')
1083
1084 let import_star_as_lines_missing_name =<< trim END
1085 vim9script
1086 import * as Export from './Xexport.vim'
1087 def Func()
1088 let imported = Export.
1089 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +02001090 defcompile
Bram Moolenaar599c89c2020-03-28 14:53:20 +01001091 END
1092 writefile(import_star_as_lines_missing_name, 'Ximport.vim')
1093 assert_fails('source Ximport.vim', 'E1048:')
1094
Bram Moolenaar1c991142020-07-04 13:15:31 +02001095 let import_star_as_lbr_lines =<< trim END
1096 vim9script
1097 import *
1098 as Export
1099 from
1100 './Xexport.vim'
1101 def UseExport()
1102 g:imported = Export.exported
1103 enddef
1104 UseExport()
1105 END
1106 writefile(import_star_as_lbr_lines, 'Ximport.vim')
1107 source Ximport.vim
1108 assert_equal(9883, g:imported)
1109
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01001110 let import_star_lines =<< trim END
1111 vim9script
1112 import * from './Xexport.vim'
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01001113 END
1114 writefile(import_star_lines, 'Ximport.vim')
1115 assert_fails('source Ximport.vim', 'E1045:')
1116
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001117 # try to import something that exists but is not exported
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001118 let import_not_exported_lines =<< trim END
1119 vim9script
1120 import name from './Xexport.vim'
1121 END
1122 writefile(import_not_exported_lines, 'Ximport.vim')
1123 assert_fails('source Ximport.vim', 'E1049:')
1124
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001125 # try to import something that is already defined
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001126 let import_already_defined =<< trim END
1127 vim9script
1128 let exported = 'something'
1129 import exported from './Xexport.vim'
1130 END
1131 writefile(import_already_defined, 'Ximport.vim')
1132 assert_fails('source Ximport.vim', 'E1073:')
1133
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001134 # try to import something that is already defined
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001135 import_already_defined =<< trim END
1136 vim9script
1137 let exported = 'something'
1138 import * as exported from './Xexport.vim'
1139 END
1140 writefile(import_already_defined, 'Ximport.vim')
1141 assert_fails('source Ximport.vim', 'E1073:')
1142
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001143 # try to import something that is already defined
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001144 import_already_defined =<< trim END
1145 vim9script
1146 let exported = 'something'
1147 import {exported} from './Xexport.vim'
1148 END
1149 writefile(import_already_defined, 'Ximport.vim')
1150 assert_fails('source Ximport.vim', 'E1073:')
1151
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001152 # import a very long name, requires making a copy
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001153 let import_long_name_lines =<< trim END
1154 vim9script
1155 import name012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789 from './Xexport.vim'
1156 END
1157 writefile(import_long_name_lines, 'Ximport.vim')
1158 assert_fails('source Ximport.vim', 'E1048:')
1159
1160 let import_no_from_lines =<< trim END
1161 vim9script
1162 import name './Xexport.vim'
1163 END
1164 writefile(import_no_from_lines, 'Ximport.vim')
1165 assert_fails('source Ximport.vim', 'E1070:')
1166
1167 let import_invalid_string_lines =<< trim END
1168 vim9script
1169 import name from Xexport.vim
1170 END
1171 writefile(import_invalid_string_lines, 'Ximport.vim')
1172 assert_fails('source Ximport.vim', 'E1071:')
1173
1174 let import_wrong_name_lines =<< trim END
1175 vim9script
1176 import name from './XnoExport.vim'
1177 END
1178 writefile(import_wrong_name_lines, 'Ximport.vim')
1179 assert_fails('source Ximport.vim', 'E1053:')
1180
1181 let import_missing_comma_lines =<< trim END
1182 vim9script
1183 import {exported name} from './Xexport.vim'
1184 END
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001185 writefile(import_missing_comma_lines, 'Ximport3.vim')
1186 assert_fails('source Ximport3.vim', 'E1046:')
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001187
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01001188 delete('Ximport.vim')
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001189 delete('Ximport3.vim')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001190 delete('Xexport.vim')
1191
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001192 # Check that in a Vim9 script 'cpo' is set to the Vim default.
Bram Moolenaar750802b2020-02-23 18:08:33 +01001193 set cpo&vi
1194 let cpo_before = &cpo
1195 let lines =<< trim END
1196 vim9script
1197 g:cpo_in_vim9script = &cpo
1198 END
1199 writefile(lines, 'Xvim9_script')
1200 source Xvim9_script
1201 assert_equal(cpo_before, &cpo)
1202 set cpo&vim
1203 assert_equal(&cpo, g:cpo_in_vim9script)
1204 delete('Xvim9_script')
1205enddef
1206
1207def Test_vim9script_fails()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001208 CheckScriptFailure(['scriptversion 2', 'vim9script'], 'E1039:')
1209 CheckScriptFailure(['vim9script', 'scriptversion 2'], 'E1040:')
Bram Moolenaar750802b2020-02-23 18:08:33 +01001210 CheckScriptFailure(['export let some = 123'], 'E1042:')
Bram Moolenaar9721fb42020-06-11 23:10:46 +02001211 CheckScriptFailure(['import some from "./Xexport.vim"'], 'E1048:')
Bram Moolenaar9b7bf9e2020-07-11 22:14:59 +02001212 CheckScriptFailure(['vim9script', 'export let g:some'], 'E1022:')
Bram Moolenaar750802b2020-02-23 18:08:33 +01001213 CheckScriptFailure(['vim9script', 'export echo 134'], 'E1043:')
1214
Bram Moolenaarc785b9a2020-06-19 18:34:15 +02001215 CheckScriptFailure(['vim9script', 'let str: string', 'str = 1234'], 'E1013:')
1216 CheckScriptFailure(['vim9script', 'const str = "asdf"', 'str = "xxx"'], 'E46:')
1217
Bram Moolenaar750802b2020-02-23 18:08:33 +01001218 assert_fails('vim9script', 'E1038')
Bram Moolenaara26b9702020-04-18 19:53:28 +02001219 assert_fails('export something', 'E1043')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001220enddef
1221
Bram Moolenaarf7d267e2020-06-17 12:04:54 +02001222func Test_import_fails_without_script()
Bram Moolenaar101f4812020-06-16 23:18:51 +02001223 CheckRunVimInTerminal
1224
Bram Moolenaar9bb3eb32020-06-17 20:03:36 +02001225 " call indirectly to avoid compilation error for missing functions
Bram Moolenaarc620c052020-07-08 15:16:19 +02001226 call Run_Test_import_fails_on_command_line()
Bram Moolenaar9bb3eb32020-06-17 20:03:36 +02001227endfunc
1228
Bram Moolenaarc620c052020-07-08 15:16:19 +02001229def Run_Test_import_fails_on_command_line()
Bram Moolenaar101f4812020-06-16 23:18:51 +02001230 let export =<< trim END
1231 vim9script
1232 export def Foo(): number
1233 return 0
1234 enddef
1235 END
Bram Moolenaar9bb3eb32020-06-17 20:03:36 +02001236 writefile(export, 'Xexport.vim')
Bram Moolenaar101f4812020-06-16 23:18:51 +02001237
Bram Moolenaar9bb3eb32020-06-17 20:03:36 +02001238 let buf = RunVimInTerminal('-c "import Foo from ''./Xexport.vim''"', #{
1239 rows: 6, wait_for_ruler: 0})
1240 WaitForAssert({-> assert_match('^E1094:', term_getline(buf, 5))})
Bram Moolenaar101f4812020-06-16 23:18:51 +02001241
Bram Moolenaar9bb3eb32020-06-17 20:03:36 +02001242 delete('Xexport.vim')
1243 StopVimInTerminal(buf)
1244enddef
Bram Moolenaar101f4812020-06-16 23:18:51 +02001245
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001246def Test_vim9script_reload_import()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001247 let lines =<< trim END
1248 vim9script
1249 const var = ''
1250 let valone = 1234
1251 def MyFunc(arg: string)
1252 valone = 5678
1253 enddef
1254 END
1255 let morelines =<< trim END
1256 let valtwo = 222
1257 export def GetValtwo(): number
1258 return valtwo
1259 enddef
1260 END
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001261 writefile(lines + morelines, 'Xreload.vim')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001262 source Xreload.vim
1263 source Xreload.vim
1264 source Xreload.vim
1265
1266 let testlines =<< trim END
1267 vim9script
1268 def TheFunc()
1269 import GetValtwo from './Xreload.vim'
1270 assert_equal(222, GetValtwo())
1271 enddef
1272 TheFunc()
1273 END
1274 writefile(testlines, 'Ximport.vim')
1275 source Ximport.vim
1276
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001277 # Test that when not using "morelines" GetValtwo() and valtwo are still
1278 # defined, because import doesn't reload a script.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001279 writefile(lines, 'Xreload.vim')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001280 source Ximport.vim
1281
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001282 # cannot declare a var twice
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001283 lines =<< trim END
1284 vim9script
1285 let valone = 1234
1286 let valone = 5678
1287 END
1288 writefile(lines, 'Xreload.vim')
1289 assert_fails('source Xreload.vim', 'E1041:')
1290
1291 delete('Xreload.vim')
1292 delete('Ximport.vim')
1293enddef
1294
Bram Moolenaarfe465a02020-07-07 22:50:12 +02001295" Not exported function that is referenced needs to be accessed by the
1296" script-local name.
1297def Test_vim9script_funcref()
1298 let sortlines =<< trim END
1299 vim9script
1300 def Compare(i1: number, i2: number): number
Bram Moolenaarbed36b92020-07-07 23:31:36 +02001301 return i2 - i1
Bram Moolenaarfe465a02020-07-07 22:50:12 +02001302 enddef
1303
1304 export def FastSort(): list<number>
1305 return range(5)->sort(Compare)
1306 enddef
1307 END
1308 writefile(sortlines, 'Xsort.vim')
1309
1310 let lines =<< trim END
1311 vim9script
1312 import FastSort from './Xsort.vim'
1313 def Test()
1314 g:result = FastSort()
1315 enddef
1316 Test()
1317 END
1318 writefile(lines, 'Xscript.vim')
1319
1320 source Xscript.vim
1321 assert_equal([4, 3, 2, 1, 0], g:result)
1322
1323 unlet g:result
1324 delete('Xsort.vim')
1325 delete('Xscript.vim')
1326enddef
1327
Bram Moolenaarc620c052020-07-08 15:16:19 +02001328" Check that when searcing for "FilterFunc" it doesn't find the import in the
1329" script where FastFilter() is called from.
1330def Test_vim9script_funcref_other_script()
1331 let filterLines =<< trim END
1332 vim9script
1333 export def FilterFunc(idx: number, val: number): bool
1334 return idx % 2 == 1
1335 enddef
1336 export def FastFilter(): list<number>
1337 return range(10)->filter('FilterFunc')
1338 enddef
1339 END
1340 writefile(filterLines, 'Xfilter.vim')
1341
1342 let lines =<< trim END
1343 vim9script
1344 import {FilterFunc, FastFilter} from './Xfilter.vim'
1345 def Test()
1346 let x: list<number> = FastFilter()
1347 enddef
1348 Test()
1349 END
1350 writefile(lines, 'Ximport.vim')
1351 assert_fails('source Ximport.vim', 'E121:')
1352
1353 delete('Xfilter.vim')
1354 delete('Ximport.vim')
1355enddef
1356
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001357def Test_vim9script_reload_delfunc()
1358 let first_lines =<< trim END
1359 vim9script
1360 def FuncYes(): string
1361 return 'yes'
1362 enddef
1363 END
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001364 let withno_lines =<< trim END
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001365 def FuncNo(): string
1366 return 'no'
1367 enddef
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001368 def g:DoCheck(no_exists: bool)
1369 assert_equal('yes', FuncYes())
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001370 assert_equal('no', FuncNo())
1371 enddef
1372 END
1373 let nono_lines =<< trim END
1374 def g:DoCheck(no_exists: bool)
1375 assert_equal('yes', FuncYes())
1376 assert_fails('call FuncNo()', 'E117:')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001377 enddef
1378 END
1379
1380 # FuncNo() is defined
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001381 writefile(first_lines + withno_lines, 'Xreloaded.vim')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001382 source Xreloaded.vim
1383 g:DoCheck(true)
1384
1385 # FuncNo() is not redefined
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001386 writefile(first_lines + nono_lines, 'Xreloaded.vim')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001387 source Xreloaded.vim
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001388 g:DoCheck()
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001389
1390 # FuncNo() is back
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001391 writefile(first_lines + withno_lines, 'Xreloaded.vim')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001392 source Xreloaded.vim
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001393 g:DoCheck()
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001394
1395 delete('Xreloaded.vim')
1396enddef
1397
Bram Moolenaar89483d42020-05-10 15:24:44 +02001398def Test_vim9script_reload_delvar()
1399 # write the script with a script-local variable
1400 let lines =<< trim END
1401 vim9script
1402 let var = 'string'
1403 END
1404 writefile(lines, 'XreloadVar.vim')
1405 source XreloadVar.vim
1406
1407 # now write the script using the same variable locally - works
1408 lines =<< trim END
1409 vim9script
1410 def Func()
1411 let var = 'string'
1412 enddef
1413 END
1414 writefile(lines, 'XreloadVar.vim')
1415 source XreloadVar.vim
1416
1417 delete('XreloadVar.vim')
1418enddef
1419
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001420def Test_import_absolute()
1421 let import_lines = [
Bram Moolenaare6085c52020-04-12 20:19:16 +02001422 'vim9script',
1423 'import exported from "' .. escape(getcwd(), '\') .. '/Xexport_abs.vim"',
1424 'def UseExported()',
1425 ' g:imported_abs = exported',
1426 ' exported = 8888',
1427 ' g:imported_after = exported',
1428 'enddef',
1429 'UseExported()',
1430 'g:import_disassembled = execute("disass UseExported")',
1431 ]
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001432 writefile(import_lines, 'Ximport_abs.vim')
1433 writefile(s:export_script_lines, 'Xexport_abs.vim')
1434
1435 source Ximport_abs.vim
1436
1437 assert_equal(9876, g:imported_abs)
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +01001438 assert_equal(8888, g:imported_after)
Bram Moolenaar675f7162020-04-12 22:53:54 +02001439 assert_match('<SNR>\d\+_UseExported.*' ..
1440 'g:imported_abs = exported.*' ..
1441 '0 LOADSCRIPT exported from .*Xexport_abs.vim.*' ..
1442 '1 STOREG g:imported_abs.*' ..
1443 'exported = 8888.*' ..
1444 '3 STORESCRIPT exported in .*Xexport_abs.vim.*' ..
1445 'g:imported_after = exported.*' ..
1446 '4 LOADSCRIPT exported from .*Xexport_abs.vim.*' ..
1447 '5 STOREG g:imported_after.*',
Bram Moolenaare6085c52020-04-12 20:19:16 +02001448 g:import_disassembled)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001449 unlet g:imported_abs
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +01001450 unlet g:import_disassembled
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001451
1452 delete('Ximport_abs.vim')
1453 delete('Xexport_abs.vim')
1454enddef
1455
1456def Test_import_rtp()
1457 let import_lines = [
Bram Moolenaare6085c52020-04-12 20:19:16 +02001458 'vim9script',
1459 'import exported from "Xexport_rtp.vim"',
1460 'g:imported_rtp = exported',
1461 ]
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001462 writefile(import_lines, 'Ximport_rtp.vim')
1463 mkdir('import')
1464 writefile(s:export_script_lines, 'import/Xexport_rtp.vim')
1465
1466 let save_rtp = &rtp
1467 &rtp = getcwd()
1468 source Ximport_rtp.vim
1469 &rtp = save_rtp
1470
1471 assert_equal(9876, g:imported_rtp)
1472 unlet g:imported_rtp
1473
1474 delete('Ximport_rtp.vim')
Bram Moolenaar89483d42020-05-10 15:24:44 +02001475 delete('import', 'rf')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001476enddef
1477
Bram Moolenaar25e0f582020-05-25 22:36:50 +02001478def Test_import_compile_error()
1479 let export_lines = [
1480 'vim9script',
1481 'export def ExpFunc(): string',
1482 ' return notDefined',
1483 'enddef',
1484 ]
1485 writefile(export_lines, 'Xexported.vim')
1486
1487 let import_lines = [
1488 'vim9script',
1489 'import ExpFunc from "./Xexported.vim"',
1490 'def ImpFunc()',
1491 ' echo ExpFunc()',
1492 'enddef',
1493 'defcompile',
1494 ]
1495 writefile(import_lines, 'Ximport.vim')
1496
1497 try
1498 source Ximport.vim
1499 catch /E1001/
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001500 # Error should be fore the Xexported.vim file.
Bram Moolenaar25e0f582020-05-25 22:36:50 +02001501 assert_match('E1001: variable not found: notDefined', v:exception)
1502 assert_match('function <SNR>\d\+_ImpFunc\[1\]..<SNR>\d\+_ExpFunc, line 1', v:throwpoint)
1503 endtry
1504
1505 delete('Xexported.vim')
1506 delete('Ximport.vim')
1507enddef
1508
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001509def Test_fixed_size_list()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001510 # will be allocated as one piece of memory, check that changes work
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001511 let l = [1, 2, 3, 4]
1512 l->remove(0)
1513 l->add(5)
1514 l->insert(99, 1)
Bram Moolenaar0f18b6d2020-02-02 17:22:27 +01001515 assert_equal([2, 99, 3, 4, 5], l)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001516enddef
1517
Bram Moolenaarae616492020-07-28 20:07:27 +02001518def Test_no_insert_xit()
1519 call CheckDefExecFailure(['x = 1'], 'E1100:')
1520 call CheckDefExecFailure(['a = 1'], 'E1100:')
1521 call CheckDefExecFailure(['i = 1'], 'E1100:')
1522 call CheckDefExecFailure(['c = 1'], 'E1100:')
1523
1524 CheckScriptFailure(['vim9script', 'x = 1'], 'E1100:')
1525 CheckScriptFailure(['vim9script', 'a = 1'], 'E488:')
1526 CheckScriptFailure(['vim9script', 'a'], 'E1100:')
1527 CheckScriptFailure(['vim9script', 'i = 1'], 'E488:')
1528 CheckScriptFailure(['vim9script', 'i'], 'E1100:')
1529 CheckScriptFailure(['vim9script', 'c = 1'], 'E488:')
1530 CheckScriptFailure(['vim9script', 'c'], 'E1100:')
1531enddef
1532
Bram Moolenaar158906c2020-02-06 20:39:45 +01001533def IfElse(what: number): string
1534 let res = ''
1535 if what == 1
1536 res = "one"
1537 elseif what == 2
1538 res = "two"
Bram Moolenaara259d8d2020-01-31 20:10:50 +01001539 else
Bram Moolenaar158906c2020-02-06 20:39:45 +01001540 res = "three"
Bram Moolenaara259d8d2020-01-31 20:10:50 +01001541 endif
Bram Moolenaar158906c2020-02-06 20:39:45 +01001542 return res
Bram Moolenaara259d8d2020-01-31 20:10:50 +01001543enddef
1544
Bram Moolenaar158906c2020-02-06 20:39:45 +01001545def Test_if_elseif_else()
1546 assert_equal('one', IfElse(1))
1547 assert_equal('two', IfElse(2))
1548 assert_equal('three', IfElse(3))
Bram Moolenaar0f18b6d2020-02-02 17:22:27 +01001549enddef
1550
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001551def Test_if_elseif_else_fails()
1552 call CheckDefFailure(['elseif true'], 'E582:')
1553 call CheckDefFailure(['else'], 'E581:')
1554 call CheckDefFailure(['endif'], 'E580:')
1555 call CheckDefFailure(['if true', 'elseif xxx'], 'E1001:')
Bram Moolenaar585fea72020-04-02 22:33:21 +02001556 call CheckDefFailure(['if true', 'echo 1'], 'E171:')
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001557enddef
1558
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001559let g:bool_true = v:true
1560let g:bool_false = v:false
1561
1562def Test_if_const_expr()
1563 let res = false
1564 if true ? true : false
1565 res = true
1566 endif
1567 assert_equal(true, res)
1568
Bram Moolenaar585fea72020-04-02 22:33:21 +02001569 g:glob = 2
1570 if false
Bram Moolenaar67979662020-06-20 22:50:47 +02001571 execute('g:glob = 3')
Bram Moolenaar585fea72020-04-02 22:33:21 +02001572 endif
1573 assert_equal(2, g:glob)
1574 if true
Bram Moolenaar67979662020-06-20 22:50:47 +02001575 execute('g:glob = 3')
Bram Moolenaar585fea72020-04-02 22:33:21 +02001576 endif
1577 assert_equal(3, g:glob)
1578
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001579 res = false
1580 if g:bool_true ? true : false
1581 res = true
1582 endif
1583 assert_equal(true, res)
1584
1585 res = false
1586 if true ? g:bool_true : false
1587 res = true
1588 endif
1589 assert_equal(true, res)
1590
1591 res = false
1592 if true ? true : g:bool_false
1593 res = true
1594 endif
1595 assert_equal(true, res)
1596
1597 res = false
1598 if true ? false : true
1599 res = true
1600 endif
1601 assert_equal(false, res)
1602
1603 res = false
1604 if false ? false : true
1605 res = true
1606 endif
1607 assert_equal(true, res)
1608
1609 res = false
1610 if false ? true : false
1611 res = true
1612 endif
1613 assert_equal(false, res)
1614
1615 res = false
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001616 if has('xyz') ? true : false
1617 res = true
1618 endif
1619 assert_equal(false, res)
1620
1621 res = false
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001622 if true && true
1623 res = true
1624 endif
1625 assert_equal(true, res)
1626
1627 res = false
1628 if true && false
1629 res = true
1630 endif
1631 assert_equal(false, res)
1632
1633 res = false
1634 if g:bool_true && false
1635 res = true
1636 endif
1637 assert_equal(false, res)
1638
1639 res = false
1640 if true && g:bool_false
1641 res = true
1642 endif
1643 assert_equal(false, res)
1644
1645 res = false
1646 if false && false
1647 res = true
1648 endif
1649 assert_equal(false, res)
1650
1651 res = false
1652 if true || false
1653 res = true
1654 endif
1655 assert_equal(true, res)
1656
1657 res = false
1658 if g:bool_true || false
1659 res = true
1660 endif
1661 assert_equal(true, res)
1662
1663 res = false
1664 if true || g:bool_false
1665 res = true
1666 endif
1667 assert_equal(true, res)
1668
1669 res = false
1670 if false || false
1671 res = true
1672 endif
1673 assert_equal(false, res)
Bram Moolenaar80c34ca2020-04-01 23:05:18 +02001674enddef
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001675
Bram Moolenaar80c34ca2020-04-01 23:05:18 +02001676def Test_if_const_expr_fails()
1677 call CheckDefFailure(['if "aaa" == "bbb'], 'E114:')
1678 call CheckDefFailure(["if 'aaa' == 'bbb"], 'E115:')
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001679 call CheckDefFailure(["if has('aaa'"], 'E110:')
1680 call CheckDefFailure(["if has('aaa') ? true false"], 'E109:')
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001681enddef
1682
Bram Moolenaar72abcf42020-06-18 18:26:24 +02001683def RunNested(i: number): number
1684 let x: number = 0
1685 if i % 2
1686 if 1
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001687 # comment
Bram Moolenaar72abcf42020-06-18 18:26:24 +02001688 else
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001689 # comment
Bram Moolenaar72abcf42020-06-18 18:26:24 +02001690 endif
1691 x += 1
1692 else
1693 x += 1000
1694 endif
1695 return x
1696enddef
1697
1698def Test_nested_if()
1699 assert_equal(1, RunNested(1))
1700 assert_equal(1000, RunNested(2))
1701enddef
1702
Bram Moolenaarad39c092020-02-26 18:23:43 +01001703def Test_execute_cmd()
1704 new
1705 setline(1, 'default')
1706 execute 'call setline(1, "execute-string")'
1707 assert_equal('execute-string', getline(1))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001708
1709 execute "call setline(1, 'execute-string')"
1710 assert_equal('execute-string', getline(1))
1711
Bram Moolenaarad39c092020-02-26 18:23:43 +01001712 let cmd1 = 'call setline(1,'
1713 let cmd2 = '"execute-var")'
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001714 execute cmd1 cmd2 # comment
Bram Moolenaarad39c092020-02-26 18:23:43 +01001715 assert_equal('execute-var', getline(1))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001716
Bram Moolenaarad39c092020-02-26 18:23:43 +01001717 execute cmd1 cmd2 '|call setline(1, "execute-var-string")'
1718 assert_equal('execute-var-string', getline(1))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001719
Bram Moolenaarad39c092020-02-26 18:23:43 +01001720 let cmd_first = 'call '
1721 let cmd_last = 'setline(1, "execute-var-var")'
1722 execute cmd_first .. cmd_last
1723 assert_equal('execute-var-var', getline(1))
1724 bwipe!
Bram Moolenaar585fea72020-04-02 22:33:21 +02001725
Bram Moolenaar2d6b20d2020-07-25 19:30:59 +02001726 let n = true
1727 execute 'echomsg' (n ? '"true"' : '"no"')
1728 assert_match('^true$', Screenline(&lines))
1729
Bram Moolenaar585fea72020-04-02 22:33:21 +02001730 call CheckDefFailure(['execute xxx'], 'E1001:')
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001731 call CheckDefFailure(['execute "cmd"# comment'], 'E488:')
Bram Moolenaarad39c092020-02-26 18:23:43 +01001732enddef
1733
Bram Moolenaar47e880d2020-06-30 22:02:02 +02001734def Test_execute_cmd_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001735 # only checks line continuation
Bram Moolenaar47e880d2020-06-30 22:02:02 +02001736 let lines =<< trim END
1737 vim9script
1738 execute 'g:someVar'
1739 .. ' = ' ..
1740 '28'
1741 assert_equal(28, g:someVar)
1742 unlet g:someVar
1743 END
1744 CheckScriptSuccess(lines)
1745enddef
1746
Bram Moolenaarad39c092020-02-26 18:23:43 +01001747def Test_echo_cmd()
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001748 echo 'some' # comment
Bram Moolenaar585fea72020-04-02 22:33:21 +02001749 echon 'thing'
Bram Moolenaarad39c092020-02-26 18:23:43 +01001750 assert_match('^something$', Screenline(&lines))
1751
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001752 echo "some" # comment
1753 echon "thing"
1754 assert_match('^something$', Screenline(&lines))
1755
Bram Moolenaarad39c092020-02-26 18:23:43 +01001756 let str1 = 'some'
1757 let str2 = 'more'
1758 echo str1 str2
1759 assert_match('^some more$', Screenline(&lines))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001760
1761 call CheckDefFailure(['echo "xxx"# comment'], 'E488:')
Bram Moolenaarad39c092020-02-26 18:23:43 +01001762enddef
1763
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001764def Test_echomsg_cmd()
1765 echomsg 'some' 'more' # comment
1766 assert_match('^some more$', Screenline(&lines))
1767 echo 'clear'
Bram Moolenaardf069ee2020-06-22 23:02:51 +02001768 :1messages
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001769 assert_match('^some more$', Screenline(&lines))
1770
1771 call CheckDefFailure(['echomsg "xxx"# comment'], 'E488:')
1772enddef
1773
Bram Moolenaar47e880d2020-06-30 22:02:02 +02001774def Test_echomsg_cmd_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001775 # only checks line continuation
Bram Moolenaar47e880d2020-06-30 22:02:02 +02001776 let lines =<< trim END
1777 vim9script
1778 echomsg 'here'
1779 .. ' is ' ..
1780 'a message'
1781 assert_match('^here is a message$', Screenline(&lines))
1782 END
1783 CheckScriptSuccess(lines)
1784enddef
1785
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001786def Test_echoerr_cmd()
Bram Moolenaar40ee4662020-05-05 22:08:26 +02001787 try
1788 echoerr 'something' 'wrong' # comment
1789 catch
1790 assert_match('something wrong', v:exception)
1791 endtry
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001792enddef
1793
Bram Moolenaar47e880d2020-06-30 22:02:02 +02001794def Test_echoerr_cmd_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001795 # only checks line continuation
Bram Moolenaar47e880d2020-06-30 22:02:02 +02001796 let lines =<< trim END
1797 vim9script
1798 try
1799 echoerr 'this'
1800 .. ' is ' ..
1801 'wrong'
1802 catch
1803 assert_match('this is wrong', v:exception)
1804 endtry
1805 END
1806 CheckScriptSuccess(lines)
1807enddef
1808
Bram Moolenaar41fe0612020-03-01 16:22:40 +01001809def Test_for_outside_of_function()
1810 let lines =<< trim END
1811 vim9script
1812 new
1813 for var in range(0, 3)
1814 append(line('$'), var)
1815 endfor
1816 assert_equal(['', '0', '1', '2', '3'], getline(1, '$'))
1817 bwipe!
1818 END
1819 writefile(lines, 'Xvim9for.vim')
1820 source Xvim9for.vim
1821 delete('Xvim9for.vim')
1822enddef
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001823
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001824def Test_for_loop()
1825 let result = ''
1826 for cnt in range(7)
1827 if cnt == 4
1828 break
1829 endif
1830 if cnt == 2
1831 continue
1832 endif
1833 result ..= cnt .. '_'
1834 endfor
1835 assert_equal('0_1_3_', result)
Bram Moolenaar0ad3e892020-07-05 21:38:11 +02001836
1837 let concat = ''
1838 for str in eval('["one", "two"]')
1839 concat ..= str
1840 endfor
1841 assert_equal('onetwo', concat)
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001842enddef
1843
1844def Test_for_loop_fails()
Bram Moolenaar675f7162020-04-12 22:53:54 +02001845 CheckDefFailure(['for # in range(5)'], 'E690:')
1846 CheckDefFailure(['for i In range(5)'], 'E690:')
1847 CheckDefFailure(['let x = 5', 'for x in range(5)'], 'E1023:')
Bram Moolenaar822ba242020-05-24 23:00:18 +02001848 CheckScriptFailure(['def Func(arg: any)', 'for arg in range(5)', 'enddef', 'defcompile'], 'E1006:')
Bram Moolenaar0ad3e892020-07-05 21:38:11 +02001849 CheckDefFailure(['for i in "text"'], 'E1013:')
Bram Moolenaar675f7162020-04-12 22:53:54 +02001850 CheckDefFailure(['for i in xxx'], 'E1001:')
1851 CheckDefFailure(['endfor'], 'E588:')
1852 CheckDefFailure(['for i in range(3)', 'echo 3'], 'E170:')
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001853enddef
1854
Bram Moolenaard0df1aa2020-03-04 21:50:46 +01001855def Test_while_loop()
1856 let result = ''
1857 let cnt = 0
1858 while cnt < 555
1859 if cnt == 3
1860 break
1861 endif
1862 cnt += 1
1863 if cnt == 2
1864 continue
1865 endif
1866 result ..= cnt .. '_'
1867 endwhile
1868 assert_equal('1_3_', result)
1869enddef
1870
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001871def Test_while_loop_fails()
Bram Moolenaar675f7162020-04-12 22:53:54 +02001872 CheckDefFailure(['while xxx'], 'E1001:')
1873 CheckDefFailure(['endwhile'], 'E588:')
1874 CheckDefFailure(['continue'], 'E586:')
1875 CheckDefFailure(['if true', 'continue'], 'E586:')
1876 CheckDefFailure(['break'], 'E587:')
1877 CheckDefFailure(['if true', 'break'], 'E587:')
1878 CheckDefFailure(['while 1', 'echo 3'], 'E170:')
Bram Moolenaarbd5da372020-03-31 23:13:10 +02001879enddef
1880
Bram Moolenaar9645e2d2020-03-20 20:48:49 +01001881def Test_interrupt_loop()
Bram Moolenaar97acfc72020-03-22 13:44:28 +01001882 let caught = false
Bram Moolenaar9645e2d2020-03-20 20:48:49 +01001883 let x = 0
Bram Moolenaar97acfc72020-03-22 13:44:28 +01001884 try
1885 while 1
1886 x += 1
1887 if x == 100
1888 feedkeys("\<C-C>", 'Lt')
1889 endif
1890 endwhile
1891 catch
1892 caught = true
1893 assert_equal(100, x)
1894 endtry
1895 assert_true(caught, 'should have caught an exception')
Bram Moolenaar9645e2d2020-03-20 20:48:49 +01001896enddef
Bram Moolenaar20431c92020-03-20 18:39:46 +01001897
Bram Moolenaar4fdae992020-04-12 16:38:57 +02001898def Test_automatic_line_continuation()
1899 let mylist = [
1900 'one',
1901 'two',
1902 'three',
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001903 ] # comment
Bram Moolenaar4fdae992020-04-12 16:38:57 +02001904 assert_equal(['one', 'two', 'three'], mylist)
1905
1906 let mydict = {
1907 'one': 1,
1908 'two': 2,
1909 'three':
1910 3,
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001911 } # comment
Bram Moolenaar4fdae992020-04-12 16:38:57 +02001912 assert_equal({'one': 1, 'two': 2, 'three': 3}, mydict)
1913 mydict = #{
Bram Moolenaar2c330432020-04-13 14:41:35 +02001914 one: 1, # comment
1915 two: # comment
1916 2, # comment
1917 three: 3 # comment
1918 }
1919 assert_equal(#{one: 1, two: 2, three: 3}, mydict)
1920 mydict = #{
1921 one: 1,
1922 two:
1923 2,
1924 three: 3
Bram Moolenaar4fdae992020-04-12 16:38:57 +02001925 }
1926 assert_equal(#{one: 1, two: 2, three: 3}, mydict)
Bram Moolenaare6085c52020-04-12 20:19:16 +02001927
1928 assert_equal(
1929 ['one', 'two', 'three'],
1930 split('one two three')
1931 )
Bram Moolenaar4fdae992020-04-12 16:38:57 +02001932enddef
1933
Bram Moolenaar7a092242020-04-16 22:10:49 +02001934def Test_vim9_comment()
1935 CheckScriptSuccess([
1936 'vim9script',
1937 '# something',
1938 ])
1939 CheckScriptFailure([
1940 'vim9script',
1941 ':# something',
1942 ], 'E488:')
1943 CheckScriptFailure([
1944 '# something',
1945 ], 'E488:')
1946 CheckScriptFailure([
1947 ':# something',
1948 ], 'E488:')
1949
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02001950 { # block start
1951 } # block end
1952 CheckDefFailure([
1953 '{# comment',
1954 ], 'E488:')
1955 CheckDefFailure([
1956 '{',
1957 '}# comment',
1958 ], 'E488:')
1959
1960 echo "yes" # comment
1961 CheckDefFailure([
1962 'echo "yes"# comment',
1963 ], 'E488:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02001964 CheckScriptSuccess([
1965 'vim9script',
1966 'echo "yes" # something',
1967 ])
1968 CheckScriptFailure([
1969 'vim9script',
1970 'echo "yes"# something',
1971 ], 'E121:')
1972 CheckScriptFailure([
1973 'vim9script',
1974 'echo# something',
1975 ], 'E121:')
1976 CheckScriptFailure([
1977 'echo "yes" # something',
1978 ], 'E121:')
1979
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02001980 exe "echo" # comment
1981 CheckDefFailure([
1982 'exe "echo"# comment',
1983 ], 'E488:')
1984 CheckScriptSuccess([
1985 'vim9script',
1986 'exe "echo" # something',
1987 ])
1988 CheckScriptFailure([
1989 'vim9script',
1990 'exe "echo"# something',
1991 ], 'E121:')
1992 CheckDefFailure([
1993 'exe # comment',
1994 ], 'E1015:')
1995 CheckScriptFailure([
1996 'vim9script',
1997 'exe# something',
1998 ], 'E121:')
1999 CheckScriptFailure([
2000 'exe "echo" # something',
2001 ], 'E121:')
2002
Bram Moolenaar7a092242020-04-16 22:10:49 +02002003 CheckDefFailure([
2004 'try# comment',
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002005 ' echo "yes"',
Bram Moolenaar7a092242020-04-16 22:10:49 +02002006 'catch',
2007 'endtry',
2008 ], 'E488:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002009 CheckScriptFailure([
2010 'vim9script',
2011 'try# comment',
2012 'echo "yes"',
2013 ], 'E488:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02002014 CheckDefFailure([
2015 'try',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002016 ' throw#comment',
2017 'catch',
2018 'endtry',
2019 ], 'E1015:')
2020 CheckDefFailure([
2021 'try',
2022 ' throw "yes"#comment',
2023 'catch',
2024 'endtry',
2025 ], 'E488:')
2026 CheckDefFailure([
2027 'try',
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002028 ' echo "yes"',
Bram Moolenaar7a092242020-04-16 22:10:49 +02002029 'catch# comment',
2030 'endtry',
2031 ], 'E488:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002032 CheckScriptFailure([
2033 'vim9script',
2034 'try',
2035 ' echo "yes"',
2036 'catch# comment',
2037 'endtry',
2038 ], 'E654:')
2039 CheckDefFailure([
2040 'try',
2041 ' echo "yes"',
2042 'catch /pat/# comment',
2043 'endtry',
2044 ], 'E488:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02002045 CheckDefFailure([
2046 'try',
2047 'echo "yes"',
2048 'catch',
2049 'endtry# comment',
2050 ], 'E488:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002051 CheckScriptFailure([
2052 'vim9script',
2053 'try',
2054 ' echo "yes"',
2055 'catch',
2056 'endtry# comment',
Bram Moolenaar9b7bf9e2020-07-11 22:14:59 +02002057 ], 'E488:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002058
2059 CheckScriptSuccess([
2060 'vim9script',
2061 'hi # comment',
2062 ])
2063 CheckScriptFailure([
2064 'vim9script',
2065 'hi# comment',
2066 ], 'E416:')
Bram Moolenaar1966c242020-04-20 22:42:32 +02002067 CheckScriptSuccess([
2068 'vim9script',
2069 'hi Search # comment',
2070 ])
2071 CheckScriptFailure([
2072 'vim9script',
2073 'hi Search# comment',
2074 ], 'E416:')
2075 CheckScriptSuccess([
2076 'vim9script',
2077 'hi link This Search # comment',
2078 ])
2079 CheckScriptFailure([
2080 'vim9script',
2081 'hi link This That# comment',
2082 ], 'E413:')
2083 CheckScriptSuccess([
2084 'vim9script',
2085 'hi clear This # comment',
2086 'hi clear # comment',
2087 ])
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002088 # not tested, because it doesn't give an error but a warning:
2089 # hi clear This# comment',
Bram Moolenaar1966c242020-04-20 22:42:32 +02002090 CheckScriptFailure([
2091 'vim9script',
2092 'hi clear# comment',
2093 ], 'E416:')
2094
2095 CheckScriptSuccess([
2096 'vim9script',
2097 'hi Group term=bold',
2098 'match Group /todo/ # comment',
2099 ])
2100 CheckScriptFailure([
2101 'vim9script',
2102 'hi Group term=bold',
2103 'match Group /todo/# comment',
2104 ], 'E488:')
2105 CheckScriptSuccess([
2106 'vim9script',
2107 'match # comment',
2108 ])
2109 CheckScriptFailure([
2110 'vim9script',
2111 'match# comment',
2112 ], 'E475:')
2113 CheckScriptSuccess([
2114 'vim9script',
2115 'match none # comment',
2116 ])
2117 CheckScriptFailure([
2118 'vim9script',
2119 'match none# comment',
2120 ], 'E475:')
2121
2122 CheckScriptSuccess([
2123 'vim9script',
2124 'menutrans clear # comment',
2125 ])
2126 CheckScriptFailure([
2127 'vim9script',
2128 'menutrans clear# comment text',
2129 ], 'E474:')
2130
2131 CheckScriptSuccess([
2132 'vim9script',
2133 'syntax clear # comment',
2134 ])
2135 CheckScriptFailure([
2136 'vim9script',
2137 'syntax clear# comment text',
2138 ], 'E28:')
2139 CheckScriptSuccess([
2140 'vim9script',
2141 'syntax keyword Word some',
2142 'syntax clear Word # comment',
2143 ])
2144 CheckScriptFailure([
2145 'vim9script',
2146 'syntax keyword Word some',
2147 'syntax clear Word# comment text',
2148 ], 'E28:')
2149
2150 CheckScriptSuccess([
2151 'vim9script',
2152 'syntax list # comment',
2153 ])
2154 CheckScriptFailure([
2155 'vim9script',
2156 'syntax list# comment text',
2157 ], 'E28:')
2158
2159 CheckScriptSuccess([
2160 'vim9script',
2161 'syntax match Word /pat/ oneline # comment',
2162 ])
2163 CheckScriptFailure([
2164 'vim9script',
2165 'syntax match Word /pat/ oneline# comment',
2166 ], 'E475:')
2167
2168 CheckScriptSuccess([
2169 'vim9script',
2170 'syntax keyword Word word # comm[ent',
2171 ])
2172 CheckScriptFailure([
2173 'vim9script',
2174 'syntax keyword Word word# comm[ent',
2175 ], 'E789:')
2176
2177 CheckScriptSuccess([
2178 'vim9script',
2179 'syntax match Word /pat/ # comment',
2180 ])
2181 CheckScriptFailure([
2182 'vim9script',
2183 'syntax match Word /pat/# comment',
2184 ], 'E402:')
2185
2186 CheckScriptSuccess([
2187 'vim9script',
2188 'syntax match Word /pat/ contains=Something # comment',
2189 ])
2190 CheckScriptFailure([
2191 'vim9script',
2192 'syntax match Word /pat/ contains=Something# comment',
2193 ], 'E475:')
2194 CheckScriptFailure([
2195 'vim9script',
2196 'syntax match Word /pat/ contains= # comment',
2197 ], 'E406:')
2198 CheckScriptFailure([
2199 'vim9script',
2200 'syntax match Word /pat/ contains=# comment',
2201 ], 'E475:')
2202
2203 CheckScriptSuccess([
2204 'vim9script',
2205 'syntax region Word start=/pat/ end=/pat/ # comment',
2206 ])
2207 CheckScriptFailure([
2208 'vim9script',
2209 'syntax region Word start=/pat/ end=/pat/# comment',
Bram Moolenaard032f342020-07-18 18:13:02 +02002210 ], 'E402:')
Bram Moolenaar1966c242020-04-20 22:42:32 +02002211
2212 CheckScriptSuccess([
2213 'vim9script',
2214 'syntax sync # comment',
2215 ])
2216 CheckScriptFailure([
2217 'vim9script',
2218 'syntax sync# comment',
2219 ], 'E404:')
2220 CheckScriptSuccess([
2221 'vim9script',
2222 'syntax sync ccomment # comment',
2223 ])
2224 CheckScriptFailure([
2225 'vim9script',
2226 'syntax sync ccomment# comment',
2227 ], 'E404:')
2228
2229 CheckScriptSuccess([
2230 'vim9script',
2231 'syntax cluster Some contains=Word # comment',
2232 ])
2233 CheckScriptFailure([
2234 'vim9script',
2235 'syntax cluster Some contains=Word# comment',
2236 ], 'E475:')
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002237
2238 CheckScriptSuccess([
2239 'vim9script',
2240 'command Echo echo # comment',
2241 'command Echo # comment',
2242 ])
2243 CheckScriptFailure([
2244 'vim9script',
2245 'command Echo echo# comment',
2246 'Echo',
2247 ], 'E121:')
2248 CheckScriptFailure([
2249 'vim9script',
2250 'command Echo# comment',
2251 ], 'E182:')
2252 CheckScriptFailure([
2253 'vim9script',
2254 'command Echo echo',
2255 'command Echo# comment',
2256 ], 'E182:')
2257
2258 CheckScriptSuccess([
2259 'vim9script',
2260 'function # comment',
2261 ])
2262 CheckScriptFailure([
2263 'vim9script',
2264 'function# comment',
2265 ], 'E129:')
2266 CheckScriptSuccess([
2267 'vim9script',
2268 'function CheckScriptSuccess # comment',
2269 ])
2270 CheckScriptFailure([
2271 'vim9script',
2272 'function CheckScriptSuccess# comment',
2273 ], 'E488:')
2274
2275 CheckScriptSuccess([
2276 'vim9script',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02002277 'func g:DeleteMeA()',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002278 'endfunc',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02002279 'delfunction g:DeleteMeA # comment',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002280 ])
2281 CheckScriptFailure([
2282 'vim9script',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02002283 'func g:DeleteMeB()',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002284 'endfunc',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02002285 'delfunction g:DeleteMeB# comment',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002286 ], 'E488:')
2287
2288 CheckScriptSuccess([
2289 'vim9script',
2290 'call execute("ls") # comment',
2291 ])
2292 CheckScriptFailure([
2293 'vim9script',
2294 'call execute("ls")# comment',
2295 ], 'E488:')
Bram Moolenaare7e48382020-07-22 18:17:08 +02002296
2297 CheckScriptFailure([
2298 'def Test() " comment',
2299 'enddef',
2300 ], 'E488:')
2301 CheckScriptFailure([
2302 'vim9script',
2303 'def Test() " comment',
2304 'enddef',
2305 ], 'E488:')
2306
2307 CheckScriptSuccess([
2308 'func Test() " comment',
2309 'endfunc',
2310 ])
2311 CheckScriptFailure([
2312 'vim9script',
2313 'func Test() " comment',
2314 'endfunc',
2315 ], 'E488:')
2316
2317 CheckScriptSuccess([
2318 'def Test() # comment',
2319 'enddef',
2320 ])
2321 CheckScriptFailure([
2322 'func Test() # comment',
2323 'endfunc',
2324 ], 'E488:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002325enddef
2326
2327def Test_vim9_comment_gui()
2328 CheckCanRunGui
2329
2330 CheckScriptFailure([
2331 'vim9script',
2332 'gui#comment'
2333 ], 'E499:')
2334 CheckScriptFailure([
2335 'vim9script',
2336 'gui -f#comment'
2337 ], 'E499:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02002338enddef
2339
Bram Moolenaara26b9702020-04-18 19:53:28 +02002340def Test_vim9_comment_not_compiled()
Bram Moolenaar67979662020-06-20 22:50:47 +02002341 au TabEnter *.vim g:entered = 1
2342 au TabEnter *.x g:entered = 2
Bram Moolenaara26b9702020-04-18 19:53:28 +02002343
2344 edit test.vim
2345 doautocmd TabEnter #comment
2346 assert_equal(1, g:entered)
2347
2348 doautocmd TabEnter f.x
2349 assert_equal(2, g:entered)
2350
2351 g:entered = 0
2352 doautocmd TabEnter f.x #comment
2353 assert_equal(2, g:entered)
2354
2355 assert_fails('doautocmd Syntax#comment', 'E216:')
2356
2357 au! TabEnter
2358 unlet g:entered
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02002359
2360 CheckScriptSuccess([
2361 'vim9script',
Bram Moolenaar67979662020-06-20 22:50:47 +02002362 'g:var = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02002363 'b:var = 456',
2364 'w:var = 777',
2365 't:var = 888',
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02002366 'unlet g:var w:var # something',
2367 ])
2368
2369 CheckScriptFailure([
2370 'vim9script',
2371 'let g:var = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02002372 ], 'E1016: Cannot declare a global variable:')
2373
2374 CheckScriptFailure([
2375 'vim9script',
2376 'let b:var = 123',
2377 ], 'E1016: Cannot declare a buffer variable:')
2378
2379 CheckScriptFailure([
2380 'vim9script',
2381 'let w:var = 123',
2382 ], 'E1016: Cannot declare a window variable:')
2383
2384 CheckScriptFailure([
2385 'vim9script',
2386 'let t:var = 123',
2387 ], 'E1016: Cannot declare a tab variable:')
2388
2389 CheckScriptFailure([
2390 'vim9script',
2391 'let v:version = 123',
2392 ], 'E1016: Cannot declare a v: variable:')
2393
2394 CheckScriptFailure([
2395 'vim9script',
2396 'let $VARIABLE = "text"',
2397 ], 'E1016: Cannot declare an environment variable:')
Bram Moolenaar67979662020-06-20 22:50:47 +02002398
2399 CheckScriptFailure([
2400 'vim9script',
2401 'g:var = 123',
Bram Moolenaar32e35112020-05-14 22:41:15 +02002402 'unlet g:var# comment1',
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02002403 ], 'E108:')
2404
2405 CheckScriptFailure([
2406 'let g:var = 123',
2407 'unlet g:var # something',
2408 ], 'E488:')
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002409
2410 CheckScriptSuccess([
2411 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02002412 'if 1 # comment2',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002413 ' echo "yes"',
2414 'elseif 2 #comment',
2415 ' echo "no"',
2416 'endif',
2417 ])
2418
2419 CheckScriptFailure([
2420 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02002421 'if 1# comment3',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002422 ' echo "yes"',
2423 'endif',
2424 ], 'E15:')
2425
2426 CheckScriptFailure([
2427 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02002428 'if 0 # comment4',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002429 ' echo "yes"',
2430 'elseif 2#comment',
2431 ' echo "no"',
2432 'endif',
2433 ], 'E15:')
2434
2435 CheckScriptSuccess([
2436 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02002437 'let v = 1 # comment5',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002438 ])
2439
2440 CheckScriptFailure([
2441 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02002442 'let v = 1# comment6',
2443 ], 'E15:')
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002444
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002445 CheckScriptSuccess([
2446 'vim9script',
2447 'new'
2448 'call setline(1, ["# define pat", "last"])',
Bram Moolenaardf069ee2020-06-22 23:02:51 +02002449 ':$',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002450 'dsearch /pat/ #comment',
2451 'bwipe!',
2452 ])
2453
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002454 CheckScriptFailure([
2455 'vim9script',
2456 'new'
2457 'call setline(1, ["# define pat", "last"])',
2458 ':$',
2459 'dsearch /pat/#comment',
2460 'bwipe!',
2461 ], 'E488:')
2462
2463 CheckScriptFailure([
2464 'vim9script',
2465 'func! SomeFunc()',
2466 ], 'E477:')
Bram Moolenaara26b9702020-04-18 19:53:28 +02002467enddef
2468
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02002469def Test_finish()
2470 let lines =<< trim END
2471 vim9script
Bram Moolenaar67979662020-06-20 22:50:47 +02002472 g:res = 'one'
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02002473 if v:false | finish | endif
Bram Moolenaar67979662020-06-20 22:50:47 +02002474 g:res = 'two'
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02002475 finish
Bram Moolenaar67979662020-06-20 22:50:47 +02002476 g:res = 'three'
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02002477 END
2478 writefile(lines, 'Xfinished')
2479 source Xfinished
2480 assert_equal('two', g:res)
2481
2482 unlet g:res
2483 delete('Xfinished')
2484enddef
2485
Bram Moolenaar32e35112020-05-14 22:41:15 +02002486def Test_let_func_call()
2487 let lines =<< trim END
2488 vim9script
2489 func GetValue()
2490 if exists('g:count')
2491 let g:count += 1
2492 else
2493 let g:count = 1
2494 endif
2495 return 'this'
2496 endfunc
2497 let val: string = GetValue()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002498 # env var is always a string
Bram Moolenaardf671b42020-05-16 22:33:33 +02002499 let env = $TERM
Bram Moolenaar32e35112020-05-14 22:41:15 +02002500 END
2501 writefile(lines, 'Xfinished')
2502 source Xfinished
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002503 # GetValue() is not called during discovery phase
Bram Moolenaar32e35112020-05-14 22:41:15 +02002504 assert_equal(1, g:count)
2505
2506 unlet g:count
2507 delete('Xfinished')
2508enddef
2509
2510def Test_let_missing_type()
2511 let lines =<< trim END
2512 vim9script
Bram Moolenaardf671b42020-05-16 22:33:33 +02002513 let var = g:unknown
Bram Moolenaar227a69d2020-05-15 18:17:28 +02002514 END
Bram Moolenaar822ba242020-05-24 23:00:18 +02002515 CheckScriptFailure(lines, 'E121:')
Bram Moolenaar227a69d2020-05-15 18:17:28 +02002516
2517 lines =<< trim END
2518 vim9script
2519 let nr: number = 123
2520 let var = nr
2521 END
Bram Moolenaar822ba242020-05-24 23:00:18 +02002522 CheckScriptSuccess(lines)
Bram Moolenaar32e35112020-05-14 22:41:15 +02002523enddef
2524
Bram Moolenaarc82a5b52020-06-13 18:09:19 +02002525def Test_let_declaration()
2526 let lines =<< trim END
2527 vim9script
2528 let var: string
2529 g:var_uninit = var
2530 var = 'text'
2531 g:var_test = var
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002532 # prefixing s: is optional
Bram Moolenaar984dddb2020-06-14 12:50:24 +02002533 s:var = 'prefixed'
2534 g:var_prefixed = s:var
2535
2536 let s:other: number
2537 other = 1234
2538 g:other_var = other
Bram Moolenaarc82a5b52020-06-13 18:09:19 +02002539 END
2540 CheckScriptSuccess(lines)
2541 assert_equal('', g:var_uninit)
2542 assert_equal('text', g:var_test)
Bram Moolenaar984dddb2020-06-14 12:50:24 +02002543 assert_equal('prefixed', g:var_prefixed)
2544 assert_equal(1234, g:other_var)
Bram Moolenaarc82a5b52020-06-13 18:09:19 +02002545
2546 unlet g:var_uninit
2547 unlet g:var_test
Bram Moolenaar984dddb2020-06-14 12:50:24 +02002548 unlet g:var_prefixed
2549 unlet g:other_var
Bram Moolenaarc82a5b52020-06-13 18:09:19 +02002550enddef
2551
Bram Moolenaarc5b1c202020-06-18 22:43:27 +02002552def Test_let_declaration_fails()
2553 let lines =<< trim END
2554 vim9script
2555 const var: string
2556 END
2557 CheckScriptFailure(lines, 'E1021:')
2558
2559 lines =<< trim END
2560 vim9script
2561 let 9var: string
2562 END
2563 CheckScriptFailure(lines, 'E475:')
2564enddef
2565
Bram Moolenaar34db91f2020-06-13 19:00:10 +02002566def Test_let_type_check()
2567 let lines =<< trim END
2568 vim9script
2569 let var: string
2570 var = 1234
2571 END
2572 CheckScriptFailure(lines, 'E1013:')
Bram Moolenaar984dddb2020-06-14 12:50:24 +02002573
2574 lines =<< trim END
2575 vim9script
2576 let var:string
2577 END
2578 CheckScriptFailure(lines, 'E1069:')
Bram Moolenaarc5b1c202020-06-18 22:43:27 +02002579
2580 lines =<< trim END
2581 vim9script
2582 let var: asdf
2583 END
2584 CheckScriptFailure(lines, 'E1010:')
Bram Moolenaar34db91f2020-06-13 19:00:10 +02002585enddef
2586
Bram Moolenaara5d00772020-05-14 23:20:55 +02002587def Test_forward_declaration()
2588 let lines =<< trim END
2589 vim9script
Bram Moolenaara5d00772020-05-14 23:20:55 +02002590 def GetValue(): string
2591 return theVal
2592 enddef
2593 let theVal = 'something'
Bram Moolenaar822ba242020-05-24 23:00:18 +02002594 g:initVal = GetValue()
Bram Moolenaara5d00772020-05-14 23:20:55 +02002595 theVal = 'else'
2596 g:laterVal = GetValue()
2597 END
2598 writefile(lines, 'Xforward')
2599 source Xforward
2600 assert_equal('something', g:initVal)
2601 assert_equal('else', g:laterVal)
2602
2603 unlet g:initVal
2604 unlet g:laterVal
2605 delete('Xforward')
2606enddef
2607
Bram Moolenaar9721fb42020-06-11 23:10:46 +02002608def Test_source_vim9_from_legacy()
2609 let legacy_lines =<< trim END
2610 source Xvim9_script.vim
2611
2612 call assert_false(exists('local'))
2613 call assert_false(exists('exported'))
2614 call assert_false(exists('s:exported'))
2615 call assert_equal('global', global)
2616 call assert_equal('global', g:global)
2617
2618 " imported variable becomes script-local
2619 import exported from './Xvim9_script.vim'
2620 call assert_equal('exported', s:exported)
2621 call assert_false(exists('exported'))
2622
2623 " imported function becomes script-local
2624 import GetText from './Xvim9_script.vim'
2625 call assert_equal('text', s:GetText())
2626 call assert_false(exists('*GetText'))
2627 END
2628 writefile(legacy_lines, 'Xlegacy_script.vim')
2629
2630 let vim9_lines =<< trim END
2631 vim9script
2632 let local = 'local'
2633 g:global = 'global'
2634 export let exported = 'exported'
2635 export def GetText(): string
2636 return 'text'
2637 enddef
2638 END
2639 writefile(vim9_lines, 'Xvim9_script.vim')
2640
2641 source Xlegacy_script.vim
2642
2643 assert_equal('global', g:global)
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002644 unlet g:global
Bram Moolenaar9721fb42020-06-11 23:10:46 +02002645
2646 delete('Xlegacy_script.vim')
2647 delete('Xvim9_script.vim')
2648enddef
Bram Moolenaara5d00772020-05-14 23:20:55 +02002649
Bram Moolenaareeb27bf2020-07-04 17:39:10 +02002650def Test_vim9_copen()
2651 # this was giving an error for setting w:quickfix_title
2652 copen
2653 quit
2654enddef
2655
Bram Moolenaar2d6b20d2020-07-25 19:30:59 +02002656" test using a vim9script that is auto-loaded from an autocmd
2657def Test_vim9_autoload()
2658 let lines =<< trim END
2659 vim9script
2660 def foo#test()
2661 echomsg getreg('"')
2662 enddef
2663 END
2664
2665 mkdir('Xdir/autoload', 'p')
2666 writefile(lines, 'Xdir/autoload/foo.vim')
2667 let save_rtp = &rtp
2668 exe 'set rtp^=' .. getcwd() .. '/Xdir'
2669 augroup test
2670 autocmd TextYankPost * call foo#test()
2671 augroup END
2672
2673 normal Y
2674
2675 augroup test
2676 autocmd!
2677 augroup END
2678 delete('Xdir', 'rf')
2679 &rtp = save_rtp
2680enddef
2681
Bram Moolenaar585fea72020-04-02 22:33:21 +02002682" Keep this last, it messes up highlighting.
2683def Test_substitute_cmd()
2684 new
2685 setline(1, 'something')
2686 :substitute(some(other(
2687 assert_equal('otherthing', getline(1))
2688 bwipe!
2689
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002690 # also when the context is Vim9 script
Bram Moolenaar585fea72020-04-02 22:33:21 +02002691 let lines =<< trim END
2692 vim9script
2693 new
2694 setline(1, 'something')
2695 :substitute(some(other(
2696 assert_equal('otherthing', getline(1))
2697 bwipe!
2698 END
2699 writefile(lines, 'Xvim9lines')
2700 source Xvim9lines
2701
2702 delete('Xvim9lines')
2703enddef
2704
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002705" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker