blob: a258bcb7a8a3a4427e2204bf3c84d7e2e8cfe1c3 [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 Moolenaare3d46852020-08-29 13:39:17 +02007source shared.vim
Bram Moolenaar37294bd2021-03-10 13:40:08 +01008source screendump.vim
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009
Bram Moolenaar5d72ce62020-08-20 23:04:06 +020010def Test_range_only()
11 new
12 setline(1, ['blah', 'Blah'])
13 :/Blah/
14 assert_equal(2, getcurpos()[1])
Bram Moolenaarc2af0af2020-08-23 21:06:02 +020015 bwipe!
16
17 # without range commands use current line
18 new
19 setline(1, ['one', 'two', 'three'])
20 :2
21 print
22 assert_equal('two', Screenline(&lines))
23 :3
24 list
25 assert_equal('three$', Screenline(&lines))
Bram Moolenaarb8554302021-02-15 21:30:30 +010026
27 # missing command does not print the line
28 var lines =<< trim END
29 vim9script
30 :1|
31 assert_equal('three$', Screenline(&lines))
32 :|
33 assert_equal('three$', Screenline(&lines))
34 END
35 CheckScriptSuccess(lines)
36
Bram Moolenaarc2af0af2020-08-23 21:06:02 +020037 bwipe!
Bram Moolenaar025cb1c2020-12-14 18:31:27 +010038
39 # won't generate anything
40 if false
41 :123
42 endif
Bram Moolenaar5d72ce62020-08-20 23:04:06 +020043enddef
44
Bram Moolenaara6e67e42020-05-15 23:36:40 +020045let g:alist = [7]
46let g:astring = 'text'
Bram Moolenaarf0b9f432020-07-17 23:03:17 +020047let g:anumber = 123
Bram Moolenaar6e587dc2020-02-06 13:15:52 +010048
Bram Moolenaar4c17ad92020-04-27 22:47:51 +020049def Test_delfunction()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +020050 # Check function is defined in script namespace
Bram Moolenaar4c17ad92020-04-27 22:47:51 +020051 CheckScriptSuccess([
52 'vim9script',
53 'func CheckMe()',
54 ' return 123',
55 'endfunc',
56 'assert_equal(123, s:CheckMe())',
57 ])
58
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +020059 # Check function in script namespace cannot be deleted
Bram Moolenaar4c17ad92020-04-27 22:47:51 +020060 CheckScriptFailure([
61 'vim9script',
62 'func DeleteMe1()',
63 'endfunc',
64 'delfunction DeleteMe1',
65 ], 'E1084:')
66 CheckScriptFailure([
67 'vim9script',
68 'func DeleteMe2()',
69 'endfunc',
70 'def DoThat()',
71 ' delfunction DeleteMe2',
72 'enddef',
73 'DoThat()',
74 ], 'E1084:')
75 CheckScriptFailure([
76 'vim9script',
77 'def DeleteMe3()',
78 'enddef',
79 'delfunction DeleteMe3',
80 ], 'E1084:')
81 CheckScriptFailure([
82 'vim9script',
83 'def DeleteMe4()',
84 'enddef',
85 'def DoThat()',
86 ' delfunction DeleteMe4',
87 'enddef',
88 'DoThat()',
89 ], 'E1084:')
Bram Moolenaar925e9fd2020-07-25 15:41:11 +020090
91 # Check that global :def function can be replaced and deleted
Bram Moolenaarcfcd0112020-09-27 15:19:27 +020092 var lines =<< trim END
Bram Moolenaar925e9fd2020-07-25 15:41:11 +020093 vim9script
94 def g:Global(): string
95 return "yes"
96 enddef
97 assert_equal("yes", g:Global())
98 def! g:Global(): string
99 return "no"
100 enddef
101 assert_equal("no", g:Global())
102 delfunc g:Global
103 assert_false(exists('*g:Global'))
104 END
105 CheckScriptSuccess(lines)
106
107 # Check that global function can be replaced by a :def function and deleted
108 lines =<< trim END
109 vim9script
110 func g:Global()
111 return "yes"
112 endfunc
113 assert_equal("yes", g:Global())
114 def! g:Global(): string
115 return "no"
116 enddef
117 assert_equal("no", g:Global())
118 delfunc g:Global
119 assert_false(exists('*g:Global'))
120 END
121 CheckScriptSuccess(lines)
122
123 # Check that global :def function can be replaced by a function and deleted
124 lines =<< trim END
125 vim9script
126 def g:Global(): string
127 return "yes"
128 enddef
129 assert_equal("yes", g:Global())
130 func! g:Global()
131 return "no"
132 endfunc
133 assert_equal("no", g:Global())
134 delfunc g:Global
135 assert_false(exists('*g:Global'))
136 END
137 CheckScriptSuccess(lines)
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200138enddef
139
Bram Moolenaar08052222020-09-14 17:04:31 +0200140def Test_wrong_type()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200141 CheckDefFailure(['var name: list<nothing>'], 'E1010:')
142 CheckDefFailure(['var name: list<list<nothing>>'], 'E1010:')
143 CheckDefFailure(['var name: dict<nothing>'], 'E1010:')
144 CheckDefFailure(['var name: dict<dict<nothing>>'], 'E1010:')
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100145
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200146 CheckDefFailure(['var name: dict<number'], 'E1009:')
147 CheckDefFailure(['var name: dict<list<number>'], 'E1009:')
Bram Moolenaar42a480b2020-02-29 23:23:47 +0100148
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200149 CheckDefFailure(['var name: ally'], 'E1010:')
150 CheckDefFailure(['var name: bram'], 'E1010:')
151 CheckDefFailure(['var name: cathy'], 'E1010:')
152 CheckDefFailure(['var name: dom'], 'E1010:')
153 CheckDefFailure(['var name: freddy'], 'E1010:')
154 CheckDefFailure(['var name: john'], 'E1010:')
155 CheckDefFailure(['var name: larry'], 'E1010:')
156 CheckDefFailure(['var name: ned'], 'E1010:')
157 CheckDefFailure(['var name: pam'], 'E1010:')
158 CheckDefFailure(['var name: sam'], 'E1010:')
159 CheckDefFailure(['var name: vim'], 'E1010:')
Bram Moolenaara0a9f432020-04-28 21:29:34 +0200160
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200161 CheckDefFailure(['var Ref: number', 'Ref()'], 'E1085:')
162 CheckDefFailure(['var Ref: string', 'var res = Ref()'], 'E1085:')
Bram Moolenaar08052222020-09-14 17:04:31 +0200163enddef
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100164
Bram Moolenaar10c65862020-10-08 21:16:42 +0200165def Test_script_wrong_type()
166 var lines =<< trim END
167 vim9script
168 var s:dict: dict<string>
169 s:dict['a'] = ['x']
170 END
171 CheckScriptFailure(lines, 'E1012: Type mismatch; expected string but got list<string>', 3)
172enddef
173
Bram Moolenaar08052222020-09-14 17:04:31 +0200174def Test_const()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200175 CheckDefFailure(['final name = 234', 'name = 99'], 'E1018:')
176 CheckDefFailure(['final one = 234', 'var one = 99'], 'E1017:')
177 CheckDefFailure(['final list = [1, 2]', 'var list = [3, 4]'], 'E1017:')
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200178 CheckDefFailure(['final two'], 'E1125:')
179 CheckDefFailure(['final &option'], 'E996:')
Bram Moolenaardbeecb22020-09-14 18:15:09 +0200180
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200181 var lines =<< trim END
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200182 final list = [1, 2, 3]
Bram Moolenaardbeecb22020-09-14 18:15:09 +0200183 list[0] = 4
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200184 list->assert_equal([4, 2, 3])
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200185 const other = [5, 6, 7]
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200186 other->assert_equal([5, 6, 7])
Bram Moolenaar71abe482020-09-14 22:28:30 +0200187
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200188 var varlist = [7, 8]
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200189 const constlist = [1, varlist, 3]
Bram Moolenaar71abe482020-09-14 22:28:30 +0200190 varlist[0] = 77
191 # TODO: does not work yet
192 # constlist[1][1] = 88
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200193 var cl = constlist[1]
Bram Moolenaar71abe482020-09-14 22:28:30 +0200194 cl[1] = 88
195 constlist->assert_equal([1, [77, 88], 3])
196
Bram Moolenaare0de1712020-12-02 17:36:54 +0100197 var vardict = {five: 5, six: 6}
198 const constdict = {one: 1, two: vardict, three: 3}
Bram Moolenaar71abe482020-09-14 22:28:30 +0200199 vardict['five'] = 55
200 # TODO: does not work yet
201 # constdict['two']['six'] = 66
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200202 var cd = constdict['two']
Bram Moolenaar71abe482020-09-14 22:28:30 +0200203 cd['six'] = 66
Bram Moolenaare0de1712020-12-02 17:36:54 +0100204 constdict->assert_equal({one: 1, two: {five: 55, six: 66}, three: 3})
Bram Moolenaardbeecb22020-09-14 18:15:09 +0200205 END
206 CheckDefAndScriptSuccess(lines)
Bram Moolenaar08052222020-09-14 17:04:31 +0200207enddef
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100208
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200209def Test_const_bang()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200210 var lines =<< trim END
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200211 const var = 234
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200212 var = 99
213 END
214 CheckDefExecFailure(lines, 'E1018:', 2)
215 CheckScriptFailure(['vim9script'] + lines, 'E46:', 3)
216
217 lines =<< trim END
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200218 const ll = [2, 3, 4]
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200219 ll[0] = 99
220 END
221 CheckDefExecFailure(lines, 'E1119:', 2)
222 CheckScriptFailure(['vim9script'] + lines, 'E741:', 3)
223
224 lines =<< trim END
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200225 const ll = [2, 3, 4]
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200226 ll[3] = 99
227 END
228 CheckDefExecFailure(lines, 'E1118:', 2)
229 CheckScriptFailure(['vim9script'] + lines, 'E684:', 3)
230
231 lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +0100232 const dd = {one: 1, two: 2}
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200233 dd["one"] = 99
234 END
235 CheckDefExecFailure(lines, 'E1121:', 2)
236 CheckScriptFailure(['vim9script'] + lines, 'E741:', 3)
237
238 lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +0100239 const dd = {one: 1, two: 2}
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200240 dd["three"] = 99
241 END
242 CheckDefExecFailure(lines, 'E1120:')
243 CheckScriptFailure(['vim9script'] + lines, 'E741:', 3)
244enddef
245
Bram Moolenaardf069ee2020-06-22 23:02:51 +0200246def Test_range_no_colon()
Bram Moolenaard2c61702020-09-06 15:58:36 +0200247 CheckDefFailure(['%s/a/b/'], 'E1050:')
248 CheckDefFailure(['+ s/a/b/'], 'E1050:')
249 CheckDefFailure(['- s/a/b/'], 'E1050:')
250 CheckDefFailure(['. s/a/b/'], 'E1050:')
Bram Moolenaardf069ee2020-06-22 23:02:51 +0200251enddef
252
253
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100254def Test_block()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200255 var outer = 1
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100256 {
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200257 var inner = 2
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100258 assert_equal(1, outer)
259 assert_equal(2, inner)
260 }
261 assert_equal(1, outer)
Bram Moolenaar3f1e9f02021-02-27 22:36:43 +0100262
263 {|echo 'yes'|}
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100264enddef
265
Bram Moolenaar08052222020-09-14 17:04:31 +0200266def Test_block_failure()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200267 CheckDefFailure(['{', 'var inner = 1', '}', 'echo inner'], 'E1001:')
Bram Moolenaar08052222020-09-14 17:04:31 +0200268 CheckDefFailure(['}'], 'E1025:')
269 CheckDefFailure(['{', 'echo 1'], 'E1026:')
270enddef
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100271
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200272def Test_block_local_vars()
273 var lines =<< trim END
274 vim9script
Bram Moolenaared234f22020-10-15 20:42:20 +0200275 v:testing = 1
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200276 if true
Bram Moolenaared234f22020-10-15 20:42:20 +0200277 var text = ['hello']
278 def SayHello(): list<string>
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200279 return text
280 enddef
281 def SetText(v: string)
Bram Moolenaared234f22020-10-15 20:42:20 +0200282 text = [v]
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200283 enddef
284 endif
285
286 if true
Bram Moolenaared234f22020-10-15 20:42:20 +0200287 var text = ['again']
288 def SayAgain(): list<string>
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200289 return text
290 enddef
291 endif
Bram Moolenaared234f22020-10-15 20:42:20 +0200292
293 # test that the "text" variables are not cleaned up
294 test_garbagecollect_now()
295
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200296 defcompile
297
Bram Moolenaared234f22020-10-15 20:42:20 +0200298 assert_equal(['hello'], SayHello())
299 assert_equal(['again'], SayAgain())
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200300
301 SetText('foobar')
Bram Moolenaared234f22020-10-15 20:42:20 +0200302 assert_equal(['foobar'], SayHello())
303
304 call writefile(['ok'], 'Xdidit')
305 qall!
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200306 END
Bram Moolenaared234f22020-10-15 20:42:20 +0200307
308 # need to execute this with a separate Vim instance to avoid the current
309 # context gets garbage collected.
310 writefile(lines, 'Xscript')
311 RunVim([], [], '-S Xscript')
312 assert_equal(['ok'], readfile('Xdidit'))
313
314 delete('Xscript')
315 delete('Xdidit')
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200316enddef
317
Bram Moolenaar39ca4122020-10-20 14:25:07 +0200318def Test_block_local_vars_with_func()
319 var lines =<< trim END
320 vim9script
321 if true
322 var foo = 'foo'
323 if true
324 var bar = 'bar'
325 def Func(): list<string>
326 return [foo, bar]
327 enddef
328 endif
329 endif
330 # function is compiled here, after blocks have finished, can still access
331 # "foo" and "bar"
332 assert_equal(['foo', 'bar'], Func())
333 END
334 CheckScriptSuccess(lines)
335enddef
336
Bram Moolenaard032f342020-07-18 18:13:02 +0200337func g:NoSuchFunc()
338 echo 'none'
339endfunc
340
Bram Moolenaar9e1d9e32021-01-11 20:17:34 +0100341def Test_try_catch_throw()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200342 var l = []
Bram Moolenaar7a092242020-04-16 22:10:49 +0200343 try # comment
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100344 add(l, '1')
345 throw 'wrong'
346 add(l, '2')
Bram Moolenaar7a092242020-04-16 22:10:49 +0200347 catch # comment
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100348 add(l, v:exception)
Bram Moolenaar7a092242020-04-16 22:10:49 +0200349 finally # comment
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100350 add(l, '3')
Bram Moolenaar7a092242020-04-16 22:10:49 +0200351 endtry # comment
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100352 assert_equal(['1', 'wrong', '3'], l)
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200353
Bram Moolenaare8593122020-07-18 15:17:02 +0200354 l = []
355 try
356 try
357 add(l, '1')
358 throw 'wrong'
359 add(l, '2')
360 catch /right/
361 add(l, v:exception)
362 endtry
363 catch /wrong/
364 add(l, 'caught')
Bram Moolenaar373863e2020-09-26 17:20:53 +0200365 fina
Bram Moolenaare8593122020-07-18 15:17:02 +0200366 add(l, 'finally')
367 endtry
368 assert_equal(['1', 'caught', 'finally'], l)
369
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200370 var n: number
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200371 try
372 n = l[3]
373 catch /E684:/
374 n = 99
375 endtry
376 assert_equal(99, n)
377
Bram Moolenaar69f70502021-01-01 16:10:46 +0100378 var done = 'no'
379 if 0
380 try | catch | endtry
381 else
382 done = 'yes'
383 endif
384 assert_equal('yes', done)
385
386 done = 'no'
387 if 1
388 done = 'yes'
389 else
390 try | catch | endtry
391 done = 'never'
392 endif
393 assert_equal('yes', done)
394
395 if 1
396 else
397 try | catch /pat/ | endtry
398 try | catch /pat/
399 endtry
400 try
401 catch /pat/ | endtry
402 try
403 catch /pat/
404 endtry
405 endif
406
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200407 try
Bram Moolenaarcc673e72020-08-16 17:33:35 +0200408 # string slice returns a string, not a number
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200409 n = g:astring[3]
Bram Moolenaar5e654232020-09-16 15:22:00 +0200410 catch /E1012:/
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200411 n = 77
412 endtry
413 assert_equal(77, n)
414
415 try
416 n = l[g:astring]
Bram Moolenaar5e654232020-09-16 15:22:00 +0200417 catch /E1012:/
Bram Moolenaar56acb092020-08-16 14:48:19 +0200418 n = 88
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200419 endtry
Bram Moolenaar56acb092020-08-16 14:48:19 +0200420 assert_equal(88, n)
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200421
422 try
423 n = s:does_not_exist
424 catch /E121:/
Bram Moolenaarf0b9f432020-07-17 23:03:17 +0200425 n = 111
426 endtry
427 assert_equal(111, n)
428
429 try
430 n = g:does_not_exist
431 catch /E121:/
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200432 n = 121
433 endtry
434 assert_equal(121, n)
435
Bram Moolenaare0de1712020-12-02 17:36:54 +0100436 var d = {one: 1}
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200437 try
438 n = d[g:astring]
439 catch /E716:/
440 n = 222
441 endtry
442 assert_equal(222, n)
Bram Moolenaarf0b9f432020-07-17 23:03:17 +0200443
444 try
445 n = -g:astring
446 catch /E39:/
447 n = 233
448 endtry
449 assert_equal(233, n)
450
451 try
452 n = +g:astring
453 catch /E1030:/
454 n = 244
455 endtry
456 assert_equal(244, n)
457
458 try
459 n = +g:alist
460 catch /E745:/
461 n = 255
462 endtry
463 assert_equal(255, n)
464
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200465 var nd: dict<any>
Bram Moolenaarf0b9f432020-07-17 23:03:17 +0200466 try
Bram Moolenaar2e5910b2021-02-03 17:41:24 +0100467 nd = {[g:alist]: 1}
468 catch /E1105:/
Bram Moolenaarf0b9f432020-07-17 23:03:17 +0200469 n = 266
470 endtry
471 assert_equal(266, n)
472
473 try
474 [n] = [1, 2, 3]
475 catch /E1093:/
476 n = 277
477 endtry
478 assert_equal(277, n)
479
Bram Moolenaare8593122020-07-18 15:17:02 +0200480 try
481 &ts = g:astring
Bram Moolenaar5e654232020-09-16 15:22:00 +0200482 catch /E1012:/
Bram Moolenaare8593122020-07-18 15:17:02 +0200483 n = 288
484 endtry
485 assert_equal(288, n)
486
487 try
488 &backspace = 'asdf'
489 catch /E474:/
490 n = 299
491 endtry
492 assert_equal(299, n)
493
494 l = [1]
495 try
496 l[3] = 3
497 catch /E684:/
498 n = 300
499 endtry
500 assert_equal(300, n)
501
502 try
Bram Moolenaare8593122020-07-18 15:17:02 +0200503 unlet g:does_not_exist
504 catch /E108:/
505 n = 322
506 endtry
507 assert_equal(322, n)
508
509 try
Bram Moolenaar2bede172020-11-19 18:53:18 +0100510 d = {text: 1, [g:astring]: 2}
Bram Moolenaare8593122020-07-18 15:17:02 +0200511 catch /E721:/
512 n = 333
513 endtry
514 assert_equal(333, n)
515
516 try
517 l = DeletedFunc()
518 catch /E933:/
519 n = 344
520 endtry
521 assert_equal(344, n)
Bram Moolenaard032f342020-07-18 18:13:02 +0200522
523 try
524 echo len(v:true)
525 catch /E701:/
526 n = 355
527 endtry
528 assert_equal(355, n)
529
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200530 var P = function('g:NoSuchFunc')
Bram Moolenaard032f342020-07-18 18:13:02 +0200531 delfunc g:NoSuchFunc
532 try
533 echo P()
534 catch /E117:/
535 n = 366
536 endtry
537 assert_equal(366, n)
538
539 try
540 echo g:NoSuchFunc()
541 catch /E117:/
542 n = 377
543 endtry
544 assert_equal(377, n)
545
546 try
547 echo g:alist + 4
548 catch /E745:/
549 n = 388
550 endtry
551 assert_equal(388, n)
552
553 try
554 echo 4 + g:alist
555 catch /E745:/
556 n = 399
557 endtry
558 assert_equal(399, n)
559
560 try
561 echo g:alist.member
562 catch /E715:/
563 n = 400
564 endtry
565 assert_equal(400, n)
566
567 try
568 echo d.member
569 catch /E716:/
570 n = 411
571 endtry
572 assert_equal(411, n)
Bram Moolenaard9d77892021-02-12 21:32:47 +0100573
574 var counter = 0
575 for i in range(4)
576 try
577 eval [][0]
578 catch
579 endtry
580 counter += 1
581 endfor
582 assert_equal(4, counter)
Bram Moolenaar7e82c5f2021-02-21 21:32:45 +0100583
584 # return in finally after empty catch
585 def ReturnInFinally(): number
586 try
587 finally
588 return 4
589 endtry
590 return 2
591 enddef
592 assert_equal(4, ReturnInFinally())
Bram Moolenaar8ac681a2021-06-15 20:06:34 +0200593
594 var lines =<< trim END
595 vim9script
596 try
597 acos('0.5')
598 ->setline(1)
599 catch
600 g:caught = v:exception
601 endtry
602 END
603 CheckScriptSuccess(lines)
604 assert_match('E808: Number or Float required', g:caught)
605 unlet g:caught
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100606enddef
607
Bram Moolenaar3f987b52021-06-30 12:02:24 +0200608def Test_try_in_catch()
609 var lines =<< trim END
610 vim9script
611 var seq = []
612 def DoIt()
613 try
614 seq->add('throw 1')
615 eval [][0]
616 seq->add('notreached')
617 catch
618 seq->add('catch')
619 try
620 seq->add('throw 2')
621 eval [][0]
622 seq->add('notreached')
623 catch /nothing/
624 seq->add('notreached')
625 endtry
626 seq->add('done')
627 endtry
628 enddef
629 DoIt()
630 assert_equal(['throw 1', 'catch', 'throw 2', 'done'], seq)
631 END
632enddef
633
Bram Moolenaard3d8fee2021-06-30 19:54:43 +0200634def Test_error_in_catch()
635 var lines =<< trim END
636 try
637 eval [][0]
638 catch /E684:/
639 eval [][0]
640 endtry
641 END
642 CheckDefExecFailure(lines, 'E684:', 4)
643enddef
644
Bram Moolenaar2e34c342021-03-14 12:13:33 +0100645" :while at the very start of a function that :continue jumps to
646def TryContinueFunc()
647 while g:Count < 2
648 g:sequence ..= 't'
649 try
650 echoerr 'Test'
651 catch
652 g:Count += 1
653 g:sequence ..= 'c'
654 continue
655 endtry
656 g:sequence ..= 'e'
657 g:Count += 1
658 endwhile
659enddef
660
661def Test_continue_in_try_in_while()
662 g:Count = 0
663 g:sequence = ''
664 TryContinueFunc()
665 assert_equal('tctc', g:sequence)
666 unlet g:Count
667 unlet g:sequence
668enddef
669
Bram Moolenaar9cb577a2021-02-22 22:45:10 +0100670def Test_nocatch_return_in_try()
671 # return in try block returns normally
672 def ReturnInTry(): string
673 try
674 return '"some message"'
675 catch
676 endtry
677 return 'not reached'
678 enddef
679 exe 'echoerr ' .. ReturnInTry()
680enddef
681
Bram Moolenaar1430cee2021-01-17 19:20:32 +0100682def Test_cnext_works_in_catch()
683 var lines =<< trim END
684 vim9script
685 au BufEnter * eval 0
686 writefile(['text'], 'Xfile1')
687 writefile(['text'], 'Xfile2')
688 var items = [
689 {lnum: 1, filename: 'Xfile1', valid: true},
690 {lnum: 1, filename: 'Xfile2', valid: true}
691 ]
692 setqflist([], ' ', {items: items})
693 cwindow
694
695 def CnextOrCfirst()
696 # if cnext fails, cfirst is used
697 try
698 cnext
699 catch
700 cfirst
701 endtry
702 enddef
703
704 CnextOrCfirst()
705 CnextOrCfirst()
706 writefile([getqflist({idx: 0}).idx], 'Xresult')
707 qall
708 END
709 writefile(lines, 'XCatchCnext')
710 RunVim([], [], '--clean -S XCatchCnext')
711 assert_equal(['1'], readfile('Xresult'))
712
713 delete('Xfile1')
714 delete('Xfile2')
715 delete('XCatchCnext')
716 delete('Xresult')
717enddef
718
Bram Moolenaar9e1d9e32021-01-11 20:17:34 +0100719def Test_throw_skipped()
720 if 0
721 throw dontgethere
722 endif
723enddef
724
Bram Moolenaar8f81b222021-01-14 21:47:06 +0100725def Test_nocatch_throw_silenced()
726 var lines =<< trim END
727 vim9script
728 def Func()
729 throw 'error'
730 enddef
731 silent! Func()
732 END
733 writefile(lines, 'XthrowSilenced')
734 source XthrowSilenced
735 delete('XthrowSilenced')
736enddef
737
Bram Moolenaare8593122020-07-18 15:17:02 +0200738def DeletedFunc(): list<any>
739 return ['delete me']
740enddef
741defcompile
742delfunc DeletedFunc
743
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100744def ThrowFromDef()
Bram Moolenaara72cfb82020-04-23 17:07:30 +0200745 throw "getout" # comment
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100746enddef
747
748func CatchInFunc()
749 try
750 call ThrowFromDef()
751 catch
752 let g:thrown_func = v:exception
753 endtry
754endfunc
755
756def CatchInDef()
757 try
758 ThrowFromDef()
759 catch
760 g:thrown_def = v:exception
761 endtry
762enddef
763
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100764def ReturnFinally(): string
765 try
766 return 'intry'
Bram Moolenaar373863e2020-09-26 17:20:53 +0200767 finall
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100768 g:in_finally = 'finally'
769 endtry
770 return 'end'
771enddef
772
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100773def Test_try_catch_nested()
774 CatchInFunc()
775 assert_equal('getout', g:thrown_func)
776
777 CatchInDef()
778 assert_equal('getout', g:thrown_def)
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100779
780 assert_equal('intry', ReturnFinally())
781 assert_equal('finally', g:in_finally)
Bram Moolenaard3d8fee2021-06-30 19:54:43 +0200782
783 var l = []
784 try
785 l->add('1')
786 throw 'bad'
787 l->add('x')
788 catch /bad/
789 l->add('2')
790 try
791 l->add('3')
792 throw 'one'
793 l->add('x')
794 catch /one/
795 l->add('4')
796 try
797 l->add('5')
798 throw 'more'
799 l->add('x')
800 catch /more/
801 l->add('6')
802 endtry
803 endtry
804 endtry
805 assert_equal(['1', '2', '3', '4', '5', '6'], l)
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100806enddef
807
Bram Moolenaar9939f572020-09-16 22:29:52 +0200808def TryOne(): number
809 try
810 return 0
811 catch
812 endtry
813 return 0
814enddef
815
816def TryTwo(n: number): string
817 try
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200818 var x = {}
Bram Moolenaar9939f572020-09-16 22:29:52 +0200819 catch
820 endtry
821 return 'text'
822enddef
823
824def Test_try_catch_twice()
825 assert_equal('text', TryOne()->TryTwo())
826enddef
827
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100828def Test_try_catch_match()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200829 var seq = 'a'
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100830 try
831 throw 'something'
832 catch /nothing/
833 seq ..= 'x'
834 catch /some/
835 seq ..= 'b'
836 catch /asdf/
837 seq ..= 'x'
Bram Moolenaare8c4abb2020-04-02 21:13:25 +0200838 catch ?a\?sdf?
839 seq ..= 'y'
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100840 finally
841 seq ..= 'c'
842 endtry
843 assert_equal('abc', seq)
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100844enddef
845
Bram Moolenaare8c4abb2020-04-02 21:13:25 +0200846def Test_try_catch_fails()
Bram Moolenaard2c61702020-09-06 15:58:36 +0200847 CheckDefFailure(['catch'], 'E603:')
848 CheckDefFailure(['try', 'echo 0', 'catch', 'catch'], 'E1033:')
849 CheckDefFailure(['try', 'echo 0', 'catch /pat'], 'E1067:')
850 CheckDefFailure(['finally'], 'E606:')
851 CheckDefFailure(['try', 'echo 0', 'finally', 'echo 1', 'finally'], 'E607:')
852 CheckDefFailure(['endtry'], 'E602:')
853 CheckDefFailure(['while 1', 'endtry'], 'E170:')
854 CheckDefFailure(['for i in range(5)', 'endtry'], 'E170:')
Bram Moolenaar13106602020-10-04 16:06:05 +0200855 CheckDefFailure(['if 1', 'endtry'], 'E171:')
Bram Moolenaard2c61702020-09-06 15:58:36 +0200856 CheckDefFailure(['try', 'echo 1', 'endtry'], 'E1032:')
Bram Moolenaar585fea72020-04-02 22:33:21 +0200857
Bram Moolenaare4984292020-12-13 14:19:25 +0100858 CheckDefFailure(['throw'], 'E1143:')
Bram Moolenaard2c61702020-09-06 15:58:36 +0200859 CheckDefFailure(['throw xxx'], 'E1001:')
Bram Moolenaare8c4abb2020-04-02 21:13:25 +0200860enddef
861
Bram Moolenaar7c5b3c0362021-02-14 22:40:57 +0100862def Try_catch_skipped()
863 var l = []
864 try
865 finally
866 endtry
867
868 if 1
869 else
870 try
871 endtry
872 endif
873enddef
874
875" The skipped try/endtry was updating the wrong instruction.
876def Test_try_catch_skipped()
877 var instr = execute('disassemble Try_catch_skipped')
878 assert_match("NEWLIST size 0\n", instr)
879enddef
880
881
882
Bram Moolenaar006ad482020-06-30 20:55:15 +0200883def Test_throw_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200884 # only checks line continuation
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200885 var lines =<< trim END
Bram Moolenaar006ad482020-06-30 20:55:15 +0200886 vim9script
887 try
888 throw 'one'
889 .. 'two'
890 catch
891 assert_equal('onetwo', v:exception)
892 endtry
893 END
894 CheckScriptSuccess(lines)
Bram Moolenaar1e021e62020-10-16 20:25:23 +0200895
896 lines =<< trim END
897 vim9script
Bram Moolenaar352134b2020-10-17 22:04:08 +0200898 @r = ''
Bram Moolenaar1e021e62020-10-16 20:25:23 +0200899 def Func()
900 throw @r
901 enddef
902 var result = ''
903 try
904 Func()
905 catch /E1129:/
906 result = 'caught'
907 endtry
908 assert_equal('caught', result)
909 END
910 CheckScriptSuccess(lines)
Bram Moolenaar006ad482020-06-30 20:55:15 +0200911enddef
912
Bram Moolenaared677f52020-08-12 16:38:10 +0200913def Test_error_in_nested_function()
Bram Moolenaar03dfde22021-02-14 13:17:22 +0100914 # an error in a nested :function aborts executing in the calling :def function
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200915 var lines =<< trim END
Bram Moolenaared677f52020-08-12 16:38:10 +0200916 vim9script
917 def Func()
918 Error()
919 g:test_var = 1
920 enddef
921 func Error() abort
922 eval [][0]
923 endfunc
924 Func()
925 END
926 g:test_var = 0
927 CheckScriptFailure(lines, 'E684:')
928 assert_equal(0, g:test_var)
929enddef
930
Bram Moolenaar227c58a2021-04-28 20:40:44 +0200931def Test_abort_after_error()
932 var lines =<< trim END
933 vim9script
934 while true
935 echo notfound
936 endwhile
937 g:gotthere = true
938 END
939 g:gotthere = false
940 CheckScriptFailure(lines, 'E121:')
941 assert_false(g:gotthere)
942 unlet g:gotthere
943enddef
944
Bram Moolenaar37c83712020-06-30 21:18:36 +0200945def Test_cexpr_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200946 # only checks line continuation
Bram Moolenaar37c83712020-06-30 21:18:36 +0200947 set errorformat=File\ %f\ line\ %l
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200948 var lines =<< trim END
Bram Moolenaar37c83712020-06-30 21:18:36 +0200949 vim9script
950 cexpr 'File'
951 .. ' someFile' ..
952 ' line 19'
953 assert_equal(19, getqflist()[0].lnum)
954 END
955 CheckScriptSuccess(lines)
956 set errorformat&
957enddef
958
Bram Moolenaarc9edd6b2020-08-12 22:18:23 +0200959def Test_statusline_syntax()
960 # legacy syntax is used for 'statusline'
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200961 var lines =<< trim END
Bram Moolenaarc9edd6b2020-08-12 22:18:23 +0200962 vim9script
963 func g:Status()
964 return '%{"x" is# "x"}'
965 endfunc
966 set laststatus=2 statusline=%!Status()
967 redrawstatus
968 set laststatus statusline=
969 END
970 CheckScriptSuccess(lines)
971enddef
972
Bram Moolenaarb2097502020-07-19 17:17:02 +0200973def Test_list_vimscript()
974 # checks line continuation and comments
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200975 var lines =<< trim END
Bram Moolenaarb2097502020-07-19 17:17:02 +0200976 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200977 var mylist = [
Bram Moolenaarb2097502020-07-19 17:17:02 +0200978 'one',
979 # comment
980 'two', # empty line follows
981
982 'three',
983 ]
984 assert_equal(['one', 'two', 'three'], mylist)
985 END
986 CheckScriptSuccess(lines)
Bram Moolenaar66250c92020-08-20 15:02:42 +0200987
988 # check all lines from heredoc are kept
989 lines =<< trim END
990 # comment 1
991 two
992 # comment 3
993
994 five
995 # comment 6
996 END
997 assert_equal(['# comment 1', 'two', '# comment 3', '', 'five', '# comment 6'], lines)
Bram Moolenaar4bce26b2021-01-22 22:06:56 +0100998
999 lines =<< trim END
1000 [{
1001 a: 0}]->string()->assert_equal("[{'a': 0}]")
1002 END
1003 CheckDefAndScriptSuccess(lines)
Bram Moolenaarb2097502020-07-19 17:17:02 +02001004enddef
1005
Bram Moolenaar2a1381c2020-05-05 23:32:58 +02001006if has('channel')
1007 let someJob = test_null_job()
Bram Moolenaar40ee4662020-05-05 22:08:26 +02001008
Bram Moolenaar2a1381c2020-05-05 23:32:58 +02001009 def FuncWithError()
1010 echomsg g:someJob
1011 enddef
Bram Moolenaar40ee4662020-05-05 22:08:26 +02001012
Bram Moolenaar2a1381c2020-05-05 23:32:58 +02001013 func Test_convert_emsg_to_exception()
1014 try
1015 call FuncWithError()
1016 catch
1017 call assert_match('Vim:E908:', v:exception)
1018 endtry
1019 endfunc
1020endif
Bram Moolenaar40ee4662020-05-05 22:08:26 +02001021
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001022let s:export_script_lines =<< trim END
1023 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001024 var name: string = 'bob'
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001025 def Concat(arg: string): string
1026 return name .. arg
1027 enddef
Bram Moolenaar227a69d2020-05-15 18:17:28 +02001028 g:result = Concat('bie')
1029 g:localname = name
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001030
1031 export const CONST = 1234
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001032 export var exported = 9876
1033 export var exp_name = 'John'
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001034 export def Exported(): string
1035 return 'Exported'
1036 enddef
Bram Moolenaar0f2a5cc2021-02-27 22:33:21 +01001037 export final theList = [1]
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001038END
1039
Bram Moolenaarb3ca9822020-08-09 14:43:58 +02001040def Undo_export_script_lines()
1041 unlet g:result
1042 unlet g:localname
1043enddef
1044
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001045def Test_vim9_import_export()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001046 var import_script_lines =<< trim END
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001047 vim9script
1048 import {exported, Exported} from './Xexport.vim'
1049 g:imported = exported
Bram Moolenaar6e587dc2020-02-06 13:15:52 +01001050 exported += 3
1051 g:imported_added = exported
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001052 g:imported_func = Exported()
Bram Moolenaar6e587dc2020-02-06 13:15:52 +01001053
Bram Moolenaar40f4f7a2020-07-23 22:41:43 +02001054 def GetExported(): string
Bram Moolenaare0de1712020-12-02 17:36:54 +01001055 var local_dict = {ref: Exported}
Bram Moolenaar40f4f7a2020-07-23 22:41:43 +02001056 return local_dict.ref()
1057 enddef
1058 g:funcref_result = GetExported()
1059
Bram Moolenaar6e587dc2020-02-06 13:15:52 +01001060 import {exp_name} from './Xexport.vim'
1061 g:imported_name = exp_name
1062 exp_name ..= ' Doe'
1063 g:imported_name_appended = exp_name
Bram Moolenaar5381c7a2020-03-02 22:53:32 +01001064 g:imported_later = exported
Bram Moolenaar0f2a5cc2021-02-27 22:33:21 +01001065
1066 import theList from './Xexport.vim'
1067 theList->add(2)
1068 assert_equal([1, 2], theList)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001069 END
1070
1071 writefile(import_script_lines, 'Ximport.vim')
1072 writefile(s:export_script_lines, 'Xexport.vim')
1073
1074 source Ximport.vim
1075
1076 assert_equal('bobbie', g:result)
1077 assert_equal('bob', g:localname)
1078 assert_equal(9876, g:imported)
Bram Moolenaar6e587dc2020-02-06 13:15:52 +01001079 assert_equal(9879, g:imported_added)
Bram Moolenaar5381c7a2020-03-02 22:53:32 +01001080 assert_equal(9879, g:imported_later)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001081 assert_equal('Exported', g:imported_func)
Bram Moolenaar40f4f7a2020-07-23 22:41:43 +02001082 assert_equal('Exported', g:funcref_result)
Bram Moolenaar6e587dc2020-02-06 13:15:52 +01001083 assert_equal('John', g:imported_name)
1084 assert_equal('John Doe', g:imported_name_appended)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001085 assert_false(exists('g:name'))
1086
Bram Moolenaarb3ca9822020-08-09 14:43:58 +02001087 Undo_export_script_lines()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001088 unlet g:imported
Bram Moolenaar6e587dc2020-02-06 13:15:52 +01001089 unlet g:imported_added
Bram Moolenaar5381c7a2020-03-02 22:53:32 +01001090 unlet g:imported_later
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001091 unlet g:imported_func
Bram Moolenaar6e587dc2020-02-06 13:15:52 +01001092 unlet g:imported_name g:imported_name_appended
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001093 delete('Ximport.vim')
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01001094
Bram Moolenaar1c991142020-07-04 13:15:31 +02001095 # similar, with line breaks
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001096 var import_line_break_script_lines =<< trim END
Bram Moolenaar1c991142020-07-04 13:15:31 +02001097 vim9script
1098 import {
1099 exported,
1100 Exported,
1101 }
1102 from
1103 './Xexport.vim'
1104 g:imported = exported
1105 exported += 5
1106 g:imported_added = exported
1107 g:imported_func = Exported()
1108 END
1109 writefile(import_line_break_script_lines, 'Ximport_lbr.vim')
1110 source Ximport_lbr.vim
1111
1112 assert_equal(9876, g:imported)
1113 assert_equal(9881, g:imported_added)
1114 assert_equal('Exported', g:imported_func)
1115
1116 # exported script not sourced again
1117 assert_false(exists('g:result'))
1118 unlet g:imported
1119 unlet g:imported_added
1120 unlet g:imported_func
1121 delete('Ximport_lbr.vim')
1122
1123 # import inside :def function
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001124 var import_in_def_lines =<< trim END
Bram Moolenaar5381c7a2020-03-02 22:53:32 +01001125 vim9script
1126 def ImportInDef()
1127 import exported from './Xexport.vim'
1128 g:imported = exported
1129 exported += 7
1130 g:imported_added = exported
1131 enddef
1132 ImportInDef()
1133 END
1134 writefile(import_in_def_lines, 'Ximport2.vim')
1135 source Ximport2.vim
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001136 # TODO: this should be 9879
Bram Moolenaar5381c7a2020-03-02 22:53:32 +01001137 assert_equal(9876, g:imported)
1138 assert_equal(9883, g:imported_added)
1139 unlet g:imported
1140 unlet g:imported_added
1141 delete('Ximport2.vim')
1142
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001143 var import_star_as_lines =<< trim END
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01001144 vim9script
1145 import * as Export from './Xexport.vim'
1146 def UseExport()
Bram Moolenaarcb4e80f2021-03-13 20:57:19 +01001147 g:imported_def = Export.exported
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01001148 enddef
Bram Moolenaarcb4e80f2021-03-13 20:57:19 +01001149 g:imported_script = Export.exported
1150 assert_equal(1, exists('Export.exported'))
1151 assert_equal(0, exists('Export.notexported'))
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01001152 UseExport()
1153 END
1154 writefile(import_star_as_lines, 'Ximport.vim')
1155 source Ximport.vim
Bram Moolenaarcb4e80f2021-03-13 20:57:19 +01001156 assert_equal(9883, g:imported_def)
1157 assert_equal(9883, g:imported_script)
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01001158
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001159 var import_star_as_lines_no_dot =<< trim END
Bram Moolenaar599c89c2020-03-28 14:53:20 +01001160 vim9script
1161 import * as Export from './Xexport.vim'
1162 def Func()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001163 var dummy = 1
1164 var imported = Export + dummy
Bram Moolenaar599c89c2020-03-28 14:53:20 +01001165 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +02001166 defcompile
Bram Moolenaar599c89c2020-03-28 14:53:20 +01001167 END
1168 writefile(import_star_as_lines_no_dot, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001169 assert_fails('source Ximport.vim', 'E1060:', '', 2, 'Func')
Bram Moolenaar599c89c2020-03-28 14:53:20 +01001170
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001171 var import_star_as_lines_dot_space =<< trim END
Bram Moolenaar599c89c2020-03-28 14:53:20 +01001172 vim9script
1173 import * as Export from './Xexport.vim'
1174 def Func()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001175 var imported = Export . exported
Bram Moolenaar599c89c2020-03-28 14:53:20 +01001176 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +02001177 defcompile
Bram Moolenaar599c89c2020-03-28 14:53:20 +01001178 END
1179 writefile(import_star_as_lines_dot_space, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001180 assert_fails('source Ximport.vim', 'E1074:', '', 1, 'Func')
Bram Moolenaar599c89c2020-03-28 14:53:20 +01001181
Bram Moolenaara6294952020-12-27 13:39:50 +01001182 var import_star_as_duplicated =<< trim END
1183 vim9script
1184 import * as Export from './Xexport.vim'
1185 var some = 'other'
1186 import * as Export from './Xexport.vim'
1187 defcompile
1188 END
1189 writefile(import_star_as_duplicated, 'Ximport.vim')
1190 assert_fails('source Ximport.vim', 'E1073:', '', 4, 'Ximport.vim')
1191
Bram Moolenaarcb4e80f2021-03-13 20:57:19 +01001192 var import_star_as_lines_script_no_dot =<< trim END
1193 vim9script
1194 import * as Export from './Xexport.vim'
1195 g:imported_script = Export exported
1196 END
1197 writefile(import_star_as_lines_script_no_dot, 'Ximport.vim')
1198 assert_fails('source Ximport.vim', 'E1029:')
1199
1200 var import_star_as_lines_script_space_after_dot =<< trim END
1201 vim9script
1202 import * as Export from './Xexport.vim'
1203 g:imported_script = Export. exported
1204 END
1205 writefile(import_star_as_lines_script_space_after_dot, 'Ximport.vim')
1206 assert_fails('source Ximport.vim', 'E1074:')
1207
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001208 var import_star_as_lines_missing_name =<< trim END
Bram Moolenaar599c89c2020-03-28 14:53:20 +01001209 vim9script
1210 import * as Export from './Xexport.vim'
1211 def Func()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001212 var imported = Export.
Bram Moolenaar599c89c2020-03-28 14:53:20 +01001213 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +02001214 defcompile
Bram Moolenaar599c89c2020-03-28 14:53:20 +01001215 END
1216 writefile(import_star_as_lines_missing_name, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001217 assert_fails('source Ximport.vim', 'E1048:', '', 1, 'Func')
Bram Moolenaar599c89c2020-03-28 14:53:20 +01001218
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001219 var import_star_as_lbr_lines =<< trim END
Bram Moolenaar1c991142020-07-04 13:15:31 +02001220 vim9script
1221 import *
1222 as Export
1223 from
1224 './Xexport.vim'
1225 def UseExport()
1226 g:imported = Export.exported
1227 enddef
1228 UseExport()
1229 END
1230 writefile(import_star_as_lbr_lines, 'Ximport.vim')
1231 source Ximport.vim
1232 assert_equal(9883, g:imported)
1233
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001234 var import_star_lines =<< trim END
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01001235 vim9script
1236 import * from './Xexport.vim'
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01001237 END
1238 writefile(import_star_lines, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001239 assert_fails('source Ximport.vim', 'E1045:', '', 2, 'Ximport.vim')
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01001240
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001241 # try to import something that exists but is not exported
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001242 var import_not_exported_lines =<< trim END
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001243 vim9script
1244 import name from './Xexport.vim'
1245 END
1246 writefile(import_not_exported_lines, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001247 assert_fails('source Ximport.vim', 'E1049:', '', 2, 'Ximport.vim')
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001248
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001249 # try to import something that is already defined
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001250 var import_already_defined =<< trim END
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001251 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001252 var exported = 'something'
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001253 import exported from './Xexport.vim'
1254 END
1255 writefile(import_already_defined, 'Ximport.vim')
Bram Moolenaar057e84a2021-02-28 16:55:11 +01001256 assert_fails('source Ximport.vim', 'E1054:', '', 3, 'Ximport.vim')
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001257
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001258 # try to import something that is already defined
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001259 import_already_defined =<< trim END
1260 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001261 var exported = 'something'
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001262 import * as exported from './Xexport.vim'
1263 END
1264 writefile(import_already_defined, 'Ximport.vim')
Bram Moolenaar057e84a2021-02-28 16:55:11 +01001265 assert_fails('source Ximport.vim', 'E1054:', '', 3, 'Ximport.vim')
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001266
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001267 # try to import something that is already defined
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001268 import_already_defined =<< trim END
1269 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001270 var exported = 'something'
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001271 import {exported} from './Xexport.vim'
1272 END
1273 writefile(import_already_defined, 'Ximport.vim')
Bram Moolenaar057e84a2021-02-28 16:55:11 +01001274 assert_fails('source Ximport.vim', 'E1054:', '', 3, 'Ximport.vim')
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001275
Bram Moolenaar918a4242020-12-06 14:37:08 +01001276 # try changing an imported const
1277 var import_assign_to_const =<< trim END
1278 vim9script
1279 import CONST from './Xexport.vim'
1280 def Assign()
1281 CONST = 987
1282 enddef
1283 defcompile
1284 END
1285 writefile(import_assign_to_const, 'Ximport.vim')
1286 assert_fails('source Ximport.vim', 'E46:', '', 1, '_Assign')
1287
Bram Moolenaar0f2a5cc2021-02-27 22:33:21 +01001288 # try changing an imported final
1289 var import_assign_to_final =<< trim END
1290 vim9script
1291 import theList from './Xexport.vim'
1292 def Assign()
1293 theList = [2]
1294 enddef
1295 defcompile
1296 END
1297 writefile(import_assign_to_final, 'Ximport.vim')
1298 assert_fails('source Ximport.vim', 'E46:', '', 1, '_Assign')
1299
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001300 # import a very long name, requires making a copy
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001301 var import_long_name_lines =<< trim END
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001302 vim9script
1303 import name012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789 from './Xexport.vim'
1304 END
1305 writefile(import_long_name_lines, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001306 assert_fails('source Ximport.vim', 'E1048:', '', 2, 'Ximport.vim')
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001307
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001308 var import_no_from_lines =<< trim END
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001309 vim9script
1310 import name './Xexport.vim'
1311 END
1312 writefile(import_no_from_lines, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001313 assert_fails('source Ximport.vim', 'E1070:', '', 2, 'Ximport.vim')
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001314
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001315 var import_invalid_string_lines =<< trim END
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001316 vim9script
1317 import name from Xexport.vim
1318 END
1319 writefile(import_invalid_string_lines, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001320 assert_fails('source Ximport.vim', 'E1071:', '', 2, 'Ximport.vim')
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001321
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001322 var import_wrong_name_lines =<< trim END
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001323 vim9script
1324 import name from './XnoExport.vim'
1325 END
1326 writefile(import_wrong_name_lines, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001327 assert_fails('source Ximport.vim', 'E1053:', '', 2, 'Ximport.vim')
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001328
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001329 var import_missing_comma_lines =<< trim END
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001330 vim9script
1331 import {exported name} from './Xexport.vim'
1332 END
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001333 writefile(import_missing_comma_lines, 'Ximport3.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001334 assert_fails('source Ximport3.vim', 'E1046:', '', 2, 'Ximport3.vim')
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001335
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01001336 delete('Ximport.vim')
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001337 delete('Ximport3.vim')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001338 delete('Xexport.vim')
1339
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001340 # Check that in a Vim9 script 'cpo' is set to the Vim default.
Bram Moolenaar3e191692021-03-17 17:46:00 +01001341 # Flags added or removed are also applied to the restored value.
1342 set cpo=abcd
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001343 var lines =<< trim END
Bram Moolenaar750802b2020-02-23 18:08:33 +01001344 vim9script
1345 g:cpo_in_vim9script = &cpo
Bram Moolenaar3e191692021-03-17 17:46:00 +01001346 set cpo+=f
1347 set cpo-=c
1348 g:cpo_after_vim9script = &cpo
Bram Moolenaar750802b2020-02-23 18:08:33 +01001349 END
1350 writefile(lines, 'Xvim9_script')
1351 source Xvim9_script
Bram Moolenaar3e191692021-03-17 17:46:00 +01001352 assert_equal('fabd', &cpo)
Bram Moolenaar750802b2020-02-23 18:08:33 +01001353 set cpo&vim
1354 assert_equal(&cpo, g:cpo_in_vim9script)
Bram Moolenaar3e191692021-03-17 17:46:00 +01001355 var newcpo = substitute(&cpo, 'c', '', '') .. 'f'
1356 assert_equal(newcpo, g:cpo_after_vim9script)
1357
Bram Moolenaar750802b2020-02-23 18:08:33 +01001358 delete('Xvim9_script')
1359enddef
1360
Bram Moolenaar0a842842021-02-27 22:41:19 +01001361def Test_import_as()
1362 var export_lines =<< trim END
1363 vim9script
1364 export var one = 1
1365 export var yes = 'yes'
1366 END
1367 writefile(export_lines, 'XexportAs')
1368
1369 var import_lines =<< trim END
1370 vim9script
Bram Moolenaar6c7cc342021-04-17 16:38:50 +02001371 var one = 'notused'
1372 var yes = 777
Bram Moolenaar0a842842021-02-27 22:41:19 +01001373 import one as thatOne from './XexportAs'
1374 assert_equal(1, thatOne)
1375 import yes as yesYes from './XexportAs'
1376 assert_equal('yes', yesYes)
1377 END
1378 CheckScriptSuccess(import_lines)
1379
1380 import_lines =<< trim END
1381 vim9script
1382 import {one as thatOne, yes as yesYes} from './XexportAs'
1383 assert_equal(1, thatOne)
1384 assert_equal('yes', yesYes)
1385 assert_fails('echo one', 'E121:')
1386 assert_fails('echo yes', 'E121:')
1387 END
1388 CheckScriptSuccess(import_lines)
1389
1390 delete('XexportAs')
1391enddef
1392
Bram Moolenaar803af682020-08-05 16:20:03 +02001393func g:Trigger()
1394 source Ximport.vim
1395 return "echo 'yes'\<CR>"
1396endfunc
1397
1398def Test_import_export_expr_map()
1399 # check that :import and :export work when buffer is locked
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001400 var export_lines =<< trim END
Bram Moolenaar803af682020-08-05 16:20:03 +02001401 vim9script
1402 export def That(): string
1403 return 'yes'
1404 enddef
1405 END
1406 writefile(export_lines, 'Xexport_that.vim')
1407
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001408 var import_lines =<< trim END
Bram Moolenaar803af682020-08-05 16:20:03 +02001409 vim9script
1410 import That from './Xexport_that.vim'
1411 assert_equal('yes', That())
1412 END
1413 writefile(import_lines, 'Ximport.vim')
1414
1415 nnoremap <expr> trigger g:Trigger()
1416 feedkeys('trigger', "xt")
1417
Bram Moolenaar730b2482020-08-09 13:02:10 +02001418 delete('Xexport_that.vim')
Bram Moolenaar803af682020-08-05 16:20:03 +02001419 delete('Ximport.vim')
1420 nunmap trigger
1421enddef
1422
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001423def Test_import_in_filetype()
1424 # check that :import works when the buffer is locked
1425 mkdir('ftplugin', 'p')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001426 var export_lines =<< trim END
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001427 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001428 export var That = 'yes'
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001429 END
Bram Moolenaar730b2482020-08-09 13:02:10 +02001430 writefile(export_lines, 'ftplugin/Xexport_ft.vim')
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001431
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001432 var import_lines =<< trim END
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001433 vim9script
Bram Moolenaar730b2482020-08-09 13:02:10 +02001434 import That from './Xexport_ft.vim'
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001435 assert_equal('yes', That)
1436 g:did_load_mytpe = 1
1437 END
1438 writefile(import_lines, 'ftplugin/qf.vim')
1439
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001440 var save_rtp = &rtp
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001441 &rtp = getcwd() .. ',' .. &rtp
1442
1443 filetype plugin on
1444 copen
1445 assert_equal(1, g:did_load_mytpe)
1446
1447 quit!
Bram Moolenaar730b2482020-08-09 13:02:10 +02001448 delete('Xexport_ft.vim')
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001449 delete('ftplugin', 'rf')
1450 &rtp = save_rtp
1451enddef
1452
Bram Moolenaarefa94442020-08-08 22:16:00 +02001453def Test_use_import_in_mapping()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001454 var lines =<< trim END
Bram Moolenaarefa94442020-08-08 22:16:00 +02001455 vim9script
1456 export def Funcx()
1457 g:result = 42
1458 enddef
1459 END
1460 writefile(lines, 'XsomeExport.vim')
1461 lines =<< trim END
1462 vim9script
1463 import Funcx from './XsomeExport.vim'
Bram Moolenaarb3ca9822020-08-09 14:43:58 +02001464 nnoremap <F3> :call <sid>Funcx()<cr>
Bram Moolenaarefa94442020-08-08 22:16:00 +02001465 END
1466 writefile(lines, 'Xmapscript.vim')
1467
1468 source Xmapscript.vim
Bram Moolenaarb3ca9822020-08-09 14:43:58 +02001469 feedkeys("\<F3>", "xt")
Bram Moolenaarefa94442020-08-08 22:16:00 +02001470 assert_equal(42, g:result)
1471
1472 unlet g:result
1473 delete('XsomeExport.vim')
1474 delete('Xmapscript.vim')
Bram Moolenaarb3ca9822020-08-09 14:43:58 +02001475 nunmap <F3>
Bram Moolenaarefa94442020-08-08 22:16:00 +02001476enddef
1477
Bram Moolenaard3f8a9e2021-02-17 21:57:03 +01001478def Test_vim9script_mix()
1479 var lines =<< trim END
1480 if has(g:feature)
1481 " legacy script
1482 let g:legacy = 1
1483 finish
1484 endif
1485 vim9script
1486 g:legacy = 0
1487 END
1488 g:feature = 'eval'
1489 g:legacy = -1
1490 CheckScriptSuccess(lines)
1491 assert_equal(1, g:legacy)
1492
1493 g:feature = 'noteval'
1494 g:legacy = -1
1495 CheckScriptSuccess(lines)
1496 assert_equal(0, g:legacy)
1497enddef
1498
Bram Moolenaar750802b2020-02-23 18:08:33 +01001499def Test_vim9script_fails()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001500 CheckScriptFailure(['scriptversion 2', 'vim9script'], 'E1039:')
1501 CheckScriptFailure(['vim9script', 'scriptversion 2'], 'E1040:')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001502 CheckScriptFailure(['export var some = 123'], 'E1042:')
Bram Moolenaar9721fb42020-06-11 23:10:46 +02001503 CheckScriptFailure(['import some from "./Xexport.vim"'], 'E1048:')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001504 CheckScriptFailure(['vim9script', 'export var g:some'], 'E1022:')
Bram Moolenaar750802b2020-02-23 18:08:33 +01001505 CheckScriptFailure(['vim9script', 'export echo 134'], 'E1043:')
1506
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001507 CheckScriptFailure(['vim9script', 'var str: string', 'str = 1234'], 'E1012:')
Bram Moolenaarc785b9a2020-06-19 18:34:15 +02001508 CheckScriptFailure(['vim9script', 'const str = "asdf"', 'str = "xxx"'], 'E46:')
1509
Bram Moolenaare2e40752020-09-04 21:18:46 +02001510 assert_fails('vim9script', 'E1038:')
1511 assert_fails('export something', 'E1043:')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001512enddef
1513
Bram Moolenaarf7d267e2020-06-17 12:04:54 +02001514func Test_import_fails_without_script()
Bram Moolenaar101f4812020-06-16 23:18:51 +02001515 CheckRunVimInTerminal
1516
Bram Moolenaar9bb3eb32020-06-17 20:03:36 +02001517 " call indirectly to avoid compilation error for missing functions
Bram Moolenaarc620c052020-07-08 15:16:19 +02001518 call Run_Test_import_fails_on_command_line()
Bram Moolenaar9bb3eb32020-06-17 20:03:36 +02001519endfunc
1520
Bram Moolenaarc620c052020-07-08 15:16:19 +02001521def Run_Test_import_fails_on_command_line()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001522 var export =<< trim END
Bram Moolenaar101f4812020-06-16 23:18:51 +02001523 vim9script
1524 export def Foo(): number
1525 return 0
1526 enddef
1527 END
Bram Moolenaar730b2482020-08-09 13:02:10 +02001528 writefile(export, 'XexportCmd.vim')
Bram Moolenaar101f4812020-06-16 23:18:51 +02001529
Bram Moolenaare0de1712020-12-02 17:36:54 +01001530 var buf = RunVimInTerminal('-c "import Foo from ''./XexportCmd.vim''"', {
Bram Moolenaar9bb3eb32020-06-17 20:03:36 +02001531 rows: 6, wait_for_ruler: 0})
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001532 WaitForAssert(() => assert_match('^E1094:', term_getline(buf, 5)))
Bram Moolenaar101f4812020-06-16 23:18:51 +02001533
Bram Moolenaar730b2482020-08-09 13:02:10 +02001534 delete('XexportCmd.vim')
Bram Moolenaar9bb3eb32020-06-17 20:03:36 +02001535 StopVimInTerminal(buf)
1536enddef
Bram Moolenaar101f4812020-06-16 23:18:51 +02001537
Bram Moolenaar2b327002020-12-26 15:39:31 +01001538def Test_vim9script_reload_noclear()
1539 var lines =<< trim END
Bram Moolenaara6294952020-12-27 13:39:50 +01001540 vim9script
1541 export var exported = 'thexport'
1542 END
1543 writefile(lines, 'XExportReload')
1544 lines =<< trim END
Bram Moolenaar2b327002020-12-26 15:39:31 +01001545 vim9script noclear
1546 g:loadCount += 1
1547 var s:reloaded = 'init'
Bram Moolenaara6294952020-12-27 13:39:50 +01001548 import exported from './XExportReload'
Bram Moolenaar2b327002020-12-26 15:39:31 +01001549
1550 def Again(): string
1551 return 'again'
1552 enddef
1553
1554 if exists('s:loaded') | finish | endif
1555 var s:loaded = true
1556
1557 var s:notReloaded = 'yes'
1558 s:reloaded = 'first'
1559 def g:Values(): list<string>
Bram Moolenaara6294952020-12-27 13:39:50 +01001560 return [s:reloaded, s:notReloaded, Again(), Once(), exported]
Bram Moolenaar2b327002020-12-26 15:39:31 +01001561 enddef
1562
1563 def Once(): string
1564 return 'once'
1565 enddef
1566 END
1567 writefile(lines, 'XReloaded')
1568 g:loadCount = 0
1569 source XReloaded
1570 assert_equal(1, g:loadCount)
Bram Moolenaara6294952020-12-27 13:39:50 +01001571 assert_equal(['first', 'yes', 'again', 'once', 'thexport'], g:Values())
Bram Moolenaar2b327002020-12-26 15:39:31 +01001572 source XReloaded
1573 assert_equal(2, g:loadCount)
Bram Moolenaara6294952020-12-27 13:39:50 +01001574 assert_equal(['init', 'yes', 'again', 'once', 'thexport'], g:Values())
Bram Moolenaar2b327002020-12-26 15:39:31 +01001575 source XReloaded
1576 assert_equal(3, g:loadCount)
Bram Moolenaara6294952020-12-27 13:39:50 +01001577 assert_equal(['init', 'yes', 'again', 'once', 'thexport'], g:Values())
Bram Moolenaar2b327002020-12-26 15:39:31 +01001578
Bram Moolenaar48e11c12021-01-11 18:47:00 +01001579 delete('XReloaded')
Bram Moolenaara6294952020-12-27 13:39:50 +01001580 delete('XExportReload')
Bram Moolenaar2b327002020-12-26 15:39:31 +01001581 delfunc g:Values
Bram Moolenaar2b327002020-12-26 15:39:31 +01001582 unlet g:loadCount
Bram Moolenaar577dc932021-06-27 15:35:40 +02001583
1584 lines =<< trim END
1585 vim9script
1586 def Inner()
1587 enddef
1588 END
1589 lines->writefile('XreloadScript.vim')
1590 source XreloadScript.vim
1591
1592 lines =<< trim END
1593 vim9script
1594 def Outer()
1595 def Inner()
1596 enddef
1597 enddef
1598 defcompile
1599 END
1600 lines->writefile('XreloadScript.vim')
1601 source XreloadScript.vim
1602
1603 delete('XreloadScript.vim')
Bram Moolenaar2b327002020-12-26 15:39:31 +01001604enddef
1605
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001606def Test_vim9script_reload_import()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001607 var lines =<< trim END
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001608 vim9script
1609 const var = ''
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001610 var valone = 1234
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001611 def MyFunc(arg: string)
1612 valone = 5678
1613 enddef
1614 END
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001615 var morelines =<< trim END
1616 var valtwo = 222
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001617 export def GetValtwo(): number
1618 return valtwo
1619 enddef
1620 END
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001621 writefile(lines + morelines, 'Xreload.vim')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001622 source Xreload.vim
1623 source Xreload.vim
1624 source Xreload.vim
1625
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001626 var testlines =<< trim END
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001627 vim9script
1628 def TheFunc()
1629 import GetValtwo from './Xreload.vim'
1630 assert_equal(222, GetValtwo())
1631 enddef
1632 TheFunc()
1633 END
1634 writefile(testlines, 'Ximport.vim')
1635 source Ximport.vim
1636
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001637 # Test that when not using "morelines" GetValtwo() and valtwo are still
1638 # defined, because import doesn't reload a script.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001639 writefile(lines, 'Xreload.vim')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001640 source Ximport.vim
1641
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001642 # cannot declare a var twice
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001643 lines =<< trim END
1644 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001645 var valone = 1234
1646 var valone = 5678
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001647 END
1648 writefile(lines, 'Xreload.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001649 assert_fails('source Xreload.vim', 'E1041:', '', 3, 'Xreload.vim')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001650
1651 delete('Xreload.vim')
1652 delete('Ximport.vim')
1653enddef
1654
Bram Moolenaar07a65d22020-12-26 20:09:15 +01001655" if a script is reloaded with a script-local variable that changed its type, a
1656" compiled function using that variable must fail.
1657def Test_script_reload_change_type()
1658 var lines =<< trim END
1659 vim9script noclear
1660 var str = 'string'
1661 def g:GetStr(): string
1662 return str .. 'xxx'
1663 enddef
1664 END
1665 writefile(lines, 'Xreload.vim')
1666 source Xreload.vim
1667 echo g:GetStr()
1668
1669 lines =<< trim END
1670 vim9script noclear
1671 var str = 1234
1672 END
1673 writefile(lines, 'Xreload.vim')
1674 source Xreload.vim
1675 assert_fails('echo g:GetStr()', 'E1150:')
1676
1677 delfunc g:GetStr
1678 delete('Xreload.vim')
1679enddef
1680
Bram Moolenaarc970e422021-03-17 15:03:04 +01001681" Define CallFunc so that the test can be compiled
1682command CallFunc echo 'nop'
1683
1684def Test_script_reload_from_function()
1685 var lines =<< trim END
1686 vim9script
1687
1688 if exists('g:loaded')
1689 finish
1690 endif
1691 g:loaded = 1
1692 delcommand CallFunc
1693 command CallFunc Func()
1694 def Func()
Bram Moolenaara4c81be2021-03-17 15:23:16 +01001695 so XreloadFunc.vim
Bram Moolenaarc970e422021-03-17 15:03:04 +01001696 g:didTheFunc = 1
1697 enddef
1698 END
1699 writefile(lines, 'XreloadFunc.vim')
1700 source XreloadFunc.vim
1701 CallFunc
1702 assert_equal(1, g:didTheFunc)
1703
1704 delete('XreloadFunc.vim')
1705 delcommand CallFunc
1706 unlet g:loaded
1707 unlet g:didTheFunc
1708enddef
1709
Bram Moolenaar6c3843c2021-03-04 12:38:21 +01001710def Test_script_var_shadows_function()
1711 var lines =<< trim END
1712 vim9script
1713 def Func(): number
1714 return 123
1715 enddef
1716 var Func = 1
1717 END
1718 CheckScriptFailure(lines, 'E1041:', 5)
1719enddef
1720
Bram Moolenaar95006e32020-08-29 17:47:08 +02001721def s:RetSome(): string
1722 return 'some'
1723enddef
1724
Bram Moolenaarfe465a02020-07-07 22:50:12 +02001725" Not exported function that is referenced needs to be accessed by the
1726" script-local name.
1727def Test_vim9script_funcref()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001728 var sortlines =<< trim END
Bram Moolenaarfe465a02020-07-07 22:50:12 +02001729 vim9script
1730 def Compare(i1: number, i2: number): number
Bram Moolenaarbed36b92020-07-07 23:31:36 +02001731 return i2 - i1
Bram Moolenaarfe465a02020-07-07 22:50:12 +02001732 enddef
1733
1734 export def FastSort(): list<number>
1735 return range(5)->sort(Compare)
1736 enddef
Bram Moolenaar529fb5a2021-04-01 12:57:57 +02001737
1738 export def GetString(arg: string): string
1739 return arg
1740 enddef
Bram Moolenaarfe465a02020-07-07 22:50:12 +02001741 END
1742 writefile(sortlines, 'Xsort.vim')
1743
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001744 var lines =<< trim END
Bram Moolenaarfe465a02020-07-07 22:50:12 +02001745 vim9script
1746 import FastSort from './Xsort.vim'
1747 def Test()
1748 g:result = FastSort()
1749 enddef
1750 Test()
Bram Moolenaar529fb5a2021-04-01 12:57:57 +02001751
1752 # using a function imported with "as"
1753 import * as anAlias from './Xsort.vim'
1754 assert_equal('yes', anAlias.GetString('yes'))
1755
1756 # using the function from a compiled function
1757 def TestMore(): string
Bram Moolenaarca51cc02021-04-01 21:38:53 +02001758 var s = s:anAlias.GetString('foo')
1759 return s .. anAlias.GetString('bar')
Bram Moolenaar529fb5a2021-04-01 12:57:57 +02001760 enddef
Bram Moolenaarca51cc02021-04-01 21:38:53 +02001761 assert_equal('foobar', TestMore())
Bram Moolenaar529fb5a2021-04-01 12:57:57 +02001762
1763 # error when using a function that isn't exported
1764 assert_fails('anAlias.Compare(1, 2)', 'E1049:')
Bram Moolenaarfe465a02020-07-07 22:50:12 +02001765 END
1766 writefile(lines, 'Xscript.vim')
1767
1768 source Xscript.vim
1769 assert_equal([4, 3, 2, 1, 0], g:result)
1770
1771 unlet g:result
1772 delete('Xsort.vim')
1773 delete('Xscript.vim')
Bram Moolenaar95006e32020-08-29 17:47:08 +02001774
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001775 var Funcref = function('s:RetSome')
Bram Moolenaar95006e32020-08-29 17:47:08 +02001776 assert_equal('some', Funcref())
Bram Moolenaarfe465a02020-07-07 22:50:12 +02001777enddef
1778
Bram Moolenaar601e76a2020-08-27 21:33:10 +02001779" Check that when searching for "FilterFunc" it finds the import in the
1780" script where FastFilter() is called from, both as a string and as a direct
1781" function reference.
Bram Moolenaarc620c052020-07-08 15:16:19 +02001782def Test_vim9script_funcref_other_script()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001783 var filterLines =<< trim END
Bram Moolenaarc620c052020-07-08 15:16:19 +02001784 vim9script
1785 export def FilterFunc(idx: number, val: number): bool
1786 return idx % 2 == 1
1787 enddef
1788 export def FastFilter(): list<number>
1789 return range(10)->filter('FilterFunc')
1790 enddef
Bram Moolenaar601e76a2020-08-27 21:33:10 +02001791 export def FastFilterDirect(): list<number>
1792 return range(10)->filter(FilterFunc)
1793 enddef
Bram Moolenaarc620c052020-07-08 15:16:19 +02001794 END
1795 writefile(filterLines, 'Xfilter.vim')
1796
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001797 var lines =<< trim END
Bram Moolenaarc620c052020-07-08 15:16:19 +02001798 vim9script
Bram Moolenaar601e76a2020-08-27 21:33:10 +02001799 import {FilterFunc, FastFilter, FastFilterDirect} from './Xfilter.vim'
Bram Moolenaarc620c052020-07-08 15:16:19 +02001800 def Test()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001801 var x: list<number> = FastFilter()
Bram Moolenaarc620c052020-07-08 15:16:19 +02001802 enddef
1803 Test()
Bram Moolenaar601e76a2020-08-27 21:33:10 +02001804 def TestDirect()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001805 var x: list<number> = FastFilterDirect()
Bram Moolenaar601e76a2020-08-27 21:33:10 +02001806 enddef
1807 TestDirect()
Bram Moolenaarc620c052020-07-08 15:16:19 +02001808 END
Bram Moolenaar601e76a2020-08-27 21:33:10 +02001809 CheckScriptSuccess(lines)
Bram Moolenaarc620c052020-07-08 15:16:19 +02001810 delete('Xfilter.vim')
Bram Moolenaarc620c052020-07-08 15:16:19 +02001811enddef
1812
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001813def Test_vim9script_reload_delfunc()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001814 var first_lines =<< trim END
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001815 vim9script
1816 def FuncYes(): string
1817 return 'yes'
1818 enddef
1819 END
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001820 var withno_lines =<< trim END
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001821 def FuncNo(): string
1822 return 'no'
1823 enddef
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001824 def g:DoCheck(no_exists: bool)
1825 assert_equal('yes', FuncYes())
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001826 assert_equal('no', FuncNo())
1827 enddef
1828 END
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001829 var nono_lines =<< trim END
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001830 def g:DoCheck(no_exists: bool)
1831 assert_equal('yes', FuncYes())
Bram Moolenaar44d66522020-09-06 22:26:57 +02001832 assert_fails('FuncNo()', 'E117:', '', 2, 'DoCheck')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001833 enddef
1834 END
1835
1836 # FuncNo() is defined
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001837 writefile(first_lines + withno_lines, 'Xreloaded.vim')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001838 source Xreloaded.vim
1839 g:DoCheck(true)
1840
1841 # FuncNo() is not redefined
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001842 writefile(first_lines + nono_lines, 'Xreloaded.vim')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001843 source Xreloaded.vim
Bram Moolenaar50824712020-12-20 21:10:17 +01001844 g:DoCheck(false)
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001845
1846 # FuncNo() is back
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001847 writefile(first_lines + withno_lines, 'Xreloaded.vim')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001848 source Xreloaded.vim
Bram Moolenaar50824712020-12-20 21:10:17 +01001849 g:DoCheck(false)
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001850
1851 delete('Xreloaded.vim')
1852enddef
1853
Bram Moolenaar89483d42020-05-10 15:24:44 +02001854def Test_vim9script_reload_delvar()
1855 # write the script with a script-local variable
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001856 var lines =<< trim END
Bram Moolenaar89483d42020-05-10 15:24:44 +02001857 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001858 var name = 'string'
Bram Moolenaar89483d42020-05-10 15:24:44 +02001859 END
1860 writefile(lines, 'XreloadVar.vim')
1861 source XreloadVar.vim
1862
1863 # now write the script using the same variable locally - works
1864 lines =<< trim END
1865 vim9script
1866 def Func()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001867 var name = 'string'
Bram Moolenaar89483d42020-05-10 15:24:44 +02001868 enddef
1869 END
1870 writefile(lines, 'XreloadVar.vim')
1871 source XreloadVar.vim
1872
1873 delete('XreloadVar.vim')
1874enddef
1875
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001876def Test_import_absolute()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001877 var import_lines = [
Bram Moolenaare6085c52020-04-12 20:19:16 +02001878 'vim9script',
1879 'import exported from "' .. escape(getcwd(), '\') .. '/Xexport_abs.vim"',
1880 'def UseExported()',
1881 ' g:imported_abs = exported',
1882 ' exported = 8888',
1883 ' g:imported_after = exported',
1884 'enddef',
1885 'UseExported()',
1886 'g:import_disassembled = execute("disass UseExported")',
1887 ]
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001888 writefile(import_lines, 'Ximport_abs.vim')
1889 writefile(s:export_script_lines, 'Xexport_abs.vim')
1890
1891 source Ximport_abs.vim
1892
1893 assert_equal(9876, g:imported_abs)
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +01001894 assert_equal(8888, g:imported_after)
Bram Moolenaarfbbcd002020-10-15 12:46:44 +02001895 assert_match('<SNR>\d\+_UseExported\_s*' ..
1896 'g:imported_abs = exported\_s*' ..
1897 '0 LOADSCRIPT exported-2 from .*Xexport_abs.vim\_s*' ..
1898 '1 STOREG g:imported_abs\_s*' ..
1899 'exported = 8888\_s*' ..
1900 '2 PUSHNR 8888\_s*' ..
1901 '3 STORESCRIPT exported-2 in .*Xexport_abs.vim\_s*' ..
1902 'g:imported_after = exported\_s*' ..
1903 '4 LOADSCRIPT exported-2 from .*Xexport_abs.vim\_s*' ..
1904 '5 STOREG g:imported_after',
Bram Moolenaare6085c52020-04-12 20:19:16 +02001905 g:import_disassembled)
Bram Moolenaarb3ca9822020-08-09 14:43:58 +02001906
1907 Undo_export_script_lines()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001908 unlet g:imported_abs
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +01001909 unlet g:import_disassembled
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001910
1911 delete('Ximport_abs.vim')
1912 delete('Xexport_abs.vim')
1913enddef
1914
1915def Test_import_rtp()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001916 var import_lines = [
Bram Moolenaare6085c52020-04-12 20:19:16 +02001917 'vim9script',
1918 'import exported from "Xexport_rtp.vim"',
1919 'g:imported_rtp = exported',
1920 ]
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001921 writefile(import_lines, 'Ximport_rtp.vim')
1922 mkdir('import')
1923 writefile(s:export_script_lines, 'import/Xexport_rtp.vim')
1924
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001925 var save_rtp = &rtp
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001926 &rtp = getcwd()
1927 source Ximport_rtp.vim
1928 &rtp = save_rtp
1929
1930 assert_equal(9876, g:imported_rtp)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001931
Bram Moolenaarb3ca9822020-08-09 14:43:58 +02001932 Undo_export_script_lines()
1933 unlet g:imported_rtp
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001934 delete('Ximport_rtp.vim')
Bram Moolenaar89483d42020-05-10 15:24:44 +02001935 delete('import', 'rf')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001936enddef
1937
Bram Moolenaar25e0f582020-05-25 22:36:50 +02001938def Test_import_compile_error()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001939 var export_lines = [
Bram Moolenaar25e0f582020-05-25 22:36:50 +02001940 'vim9script',
1941 'export def ExpFunc(): string',
1942 ' return notDefined',
1943 'enddef',
1944 ]
1945 writefile(export_lines, 'Xexported.vim')
1946
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001947 var import_lines = [
Bram Moolenaar25e0f582020-05-25 22:36:50 +02001948 'vim9script',
1949 'import ExpFunc from "./Xexported.vim"',
1950 'def ImpFunc()',
1951 ' echo ExpFunc()',
1952 'enddef',
1953 'defcompile',
1954 ]
1955 writefile(import_lines, 'Ximport.vim')
1956
1957 try
1958 source Ximport.vim
1959 catch /E1001/
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001960 # Error should be fore the Xexported.vim file.
Bram Moolenaar77072282020-09-16 17:55:40 +02001961 assert_match('E1001: Variable not found: notDefined', v:exception)
Bram Moolenaar25e0f582020-05-25 22:36:50 +02001962 assert_match('function <SNR>\d\+_ImpFunc\[1\]..<SNR>\d\+_ExpFunc, line 1', v:throwpoint)
1963 endtry
1964
1965 delete('Xexported.vim')
1966 delete('Ximport.vim')
1967enddef
1968
Bram Moolenaarc4ce36d2020-08-14 17:08:15 +02001969def Test_func_redefine_error()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001970 var lines = [
Bram Moolenaarc4ce36d2020-08-14 17:08:15 +02001971 'vim9script',
1972 'def Func()',
1973 ' eval [][0]',
1974 'enddef',
1975 'Func()',
1976 ]
1977 writefile(lines, 'Xtestscript.vim')
1978
1979 for count in range(3)
1980 try
1981 source Xtestscript.vim
1982 catch /E684/
1983 # function name should contain <SNR> every time
1984 assert_match('E684: list index out of range', v:exception)
1985 assert_match('function <SNR>\d\+_Func, line 1', v:throwpoint)
1986 endtry
1987 endfor
1988
1989 delete('Xtestscript.vim')
1990enddef
1991
Bram Moolenaareef21022020-08-01 22:16:43 +02001992def Test_func_overrules_import_fails()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001993 var export_lines =<< trim END
Bram Moolenaareef21022020-08-01 22:16:43 +02001994 vim9script
1995 export def Func()
1996 echo 'imported'
1997 enddef
1998 END
1999 writefile(export_lines, 'XexportedFunc.vim')
2000
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002001 var lines =<< trim END
Bram Moolenaareef21022020-08-01 22:16:43 +02002002 vim9script
2003 import Func from './XexportedFunc.vim'
2004 def Func()
2005 echo 'local to function'
2006 enddef
2007 END
2008 CheckScriptFailure(lines, 'E1073:')
2009
2010 lines =<< trim END
2011 vim9script
2012 import Func from './XexportedFunc.vim'
2013 def Outer()
2014 def Func()
2015 echo 'local to function'
2016 enddef
2017 enddef
2018 defcompile
2019 END
2020 CheckScriptFailure(lines, 'E1073:')
2021
2022 delete('XexportedFunc.vim')
2023enddef
2024
Bram Moolenaarb9a2cac2020-08-01 22:23:20 +02002025def Test_func_redefine_fails()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002026 var lines =<< trim END
Bram Moolenaarb9a2cac2020-08-01 22:23:20 +02002027 vim9script
2028 def Func()
2029 echo 'one'
2030 enddef
2031 def Func()
2032 echo 'two'
2033 enddef
2034 END
2035 CheckScriptFailure(lines, 'E1073:')
Bram Moolenaarfa211f32020-08-07 22:00:26 +02002036
2037 lines =<< trim END
2038 vim9script
2039 def Foo(): string
2040 return 'foo'
2041 enddef
2042 def Func()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002043 var Foo = {-> 'lambda'}
Bram Moolenaarfa211f32020-08-07 22:00:26 +02002044 enddef
2045 defcompile
2046 END
2047 CheckScriptFailure(lines, 'E1073:')
Bram Moolenaarb9a2cac2020-08-01 22:23:20 +02002048enddef
2049
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002050def Test_fixed_size_list()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002051 # will be allocated as one piece of memory, check that changes work
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002052 var l = [1, 2, 3, 4]
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002053 l->remove(0)
2054 l->add(5)
2055 l->insert(99, 1)
Bram Moolenaar0f18b6d2020-02-02 17:22:27 +01002056 assert_equal([2, 99, 3, 4, 5], l)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002057enddef
2058
Bram Moolenaarae616492020-07-28 20:07:27 +02002059def Test_no_insert_xit()
Bram Moolenaard2c61702020-09-06 15:58:36 +02002060 CheckDefExecFailure(['a = 1'], 'E1100:')
2061 CheckDefExecFailure(['c = 1'], 'E1100:')
2062 CheckDefExecFailure(['i = 1'], 'E1100:')
2063 CheckDefExecFailure(['t = 1'], 'E1100:')
2064 CheckDefExecFailure(['x = 1'], 'E1100:')
Bram Moolenaarae616492020-07-28 20:07:27 +02002065
Bram Moolenaarae616492020-07-28 20:07:27 +02002066 CheckScriptFailure(['vim9script', 'a = 1'], 'E488:')
2067 CheckScriptFailure(['vim9script', 'a'], 'E1100:')
Bram Moolenaarae616492020-07-28 20:07:27 +02002068 CheckScriptFailure(['vim9script', 'c = 1'], 'E488:')
2069 CheckScriptFailure(['vim9script', 'c'], 'E1100:')
Bram Moolenaarf5a48012020-08-01 17:00:03 +02002070 CheckScriptFailure(['vim9script', 'i = 1'], 'E488:')
2071 CheckScriptFailure(['vim9script', 'i'], 'E1100:')
Bram Moolenaar65088802021-03-13 21:07:21 +01002072 CheckScriptFailure(['vim9script', 'o = 1'], 'E1100:')
2073 CheckScriptFailure(['vim9script', 'o'], 'E1100:')
Bram Moolenaarf5a48012020-08-01 17:00:03 +02002074 CheckScriptFailure(['vim9script', 't'], 'E1100:')
2075 CheckScriptFailure(['vim9script', 't = 1'], 'E1100:')
2076 CheckScriptFailure(['vim9script', 'x = 1'], 'E1100:')
Bram Moolenaarae616492020-07-28 20:07:27 +02002077enddef
2078
Bram Moolenaar158906c2020-02-06 20:39:45 +01002079def IfElse(what: number): string
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002080 var res = ''
Bram Moolenaar158906c2020-02-06 20:39:45 +01002081 if what == 1
2082 res = "one"
2083 elseif what == 2
2084 res = "two"
Bram Moolenaara259d8d2020-01-31 20:10:50 +01002085 else
Bram Moolenaar158906c2020-02-06 20:39:45 +01002086 res = "three"
Bram Moolenaara259d8d2020-01-31 20:10:50 +01002087 endif
Bram Moolenaar158906c2020-02-06 20:39:45 +01002088 return res
Bram Moolenaara259d8d2020-01-31 20:10:50 +01002089enddef
2090
Bram Moolenaar158906c2020-02-06 20:39:45 +01002091def Test_if_elseif_else()
2092 assert_equal('one', IfElse(1))
2093 assert_equal('two', IfElse(2))
2094 assert_equal('three', IfElse(3))
Bram Moolenaar0f18b6d2020-02-02 17:22:27 +01002095enddef
2096
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02002097def Test_if_elseif_else_fails()
Bram Moolenaard2c61702020-09-06 15:58:36 +02002098 CheckDefFailure(['elseif true'], 'E582:')
2099 CheckDefFailure(['else'], 'E581:')
2100 CheckDefFailure(['endif'], 'E580:')
Bram Moolenaarced68a02021-01-24 17:53:47 +01002101 CheckDefFailure(['if g:abool', 'elseif xxx'], 'E1001:')
Bram Moolenaard2c61702020-09-06 15:58:36 +02002102 CheckDefFailure(['if true', 'echo 1'], 'E171:')
Bram Moolenaar6628b7e2021-02-07 16:33:35 +01002103
2104 var lines =<< trim END
2105 var s = ''
2106 if s = ''
2107 endif
2108 END
2109 CheckDefFailure(lines, 'E488:')
2110
2111 lines =<< trim END
2112 var s = ''
2113 if s == ''
2114 elseif s = ''
2115 endif
2116 END
2117 CheckDefFailure(lines, 'E488:')
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02002118enddef
2119
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01002120let g:bool_true = v:true
2121let g:bool_false = v:false
2122
2123def Test_if_const_expr()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002124 var res = false
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01002125 if true ? true : false
2126 res = true
2127 endif
2128 assert_equal(true, res)
2129
Bram Moolenaar585fea72020-04-02 22:33:21 +02002130 g:glob = 2
2131 if false
Bram Moolenaar67979662020-06-20 22:50:47 +02002132 execute('g:glob = 3')
Bram Moolenaar585fea72020-04-02 22:33:21 +02002133 endif
2134 assert_equal(2, g:glob)
2135 if true
Bram Moolenaar67979662020-06-20 22:50:47 +02002136 execute('g:glob = 3')
Bram Moolenaar585fea72020-04-02 22:33:21 +02002137 endif
2138 assert_equal(3, g:glob)
2139
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01002140 res = false
2141 if g:bool_true ? true : false
2142 res = true
2143 endif
2144 assert_equal(true, res)
2145
2146 res = false
2147 if true ? g:bool_true : false
2148 res = true
2149 endif
2150 assert_equal(true, res)
2151
2152 res = false
2153 if true ? true : g:bool_false
2154 res = true
2155 endif
2156 assert_equal(true, res)
2157
2158 res = false
2159 if true ? false : true
2160 res = true
2161 endif
2162 assert_equal(false, res)
2163
2164 res = false
2165 if false ? false : true
2166 res = true
2167 endif
2168 assert_equal(true, res)
2169
2170 res = false
2171 if false ? true : false
2172 res = true
2173 endif
2174 assert_equal(false, res)
2175
2176 res = false
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02002177 if has('xyz') ? true : false
2178 res = true
2179 endif
2180 assert_equal(false, res)
2181
2182 res = false
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01002183 if true && true
2184 res = true
2185 endif
2186 assert_equal(true, res)
2187
2188 res = false
2189 if true && false
2190 res = true
2191 endif
2192 assert_equal(false, res)
2193
2194 res = false
2195 if g:bool_true && false
2196 res = true
2197 endif
2198 assert_equal(false, res)
2199
2200 res = false
2201 if true && g:bool_false
2202 res = true
2203 endif
2204 assert_equal(false, res)
2205
2206 res = false
2207 if false && false
2208 res = true
2209 endif
2210 assert_equal(false, res)
2211
2212 res = false
2213 if true || false
2214 res = true
2215 endif
2216 assert_equal(true, res)
2217
2218 res = false
2219 if g:bool_true || false
2220 res = true
2221 endif
2222 assert_equal(true, res)
2223
2224 res = false
2225 if true || g:bool_false
2226 res = true
2227 endif
2228 assert_equal(true, res)
2229
2230 res = false
2231 if false || false
2232 res = true
2233 endif
2234 assert_equal(false, res)
Bram Moolenaar3988f642020-08-27 22:43:03 +02002235
2236 # with constant "false" expression may be invalid so long as the syntax is OK
2237 if false | eval 0 | endif
2238 if false | eval burp + 234 | endif
2239 if false | echo burp 234 'asd' | endif
2240 if false
2241 burp
2242 endif
Bram Moolenaar80c34ca2020-04-01 23:05:18 +02002243enddef
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01002244
Bram Moolenaar80c34ca2020-04-01 23:05:18 +02002245def Test_if_const_expr_fails()
Bram Moolenaard2c61702020-09-06 15:58:36 +02002246 CheckDefFailure(['if "aaa" == "bbb'], 'E114:')
2247 CheckDefFailure(["if 'aaa' == 'bbb"], 'E115:')
2248 CheckDefFailure(["if has('aaa'"], 'E110:')
2249 CheckDefFailure(["if has('aaa') ? true false"], 'E109:')
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01002250enddef
2251
Bram Moolenaar72abcf42020-06-18 18:26:24 +02002252def RunNested(i: number): number
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002253 var x: number = 0
Bram Moolenaar72abcf42020-06-18 18:26:24 +02002254 if i % 2
2255 if 1
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002256 # comment
Bram Moolenaar72abcf42020-06-18 18:26:24 +02002257 else
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002258 # comment
Bram Moolenaar72abcf42020-06-18 18:26:24 +02002259 endif
2260 x += 1
2261 else
2262 x += 1000
2263 endif
2264 return x
2265enddef
2266
2267def Test_nested_if()
2268 assert_equal(1, RunNested(1))
2269 assert_equal(1000, RunNested(2))
2270enddef
2271
Bram Moolenaarad39c092020-02-26 18:23:43 +01002272def Test_execute_cmd()
Bram Moolenaare4984292020-12-13 14:19:25 +01002273 # missing argument is ignored
2274 execute
2275 execute # comment
2276
Bram Moolenaarad39c092020-02-26 18:23:43 +01002277 new
2278 setline(1, 'default')
Bram Moolenaard2c61702020-09-06 15:58:36 +02002279 execute 'setline(1, "execute-string")'
Bram Moolenaarad39c092020-02-26 18:23:43 +01002280 assert_equal('execute-string', getline(1))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002281
Bram Moolenaard2c61702020-09-06 15:58:36 +02002282 execute "setline(1, 'execute-string')"
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002283 assert_equal('execute-string', getline(1))
2284
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002285 var cmd1 = 'setline(1,'
2286 var cmd2 = '"execute-var")'
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002287 execute cmd1 cmd2 # comment
Bram Moolenaarad39c092020-02-26 18:23:43 +01002288 assert_equal('execute-var', getline(1))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002289
Bram Moolenaard2c61702020-09-06 15:58:36 +02002290 execute cmd1 cmd2 '|setline(1, "execute-var-string")'
Bram Moolenaarad39c092020-02-26 18:23:43 +01002291 assert_equal('execute-var-string', getline(1))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002292
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002293 var cmd_first = 'call '
2294 var cmd_last = 'setline(1, "execute-var-var")'
Bram Moolenaarad39c092020-02-26 18:23:43 +01002295 execute cmd_first .. cmd_last
2296 assert_equal('execute-var-var', getline(1))
2297 bwipe!
Bram Moolenaar585fea72020-04-02 22:33:21 +02002298
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002299 var n = true
Bram Moolenaar2d6b20d2020-07-25 19:30:59 +02002300 execute 'echomsg' (n ? '"true"' : '"no"')
2301 assert_match('^true$', Screenline(&lines))
2302
Bram Moolenaare0de1712020-12-02 17:36:54 +01002303 echomsg [1, 2, 3] {a: 1, b: 2}
Bram Moolenaare5abf7a2020-08-16 18:29:35 +02002304 assert_match('^\[1, 2, 3\] {''a'': 1, ''b'': 2}$', Screenline(&lines))
2305
Bram Moolenaard2c61702020-09-06 15:58:36 +02002306 CheckDefFailure(['execute xxx'], 'E1001:', 1)
2307 CheckDefExecFailure(['execute "tabnext " .. 8'], 'E475:', 1)
2308 CheckDefFailure(['execute "cmd"# comment'], 'E488:', 1)
Bram Moolenaarad39c092020-02-26 18:23:43 +01002309enddef
2310
Bram Moolenaar47e880d2020-06-30 22:02:02 +02002311def Test_execute_cmd_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002312 # only checks line continuation
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002313 var lines =<< trim END
Bram Moolenaar47e880d2020-06-30 22:02:02 +02002314 vim9script
2315 execute 'g:someVar'
2316 .. ' = ' ..
2317 '28'
2318 assert_equal(28, g:someVar)
2319 unlet g:someVar
2320 END
2321 CheckScriptSuccess(lines)
2322enddef
2323
Bram Moolenaarad39c092020-02-26 18:23:43 +01002324def Test_echo_cmd()
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002325 echo 'some' # comment
Bram Moolenaar585fea72020-04-02 22:33:21 +02002326 echon 'thing'
Bram Moolenaarad39c092020-02-26 18:23:43 +01002327 assert_match('^something$', Screenline(&lines))
2328
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002329 echo "some" # comment
2330 echon "thing"
2331 assert_match('^something$', Screenline(&lines))
2332
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002333 var str1 = 'some'
2334 var str2 = 'more'
Bram Moolenaarad39c092020-02-26 18:23:43 +01002335 echo str1 str2
2336 assert_match('^some more$', Screenline(&lines))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002337
Bram Moolenaard2c61702020-09-06 15:58:36 +02002338 CheckDefFailure(['echo "xxx"# comment'], 'E488:')
Bram Moolenaarad39c092020-02-26 18:23:43 +01002339enddef
2340
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02002341def Test_echomsg_cmd()
2342 echomsg 'some' 'more' # comment
2343 assert_match('^some more$', Screenline(&lines))
2344 echo 'clear'
Bram Moolenaardf069ee2020-06-22 23:02:51 +02002345 :1messages
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02002346 assert_match('^some more$', Screenline(&lines))
2347
Bram Moolenaard2c61702020-09-06 15:58:36 +02002348 CheckDefFailure(['echomsg "xxx"# comment'], 'E488:')
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02002349enddef
2350
Bram Moolenaar47e880d2020-06-30 22:02:02 +02002351def Test_echomsg_cmd_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002352 # only checks line continuation
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002353 var lines =<< trim END
Bram Moolenaar47e880d2020-06-30 22:02:02 +02002354 vim9script
2355 echomsg 'here'
2356 .. ' is ' ..
2357 'a message'
2358 assert_match('^here is a message$', Screenline(&lines))
2359 END
2360 CheckScriptSuccess(lines)
2361enddef
2362
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02002363def Test_echoerr_cmd()
Bram Moolenaar40ee4662020-05-05 22:08:26 +02002364 try
2365 echoerr 'something' 'wrong' # comment
2366 catch
2367 assert_match('something wrong', v:exception)
2368 endtry
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02002369enddef
2370
Bram Moolenaar47e880d2020-06-30 22:02:02 +02002371def Test_echoerr_cmd_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002372 # only checks line continuation
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002373 var lines =<< trim END
Bram Moolenaar47e880d2020-06-30 22:02:02 +02002374 vim9script
2375 try
2376 echoerr 'this'
2377 .. ' is ' ..
2378 'wrong'
2379 catch
2380 assert_match('this is wrong', v:exception)
2381 endtry
2382 END
2383 CheckScriptSuccess(lines)
2384enddef
2385
Bram Moolenaar41fe0612020-03-01 16:22:40 +01002386def Test_for_outside_of_function()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002387 var lines =<< trim END
Bram Moolenaar41fe0612020-03-01 16:22:40 +01002388 vim9script
2389 new
2390 for var in range(0, 3)
2391 append(line('$'), var)
2392 endfor
2393 assert_equal(['', '0', '1', '2', '3'], getline(1, '$'))
2394 bwipe!
Bram Moolenaar522eefd2021-03-26 18:49:22 +01002395
2396 var result = ''
2397 for i in [1, 2, 3]
2398 var loop = ' loop ' .. i
2399 result ..= loop
2400 endfor
2401 assert_equal(' loop 1 loop 2 loop 3', result)
Bram Moolenaar41fe0612020-03-01 16:22:40 +01002402 END
2403 writefile(lines, 'Xvim9for.vim')
2404 source Xvim9for.vim
2405 delete('Xvim9for.vim')
2406enddef
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002407
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02002408def Test_for_loop()
Bram Moolenaarf2253962021-04-13 20:53:13 +02002409 var lines =<< trim END
2410 var result = ''
2411 for cnt in range(7)
2412 if cnt == 4
2413 break
2414 endif
2415 if cnt == 2
2416 continue
2417 endif
2418 result ..= cnt .. '_'
2419 endfor
2420 assert_equal('0_1_3_', result)
Bram Moolenaar0ad3e892020-07-05 21:38:11 +02002421
Bram Moolenaarf2253962021-04-13 20:53:13 +02002422 var concat = ''
2423 for str in eval('["one", "two"]')
2424 concat ..= str
2425 endfor
2426 assert_equal('onetwo', concat)
Bram Moolenaar38bd8de2020-12-02 13:23:36 +01002427
Bram Moolenaarf2253962021-04-13 20:53:13 +02002428 var total = 0
2429 for nr in
2430 [1, 2, 3]
2431 total += nr
2432 endfor
2433 assert_equal(6, total)
Bram Moolenaar38bd8de2020-12-02 13:23:36 +01002434
Bram Moolenaarf2253962021-04-13 20:53:13 +02002435 total = 0
2436 for nr
2437 in [1, 2, 3]
2438 total += nr
2439 endfor
2440 assert_equal(6, total)
Bram Moolenaar38bd8de2020-12-02 13:23:36 +01002441
Bram Moolenaarf2253962021-04-13 20:53:13 +02002442 total = 0
2443 for nr
2444 in
2445 [1, 2, 3]
2446 total += nr
2447 endfor
2448 assert_equal(6, total)
Bram Moolenaar036d0712021-01-17 20:23:38 +01002449
Bram Moolenaara3589a02021-04-14 13:30:46 +02002450 # with type
2451 total = 0
2452 for n: number in [1, 2, 3]
2453 total += n
2454 endfor
2455 assert_equal(6, total)
2456
Bram Moolenaarfe090eb2021-04-15 21:48:32 +02002457 var chars = ''
2458 for s: string in 'foobar'
2459 chars ..= s
2460 endfor
2461 assert_equal('foobar', chars)
2462
Bram Moolenaara3589a02021-04-14 13:30:46 +02002463 # unpack with type
Bram Moolenaarf2253962021-04-13 20:53:13 +02002464 var res = ''
Bram Moolenaara3589a02021-04-14 13:30:46 +02002465 for [n: number, s: string] in [[1, 'a'], [2, 'b']]
2466 res ..= n .. s
2467 endfor
2468 assert_equal('1a2b', res)
2469
Bram Moolenaar444d8782021-06-26 12:40:56 +02002470 # unpack with one var
2471 var reslist = []
2472 for [x] in [['aaa'], ['bbb']]
2473 reslist->add(x)
2474 endfor
2475 assert_equal(['aaa', 'bbb'], reslist)
2476
Bram Moolenaara3589a02021-04-14 13:30:46 +02002477 # loop over string
2478 res = ''
Bram Moolenaarf2253962021-04-13 20:53:13 +02002479 for c in 'aéc̀d'
2480 res ..= c .. '-'
2481 endfor
2482 assert_equal('a-é-c̀-d-', res)
2483
2484 res = ''
2485 for c in ''
2486 res ..= c .. '-'
2487 endfor
2488 assert_equal('', res)
2489
2490 res = ''
2491 for c in test_null_string()
2492 res ..= c .. '-'
2493 endfor
2494 assert_equal('', res)
2495
2496 var foo: list<dict<any>> = [
2497 {a: 'Cat'}
2498 ]
2499 for dd in foo
2500 dd.counter = 12
2501 endfor
2502 assert_equal([{a: 'Cat', counter: 12}], foo)
2503 END
2504 CheckDefAndScriptSuccess(lines)
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02002505enddef
2506
2507def Test_for_loop_fails()
Bram Moolenaar025cb1c2020-12-14 18:31:27 +01002508 CheckDefFailure(['for '], 'E1097:')
2509 CheckDefFailure(['for x'], 'E1097:')
2510 CheckDefFailure(['for x in'], 'E1097:')
Bram Moolenaar675f7162020-04-12 22:53:54 +02002511 CheckDefFailure(['for # in range(5)'], 'E690:')
2512 CheckDefFailure(['for i In range(5)'], 'E690:')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002513 CheckDefFailure(['var x = 5', 'for x in range(5)'], 'E1017:')
Bram Moolenaar822ba242020-05-24 23:00:18 +02002514 CheckScriptFailure(['def Func(arg: any)', 'for arg in range(5)', 'enddef', 'defcompile'], 'E1006:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002515 delfunc! g:Func
Bram Moolenaar675f7162020-04-12 22:53:54 +02002516 CheckDefFailure(['for i in xxx'], 'E1001:')
2517 CheckDefFailure(['endfor'], 'E588:')
2518 CheckDefFailure(['for i in range(3)', 'echo 3'], 'E170:')
Bram Moolenaar74e54fc2021-03-26 20:41:29 +01002519
2520 # wrong type detected at compile time
2521 CheckDefFailure(['for i in {a: 1}', 'echo 3', 'endfor'], 'E1177: For loop on dict not supported')
2522
2523 # wrong type detected at runtime
2524 g:adict = {a: 1}
2525 CheckDefExecFailure(['for i in g:adict', 'echo 3', 'endfor'], 'E1177: For loop on dict not supported')
2526 unlet g:adict
Bram Moolenaarf6a8d422021-04-13 21:48:03 +02002527
2528 var lines =<< trim END
2529 var d: list<dict<any>> = [{a: 0}]
2530 for e in d
2531 e = {a: 0, b: ''}
2532 endfor
2533 END
2534 CheckDefAndScriptFailure2(lines, 'E1018:', 'E46:', 3)
Bram Moolenaarfe090eb2021-04-15 21:48:32 +02002535
2536 lines =<< trim END
2537 for nr: number in ['foo']
2538 endfor
2539 END
2540 CheckDefAndScriptFailure(lines, 'E1012: Type mismatch; expected number but got string', 1)
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02002541enddef
2542
Bram Moolenaarea870692020-12-02 14:24:30 +01002543def Test_for_loop_script_var()
2544 # cannot use s:var in a :def function
2545 CheckDefFailure(['for s:var in range(3)', 'echo 3'], 'E1101:')
2546
2547 # can use s:var in Vim9 script, with or without s:
2548 var lines =<< trim END
2549 vim9script
2550 var total = 0
2551 for s:var in [1, 2, 3]
2552 total += s:var
2553 endfor
2554 assert_equal(6, total)
2555
2556 total = 0
2557 for var in [1, 2, 3]
2558 total += var
2559 endfor
2560 assert_equal(6, total)
2561 END
2562enddef
2563
Bram Moolenaar792f7862020-11-23 08:31:18 +01002564def Test_for_loop_unpack()
Bram Moolenaar792f7862020-11-23 08:31:18 +01002565 var lines =<< trim END
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01002566 var result = []
2567 for [v1, v2] in [[1, 2], [3, 4]]
2568 result->add(v1)
2569 result->add(v2)
2570 endfor
2571 assert_equal([1, 2, 3, 4], result)
2572
2573 result = []
2574 for [v1, v2; v3] in [[1, 2], [3, 4, 5, 6]]
2575 result->add(v1)
2576 result->add(v2)
2577 result->add(v3)
2578 endfor
2579 assert_equal([1, 2, [], 3, 4, [5, 6]], result)
2580
2581 result = []
2582 for [&ts, &sw] in [[1, 2], [3, 4]]
2583 result->add(&ts)
2584 result->add(&sw)
2585 endfor
2586 assert_equal([1, 2, 3, 4], result)
2587
2588 var slist: list<string>
2589 for [$LOOPVAR, @r, v:errmsg] in [['a', 'b', 'c'], ['d', 'e', 'f']]
2590 slist->add($LOOPVAR)
2591 slist->add(@r)
2592 slist->add(v:errmsg)
2593 endfor
2594 assert_equal(['a', 'b', 'c', 'd', 'e', 'f'], slist)
2595
2596 slist = []
2597 for [g:globalvar, b:bufvar, w:winvar, t:tabvar] in [['global', 'buf', 'win', 'tab'], ['1', '2', '3', '4']]
2598 slist->add(g:globalvar)
2599 slist->add(b:bufvar)
2600 slist->add(w:winvar)
2601 slist->add(t:tabvar)
2602 endfor
2603 assert_equal(['global', 'buf', 'win', 'tab', '1', '2', '3', '4'], slist)
Bram Moolenaarf6c177a2020-12-04 17:38:00 +01002604 unlet! g:globalvar b:bufvar w:winvar t:tabvar
Bram Moolenaarb777da92021-05-22 21:40:39 +02002605
2606 var res = []
2607 for [_, n, _] in [[1, 2, 3], [4, 5, 6]]
2608 res->add(n)
2609 endfor
2610 assert_equal([2, 5], res)
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01002611 END
2612 CheckDefAndScriptSuccess(lines)
2613
2614 lines =<< trim END
Bram Moolenaar792f7862020-11-23 08:31:18 +01002615 for [v1, v2] in [[1, 2, 3], [3, 4]]
2616 echo v1 v2
2617 endfor
2618 END
2619 CheckDefExecFailure(lines, 'E710:', 1)
2620
2621 lines =<< trim END
2622 for [v1, v2] in [[1], [3, 4]]
2623 echo v1 v2
2624 endfor
2625 END
2626 CheckDefExecFailure(lines, 'E711:', 1)
2627
2628 lines =<< trim END
2629 for [v1, v1] in [[1, 2], [3, 4]]
2630 echo v1
2631 endfor
2632 END
2633 CheckDefExecFailure(lines, 'E1017:', 1)
2634enddef
2635
Bram Moolenaarc150c092021-02-13 15:02:46 +01002636def Test_for_loop_with_try_continue()
Bram Moolenaarf2253962021-04-13 20:53:13 +02002637 var lines =<< trim END
2638 var looped = 0
2639 var cleanup = 0
2640 for i in range(3)
2641 looped += 1
2642 try
2643 eval [][0]
2644 catch
2645 continue
2646 finally
2647 cleanup += 1
2648 endtry
2649 endfor
2650 assert_equal(3, looped)
2651 assert_equal(3, cleanup)
2652 END
2653 CheckDefAndScriptSuccess(lines)
Bram Moolenaarc150c092021-02-13 15:02:46 +01002654enddef
2655
Bram Moolenaard0df1aa2020-03-04 21:50:46 +01002656def Test_while_loop()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002657 var result = ''
2658 var cnt = 0
Bram Moolenaard0df1aa2020-03-04 21:50:46 +01002659 while cnt < 555
2660 if cnt == 3
2661 break
2662 endif
2663 cnt += 1
2664 if cnt == 2
2665 continue
2666 endif
2667 result ..= cnt .. '_'
2668 endwhile
2669 assert_equal('1_3_', result)
Bram Moolenaardee37dc2021-02-07 16:40:05 +01002670
2671 var s = ''
Bram Moolenaar4b3e1962021-03-18 21:37:55 +01002672 while s == 'x' # {comment}
Bram Moolenaardee37dc2021-02-07 16:40:05 +01002673 endwhile
Bram Moolenaard0df1aa2020-03-04 21:50:46 +01002674enddef
2675
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02002676def Test_while_loop_fails()
Bram Moolenaar675f7162020-04-12 22:53:54 +02002677 CheckDefFailure(['while xxx'], 'E1001:')
2678 CheckDefFailure(['endwhile'], 'E588:')
2679 CheckDefFailure(['continue'], 'E586:')
2680 CheckDefFailure(['if true', 'continue'], 'E586:')
2681 CheckDefFailure(['break'], 'E587:')
2682 CheckDefFailure(['if true', 'break'], 'E587:')
2683 CheckDefFailure(['while 1', 'echo 3'], 'E170:')
Bram Moolenaar6628b7e2021-02-07 16:33:35 +01002684
2685 var lines =<< trim END
2686 var s = ''
2687 while s = ''
2688 endwhile
2689 END
2690 CheckDefFailure(lines, 'E488:')
Bram Moolenaarbd5da372020-03-31 23:13:10 +02002691enddef
2692
Bram Moolenaar9645e2d2020-03-20 20:48:49 +01002693def Test_interrupt_loop()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002694 var caught = false
2695 var x = 0
Bram Moolenaar97acfc72020-03-22 13:44:28 +01002696 try
2697 while 1
2698 x += 1
2699 if x == 100
2700 feedkeys("\<C-C>", 'Lt')
2701 endif
2702 endwhile
2703 catch
2704 caught = true
2705 assert_equal(100, x)
2706 endtry
2707 assert_true(caught, 'should have caught an exception')
Bram Moolenaar25859dd2020-08-30 12:54:53 +02002708 # consume the CTRL-C
2709 getchar(0)
Bram Moolenaar9645e2d2020-03-20 20:48:49 +01002710enddef
Bram Moolenaar20431c92020-03-20 18:39:46 +01002711
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002712def Test_automatic_line_continuation()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002713 var mylist = [
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002714 'one',
2715 'two',
2716 'three',
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002717 ] # comment
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002718 assert_equal(['one', 'two', 'three'], mylist)
2719
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002720 var mydict = {
Bram Moolenaare0de1712020-12-02 17:36:54 +01002721 ['one']: 1,
2722 ['two']: 2,
2723 ['three']:
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002724 3,
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002725 } # comment
Bram Moolenaare0de1712020-12-02 17:36:54 +01002726 assert_equal({one: 1, two: 2, three: 3}, mydict)
2727 mydict = {
Bram Moolenaar2c330432020-04-13 14:41:35 +02002728 one: 1, # comment
2729 two: # comment
2730 2, # comment
2731 three: 3 # comment
2732 }
Bram Moolenaare0de1712020-12-02 17:36:54 +01002733 assert_equal({one: 1, two: 2, three: 3}, mydict)
2734 mydict = {
Bram Moolenaar2c330432020-04-13 14:41:35 +02002735 one: 1,
2736 two:
2737 2,
2738 three: 3
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002739 }
Bram Moolenaare0de1712020-12-02 17:36:54 +01002740 assert_equal({one: 1, two: 2, three: 3}, mydict)
Bram Moolenaare6085c52020-04-12 20:19:16 +02002741
2742 assert_equal(
2743 ['one', 'two', 'three'],
2744 split('one two three')
2745 )
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002746enddef
2747
Bram Moolenaar7a092242020-04-16 22:10:49 +02002748def Test_vim9_comment()
2749 CheckScriptSuccess([
2750 'vim9script',
2751 '# something',
Bram Moolenaar93f82cb2020-12-12 21:25:56 +01002752 '#something',
2753 '#{something',
Bram Moolenaar7a092242020-04-16 22:10:49 +02002754 ])
Bram Moolenaar93f82cb2020-12-12 21:25:56 +01002755
2756 split Xfile
2757 CheckScriptSuccess([
2758 'vim9script',
2759 'edit #something',
2760 ])
2761 CheckScriptSuccess([
2762 'vim9script',
2763 'edit #{something',
2764 ])
2765 close
2766
Bram Moolenaar7a092242020-04-16 22:10:49 +02002767 CheckScriptFailure([
2768 'vim9script',
2769 ':# something',
2770 ], 'E488:')
2771 CheckScriptFailure([
2772 '# something',
2773 ], 'E488:')
2774 CheckScriptFailure([
2775 ':# something',
2776 ], 'E488:')
2777
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02002778 { # block start
2779 } # block end
2780 CheckDefFailure([
2781 '{# comment',
2782 ], 'E488:')
2783 CheckDefFailure([
2784 '{',
2785 '}# comment',
2786 ], 'E488:')
2787
2788 echo "yes" # comment
2789 CheckDefFailure([
2790 'echo "yes"# comment',
2791 ], 'E488:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02002792 CheckScriptSuccess([
2793 'vim9script',
2794 'echo "yes" # something',
2795 ])
2796 CheckScriptFailure([
2797 'vim9script',
2798 'echo "yes"# something',
2799 ], 'E121:')
2800 CheckScriptFailure([
2801 'vim9script',
2802 'echo# something',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002803 ], 'E1144:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02002804 CheckScriptFailure([
2805 'echo "yes" # something',
2806 ], 'E121:')
2807
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02002808 exe "echo" # comment
2809 CheckDefFailure([
2810 'exe "echo"# comment',
2811 ], 'E488:')
2812 CheckScriptSuccess([
2813 'vim9script',
2814 'exe "echo" # something',
2815 ])
2816 CheckScriptFailure([
2817 'vim9script',
2818 'exe "echo"# something',
2819 ], 'E121:')
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02002820 CheckScriptFailure([
2821 'vim9script',
2822 'exe# something',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002823 ], 'E1144:')
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02002824 CheckScriptFailure([
2825 'exe "echo" # something',
2826 ], 'E121:')
2827
Bram Moolenaar7a092242020-04-16 22:10:49 +02002828 CheckDefFailure([
2829 'try# comment',
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002830 ' echo "yes"',
Bram Moolenaar7a092242020-04-16 22:10:49 +02002831 'catch',
2832 'endtry',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002833 ], 'E1144:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002834 CheckScriptFailure([
2835 'vim9script',
2836 'try# comment',
2837 'echo "yes"',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002838 ], 'E1144:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02002839 CheckDefFailure([
2840 'try',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002841 ' throw#comment',
2842 'catch',
2843 'endtry',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002844 ], 'E1144:')
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002845 CheckDefFailure([
2846 'try',
2847 ' throw "yes"#comment',
2848 'catch',
2849 'endtry',
2850 ], 'E488:')
2851 CheckDefFailure([
2852 'try',
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002853 ' echo "yes"',
Bram Moolenaar7a092242020-04-16 22:10:49 +02002854 'catch# comment',
2855 'endtry',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002856 ], 'E1144:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002857 CheckScriptFailure([
2858 'vim9script',
2859 'try',
2860 ' echo "yes"',
2861 'catch# comment',
2862 'endtry',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002863 ], 'E1144:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002864 CheckDefFailure([
2865 'try',
2866 ' echo "yes"',
2867 'catch /pat/# comment',
2868 'endtry',
2869 ], 'E488:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02002870 CheckDefFailure([
2871 'try',
2872 'echo "yes"',
2873 'catch',
2874 'endtry# comment',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002875 ], 'E1144:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002876 CheckScriptFailure([
2877 'vim9script',
2878 'try',
2879 ' echo "yes"',
2880 'catch',
2881 'endtry# comment',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002882 ], 'E1144:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002883
2884 CheckScriptSuccess([
2885 'vim9script',
2886 'hi # comment',
2887 ])
2888 CheckScriptFailure([
2889 'vim9script',
2890 'hi# comment',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002891 ], 'E1144:')
Bram Moolenaar1966c242020-04-20 22:42:32 +02002892 CheckScriptSuccess([
2893 'vim9script',
2894 'hi Search # comment',
2895 ])
2896 CheckScriptFailure([
2897 'vim9script',
2898 'hi Search# comment',
2899 ], 'E416:')
2900 CheckScriptSuccess([
2901 'vim9script',
2902 'hi link This Search # comment',
2903 ])
2904 CheckScriptFailure([
2905 'vim9script',
2906 'hi link This That# comment',
2907 ], 'E413:')
2908 CheckScriptSuccess([
2909 'vim9script',
2910 'hi clear This # comment',
2911 'hi clear # comment',
2912 ])
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002913 # not tested, because it doesn't give an error but a warning:
2914 # hi clear This# comment',
Bram Moolenaar1966c242020-04-20 22:42:32 +02002915 CheckScriptFailure([
2916 'vim9script',
2917 'hi clear# comment',
2918 ], 'E416:')
2919
2920 CheckScriptSuccess([
2921 'vim9script',
2922 'hi Group term=bold',
2923 'match Group /todo/ # comment',
2924 ])
2925 CheckScriptFailure([
2926 'vim9script',
2927 'hi Group term=bold',
2928 'match Group /todo/# comment',
2929 ], 'E488:')
2930 CheckScriptSuccess([
2931 'vim9script',
2932 'match # comment',
2933 ])
2934 CheckScriptFailure([
2935 'vim9script',
2936 'match# comment',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002937 ], 'E1144:')
Bram Moolenaar1966c242020-04-20 22:42:32 +02002938 CheckScriptSuccess([
2939 'vim9script',
2940 'match none # comment',
2941 ])
2942 CheckScriptFailure([
2943 'vim9script',
2944 'match none# comment',
2945 ], 'E475:')
2946
2947 CheckScriptSuccess([
2948 'vim9script',
2949 'menutrans clear # comment',
2950 ])
2951 CheckScriptFailure([
2952 'vim9script',
2953 'menutrans clear# comment text',
2954 ], 'E474:')
2955
2956 CheckScriptSuccess([
2957 'vim9script',
2958 'syntax clear # comment',
2959 ])
2960 CheckScriptFailure([
2961 'vim9script',
2962 'syntax clear# comment text',
2963 ], 'E28:')
2964 CheckScriptSuccess([
2965 'vim9script',
2966 'syntax keyword Word some',
2967 'syntax clear Word # comment',
2968 ])
2969 CheckScriptFailure([
2970 'vim9script',
2971 'syntax keyword Word some',
2972 'syntax clear Word# comment text',
2973 ], 'E28:')
2974
2975 CheckScriptSuccess([
2976 'vim9script',
2977 'syntax list # comment',
2978 ])
2979 CheckScriptFailure([
2980 'vim9script',
2981 'syntax list# comment text',
2982 ], 'E28:')
2983
2984 CheckScriptSuccess([
2985 'vim9script',
2986 'syntax match Word /pat/ oneline # comment',
2987 ])
2988 CheckScriptFailure([
2989 'vim9script',
2990 'syntax match Word /pat/ oneline# comment',
2991 ], 'E475:')
2992
2993 CheckScriptSuccess([
2994 'vim9script',
2995 'syntax keyword Word word # comm[ent',
2996 ])
2997 CheckScriptFailure([
2998 'vim9script',
2999 'syntax keyword Word word# comm[ent',
3000 ], 'E789:')
3001
3002 CheckScriptSuccess([
3003 'vim9script',
3004 'syntax match Word /pat/ # comment',
3005 ])
3006 CheckScriptFailure([
3007 'vim9script',
3008 'syntax match Word /pat/# comment',
3009 ], 'E402:')
3010
3011 CheckScriptSuccess([
3012 'vim9script',
3013 'syntax match Word /pat/ contains=Something # comment',
3014 ])
3015 CheckScriptFailure([
3016 'vim9script',
3017 'syntax match Word /pat/ contains=Something# comment',
3018 ], 'E475:')
3019 CheckScriptFailure([
3020 'vim9script',
3021 'syntax match Word /pat/ contains= # comment',
3022 ], 'E406:')
3023 CheckScriptFailure([
3024 'vim9script',
3025 'syntax match Word /pat/ contains=# comment',
3026 ], 'E475:')
3027
3028 CheckScriptSuccess([
3029 'vim9script',
3030 'syntax region Word start=/pat/ end=/pat/ # comment',
3031 ])
3032 CheckScriptFailure([
3033 'vim9script',
3034 'syntax region Word start=/pat/ end=/pat/# comment',
Bram Moolenaard032f342020-07-18 18:13:02 +02003035 ], 'E402:')
Bram Moolenaar1966c242020-04-20 22:42:32 +02003036
3037 CheckScriptSuccess([
3038 'vim9script',
3039 'syntax sync # comment',
3040 ])
3041 CheckScriptFailure([
3042 'vim9script',
3043 'syntax sync# comment',
3044 ], 'E404:')
3045 CheckScriptSuccess([
3046 'vim9script',
3047 'syntax sync ccomment # comment',
3048 ])
3049 CheckScriptFailure([
3050 'vim9script',
3051 'syntax sync ccomment# comment',
3052 ], 'E404:')
3053
3054 CheckScriptSuccess([
3055 'vim9script',
3056 'syntax cluster Some contains=Word # comment',
3057 ])
3058 CheckScriptFailure([
3059 'vim9script',
3060 'syntax cluster Some contains=Word# comment',
3061 ], 'E475:')
Bram Moolenaara72cfb82020-04-23 17:07:30 +02003062
3063 CheckScriptSuccess([
3064 'vim9script',
3065 'command Echo echo # comment',
3066 'command Echo # comment',
Bram Moolenaar2d870f82020-12-05 13:41:01 +01003067 'delcommand Echo',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02003068 ])
3069 CheckScriptFailure([
3070 'vim9script',
3071 'command Echo echo# comment',
3072 'Echo',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01003073 ], 'E1144:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01003074 delcommand Echo
Bram Moolenaar70249ee2020-12-10 21:01:30 +01003075
3076 var curdir = getcwd()
3077 CheckScriptSuccess([
3078 'command Echo cd " comment',
3079 'Echo',
3080 'delcommand Echo',
3081 ])
3082 CheckScriptSuccess([
Bram Moolenaar090728a2020-12-20 15:43:31 +01003083 'vim9script',
Bram Moolenaar70249ee2020-12-10 21:01:30 +01003084 'command Echo cd # comment',
3085 'Echo',
3086 'delcommand Echo',
3087 ])
3088 CheckScriptFailure([
3089 'vim9script',
3090 'command Echo cd " comment',
3091 'Echo',
3092 ], 'E344:')
3093 delcommand Echo
3094 chdir(curdir)
3095
Bram Moolenaara72cfb82020-04-23 17:07:30 +02003096 CheckScriptFailure([
3097 'vim9script',
3098 'command Echo# comment',
3099 ], 'E182:')
3100 CheckScriptFailure([
3101 'vim9script',
3102 'command Echo echo',
3103 'command Echo# comment',
3104 ], 'E182:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01003105 delcommand Echo
Bram Moolenaara72cfb82020-04-23 17:07:30 +02003106
3107 CheckScriptSuccess([
3108 'vim9script',
3109 'function # comment',
3110 ])
3111 CheckScriptFailure([
3112 'vim9script',
Bram Moolenaar98981072020-07-29 14:40:25 +02003113 'function " comment',
3114 ], 'E129:')
3115 CheckScriptFailure([
3116 'vim9script',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02003117 'function# comment',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01003118 ], 'E1144:')
Bram Moolenaara72cfb82020-04-23 17:07:30 +02003119 CheckScriptSuccess([
3120 'vim9script',
3121 'function CheckScriptSuccess # comment',
3122 ])
3123 CheckScriptFailure([
3124 'vim9script',
3125 'function CheckScriptSuccess# comment',
3126 ], 'E488:')
3127
3128 CheckScriptSuccess([
3129 'vim9script',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02003130 'func g:DeleteMeA()',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02003131 'endfunc',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02003132 'delfunction g:DeleteMeA # comment',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02003133 ])
3134 CheckScriptFailure([
3135 'vim9script',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02003136 'func g:DeleteMeB()',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02003137 'endfunc',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02003138 'delfunction g:DeleteMeB# comment',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02003139 ], 'E488:')
3140
3141 CheckScriptSuccess([
3142 'vim9script',
3143 'call execute("ls") # comment',
3144 ])
3145 CheckScriptFailure([
3146 'vim9script',
3147 'call execute("ls")# comment',
3148 ], 'E488:')
Bram Moolenaare7e48382020-07-22 18:17:08 +02003149
3150 CheckScriptFailure([
3151 'def Test() " comment',
3152 'enddef',
3153 ], 'E488:')
3154 CheckScriptFailure([
3155 'vim9script',
3156 'def Test() " comment',
3157 'enddef',
3158 ], 'E488:')
3159
3160 CheckScriptSuccess([
3161 'func Test() " comment',
3162 'endfunc',
Bram Moolenaar2d870f82020-12-05 13:41:01 +01003163 'delfunc Test',
Bram Moolenaare7e48382020-07-22 18:17:08 +02003164 ])
Bram Moolenaar98981072020-07-29 14:40:25 +02003165 CheckScriptSuccess([
Bram Moolenaare7e48382020-07-22 18:17:08 +02003166 'vim9script',
3167 'func Test() " comment',
3168 'endfunc',
Bram Moolenaar98981072020-07-29 14:40:25 +02003169 ])
Bram Moolenaare7e48382020-07-22 18:17:08 +02003170
3171 CheckScriptSuccess([
3172 'def Test() # comment',
3173 'enddef',
3174 ])
3175 CheckScriptFailure([
3176 'func Test() # comment',
3177 'endfunc',
3178 ], 'E488:')
Bram Moolenaar0f37e352021-06-02 15:28:15 +02003179
3180 var lines =<< trim END
3181 vim9script
3182 syn region Text
3183 \ start='foo'
3184 #\ comment
3185 \ end='bar'
Bram Moolenaar5072b472021-06-03 21:56:10 +02003186 syn region Text start='foo'
3187 #\ comment
3188 \ end='bar'
Bram Moolenaar0f37e352021-06-02 15:28:15 +02003189 END
3190 CheckScriptSuccess(lines)
3191
3192 lines =<< trim END
3193 vim9script
3194 syn region Text
3195 \ start='foo'
3196 "\ comment
3197 \ end='bar'
3198 END
3199 CheckScriptFailure(lines, 'E399:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02003200enddef
3201
3202def Test_vim9_comment_gui()
3203 CheckCanRunGui
3204
3205 CheckScriptFailure([
3206 'vim9script',
3207 'gui#comment'
Bram Moolenaarf8103f22020-12-25 17:36:27 +01003208 ], 'E1144:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02003209 CheckScriptFailure([
3210 'vim9script',
3211 'gui -f#comment'
3212 ], 'E499:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02003213enddef
3214
Bram Moolenaara26b9702020-04-18 19:53:28 +02003215def Test_vim9_comment_not_compiled()
Bram Moolenaar67979662020-06-20 22:50:47 +02003216 au TabEnter *.vim g:entered = 1
3217 au TabEnter *.x g:entered = 2
Bram Moolenaara26b9702020-04-18 19:53:28 +02003218
3219 edit test.vim
3220 doautocmd TabEnter #comment
3221 assert_equal(1, g:entered)
3222
3223 doautocmd TabEnter f.x
3224 assert_equal(2, g:entered)
3225
3226 g:entered = 0
3227 doautocmd TabEnter f.x #comment
3228 assert_equal(2, g:entered)
3229
3230 assert_fails('doautocmd Syntax#comment', 'E216:')
3231
3232 au! TabEnter
3233 unlet g:entered
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02003234
3235 CheckScriptSuccess([
3236 'vim9script',
Bram Moolenaar67979662020-06-20 22:50:47 +02003237 'g:var = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02003238 'b:var = 456',
3239 'w:var = 777',
3240 't:var = 888',
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02003241 'unlet g:var w:var # something',
3242 ])
3243
3244 CheckScriptFailure([
3245 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003246 'let var = 123',
3247 ], 'E1126: Cannot use :let in Vim9 script')
3248
3249 CheckScriptFailure([
3250 'vim9script',
3251 'var g:var = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02003252 ], 'E1016: Cannot declare a global variable:')
3253
3254 CheckScriptFailure([
3255 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003256 'var b:var = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02003257 ], 'E1016: Cannot declare a buffer variable:')
3258
3259 CheckScriptFailure([
3260 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003261 'var w:var = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02003262 ], 'E1016: Cannot declare a window variable:')
3263
3264 CheckScriptFailure([
3265 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003266 'var t:var = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02003267 ], 'E1016: Cannot declare a tab variable:')
3268
3269 CheckScriptFailure([
3270 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003271 'var v:version = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02003272 ], 'E1016: Cannot declare a v: variable:')
3273
3274 CheckScriptFailure([
3275 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003276 'var $VARIABLE = "text"',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02003277 ], 'E1016: Cannot declare an environment variable:')
Bram Moolenaar67979662020-06-20 22:50:47 +02003278
3279 CheckScriptFailure([
3280 'vim9script',
3281 'g:var = 123',
Bram Moolenaar32e35112020-05-14 22:41:15 +02003282 'unlet g:var# comment1',
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02003283 ], 'E108:')
3284
3285 CheckScriptFailure([
3286 'let g:var = 123',
3287 'unlet g:var # something',
3288 ], 'E488:')
Bram Moolenaarfaac4102020-04-20 17:46:14 +02003289
3290 CheckScriptSuccess([
3291 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02003292 'if 1 # comment2',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02003293 ' echo "yes"',
3294 'elseif 2 #comment',
3295 ' echo "no"',
3296 'endif',
3297 ])
3298
3299 CheckScriptFailure([
3300 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02003301 'if 1# comment3',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02003302 ' echo "yes"',
3303 'endif',
Bram Moolenaarfae55a92021-06-17 22:08:30 +02003304 ], 'E488:')
Bram Moolenaarfaac4102020-04-20 17:46:14 +02003305
3306 CheckScriptFailure([
3307 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02003308 'if 0 # comment4',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02003309 ' echo "yes"',
3310 'elseif 2#comment',
3311 ' echo "no"',
3312 'endif',
Bram Moolenaarfae55a92021-06-17 22:08:30 +02003313 ], 'E488:')
Bram Moolenaarfaac4102020-04-20 17:46:14 +02003314
3315 CheckScriptSuccess([
3316 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003317 'var v = 1 # comment5',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02003318 ])
3319
3320 CheckScriptFailure([
3321 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003322 'var v = 1# comment6',
Bram Moolenaarfae55a92021-06-17 22:08:30 +02003323 ], 'E488:')
Bram Moolenaarfaac4102020-04-20 17:46:14 +02003324
Bram Moolenaarfaac4102020-04-20 17:46:14 +02003325 CheckScriptSuccess([
3326 'vim9script',
3327 'new'
Bram Moolenaard2c61702020-09-06 15:58:36 +02003328 'setline(1, ["# define pat", "last"])',
Bram Moolenaardf069ee2020-06-22 23:02:51 +02003329 ':$',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02003330 'dsearch /pat/ #comment',
3331 'bwipe!',
3332 ])
3333
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02003334 CheckScriptFailure([
3335 'vim9script',
3336 'new'
Bram Moolenaard2c61702020-09-06 15:58:36 +02003337 'setline(1, ["# define pat", "last"])',
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02003338 ':$',
3339 'dsearch /pat/#comment',
3340 'bwipe!',
3341 ], 'E488:')
3342
3343 CheckScriptFailure([
3344 'vim9script',
3345 'func! SomeFunc()',
3346 ], 'E477:')
Bram Moolenaara26b9702020-04-18 19:53:28 +02003347enddef
3348
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02003349def Test_finish()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003350 var lines =<< trim END
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02003351 vim9script
Bram Moolenaar67979662020-06-20 22:50:47 +02003352 g:res = 'one'
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02003353 if v:false | finish | endif
Bram Moolenaar67979662020-06-20 22:50:47 +02003354 g:res = 'two'
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02003355 finish
Bram Moolenaar67979662020-06-20 22:50:47 +02003356 g:res = 'three'
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02003357 END
3358 writefile(lines, 'Xfinished')
3359 source Xfinished
3360 assert_equal('two', g:res)
3361
3362 unlet g:res
3363 delete('Xfinished')
3364enddef
3365
Bram Moolenaara5d00772020-05-14 23:20:55 +02003366def Test_forward_declaration()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003367 var lines =<< trim END
Bram Moolenaara5d00772020-05-14 23:20:55 +02003368 vim9script
Bram Moolenaara5d00772020-05-14 23:20:55 +02003369 def GetValue(): string
3370 return theVal
3371 enddef
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003372 var theVal = 'something'
Bram Moolenaar822ba242020-05-24 23:00:18 +02003373 g:initVal = GetValue()
Bram Moolenaara5d00772020-05-14 23:20:55 +02003374 theVal = 'else'
3375 g:laterVal = GetValue()
3376 END
3377 writefile(lines, 'Xforward')
3378 source Xforward
3379 assert_equal('something', g:initVal)
3380 assert_equal('else', g:laterVal)
3381
3382 unlet g:initVal
3383 unlet g:laterVal
3384 delete('Xforward')
3385enddef
3386
Bram Moolenaar9721fb42020-06-11 23:10:46 +02003387def Test_source_vim9_from_legacy()
Bram Moolenaara6294952020-12-27 13:39:50 +01003388 var vim9_lines =<< trim END
3389 vim9script
3390 var local = 'local'
3391 g:global = 'global'
3392 export var exported = 'exported'
3393 export def GetText(): string
3394 return 'text'
3395 enddef
3396 END
3397 writefile(vim9_lines, 'Xvim9_script.vim')
3398
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003399 var legacy_lines =<< trim END
Bram Moolenaar9721fb42020-06-11 23:10:46 +02003400 source Xvim9_script.vim
3401
3402 call assert_false(exists('local'))
3403 call assert_false(exists('exported'))
3404 call assert_false(exists('s:exported'))
3405 call assert_equal('global', global)
3406 call assert_equal('global', g:global)
3407
3408 " imported variable becomes script-local
3409 import exported from './Xvim9_script.vim'
3410 call assert_equal('exported', s:exported)
3411 call assert_false(exists('exported'))
3412
3413 " imported function becomes script-local
3414 import GetText from './Xvim9_script.vim'
3415 call assert_equal('text', s:GetText())
3416 call assert_false(exists('*GetText'))
3417 END
3418 writefile(legacy_lines, 'Xlegacy_script.vim')
3419
Bram Moolenaar9721fb42020-06-11 23:10:46 +02003420 source Xlegacy_script.vim
Bram Moolenaar9721fb42020-06-11 23:10:46 +02003421 assert_equal('global', g:global)
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02003422 unlet g:global
Bram Moolenaar9721fb42020-06-11 23:10:46 +02003423
3424 delete('Xlegacy_script.vim')
3425 delete('Xvim9_script.vim')
3426enddef
Bram Moolenaara5d00772020-05-14 23:20:55 +02003427
Bram Moolenaare535db82021-03-31 21:07:24 +02003428def Test_declare_script_in_func()
3429 var lines =<< trim END
3430 vim9script
3431 func Declare()
3432 let s:local = 123
3433 endfunc
3434 Declare()
3435 assert_equal(123, local)
3436
3437 var error: string
3438 try
3439 local = 'asdf'
3440 catch
3441 error = v:exception
3442 endtry
3443 assert_match('E1012: Type mismatch; expected number but got string', error)
3444
3445 lockvar local
3446 try
3447 local = 999
3448 catch
3449 error = v:exception
3450 endtry
3451 assert_match('E741: Value is locked: local', error)
3452 END
3453 CheckScriptSuccess(lines)
3454enddef
3455
3456
Bram Moolenaar7d699702020-08-14 20:52:28 +02003457func Test_vim9script_not_global()
3458 " check that items defined in Vim9 script are script-local, not global
3459 let vim9lines =<< trim END
3460 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003461 var name = 'local'
Bram Moolenaar7d699702020-08-14 20:52:28 +02003462 func TheFunc()
3463 echo 'local'
3464 endfunc
3465 def DefFunc()
3466 echo 'local'
3467 enddef
3468 END
3469 call writefile(vim9lines, 'Xvim9script.vim')
3470 source Xvim9script.vim
3471 try
3472 echo g:var
3473 assert_report('did not fail')
3474 catch /E121:/
3475 " caught
3476 endtry
3477 try
3478 call TheFunc()
3479 assert_report('did not fail')
3480 catch /E117:/
3481 " caught
3482 endtry
3483 try
3484 call DefFunc()
3485 assert_report('did not fail')
3486 catch /E117:/
3487 " caught
3488 endtry
3489
Bram Moolenaar25859dd2020-08-30 12:54:53 +02003490 call delete('Xvim9script.vim')
Bram Moolenaar7d699702020-08-14 20:52:28 +02003491endfunc
3492
Bram Moolenaareeb27bf2020-07-04 17:39:10 +02003493def Test_vim9_copen()
3494 # this was giving an error for setting w:quickfix_title
3495 copen
3496 quit
3497enddef
3498
Bram Moolenaar03290b82020-12-19 16:30:44 +01003499" test using an auto-loaded function and variable
Bram Moolenaar2d6b20d2020-07-25 19:30:59 +02003500def Test_vim9_autoload()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003501 var lines =<< trim END
Bram Moolenaar2d6b20d2020-07-25 19:30:59 +02003502 vim9script
Bram Moolenaar03290b82020-12-19 16:30:44 +01003503 def some#gettest(): string
3504 return 'test'
3505 enddef
3506 g:some#name = 'name'
Bram Moolenaar227c58a2021-04-28 20:40:44 +02003507 g:some#dict = {key: 'value'}
Bram Moolenaare3ffcd92021-03-08 21:47:13 +01003508
3509 def some#varargs(a1: string, ...l: list<string>): string
3510 return a1 .. l[0] .. l[1]
3511 enddef
Bram Moolenaar03290b82020-12-19 16:30:44 +01003512 END
3513
3514 mkdir('Xdir/autoload', 'p')
3515 writefile(lines, 'Xdir/autoload/some.vim')
3516 var save_rtp = &rtp
3517 exe 'set rtp^=' .. getcwd() .. '/Xdir'
3518
3519 assert_equal('test', g:some#gettest())
3520 assert_equal('name', g:some#name)
Bram Moolenaar227c58a2021-04-28 20:40:44 +02003521 assert_equal('value', g:some#dict.key)
Bram Moolenaar03290b82020-12-19 16:30:44 +01003522 g:some#other = 'other'
3523 assert_equal('other', g:some#other)
3524
Bram Moolenaare3ffcd92021-03-08 21:47:13 +01003525 assert_equal('abc', some#varargs('a', 'b', 'c'))
3526
Bram Moolenaar17f700a2020-12-19 21:23:42 +01003527 # upper case script name works
3528 lines =<< trim END
3529 vim9script
3530 def Other#getOther(): string
3531 return 'other'
3532 enddef
3533 END
3534 writefile(lines, 'Xdir/autoload/Other.vim')
3535 assert_equal('other', g:Other#getOther())
3536
Bram Moolenaar03290b82020-12-19 16:30:44 +01003537 delete('Xdir', 'rf')
3538 &rtp = save_rtp
3539enddef
3540
3541" test using a vim9script that is auto-loaded from an autocmd
3542def Test_vim9_aucmd_autoload()
3543 var lines =<< trim END
3544 vim9script
Bram Moolenaar2d6b20d2020-07-25 19:30:59 +02003545 def foo#test()
3546 echomsg getreg('"')
3547 enddef
3548 END
3549
3550 mkdir('Xdir/autoload', 'p')
3551 writefile(lines, 'Xdir/autoload/foo.vim')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003552 var save_rtp = &rtp
Bram Moolenaar2d6b20d2020-07-25 19:30:59 +02003553 exe 'set rtp^=' .. getcwd() .. '/Xdir'
3554 augroup test
3555 autocmd TextYankPost * call foo#test()
3556 augroup END
3557
3558 normal Y
3559
3560 augroup test
3561 autocmd!
3562 augroup END
3563 delete('Xdir', 'rf')
3564 &rtp = save_rtp
3565enddef
3566
Bram Moolenaar77e5dcc2020-09-17 21:29:03 +02003567" This was causing a crash because suppress_errthrow wasn't reset.
3568def Test_vim9_autoload_error()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003569 var lines =<< trim END
Bram Moolenaar77e5dcc2020-09-17 21:29:03 +02003570 vim9script
3571 def crash#func()
3572 try
3573 for x in List()
3574 endfor
3575 catch
3576 endtry
3577 g:ok = true
3578 enddef
3579 fu List()
3580 invalid
3581 endfu
3582 try
Bram Moolenaar48e11c12021-01-11 18:47:00 +01003583 alsoinvalid
Bram Moolenaar77e5dcc2020-09-17 21:29:03 +02003584 catch /wontmatch/
3585 endtry
3586 END
3587 call mkdir('Xruntime/autoload', 'p')
3588 call writefile(lines, 'Xruntime/autoload/crash.vim')
3589
3590 # run in a separate Vim to avoid the side effects of assert_fails()
3591 lines =<< trim END
3592 exe 'set rtp^=' .. getcwd() .. '/Xruntime'
3593 call crash#func()
3594 call writefile(['ok'], 'Xdidit')
Bram Moolenaar9c4f5522020-09-25 21:47:28 +02003595 qall!
Bram Moolenaar77e5dcc2020-09-17 21:29:03 +02003596 END
3597 writefile(lines, 'Xscript')
3598 RunVim([], [], '-S Xscript')
3599 assert_equal(['ok'], readfile('Xdidit'))
3600
3601 delete('Xdidit')
3602 delete('Xscript')
3603 delete('Xruntime', 'rf')
Bram Moolenaar03290b82020-12-19 16:30:44 +01003604
3605 lines =<< trim END
3606 vim9script
3607 var foo#bar = 'asdf'
3608 END
3609 CheckScriptFailure(lines, 'E461: Illegal variable name: foo#bar', 2)
Bram Moolenaar77e5dcc2020-09-17 21:29:03 +02003610enddef
3611
Bram Moolenaar81e17fb2020-08-21 21:55:43 +02003612def Test_script_var_in_autocmd()
3613 # using a script variable from an autocommand, defined in a :def function in a
3614 # legacy Vim script, cannot check the variable type.
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003615 var lines =<< trim END
Bram Moolenaar81e17fb2020-08-21 21:55:43 +02003616 let s:counter = 1
3617 def s:Func()
3618 au! CursorHold
3619 au CursorHold * s:counter += 1
3620 enddef
3621 call s:Func()
3622 doau CursorHold
3623 call assert_equal(2, s:counter)
3624 au! CursorHold
3625 END
3626 CheckScriptSuccess(lines)
3627enddef
3628
Bram Moolenaar3896a102020-08-09 14:33:55 +02003629def Test_cmdline_win()
3630 # if the Vim syntax highlighting uses Vim9 constructs they can be used from
3631 # the command line window.
3632 mkdir('rtp/syntax', 'p')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003633 var export_lines =<< trim END
Bram Moolenaar3896a102020-08-09 14:33:55 +02003634 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003635 export var That = 'yes'
Bram Moolenaar3896a102020-08-09 14:33:55 +02003636 END
3637 writefile(export_lines, 'rtp/syntax/Xexport.vim')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003638 var import_lines =<< trim END
Bram Moolenaar3896a102020-08-09 14:33:55 +02003639 vim9script
3640 import That from './Xexport.vim'
3641 END
3642 writefile(import_lines, 'rtp/syntax/vim.vim')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003643 var save_rtp = &rtp
Bram Moolenaar3896a102020-08-09 14:33:55 +02003644 &rtp = getcwd() .. '/rtp' .. ',' .. &rtp
3645 syntax on
3646 augroup CmdWin
3647 autocmd CmdwinEnter * g:got_there = 'yes'
3648 augroup END
3649 # this will open and also close the cmdline window
3650 feedkeys('q:', 'xt')
3651 assert_equal('yes', g:got_there)
3652
3653 augroup CmdWin
3654 au!
3655 augroup END
3656 &rtp = save_rtp
3657 delete('rtp', 'rf')
3658enddef
3659
Bram Moolenaare3d46852020-08-29 13:39:17 +02003660def Test_invalid_sid()
3661 assert_fails('func <SNR>1234_func', 'E123:')
Bram Moolenaar25859dd2020-08-30 12:54:53 +02003662
Bram Moolenaar9c4f5522020-09-25 21:47:28 +02003663 if RunVim([], ['wq! Xdidit'], '+"func <SNR>1_func"')
Bram Moolenaard2c61702020-09-06 15:58:36 +02003664 assert_equal([], readfile('Xdidit'))
Bram Moolenaare3d46852020-08-29 13:39:17 +02003665 endif
3666 delete('Xdidit')
3667enddef
3668
Bram Moolenaar9ec70262020-12-09 17:16:59 +01003669def Test_restoring_cpo()
3670 writefile(['vim9script', 'set nocp'], 'Xsourced')
3671 writefile(['call writefile(["done"], "Xdone")', 'quit!'], 'Xclose')
3672 if RunVim([], [], '-u NONE +"set cpo+=a" -S Xsourced -S Xclose')
3673 assert_equal(['done'], readfile('Xdone'))
3674 endif
3675 delete('Xsourced')
3676 delete('Xclose')
Bram Moolenaar090728a2020-12-20 15:43:31 +01003677 delete('Xdone')
Bram Moolenaar0123cc12021-02-07 17:17:58 +01003678
3679 writefile(['vim9script'], 'XanotherScript')
3680 set cpo=aABceFsMny>
3681 edit XanotherScript
3682 so %
3683 assert_equal('aABceFsMny>', &cpo)
3684 :1del
3685 w
3686 so %
3687 assert_equal('aABceFsMny>', &cpo)
3688
3689 delete('XanotherScript')
3690 set cpo&vim
Bram Moolenaar9ec70262020-12-09 17:16:59 +01003691enddef
3692
Bram Moolenaarffb7dcd2021-03-10 14:00:18 +01003693" Use :function so we can use Check commands
3694func Test_no_redraw_when_restoring_cpo()
Bram Moolenaar37294bd2021-03-10 13:40:08 +01003695 CheckScreendump
Bram Moolenaarffb7dcd2021-03-10 14:00:18 +01003696 CheckFeature timers
Bram Moolenaar37294bd2021-03-10 13:40:08 +01003697
Bram Moolenaarffb7dcd2021-03-10 14:00:18 +01003698 let lines =<< trim END
Bram Moolenaar37294bd2021-03-10 13:40:08 +01003699 vim9script
3700 def script#func()
3701 enddef
3702 END
Bram Moolenaarffb7dcd2021-03-10 14:00:18 +01003703 call mkdir('Xdir/autoload', 'p')
3704 call writefile(lines, 'Xdir/autoload/script.vim')
Bram Moolenaar37294bd2021-03-10 13:40:08 +01003705
Bram Moolenaarffb7dcd2021-03-10 14:00:18 +01003706 let lines =<< trim END
Bram Moolenaar37294bd2021-03-10 13:40:08 +01003707 vim9script
3708 set cpo+=M
3709 exe 'set rtp^=' .. getcwd() .. '/Xdir'
Bram Moolenaar767034c2021-04-09 17:24:52 +02003710 au CmdlineEnter : ++once timer_start(0, (_) => script#func())
Bram Moolenaar37294bd2021-03-10 13:40:08 +01003711 setline(1, 'some text')
3712 END
Bram Moolenaarffb7dcd2021-03-10 14:00:18 +01003713 call writefile(lines, 'XTest_redraw_cpo')
3714 let buf = RunVimInTerminal('-S XTest_redraw_cpo', {'rows': 6})
3715 call term_sendkeys(buf, "V:")
3716 call VerifyScreenDump(buf, 'Test_vim9_no_redraw', {})
Bram Moolenaar37294bd2021-03-10 13:40:08 +01003717
Bram Moolenaarffb7dcd2021-03-10 14:00:18 +01003718 " clean up
3719 call term_sendkeys(buf, "\<Esc>u")
3720 call StopVimInTerminal(buf)
3721 call delete('XTest_redraw_cpo')
3722 call delete('Xdir', 'rf')
3723endfunc
Bram Moolenaar37294bd2021-03-10 13:40:08 +01003724
Bram Moolenaar9ec70262020-12-09 17:16:59 +01003725
Bram Moolenaarf0afd9e2020-09-13 18:57:47 +02003726def Test_unset_any_variable()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003727 var lines =<< trim END
3728 var name: any
3729 assert_equal(0, name)
Bram Moolenaarf0afd9e2020-09-13 18:57:47 +02003730 END
3731 CheckDefAndScriptSuccess(lines)
3732enddef
3733
Bram Moolenaar7e9210e2020-09-25 23:12:51 +02003734func Test_define_func_at_command_line()
Bram Moolenaar58dbef32020-09-25 22:13:05 +02003735 CheckRunVimInTerminal
3736
Bram Moolenaar7e9210e2020-09-25 23:12:51 +02003737 " call indirectly to avoid compilation error for missing functions
3738 call Run_Test_define_func_at_command_line()
3739endfunc
3740
3741def Run_Test_define_func_at_command_line()
Bram Moolenaar9c4f5522020-09-25 21:47:28 +02003742 # run in a separate Vim instance to avoid the script context
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003743 var lines =<< trim END
Bram Moolenaar9c4f5522020-09-25 21:47:28 +02003744 func CheckAndQuit()
3745 call assert_fails('call Afunc()', 'E117: Unknown function: Bfunc')
3746 call writefile(['errors: ' .. string(v:errors)], 'Xdidcmd')
3747 endfunc
3748 END
3749 writefile([''], 'Xdidcmd')
3750 writefile(lines, 'XcallFunc')
Bram Moolenaare0de1712020-12-02 17:36:54 +01003751 var buf = RunVimInTerminal('-S XcallFunc', {rows: 6})
Bram Moolenaar9c4f5522020-09-25 21:47:28 +02003752 # define Afunc() on the command line
3753 term_sendkeys(buf, ":def Afunc()\<CR>Bfunc()\<CR>enddef\<CR>")
3754 term_sendkeys(buf, ":call CheckAndQuit()\<CR>")
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01003755 WaitForAssert(() => assert_equal(['errors: []'], readfile('Xdidcmd')))
Bram Moolenaar9c4f5522020-09-25 21:47:28 +02003756
3757 call StopVimInTerminal(buf)
3758 delete('XcallFunc')
3759 delete('Xdidcmd')
3760enddef
3761
Bram Moolenaarfcdc5d82020-10-10 19:07:09 +02003762def Test_script_var_scope()
3763 var lines =<< trim END
3764 vim9script
3765 if true
3766 if true
3767 var one = 'one'
3768 echo one
3769 endif
3770 echo one
3771 endif
3772 END
3773 CheckScriptFailure(lines, 'E121:', 7)
3774
3775 lines =<< trim END
3776 vim9script
3777 if true
3778 if false
3779 var one = 'one'
3780 echo one
3781 else
3782 var one = 'one'
3783 echo one
3784 endif
3785 echo one
3786 endif
3787 END
3788 CheckScriptFailure(lines, 'E121:', 10)
3789
3790 lines =<< trim END
3791 vim9script
3792 while true
3793 var one = 'one'
3794 echo one
3795 break
3796 endwhile
3797 echo one
3798 END
3799 CheckScriptFailure(lines, 'E121:', 7)
3800
3801 lines =<< trim END
3802 vim9script
3803 for i in range(1)
3804 var one = 'one'
3805 echo one
3806 endfor
3807 echo one
3808 END
3809 CheckScriptFailure(lines, 'E121:', 6)
Bram Moolenaar9becdf22020-10-10 21:33:48 +02003810
3811 lines =<< trim END
3812 vim9script
3813 {
3814 var one = 'one'
3815 assert_equal('one', one)
3816 }
3817 assert_false(exists('one'))
3818 assert_false(exists('s:one'))
3819 END
3820 CheckScriptSuccess(lines)
3821
3822 lines =<< trim END
3823 vim9script
3824 {
3825 var one = 'one'
3826 echo one
3827 }
3828 echo one
3829 END
3830 CheckScriptFailure(lines, 'E121:', 6)
Bram Moolenaarfcdc5d82020-10-10 19:07:09 +02003831enddef
3832
Bram Moolenaar352134b2020-10-17 22:04:08 +02003833def Test_catch_exception_in_callback()
3834 var lines =<< trim END
3835 vim9script
Bram Moolenaar2a389082021-04-09 20:24:31 +02003836 def Callback(...l: list<any>)
Bram Moolenaar352134b2020-10-17 22:04:08 +02003837 try
3838 var x: string
3839 var y: string
3840 # this error should be caught with CHECKLEN
3841 [x, y] = ['']
3842 catch
3843 g:caught = 'yes'
3844 endtry
3845 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +01003846 popup_menu('popup', {callback: Callback})
Bram Moolenaar352134b2020-10-17 22:04:08 +02003847 feedkeys("\r", 'xt')
3848 END
3849 CheckScriptSuccess(lines)
3850
3851 unlet g:caught
3852enddef
3853
Bram Moolenaar631e8f92020-11-04 15:07:16 +01003854def Test_no_unknown_error_after_error()
3855 if !has('unix') || !has('job')
3856 throw 'Skipped: not unix of missing +job feature'
3857 endif
3858 var lines =<< trim END
3859 vim9script
3860 var source: list<number>
Bram Moolenaar2a389082021-04-09 20:24:31 +02003861 def Out_cb(...l: list<any>)
Bram Moolenaar631e8f92020-11-04 15:07:16 +01003862 eval [][0]
3863 enddef
Bram Moolenaar2a389082021-04-09 20:24:31 +02003864 def Exit_cb(...l: list<any>)
Bram Moolenaar631e8f92020-11-04 15:07:16 +01003865 sleep 1m
3866 source += l
3867 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +01003868 var myjob = job_start('echo burp', {out_cb: Out_cb, exit_cb: Exit_cb, mode: 'raw'})
Bram Moolenaar6f17a3f2020-12-21 18:11:24 +01003869 while job_status(myjob) == 'run'
3870 sleep 10m
3871 endwhile
Bram Moolenaar206c2a62021-01-31 14:04:44 +01003872 # wait for Exit_cb() to be called
Bram Moolenaarfe95b942021-04-10 20:52:43 +02003873 sleep 200m
Bram Moolenaar631e8f92020-11-04 15:07:16 +01003874 END
3875 writefile(lines, 'Xdef')
3876 assert_fails('so Xdef', ['E684:', 'E1012:'])
3877 delete('Xdef')
3878enddef
3879
Bram Moolenaar4324d872020-12-01 20:12:24 +01003880def InvokeNormal()
3881 exe "norm! :m+1\r"
3882enddef
3883
3884def Test_invoke_normal_in_visual_mode()
3885 xnoremap <F3> <Cmd>call <SID>InvokeNormal()<CR>
3886 new
3887 setline(1, ['aaa', 'bbb'])
3888 feedkeys("V\<F3>", 'xt')
3889 assert_equal(['bbb', 'aaa'], getline(1, 2))
3890 xunmap <F3>
3891enddef
3892
Bram Moolenaarb5b94802020-12-13 17:50:20 +01003893def Test_white_space_after_command()
3894 var lines =<< trim END
3895 exit_cb: Func})
3896 END
3897 CheckDefAndScriptFailure(lines, 'E1144:', 1)
Bram Moolenaarf8103f22020-12-25 17:36:27 +01003898
3899 lines =<< trim END
3900 e#
3901 END
3902 CheckDefAndScriptFailure(lines, 'E1144:', 1)
Bram Moolenaarb5b94802020-12-13 17:50:20 +01003903enddef
3904
Bram Moolenaar4aab88d2020-12-24 21:56:41 +01003905def Test_script_var_gone_when_sourced_twice()
3906 var lines =<< trim END
3907 vim9script
3908 if exists('g:guard')
3909 finish
3910 endif
3911 g:guard = 1
3912 var name = 'thename'
3913 def g:GetName(): string
3914 return name
3915 enddef
3916 def g:SetName(arg: string)
3917 name = arg
3918 enddef
3919 END
3920 writefile(lines, 'XscriptTwice.vim')
3921 so XscriptTwice.vim
3922 assert_equal('thename', g:GetName())
3923 g:SetName('newname')
3924 assert_equal('newname', g:GetName())
3925 so XscriptTwice.vim
3926 assert_fails('call g:GetName()', 'E1149:')
3927 assert_fails('call g:SetName("x")', 'E1149:')
3928
3929 delfunc g:GetName
3930 delfunc g:SetName
3931 delete('XscriptTwice.vim')
3932 unlet g:guard
3933enddef
3934
3935def Test_import_gone_when_sourced_twice()
3936 var exportlines =<< trim END
3937 vim9script
3938 if exists('g:guard')
3939 finish
3940 endif
3941 g:guard = 1
3942 export var name = 'someName'
3943 END
3944 writefile(exportlines, 'XexportScript.vim')
3945
3946 var lines =<< trim END
3947 vim9script
3948 import name from './XexportScript.vim'
3949 def g:GetName(): string
3950 return name
3951 enddef
3952 END
3953 writefile(lines, 'XscriptImport.vim')
3954 so XscriptImport.vim
3955 assert_equal('someName', g:GetName())
3956
3957 so XexportScript.vim
3958 assert_fails('call g:GetName()', 'E1149:')
3959
3960 delfunc g:GetName
3961 delete('XexportScript.vim')
3962 delete('XscriptImport.vim')
3963 unlet g:guard
3964enddef
3965
Bram Moolenaar10b94212021-02-19 21:42:57 +01003966def Test_unsupported_commands()
3967 var lines =<< trim END
3968 ka
3969 END
Bram Moolenaar7d840e92021-05-26 21:10:11 +02003970 CheckDefFailure(lines, 'E476:')
3971 CheckScriptFailure(['vim9script'] + lines, 'E492:')
Bram Moolenaar10b94212021-02-19 21:42:57 +01003972
3973 lines =<< trim END
Bram Moolenaarada1d872021-02-20 08:16:51 +01003974 :1ka
3975 END
Bram Moolenaar7d840e92021-05-26 21:10:11 +02003976 CheckDefFailure(lines, 'E476:')
3977 CheckScriptFailure(['vim9script'] + lines, 'E492:')
Bram Moolenaarada1d872021-02-20 08:16:51 +01003978
3979 lines =<< trim END
Bram Moolenaar10b94212021-02-19 21:42:57 +01003980 t
3981 END
3982 CheckDefFailure(lines, 'E1100:')
3983 CheckScriptFailure(['vim9script'] + lines, 'E1100:')
3984
3985 lines =<< trim END
3986 x
3987 END
3988 CheckDefFailure(lines, 'E1100:')
3989 CheckScriptFailure(['vim9script'] + lines, 'E1100:')
3990
3991 lines =<< trim END
3992 xit
3993 END
3994 CheckDefFailure(lines, 'E1100:')
3995 CheckScriptFailure(['vim9script'] + lines, 'E1100:')
3996enddef
3997
Bram Moolenaarc70fe462021-04-17 17:59:19 +02003998def Test_mapping_line_number()
3999 var lines =<< trim END
4000 vim9script
4001 def g:FuncA()
4002 # Some comment
4003 FuncB(0)
4004 enddef
4005 # Some comment
4006 def FuncB(
4007 # Some comment
4008 n: number
4009 )
4010 exe 'nno '
4011 # Some comment
4012 .. '<F3> a'
4013 .. 'b'
4014 .. 'c'
4015 enddef
4016 END
4017 CheckScriptSuccess(lines)
4018 var res = execute('verbose nmap <F3>')
4019 assert_match('No mapping found', res)
4020
4021 g:FuncA()
4022 res = execute('verbose nmap <F3>')
4023 assert_match(' <F3> .* abc.*Last set from .*XScriptSuccess\d\+ line 11', res)
4024
4025 nunmap <F3>
4026 delfunc g:FuncA
4027enddef
4028
Bram Moolenaar208f0b42021-06-20 12:40:08 +02004029def Test_option_modifier()
4030 var lines =<< trim END
4031 set hlsearch & hlsearch !
4032 call assert_equal(1, &hlsearch)
4033 END
4034 CheckScriptSuccess(lines)
4035
4036 lines =<< trim END
4037 vim9script
4038 set hlsearch &
4039 END
4040 CheckScriptFailure(lines, 'E518:')
4041
4042 lines =<< trim END
4043 vim9script
4044 set hlsearch & hlsearch !
4045 END
4046 CheckScriptFailure(lines, 'E518:')
4047enddef
4048
Bram Moolenaar585fea72020-04-02 22:33:21 +02004049" Keep this last, it messes up highlighting.
4050def Test_substitute_cmd()
4051 new
4052 setline(1, 'something')
4053 :substitute(some(other(
4054 assert_equal('otherthing', getline(1))
4055 bwipe!
4056
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02004057 # also when the context is Vim9 script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02004058 var lines =<< trim END
Bram Moolenaar585fea72020-04-02 22:33:21 +02004059 vim9script
4060 new
4061 setline(1, 'something')
4062 :substitute(some(other(
4063 assert_equal('otherthing', getline(1))
4064 bwipe!
4065 END
4066 writefile(lines, 'Xvim9lines')
4067 source Xvim9lines
4068
4069 delete('Xvim9lines')
4070enddef
4071
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004072" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker