blob: 2f6655287df173a11968beccfc68520e5411f643 [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 Moolenaar8a7d6542020-01-26 15:56:19 +01008
Bram Moolenaar5d72ce62020-08-20 23:04:06 +02009def Test_range_only()
10 new
11 setline(1, ['blah', 'Blah'])
12 :/Blah/
13 assert_equal(2, getcurpos()[1])
Bram Moolenaarc2af0af2020-08-23 21:06:02 +020014 bwipe!
15
16 # without range commands use current line
17 new
18 setline(1, ['one', 'two', 'three'])
19 :2
20 print
21 assert_equal('two', Screenline(&lines))
22 :3
23 list
24 assert_equal('three$', Screenline(&lines))
25 bwipe!
Bram Moolenaar025cb1c2020-12-14 18:31:27 +010026
27 # won't generate anything
28 if false
29 :123
30 endif
Bram Moolenaar5d72ce62020-08-20 23:04:06 +020031enddef
32
Bram Moolenaara6e67e42020-05-15 23:36:40 +020033let g:alist = [7]
34let g:astring = 'text'
Bram Moolenaarf0b9f432020-07-17 23:03:17 +020035let g:anumber = 123
Bram Moolenaar6e587dc2020-02-06 13:15:52 +010036
Bram Moolenaar4c17ad92020-04-27 22:47:51 +020037def Test_delfunction()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +020038 # Check function is defined in script namespace
Bram Moolenaar4c17ad92020-04-27 22:47:51 +020039 CheckScriptSuccess([
40 'vim9script',
41 'func CheckMe()',
42 ' return 123',
43 'endfunc',
44 'assert_equal(123, s:CheckMe())',
45 ])
46
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +020047 # Check function in script namespace cannot be deleted
Bram Moolenaar4c17ad92020-04-27 22:47:51 +020048 CheckScriptFailure([
49 'vim9script',
50 'func DeleteMe1()',
51 'endfunc',
52 'delfunction DeleteMe1',
53 ], 'E1084:')
54 CheckScriptFailure([
55 'vim9script',
56 'func DeleteMe2()',
57 'endfunc',
58 'def DoThat()',
59 ' delfunction DeleteMe2',
60 'enddef',
61 'DoThat()',
62 ], 'E1084:')
63 CheckScriptFailure([
64 'vim9script',
65 'def DeleteMe3()',
66 'enddef',
67 'delfunction DeleteMe3',
68 ], 'E1084:')
69 CheckScriptFailure([
70 'vim9script',
71 'def DeleteMe4()',
72 'enddef',
73 'def DoThat()',
74 ' delfunction DeleteMe4',
75 'enddef',
76 'DoThat()',
77 ], 'E1084:')
Bram Moolenaar925e9fd2020-07-25 15:41:11 +020078
79 # Check that global :def function can be replaced and deleted
Bram Moolenaarcfcd0112020-09-27 15:19:27 +020080 var lines =<< trim END
Bram Moolenaar925e9fd2020-07-25 15:41:11 +020081 vim9script
82 def g:Global(): string
83 return "yes"
84 enddef
85 assert_equal("yes", g:Global())
86 def! g:Global(): string
87 return "no"
88 enddef
89 assert_equal("no", g:Global())
90 delfunc g:Global
91 assert_false(exists('*g:Global'))
92 END
93 CheckScriptSuccess(lines)
94
95 # Check that global function can be replaced by a :def function and deleted
96 lines =<< trim END
97 vim9script
98 func g:Global()
99 return "yes"
100 endfunc
101 assert_equal("yes", g:Global())
102 def! g:Global(): string
103 return "no"
104 enddef
105 assert_equal("no", g:Global())
106 delfunc g:Global
107 assert_false(exists('*g:Global'))
108 END
109 CheckScriptSuccess(lines)
110
111 # Check that global :def function can be replaced by a function and deleted
112 lines =<< trim END
113 vim9script
114 def g:Global(): string
115 return "yes"
116 enddef
117 assert_equal("yes", g:Global())
118 func! g:Global()
119 return "no"
120 endfunc
121 assert_equal("no", g:Global())
122 delfunc g:Global
123 assert_false(exists('*g:Global'))
124 END
125 CheckScriptSuccess(lines)
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200126enddef
127
Bram Moolenaar08052222020-09-14 17:04:31 +0200128def Test_wrong_type()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200129 CheckDefFailure(['var name: list<nothing>'], 'E1010:')
130 CheckDefFailure(['var name: list<list<nothing>>'], 'E1010:')
131 CheckDefFailure(['var name: dict<nothing>'], 'E1010:')
132 CheckDefFailure(['var name: dict<dict<nothing>>'], 'E1010:')
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100133
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200134 CheckDefFailure(['var name: dict<number'], 'E1009:')
135 CheckDefFailure(['var name: dict<list<number>'], 'E1009:')
Bram Moolenaar42a480b2020-02-29 23:23:47 +0100136
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200137 CheckDefFailure(['var name: ally'], 'E1010:')
138 CheckDefFailure(['var name: bram'], 'E1010:')
139 CheckDefFailure(['var name: cathy'], 'E1010:')
140 CheckDefFailure(['var name: dom'], 'E1010:')
141 CheckDefFailure(['var name: freddy'], 'E1010:')
142 CheckDefFailure(['var name: john'], 'E1010:')
143 CheckDefFailure(['var name: larry'], 'E1010:')
144 CheckDefFailure(['var name: ned'], 'E1010:')
145 CheckDefFailure(['var name: pam'], 'E1010:')
146 CheckDefFailure(['var name: sam'], 'E1010:')
147 CheckDefFailure(['var name: vim'], 'E1010:')
Bram Moolenaara0a9f432020-04-28 21:29:34 +0200148
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200149 CheckDefFailure(['var Ref: number', 'Ref()'], 'E1085:')
150 CheckDefFailure(['var Ref: string', 'var res = Ref()'], 'E1085:')
Bram Moolenaar08052222020-09-14 17:04:31 +0200151enddef
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100152
Bram Moolenaar10c65862020-10-08 21:16:42 +0200153def Test_script_wrong_type()
154 var lines =<< trim END
155 vim9script
156 var s:dict: dict<string>
157 s:dict['a'] = ['x']
158 END
159 CheckScriptFailure(lines, 'E1012: Type mismatch; expected string but got list<string>', 3)
160enddef
161
Bram Moolenaar08052222020-09-14 17:04:31 +0200162def Test_const()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200163 CheckDefFailure(['final name = 234', 'name = 99'], 'E1018:')
164 CheckDefFailure(['final one = 234', 'var one = 99'], 'E1017:')
165 CheckDefFailure(['final list = [1, 2]', 'var list = [3, 4]'], 'E1017:')
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200166 CheckDefFailure(['final two'], 'E1125:')
167 CheckDefFailure(['final &option'], 'E996:')
Bram Moolenaardbeecb22020-09-14 18:15:09 +0200168
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200169 var lines =<< trim END
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200170 final list = [1, 2, 3]
Bram Moolenaardbeecb22020-09-14 18:15:09 +0200171 list[0] = 4
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200172 list->assert_equal([4, 2, 3])
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200173 const other = [5, 6, 7]
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200174 other->assert_equal([5, 6, 7])
Bram Moolenaar71abe482020-09-14 22:28:30 +0200175
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200176 var varlist = [7, 8]
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200177 const constlist = [1, varlist, 3]
Bram Moolenaar71abe482020-09-14 22:28:30 +0200178 varlist[0] = 77
179 # TODO: does not work yet
180 # constlist[1][1] = 88
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200181 var cl = constlist[1]
Bram Moolenaar71abe482020-09-14 22:28:30 +0200182 cl[1] = 88
183 constlist->assert_equal([1, [77, 88], 3])
184
Bram Moolenaare0de1712020-12-02 17:36:54 +0100185 var vardict = {five: 5, six: 6}
186 const constdict = {one: 1, two: vardict, three: 3}
Bram Moolenaar71abe482020-09-14 22:28:30 +0200187 vardict['five'] = 55
188 # TODO: does not work yet
189 # constdict['two']['six'] = 66
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200190 var cd = constdict['two']
Bram Moolenaar71abe482020-09-14 22:28:30 +0200191 cd['six'] = 66
Bram Moolenaare0de1712020-12-02 17:36:54 +0100192 constdict->assert_equal({one: 1, two: {five: 55, six: 66}, three: 3})
Bram Moolenaardbeecb22020-09-14 18:15:09 +0200193 END
194 CheckDefAndScriptSuccess(lines)
Bram Moolenaar08052222020-09-14 17:04:31 +0200195enddef
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100196
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200197def Test_const_bang()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200198 var lines =<< trim END
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200199 const var = 234
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200200 var = 99
201 END
202 CheckDefExecFailure(lines, 'E1018:', 2)
203 CheckScriptFailure(['vim9script'] + lines, 'E46:', 3)
204
205 lines =<< trim END
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200206 const ll = [2, 3, 4]
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200207 ll[0] = 99
208 END
209 CheckDefExecFailure(lines, 'E1119:', 2)
210 CheckScriptFailure(['vim9script'] + lines, 'E741:', 3)
211
212 lines =<< trim END
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200213 const ll = [2, 3, 4]
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200214 ll[3] = 99
215 END
216 CheckDefExecFailure(lines, 'E1118:', 2)
217 CheckScriptFailure(['vim9script'] + lines, 'E684:', 3)
218
219 lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +0100220 const dd = {one: 1, two: 2}
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200221 dd["one"] = 99
222 END
223 CheckDefExecFailure(lines, 'E1121:', 2)
224 CheckScriptFailure(['vim9script'] + lines, 'E741:', 3)
225
226 lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +0100227 const dd = {one: 1, two: 2}
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200228 dd["three"] = 99
229 END
230 CheckDefExecFailure(lines, 'E1120:')
231 CheckScriptFailure(['vim9script'] + lines, 'E741:', 3)
232enddef
233
Bram Moolenaardf069ee2020-06-22 23:02:51 +0200234def Test_range_no_colon()
Bram Moolenaard2c61702020-09-06 15:58:36 +0200235 CheckDefFailure(['%s/a/b/'], 'E1050:')
236 CheckDefFailure(['+ s/a/b/'], 'E1050:')
237 CheckDefFailure(['- s/a/b/'], 'E1050:')
238 CheckDefFailure(['. s/a/b/'], 'E1050:')
Bram Moolenaardf069ee2020-06-22 23:02:51 +0200239enddef
240
241
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100242def Test_block()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200243 var outer = 1
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100244 {
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200245 var inner = 2
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100246 assert_equal(1, outer)
247 assert_equal(2, inner)
248 }
249 assert_equal(1, outer)
250enddef
251
Bram Moolenaar08052222020-09-14 17:04:31 +0200252def Test_block_failure()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200253 CheckDefFailure(['{', 'var inner = 1', '}', 'echo inner'], 'E1001:')
Bram Moolenaar08052222020-09-14 17:04:31 +0200254 CheckDefFailure(['}'], 'E1025:')
255 CheckDefFailure(['{', 'echo 1'], 'E1026:')
256enddef
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100257
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200258def Test_block_local_vars()
259 var lines =<< trim END
260 vim9script
Bram Moolenaared234f22020-10-15 20:42:20 +0200261 v:testing = 1
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200262 if true
Bram Moolenaared234f22020-10-15 20:42:20 +0200263 var text = ['hello']
264 def SayHello(): list<string>
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200265 return text
266 enddef
267 def SetText(v: string)
Bram Moolenaared234f22020-10-15 20:42:20 +0200268 text = [v]
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200269 enddef
270 endif
271
272 if true
Bram Moolenaared234f22020-10-15 20:42:20 +0200273 var text = ['again']
274 def SayAgain(): list<string>
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200275 return text
276 enddef
277 endif
Bram Moolenaared234f22020-10-15 20:42:20 +0200278
279 # test that the "text" variables are not cleaned up
280 test_garbagecollect_now()
281
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200282 defcompile
283
Bram Moolenaared234f22020-10-15 20:42:20 +0200284 assert_equal(['hello'], SayHello())
285 assert_equal(['again'], SayAgain())
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200286
287 SetText('foobar')
Bram Moolenaared234f22020-10-15 20:42:20 +0200288 assert_equal(['foobar'], SayHello())
289
290 call writefile(['ok'], 'Xdidit')
291 qall!
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200292 END
Bram Moolenaared234f22020-10-15 20:42:20 +0200293
294 # need to execute this with a separate Vim instance to avoid the current
295 # context gets garbage collected.
296 writefile(lines, 'Xscript')
297 RunVim([], [], '-S Xscript')
298 assert_equal(['ok'], readfile('Xdidit'))
299
300 delete('Xscript')
301 delete('Xdidit')
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200302enddef
303
Bram Moolenaar39ca4122020-10-20 14:25:07 +0200304def Test_block_local_vars_with_func()
305 var lines =<< trim END
306 vim9script
307 if true
308 var foo = 'foo'
309 if true
310 var bar = 'bar'
311 def Func(): list<string>
312 return [foo, bar]
313 enddef
314 endif
315 endif
316 # function is compiled here, after blocks have finished, can still access
317 # "foo" and "bar"
318 assert_equal(['foo', 'bar'], Func())
319 END
320 CheckScriptSuccess(lines)
321enddef
322
Bram Moolenaard032f342020-07-18 18:13:02 +0200323func g:NoSuchFunc()
324 echo 'none'
325endfunc
326
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100327def Test_try_catch()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200328 var l = []
Bram Moolenaar7a092242020-04-16 22:10:49 +0200329 try # comment
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100330 add(l, '1')
331 throw 'wrong'
332 add(l, '2')
Bram Moolenaar7a092242020-04-16 22:10:49 +0200333 catch # comment
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100334 add(l, v:exception)
Bram Moolenaar7a092242020-04-16 22:10:49 +0200335 finally # comment
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100336 add(l, '3')
Bram Moolenaar7a092242020-04-16 22:10:49 +0200337 endtry # comment
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100338 assert_equal(['1', 'wrong', '3'], l)
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200339
Bram Moolenaare8593122020-07-18 15:17:02 +0200340 l = []
341 try
342 try
343 add(l, '1')
344 throw 'wrong'
345 add(l, '2')
346 catch /right/
347 add(l, v:exception)
348 endtry
349 catch /wrong/
350 add(l, 'caught')
Bram Moolenaar373863e2020-09-26 17:20:53 +0200351 fina
Bram Moolenaare8593122020-07-18 15:17:02 +0200352 add(l, 'finally')
353 endtry
354 assert_equal(['1', 'caught', 'finally'], l)
355
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200356 var n: number
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200357 try
358 n = l[3]
359 catch /E684:/
360 n = 99
361 endtry
362 assert_equal(99, n)
363
364 try
Bram Moolenaarcc673e72020-08-16 17:33:35 +0200365 # string slice returns a string, not a number
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200366 n = g:astring[3]
Bram Moolenaar5e654232020-09-16 15:22:00 +0200367 catch /E1012:/
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200368 n = 77
369 endtry
370 assert_equal(77, n)
371
372 try
373 n = l[g:astring]
Bram Moolenaar5e654232020-09-16 15:22:00 +0200374 catch /E1012:/
Bram Moolenaar56acb092020-08-16 14:48:19 +0200375 n = 88
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200376 endtry
Bram Moolenaar56acb092020-08-16 14:48:19 +0200377 assert_equal(88, n)
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200378
379 try
380 n = s:does_not_exist
381 catch /E121:/
Bram Moolenaarf0b9f432020-07-17 23:03:17 +0200382 n = 111
383 endtry
384 assert_equal(111, n)
385
386 try
387 n = g:does_not_exist
388 catch /E121:/
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200389 n = 121
390 endtry
391 assert_equal(121, n)
392
Bram Moolenaare0de1712020-12-02 17:36:54 +0100393 var d = {one: 1}
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200394 try
395 n = d[g:astring]
396 catch /E716:/
397 n = 222
398 endtry
399 assert_equal(222, n)
Bram Moolenaarf0b9f432020-07-17 23:03:17 +0200400
401 try
402 n = -g:astring
403 catch /E39:/
404 n = 233
405 endtry
406 assert_equal(233, n)
407
408 try
409 n = +g:astring
410 catch /E1030:/
411 n = 244
412 endtry
413 assert_equal(244, n)
414
415 try
416 n = +g:alist
417 catch /E745:/
418 n = 255
419 endtry
420 assert_equal(255, n)
421
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200422 var nd: dict<any>
Bram Moolenaarf0b9f432020-07-17 23:03:17 +0200423 try
Bram Moolenaar2bede172020-11-19 18:53:18 +0100424 nd = {[g:anumber]: 1}
Bram Moolenaar5e654232020-09-16 15:22:00 +0200425 catch /E1012:/
Bram Moolenaarf0b9f432020-07-17 23:03:17 +0200426 n = 266
427 endtry
428 assert_equal(266, n)
429
430 try
431 [n] = [1, 2, 3]
432 catch /E1093:/
433 n = 277
434 endtry
435 assert_equal(277, n)
436
Bram Moolenaare8593122020-07-18 15:17:02 +0200437 try
438 &ts = g:astring
Bram Moolenaar5e654232020-09-16 15:22:00 +0200439 catch /E1012:/
Bram Moolenaare8593122020-07-18 15:17:02 +0200440 n = 288
441 endtry
442 assert_equal(288, n)
443
444 try
445 &backspace = 'asdf'
446 catch /E474:/
447 n = 299
448 endtry
449 assert_equal(299, n)
450
451 l = [1]
452 try
453 l[3] = 3
454 catch /E684:/
455 n = 300
456 endtry
457 assert_equal(300, n)
458
459 try
Bram Moolenaare8593122020-07-18 15:17:02 +0200460 unlet g:does_not_exist
461 catch /E108:/
462 n = 322
463 endtry
464 assert_equal(322, n)
465
466 try
Bram Moolenaar2bede172020-11-19 18:53:18 +0100467 d = {text: 1, [g:astring]: 2}
Bram Moolenaare8593122020-07-18 15:17:02 +0200468 catch /E721:/
469 n = 333
470 endtry
471 assert_equal(333, n)
472
473 try
474 l = DeletedFunc()
475 catch /E933:/
476 n = 344
477 endtry
478 assert_equal(344, n)
Bram Moolenaard032f342020-07-18 18:13:02 +0200479
480 try
481 echo len(v:true)
482 catch /E701:/
483 n = 355
484 endtry
485 assert_equal(355, n)
486
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200487 var P = function('g:NoSuchFunc')
Bram Moolenaard032f342020-07-18 18:13:02 +0200488 delfunc g:NoSuchFunc
489 try
490 echo P()
491 catch /E117:/
492 n = 366
493 endtry
494 assert_equal(366, n)
495
496 try
497 echo g:NoSuchFunc()
498 catch /E117:/
499 n = 377
500 endtry
501 assert_equal(377, n)
502
503 try
504 echo g:alist + 4
505 catch /E745:/
506 n = 388
507 endtry
508 assert_equal(388, n)
509
510 try
511 echo 4 + g:alist
512 catch /E745:/
513 n = 399
514 endtry
515 assert_equal(399, n)
516
517 try
518 echo g:alist.member
519 catch /E715:/
520 n = 400
521 endtry
522 assert_equal(400, n)
523
524 try
525 echo d.member
526 catch /E716:/
527 n = 411
528 endtry
529 assert_equal(411, n)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100530enddef
531
Bram Moolenaare8593122020-07-18 15:17:02 +0200532def DeletedFunc(): list<any>
533 return ['delete me']
534enddef
535defcompile
536delfunc DeletedFunc
537
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100538def ThrowFromDef()
Bram Moolenaara72cfb82020-04-23 17:07:30 +0200539 throw "getout" # comment
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100540enddef
541
542func CatchInFunc()
543 try
544 call ThrowFromDef()
545 catch
546 let g:thrown_func = v:exception
547 endtry
548endfunc
549
550def CatchInDef()
551 try
552 ThrowFromDef()
553 catch
554 g:thrown_def = v:exception
555 endtry
556enddef
557
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100558def ReturnFinally(): string
559 try
560 return 'intry'
Bram Moolenaar373863e2020-09-26 17:20:53 +0200561 finall
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100562 g:in_finally = 'finally'
563 endtry
564 return 'end'
565enddef
566
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100567def Test_try_catch_nested()
568 CatchInFunc()
569 assert_equal('getout', g:thrown_func)
570
571 CatchInDef()
572 assert_equal('getout', g:thrown_def)
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100573
574 assert_equal('intry', ReturnFinally())
575 assert_equal('finally', g:in_finally)
576enddef
577
Bram Moolenaar9939f572020-09-16 22:29:52 +0200578def TryOne(): number
579 try
580 return 0
581 catch
582 endtry
583 return 0
584enddef
585
586def TryTwo(n: number): string
587 try
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200588 var x = {}
Bram Moolenaar9939f572020-09-16 22:29:52 +0200589 catch
590 endtry
591 return 'text'
592enddef
593
594def Test_try_catch_twice()
595 assert_equal('text', TryOne()->TryTwo())
596enddef
597
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100598def Test_try_catch_match()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200599 var seq = 'a'
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100600 try
601 throw 'something'
602 catch /nothing/
603 seq ..= 'x'
604 catch /some/
605 seq ..= 'b'
606 catch /asdf/
607 seq ..= 'x'
Bram Moolenaare8c4abb2020-04-02 21:13:25 +0200608 catch ?a\?sdf?
609 seq ..= 'y'
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100610 finally
611 seq ..= 'c'
612 endtry
613 assert_equal('abc', seq)
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100614enddef
615
Bram Moolenaare8c4abb2020-04-02 21:13:25 +0200616def Test_try_catch_fails()
Bram Moolenaard2c61702020-09-06 15:58:36 +0200617 CheckDefFailure(['catch'], 'E603:')
618 CheckDefFailure(['try', 'echo 0', 'catch', 'catch'], 'E1033:')
619 CheckDefFailure(['try', 'echo 0', 'catch /pat'], 'E1067:')
620 CheckDefFailure(['finally'], 'E606:')
621 CheckDefFailure(['try', 'echo 0', 'finally', 'echo 1', 'finally'], 'E607:')
622 CheckDefFailure(['endtry'], 'E602:')
623 CheckDefFailure(['while 1', 'endtry'], 'E170:')
624 CheckDefFailure(['for i in range(5)', 'endtry'], 'E170:')
Bram Moolenaar13106602020-10-04 16:06:05 +0200625 CheckDefFailure(['if 1', 'endtry'], 'E171:')
Bram Moolenaard2c61702020-09-06 15:58:36 +0200626 CheckDefFailure(['try', 'echo 1', 'endtry'], 'E1032:')
Bram Moolenaar585fea72020-04-02 22:33:21 +0200627
Bram Moolenaare4984292020-12-13 14:19:25 +0100628 CheckDefFailure(['throw'], 'E1143:')
Bram Moolenaard2c61702020-09-06 15:58:36 +0200629 CheckDefFailure(['throw xxx'], 'E1001:')
Bram Moolenaare8c4abb2020-04-02 21:13:25 +0200630enddef
631
Bram Moolenaar006ad482020-06-30 20:55:15 +0200632def Test_throw_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200633 # only checks line continuation
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200634 var lines =<< trim END
Bram Moolenaar006ad482020-06-30 20:55:15 +0200635 vim9script
636 try
637 throw 'one'
638 .. 'two'
639 catch
640 assert_equal('onetwo', v:exception)
641 endtry
642 END
643 CheckScriptSuccess(lines)
Bram Moolenaar1e021e62020-10-16 20:25:23 +0200644
645 lines =<< trim END
646 vim9script
Bram Moolenaar352134b2020-10-17 22:04:08 +0200647 @r = ''
Bram Moolenaar1e021e62020-10-16 20:25:23 +0200648 def Func()
649 throw @r
650 enddef
651 var result = ''
652 try
653 Func()
654 catch /E1129:/
655 result = 'caught'
656 endtry
657 assert_equal('caught', result)
658 END
659 CheckScriptSuccess(lines)
Bram Moolenaar006ad482020-06-30 20:55:15 +0200660enddef
661
Bram Moolenaared677f52020-08-12 16:38:10 +0200662def Test_error_in_nested_function()
663 # an error in a nested :function aborts executin in the calling :def function
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200664 var lines =<< trim END
Bram Moolenaared677f52020-08-12 16:38:10 +0200665 vim9script
666 def Func()
667 Error()
668 g:test_var = 1
669 enddef
670 func Error() abort
671 eval [][0]
672 endfunc
673 Func()
674 END
675 g:test_var = 0
676 CheckScriptFailure(lines, 'E684:')
677 assert_equal(0, g:test_var)
678enddef
679
Bram Moolenaar37c83712020-06-30 21:18:36 +0200680def Test_cexpr_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200681 # only checks line continuation
Bram Moolenaar37c83712020-06-30 21:18:36 +0200682 set errorformat=File\ %f\ line\ %l
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200683 var lines =<< trim END
Bram Moolenaar37c83712020-06-30 21:18:36 +0200684 vim9script
685 cexpr 'File'
686 .. ' someFile' ..
687 ' line 19'
688 assert_equal(19, getqflist()[0].lnum)
689 END
690 CheckScriptSuccess(lines)
691 set errorformat&
692enddef
693
Bram Moolenaarc9edd6b2020-08-12 22:18:23 +0200694def Test_statusline_syntax()
695 # legacy syntax is used for 'statusline'
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200696 var lines =<< trim END
Bram Moolenaarc9edd6b2020-08-12 22:18:23 +0200697 vim9script
698 func g:Status()
699 return '%{"x" is# "x"}'
700 endfunc
701 set laststatus=2 statusline=%!Status()
702 redrawstatus
703 set laststatus statusline=
704 END
705 CheckScriptSuccess(lines)
706enddef
707
Bram Moolenaarb2097502020-07-19 17:17:02 +0200708def Test_list_vimscript()
709 # checks line continuation and comments
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200710 var lines =<< trim END
Bram Moolenaarb2097502020-07-19 17:17:02 +0200711 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200712 var mylist = [
Bram Moolenaarb2097502020-07-19 17:17:02 +0200713 'one',
714 # comment
715 'two', # empty line follows
716
717 'three',
718 ]
719 assert_equal(['one', 'two', 'three'], mylist)
720 END
721 CheckScriptSuccess(lines)
Bram Moolenaar66250c92020-08-20 15:02:42 +0200722
723 # check all lines from heredoc are kept
724 lines =<< trim END
725 # comment 1
726 two
727 # comment 3
728
729 five
730 # comment 6
731 END
732 assert_equal(['# comment 1', 'two', '# comment 3', '', 'five', '# comment 6'], lines)
Bram Moolenaarb2097502020-07-19 17:17:02 +0200733enddef
734
Bram Moolenaar2a1381c2020-05-05 23:32:58 +0200735if has('channel')
736 let someJob = test_null_job()
Bram Moolenaar40ee4662020-05-05 22:08:26 +0200737
Bram Moolenaar2a1381c2020-05-05 23:32:58 +0200738 def FuncWithError()
739 echomsg g:someJob
740 enddef
Bram Moolenaar40ee4662020-05-05 22:08:26 +0200741
Bram Moolenaar2a1381c2020-05-05 23:32:58 +0200742 func Test_convert_emsg_to_exception()
743 try
744 call FuncWithError()
745 catch
746 call assert_match('Vim:E908:', v:exception)
747 endtry
748 endfunc
749endif
Bram Moolenaar40ee4662020-05-05 22:08:26 +0200750
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100751let s:export_script_lines =<< trim END
752 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200753 var name: string = 'bob'
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100754 def Concat(arg: string): string
755 return name .. arg
756 enddef
Bram Moolenaar227a69d2020-05-15 18:17:28 +0200757 g:result = Concat('bie')
758 g:localname = name
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100759
760 export const CONST = 1234
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200761 export var exported = 9876
762 export var exp_name = 'John'
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100763 export def Exported(): string
764 return 'Exported'
765 enddef
766END
767
Bram Moolenaarb3ca9822020-08-09 14:43:58 +0200768def Undo_export_script_lines()
769 unlet g:result
770 unlet g:localname
771enddef
772
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100773def Test_vim9_import_export()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200774 var import_script_lines =<< trim END
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100775 vim9script
776 import {exported, Exported} from './Xexport.vim'
777 g:imported = exported
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100778 exported += 3
779 g:imported_added = exported
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100780 g:imported_func = Exported()
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100781
Bram Moolenaar40f4f7a2020-07-23 22:41:43 +0200782 def GetExported(): string
Bram Moolenaare0de1712020-12-02 17:36:54 +0100783 var local_dict = {ref: Exported}
Bram Moolenaar40f4f7a2020-07-23 22:41:43 +0200784 return local_dict.ref()
785 enddef
786 g:funcref_result = GetExported()
787
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100788 import {exp_name} from './Xexport.vim'
789 g:imported_name = exp_name
790 exp_name ..= ' Doe'
791 g:imported_name_appended = exp_name
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100792 g:imported_later = exported
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100793 END
794
795 writefile(import_script_lines, 'Ximport.vim')
796 writefile(s:export_script_lines, 'Xexport.vim')
797
798 source Ximport.vim
799
800 assert_equal('bobbie', g:result)
801 assert_equal('bob', g:localname)
802 assert_equal(9876, g:imported)
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100803 assert_equal(9879, g:imported_added)
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100804 assert_equal(9879, g:imported_later)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100805 assert_equal('Exported', g:imported_func)
Bram Moolenaar40f4f7a2020-07-23 22:41:43 +0200806 assert_equal('Exported', g:funcref_result)
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100807 assert_equal('John', g:imported_name)
808 assert_equal('John Doe', g:imported_name_appended)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100809 assert_false(exists('g:name'))
810
Bram Moolenaarb3ca9822020-08-09 14:43:58 +0200811 Undo_export_script_lines()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100812 unlet g:imported
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100813 unlet g:imported_added
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100814 unlet g:imported_later
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100815 unlet g:imported_func
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100816 unlet g:imported_name g:imported_name_appended
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100817 delete('Ximport.vim')
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100818
Bram Moolenaar1c991142020-07-04 13:15:31 +0200819 # similar, with line breaks
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200820 var import_line_break_script_lines =<< trim END
Bram Moolenaar1c991142020-07-04 13:15:31 +0200821 vim9script
822 import {
823 exported,
824 Exported,
825 }
826 from
827 './Xexport.vim'
828 g:imported = exported
829 exported += 5
830 g:imported_added = exported
831 g:imported_func = Exported()
832 END
833 writefile(import_line_break_script_lines, 'Ximport_lbr.vim')
834 source Ximport_lbr.vim
835
836 assert_equal(9876, g:imported)
837 assert_equal(9881, g:imported_added)
838 assert_equal('Exported', g:imported_func)
839
840 # exported script not sourced again
841 assert_false(exists('g:result'))
842 unlet g:imported
843 unlet g:imported_added
844 unlet g:imported_func
845 delete('Ximport_lbr.vim')
846
847 # import inside :def function
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200848 var import_in_def_lines =<< trim END
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100849 vim9script
850 def ImportInDef()
851 import exported from './Xexport.vim'
852 g:imported = exported
853 exported += 7
854 g:imported_added = exported
855 enddef
856 ImportInDef()
857 END
858 writefile(import_in_def_lines, 'Ximport2.vim')
859 source Ximport2.vim
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200860 # TODO: this should be 9879
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100861 assert_equal(9876, g:imported)
862 assert_equal(9883, g:imported_added)
863 unlet g:imported
864 unlet g:imported_added
865 delete('Ximport2.vim')
866
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200867 var import_star_as_lines =<< trim END
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100868 vim9script
869 import * as Export from './Xexport.vim'
870 def UseExport()
871 g:imported = Export.exported
872 enddef
873 UseExport()
874 END
875 writefile(import_star_as_lines, 'Ximport.vim')
876 source Ximport.vim
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100877 assert_equal(9883, g:imported)
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100878
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200879 var import_star_as_lines_no_dot =<< trim END
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100880 vim9script
881 import * as Export from './Xexport.vim'
882 def Func()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200883 var dummy = 1
884 var imported = Export + dummy
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100885 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +0200886 defcompile
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100887 END
888 writefile(import_star_as_lines_no_dot, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +0200889 assert_fails('source Ximport.vim', 'E1060:', '', 2, 'Func')
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100890
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200891 var import_star_as_lines_dot_space =<< trim END
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100892 vim9script
893 import * as Export from './Xexport.vim'
894 def Func()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200895 var imported = Export . exported
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100896 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +0200897 defcompile
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100898 END
899 writefile(import_star_as_lines_dot_space, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +0200900 assert_fails('source Ximport.vim', 'E1074:', '', 1, 'Func')
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100901
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200902 var import_star_as_lines_missing_name =<< trim END
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100903 vim9script
904 import * as Export from './Xexport.vim'
905 def Func()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200906 var imported = Export.
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100907 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +0200908 defcompile
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100909 END
910 writefile(import_star_as_lines_missing_name, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +0200911 assert_fails('source Ximport.vim', 'E1048:', '', 1, 'Func')
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100912
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200913 var import_star_as_lbr_lines =<< trim END
Bram Moolenaar1c991142020-07-04 13:15:31 +0200914 vim9script
915 import *
916 as Export
917 from
918 './Xexport.vim'
919 def UseExport()
920 g:imported = Export.exported
921 enddef
922 UseExport()
923 END
924 writefile(import_star_as_lbr_lines, 'Ximport.vim')
925 source Ximport.vim
926 assert_equal(9883, g:imported)
927
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200928 var import_star_lines =<< trim END
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100929 vim9script
930 import * from './Xexport.vim'
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100931 END
932 writefile(import_star_lines, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +0200933 assert_fails('source Ximport.vim', 'E1045:', '', 2, 'Ximport.vim')
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100934
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200935 # try to import something that exists but is not exported
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200936 var import_not_exported_lines =<< trim END
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +0100937 vim9script
938 import name from './Xexport.vim'
939 END
940 writefile(import_not_exported_lines, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +0200941 assert_fails('source Ximport.vim', 'E1049:', '', 2, 'Ximport.vim')
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +0100942
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200943 # try to import something that is already defined
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200944 var import_already_defined =<< trim END
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100945 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200946 var exported = 'something'
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100947 import exported from './Xexport.vim'
948 END
949 writefile(import_already_defined, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +0200950 assert_fails('source Ximport.vim', 'E1073:', '', 3, 'Ximport.vim')
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100951
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200952 # try to import something that is already defined
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100953 import_already_defined =<< trim END
954 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200955 var exported = 'something'
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100956 import * as exported from './Xexport.vim'
957 END
958 writefile(import_already_defined, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +0200959 assert_fails('source Ximport.vim', 'E1073:', '', 3, 'Ximport.vim')
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100960
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200961 # try to import something that is already defined
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100962 import_already_defined =<< trim END
963 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200964 var exported = 'something'
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100965 import {exported} from './Xexport.vim'
966 END
967 writefile(import_already_defined, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +0200968 assert_fails('source Ximport.vim', 'E1073:', '', 3, 'Ximport.vim')
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100969
Bram Moolenaar918a4242020-12-06 14:37:08 +0100970 # try changing an imported const
971 var import_assign_to_const =<< trim END
972 vim9script
973 import CONST from './Xexport.vim'
974 def Assign()
975 CONST = 987
976 enddef
977 defcompile
978 END
979 writefile(import_assign_to_const, 'Ximport.vim')
980 assert_fails('source Ximport.vim', 'E46:', '', 1, '_Assign')
981
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200982 # import a very long name, requires making a copy
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200983 var import_long_name_lines =<< trim END
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +0100984 vim9script
985 import name012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789 from './Xexport.vim'
986 END
987 writefile(import_long_name_lines, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +0200988 assert_fails('source Ximport.vim', 'E1048:', '', 2, 'Ximport.vim')
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +0100989
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200990 var import_no_from_lines =<< trim END
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +0100991 vim9script
992 import name './Xexport.vim'
993 END
994 writefile(import_no_from_lines, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +0200995 assert_fails('source Ximport.vim', 'E1070:', '', 2, 'Ximport.vim')
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +0100996
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200997 var import_invalid_string_lines =<< trim END
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +0100998 vim9script
999 import name from Xexport.vim
1000 END
1001 writefile(import_invalid_string_lines, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001002 assert_fails('source Ximport.vim', 'E1071:', '', 2, 'Ximport.vim')
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001003
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001004 var import_wrong_name_lines =<< trim END
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001005 vim9script
1006 import name from './XnoExport.vim'
1007 END
1008 writefile(import_wrong_name_lines, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001009 assert_fails('source Ximport.vim', 'E1053:', '', 2, 'Ximport.vim')
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001010
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001011 var import_missing_comma_lines =<< trim END
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001012 vim9script
1013 import {exported name} from './Xexport.vim'
1014 END
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001015 writefile(import_missing_comma_lines, 'Ximport3.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001016 assert_fails('source Ximport3.vim', 'E1046:', '', 2, 'Ximport3.vim')
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001017
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01001018 delete('Ximport.vim')
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001019 delete('Ximport3.vim')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001020 delete('Xexport.vim')
1021
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001022 # Check that in a Vim9 script 'cpo' is set to the Vim default.
Bram Moolenaar750802b2020-02-23 18:08:33 +01001023 set cpo&vi
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001024 var cpo_before = &cpo
1025 var lines =<< trim END
Bram Moolenaar750802b2020-02-23 18:08:33 +01001026 vim9script
1027 g:cpo_in_vim9script = &cpo
1028 END
1029 writefile(lines, 'Xvim9_script')
1030 source Xvim9_script
1031 assert_equal(cpo_before, &cpo)
1032 set cpo&vim
1033 assert_equal(&cpo, g:cpo_in_vim9script)
1034 delete('Xvim9_script')
1035enddef
1036
Bram Moolenaar803af682020-08-05 16:20:03 +02001037func g:Trigger()
1038 source Ximport.vim
1039 return "echo 'yes'\<CR>"
1040endfunc
1041
1042def Test_import_export_expr_map()
1043 # check that :import and :export work when buffer is locked
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001044 var export_lines =<< trim END
Bram Moolenaar803af682020-08-05 16:20:03 +02001045 vim9script
1046 export def That(): string
1047 return 'yes'
1048 enddef
1049 END
1050 writefile(export_lines, 'Xexport_that.vim')
1051
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001052 var import_lines =<< trim END
Bram Moolenaar803af682020-08-05 16:20:03 +02001053 vim9script
1054 import That from './Xexport_that.vim'
1055 assert_equal('yes', That())
1056 END
1057 writefile(import_lines, 'Ximport.vim')
1058
1059 nnoremap <expr> trigger g:Trigger()
1060 feedkeys('trigger', "xt")
1061
Bram Moolenaar730b2482020-08-09 13:02:10 +02001062 delete('Xexport_that.vim')
Bram Moolenaar803af682020-08-05 16:20:03 +02001063 delete('Ximport.vim')
1064 nunmap trigger
1065enddef
1066
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001067def Test_import_in_filetype()
1068 # check that :import works when the buffer is locked
1069 mkdir('ftplugin', 'p')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001070 var export_lines =<< trim END
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001071 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001072 export var That = 'yes'
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001073 END
Bram Moolenaar730b2482020-08-09 13:02:10 +02001074 writefile(export_lines, 'ftplugin/Xexport_ft.vim')
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001075
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001076 var import_lines =<< trim END
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001077 vim9script
Bram Moolenaar730b2482020-08-09 13:02:10 +02001078 import That from './Xexport_ft.vim'
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001079 assert_equal('yes', That)
1080 g:did_load_mytpe = 1
1081 END
1082 writefile(import_lines, 'ftplugin/qf.vim')
1083
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001084 var save_rtp = &rtp
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001085 &rtp = getcwd() .. ',' .. &rtp
1086
1087 filetype plugin on
1088 copen
1089 assert_equal(1, g:did_load_mytpe)
1090
1091 quit!
Bram Moolenaar730b2482020-08-09 13:02:10 +02001092 delete('Xexport_ft.vim')
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001093 delete('ftplugin', 'rf')
1094 &rtp = save_rtp
1095enddef
1096
Bram Moolenaarefa94442020-08-08 22:16:00 +02001097def Test_use_import_in_mapping()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001098 var lines =<< trim END
Bram Moolenaarefa94442020-08-08 22:16:00 +02001099 vim9script
1100 export def Funcx()
1101 g:result = 42
1102 enddef
1103 END
1104 writefile(lines, 'XsomeExport.vim')
1105 lines =<< trim END
1106 vim9script
1107 import Funcx from './XsomeExport.vim'
Bram Moolenaarb3ca9822020-08-09 14:43:58 +02001108 nnoremap <F3> :call <sid>Funcx()<cr>
Bram Moolenaarefa94442020-08-08 22:16:00 +02001109 END
1110 writefile(lines, 'Xmapscript.vim')
1111
1112 source Xmapscript.vim
Bram Moolenaarb3ca9822020-08-09 14:43:58 +02001113 feedkeys("\<F3>", "xt")
Bram Moolenaarefa94442020-08-08 22:16:00 +02001114 assert_equal(42, g:result)
1115
1116 unlet g:result
1117 delete('XsomeExport.vim')
1118 delete('Xmapscript.vim')
Bram Moolenaarb3ca9822020-08-09 14:43:58 +02001119 nunmap <F3>
Bram Moolenaarefa94442020-08-08 22:16:00 +02001120enddef
1121
Bram Moolenaar750802b2020-02-23 18:08:33 +01001122def Test_vim9script_fails()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001123 CheckScriptFailure(['scriptversion 2', 'vim9script'], 'E1039:')
1124 CheckScriptFailure(['vim9script', 'scriptversion 2'], 'E1040:')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001125 CheckScriptFailure(['export var some = 123'], 'E1042:')
Bram Moolenaar9721fb42020-06-11 23:10:46 +02001126 CheckScriptFailure(['import some from "./Xexport.vim"'], 'E1048:')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001127 CheckScriptFailure(['vim9script', 'export var g:some'], 'E1022:')
Bram Moolenaar750802b2020-02-23 18:08:33 +01001128 CheckScriptFailure(['vim9script', 'export echo 134'], 'E1043:')
1129
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001130 CheckScriptFailure(['vim9script', 'var str: string', 'str = 1234'], 'E1012:')
Bram Moolenaarc785b9a2020-06-19 18:34:15 +02001131 CheckScriptFailure(['vim9script', 'const str = "asdf"', 'str = "xxx"'], 'E46:')
1132
Bram Moolenaare2e40752020-09-04 21:18:46 +02001133 assert_fails('vim9script', 'E1038:')
1134 assert_fails('export something', 'E1043:')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001135enddef
1136
Bram Moolenaarf7d267e2020-06-17 12:04:54 +02001137func Test_import_fails_without_script()
Bram Moolenaar101f4812020-06-16 23:18:51 +02001138 CheckRunVimInTerminal
1139
Bram Moolenaar9bb3eb32020-06-17 20:03:36 +02001140 " call indirectly to avoid compilation error for missing functions
Bram Moolenaarc620c052020-07-08 15:16:19 +02001141 call Run_Test_import_fails_on_command_line()
Bram Moolenaar9bb3eb32020-06-17 20:03:36 +02001142endfunc
1143
Bram Moolenaarc620c052020-07-08 15:16:19 +02001144def Run_Test_import_fails_on_command_line()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001145 var export =<< trim END
Bram Moolenaar101f4812020-06-16 23:18:51 +02001146 vim9script
1147 export def Foo(): number
1148 return 0
1149 enddef
1150 END
Bram Moolenaar730b2482020-08-09 13:02:10 +02001151 writefile(export, 'XexportCmd.vim')
Bram Moolenaar101f4812020-06-16 23:18:51 +02001152
Bram Moolenaare0de1712020-12-02 17:36:54 +01001153 var buf = RunVimInTerminal('-c "import Foo from ''./XexportCmd.vim''"', {
Bram Moolenaar9bb3eb32020-06-17 20:03:36 +02001154 rows: 6, wait_for_ruler: 0})
1155 WaitForAssert({-> assert_match('^E1094:', term_getline(buf, 5))})
Bram Moolenaar101f4812020-06-16 23:18:51 +02001156
Bram Moolenaar730b2482020-08-09 13:02:10 +02001157 delete('XexportCmd.vim')
Bram Moolenaar9bb3eb32020-06-17 20:03:36 +02001158 StopVimInTerminal(buf)
1159enddef
Bram Moolenaar101f4812020-06-16 23:18:51 +02001160
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001161def Test_vim9script_reload_import()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001162 var lines =<< trim END
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001163 vim9script
1164 const var = ''
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001165 var valone = 1234
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001166 def MyFunc(arg: string)
1167 valone = 5678
1168 enddef
1169 END
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001170 var morelines =<< trim END
1171 var valtwo = 222
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001172 export def GetValtwo(): number
1173 return valtwo
1174 enddef
1175 END
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001176 writefile(lines + morelines, 'Xreload.vim')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001177 source Xreload.vim
1178 source Xreload.vim
1179 source Xreload.vim
1180
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001181 var testlines =<< trim END
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001182 vim9script
1183 def TheFunc()
1184 import GetValtwo from './Xreload.vim'
1185 assert_equal(222, GetValtwo())
1186 enddef
1187 TheFunc()
1188 END
1189 writefile(testlines, 'Ximport.vim')
1190 source Ximport.vim
1191
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001192 # Test that when not using "morelines" GetValtwo() and valtwo are still
1193 # defined, because import doesn't reload a script.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001194 writefile(lines, 'Xreload.vim')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001195 source Ximport.vim
1196
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001197 # cannot declare a var twice
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001198 lines =<< trim END
1199 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001200 var valone = 1234
1201 var valone = 5678
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001202 END
1203 writefile(lines, 'Xreload.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001204 assert_fails('source Xreload.vim', 'E1041:', '', 3, 'Xreload.vim')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001205
1206 delete('Xreload.vim')
1207 delete('Ximport.vim')
1208enddef
1209
Bram Moolenaar95006e32020-08-29 17:47:08 +02001210def s:RetSome(): string
1211 return 'some'
1212enddef
1213
Bram Moolenaarfe465a02020-07-07 22:50:12 +02001214" Not exported function that is referenced needs to be accessed by the
1215" script-local name.
1216def Test_vim9script_funcref()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001217 var sortlines =<< trim END
Bram Moolenaarfe465a02020-07-07 22:50:12 +02001218 vim9script
1219 def Compare(i1: number, i2: number): number
Bram Moolenaarbed36b92020-07-07 23:31:36 +02001220 return i2 - i1
Bram Moolenaarfe465a02020-07-07 22:50:12 +02001221 enddef
1222
1223 export def FastSort(): list<number>
1224 return range(5)->sort(Compare)
1225 enddef
1226 END
1227 writefile(sortlines, 'Xsort.vim')
1228
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001229 var lines =<< trim END
Bram Moolenaarfe465a02020-07-07 22:50:12 +02001230 vim9script
1231 import FastSort from './Xsort.vim'
1232 def Test()
1233 g:result = FastSort()
1234 enddef
1235 Test()
1236 END
1237 writefile(lines, 'Xscript.vim')
1238
1239 source Xscript.vim
1240 assert_equal([4, 3, 2, 1, 0], g:result)
1241
1242 unlet g:result
1243 delete('Xsort.vim')
1244 delete('Xscript.vim')
Bram Moolenaar95006e32020-08-29 17:47:08 +02001245
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001246 var Funcref = function('s:RetSome')
Bram Moolenaar95006e32020-08-29 17:47:08 +02001247 assert_equal('some', Funcref())
Bram Moolenaarfe465a02020-07-07 22:50:12 +02001248enddef
1249
Bram Moolenaar601e76a2020-08-27 21:33:10 +02001250" Check that when searching for "FilterFunc" it finds the import in the
1251" script where FastFilter() is called from, both as a string and as a direct
1252" function reference.
Bram Moolenaarc620c052020-07-08 15:16:19 +02001253def Test_vim9script_funcref_other_script()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001254 var filterLines =<< trim END
Bram Moolenaarc620c052020-07-08 15:16:19 +02001255 vim9script
1256 export def FilterFunc(idx: number, val: number): bool
1257 return idx % 2 == 1
1258 enddef
1259 export def FastFilter(): list<number>
1260 return range(10)->filter('FilterFunc')
1261 enddef
Bram Moolenaar601e76a2020-08-27 21:33:10 +02001262 export def FastFilterDirect(): list<number>
1263 return range(10)->filter(FilterFunc)
1264 enddef
Bram Moolenaarc620c052020-07-08 15:16:19 +02001265 END
1266 writefile(filterLines, 'Xfilter.vim')
1267
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001268 var lines =<< trim END
Bram Moolenaarc620c052020-07-08 15:16:19 +02001269 vim9script
Bram Moolenaar601e76a2020-08-27 21:33:10 +02001270 import {FilterFunc, FastFilter, FastFilterDirect} from './Xfilter.vim'
Bram Moolenaarc620c052020-07-08 15:16:19 +02001271 def Test()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001272 var x: list<number> = FastFilter()
Bram Moolenaarc620c052020-07-08 15:16:19 +02001273 enddef
1274 Test()
Bram Moolenaar601e76a2020-08-27 21:33:10 +02001275 def TestDirect()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001276 var x: list<number> = FastFilterDirect()
Bram Moolenaar601e76a2020-08-27 21:33:10 +02001277 enddef
1278 TestDirect()
Bram Moolenaarc620c052020-07-08 15:16:19 +02001279 END
Bram Moolenaar601e76a2020-08-27 21:33:10 +02001280 CheckScriptSuccess(lines)
Bram Moolenaarc620c052020-07-08 15:16:19 +02001281 delete('Xfilter.vim')
Bram Moolenaarc620c052020-07-08 15:16:19 +02001282enddef
1283
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001284def Test_vim9script_reload_delfunc()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001285 var first_lines =<< trim END
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001286 vim9script
1287 def FuncYes(): string
1288 return 'yes'
1289 enddef
1290 END
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001291 var withno_lines =<< trim END
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001292 def FuncNo(): string
1293 return 'no'
1294 enddef
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001295 def g:DoCheck(no_exists: bool)
1296 assert_equal('yes', FuncYes())
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001297 assert_equal('no', FuncNo())
1298 enddef
1299 END
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001300 var nono_lines =<< trim END
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001301 def g:DoCheck(no_exists: bool)
1302 assert_equal('yes', FuncYes())
Bram Moolenaar44d66522020-09-06 22:26:57 +02001303 assert_fails('FuncNo()', 'E117:', '', 2, 'DoCheck')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001304 enddef
1305 END
1306
1307 # FuncNo() is defined
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001308 writefile(first_lines + withno_lines, 'Xreloaded.vim')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001309 source Xreloaded.vim
1310 g:DoCheck(true)
1311
1312 # FuncNo() is not redefined
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001313 writefile(first_lines + nono_lines, 'Xreloaded.vim')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001314 source Xreloaded.vim
Bram Moolenaar50824712020-12-20 21:10:17 +01001315 g:DoCheck(false)
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001316
1317 # FuncNo() is back
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001318 writefile(first_lines + withno_lines, 'Xreloaded.vim')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001319 source Xreloaded.vim
Bram Moolenaar50824712020-12-20 21:10:17 +01001320 g:DoCheck(false)
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001321
1322 delete('Xreloaded.vim')
1323enddef
1324
Bram Moolenaar89483d42020-05-10 15:24:44 +02001325def Test_vim9script_reload_delvar()
1326 # write the script with a script-local variable
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001327 var lines =<< trim END
Bram Moolenaar89483d42020-05-10 15:24:44 +02001328 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001329 var name = 'string'
Bram Moolenaar89483d42020-05-10 15:24:44 +02001330 END
1331 writefile(lines, 'XreloadVar.vim')
1332 source XreloadVar.vim
1333
1334 # now write the script using the same variable locally - works
1335 lines =<< trim END
1336 vim9script
1337 def Func()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001338 var name = 'string'
Bram Moolenaar89483d42020-05-10 15:24:44 +02001339 enddef
1340 END
1341 writefile(lines, 'XreloadVar.vim')
1342 source XreloadVar.vim
1343
1344 delete('XreloadVar.vim')
1345enddef
1346
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001347def Test_import_absolute()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001348 var import_lines = [
Bram Moolenaare6085c52020-04-12 20:19:16 +02001349 'vim9script',
1350 'import exported from "' .. escape(getcwd(), '\') .. '/Xexport_abs.vim"',
1351 'def UseExported()',
1352 ' g:imported_abs = exported',
1353 ' exported = 8888',
1354 ' g:imported_after = exported',
1355 'enddef',
1356 'UseExported()',
1357 'g:import_disassembled = execute("disass UseExported")',
1358 ]
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001359 writefile(import_lines, 'Ximport_abs.vim')
1360 writefile(s:export_script_lines, 'Xexport_abs.vim')
1361
1362 source Ximport_abs.vim
1363
1364 assert_equal(9876, g:imported_abs)
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +01001365 assert_equal(8888, g:imported_after)
Bram Moolenaarfbbcd002020-10-15 12:46:44 +02001366 assert_match('<SNR>\d\+_UseExported\_s*' ..
1367 'g:imported_abs = exported\_s*' ..
1368 '0 LOADSCRIPT exported-2 from .*Xexport_abs.vim\_s*' ..
1369 '1 STOREG g:imported_abs\_s*' ..
1370 'exported = 8888\_s*' ..
1371 '2 PUSHNR 8888\_s*' ..
1372 '3 STORESCRIPT exported-2 in .*Xexport_abs.vim\_s*' ..
1373 'g:imported_after = exported\_s*' ..
1374 '4 LOADSCRIPT exported-2 from .*Xexport_abs.vim\_s*' ..
1375 '5 STOREG g:imported_after',
Bram Moolenaare6085c52020-04-12 20:19:16 +02001376 g:import_disassembled)
Bram Moolenaarb3ca9822020-08-09 14:43:58 +02001377
1378 Undo_export_script_lines()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001379 unlet g:imported_abs
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +01001380 unlet g:import_disassembled
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001381
1382 delete('Ximport_abs.vim')
1383 delete('Xexport_abs.vim')
1384enddef
1385
1386def Test_import_rtp()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001387 var import_lines = [
Bram Moolenaare6085c52020-04-12 20:19:16 +02001388 'vim9script',
1389 'import exported from "Xexport_rtp.vim"',
1390 'g:imported_rtp = exported',
1391 ]
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001392 writefile(import_lines, 'Ximport_rtp.vim')
1393 mkdir('import')
1394 writefile(s:export_script_lines, 'import/Xexport_rtp.vim')
1395
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001396 var save_rtp = &rtp
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001397 &rtp = getcwd()
1398 source Ximport_rtp.vim
1399 &rtp = save_rtp
1400
1401 assert_equal(9876, g:imported_rtp)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001402
Bram Moolenaarb3ca9822020-08-09 14:43:58 +02001403 Undo_export_script_lines()
1404 unlet g:imported_rtp
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001405 delete('Ximport_rtp.vim')
Bram Moolenaar89483d42020-05-10 15:24:44 +02001406 delete('import', 'rf')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001407enddef
1408
Bram Moolenaar25e0f582020-05-25 22:36:50 +02001409def Test_import_compile_error()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001410 var export_lines = [
Bram Moolenaar25e0f582020-05-25 22:36:50 +02001411 'vim9script',
1412 'export def ExpFunc(): string',
1413 ' return notDefined',
1414 'enddef',
1415 ]
1416 writefile(export_lines, 'Xexported.vim')
1417
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001418 var import_lines = [
Bram Moolenaar25e0f582020-05-25 22:36:50 +02001419 'vim9script',
1420 'import ExpFunc from "./Xexported.vim"',
1421 'def ImpFunc()',
1422 ' echo ExpFunc()',
1423 'enddef',
1424 'defcompile',
1425 ]
1426 writefile(import_lines, 'Ximport.vim')
1427
1428 try
1429 source Ximport.vim
1430 catch /E1001/
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001431 # Error should be fore the Xexported.vim file.
Bram Moolenaar77072282020-09-16 17:55:40 +02001432 assert_match('E1001: Variable not found: notDefined', v:exception)
Bram Moolenaar25e0f582020-05-25 22:36:50 +02001433 assert_match('function <SNR>\d\+_ImpFunc\[1\]..<SNR>\d\+_ExpFunc, line 1', v:throwpoint)
1434 endtry
1435
1436 delete('Xexported.vim')
1437 delete('Ximport.vim')
1438enddef
1439
Bram Moolenaarc4ce36d2020-08-14 17:08:15 +02001440def Test_func_redefine_error()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001441 var lines = [
Bram Moolenaarc4ce36d2020-08-14 17:08:15 +02001442 'vim9script',
1443 'def Func()',
1444 ' eval [][0]',
1445 'enddef',
1446 'Func()',
1447 ]
1448 writefile(lines, 'Xtestscript.vim')
1449
1450 for count in range(3)
1451 try
1452 source Xtestscript.vim
1453 catch /E684/
1454 # function name should contain <SNR> every time
1455 assert_match('E684: list index out of range', v:exception)
1456 assert_match('function <SNR>\d\+_Func, line 1', v:throwpoint)
1457 endtry
1458 endfor
1459
1460 delete('Xtestscript.vim')
1461enddef
1462
Bram Moolenaareef21022020-08-01 22:16:43 +02001463def Test_func_overrules_import_fails()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001464 var export_lines =<< trim END
Bram Moolenaareef21022020-08-01 22:16:43 +02001465 vim9script
1466 export def Func()
1467 echo 'imported'
1468 enddef
1469 END
1470 writefile(export_lines, 'XexportedFunc.vim')
1471
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001472 var lines =<< trim END
Bram Moolenaareef21022020-08-01 22:16:43 +02001473 vim9script
1474 import Func from './XexportedFunc.vim'
1475 def Func()
1476 echo 'local to function'
1477 enddef
1478 END
1479 CheckScriptFailure(lines, 'E1073:')
1480
1481 lines =<< trim END
1482 vim9script
1483 import Func from './XexportedFunc.vim'
1484 def Outer()
1485 def Func()
1486 echo 'local to function'
1487 enddef
1488 enddef
1489 defcompile
1490 END
1491 CheckScriptFailure(lines, 'E1073:')
1492
1493 delete('XexportedFunc.vim')
1494enddef
1495
Bram Moolenaarb9a2cac2020-08-01 22:23:20 +02001496def Test_func_redefine_fails()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001497 var lines =<< trim END
Bram Moolenaarb9a2cac2020-08-01 22:23:20 +02001498 vim9script
1499 def Func()
1500 echo 'one'
1501 enddef
1502 def Func()
1503 echo 'two'
1504 enddef
1505 END
1506 CheckScriptFailure(lines, 'E1073:')
Bram Moolenaarfa211f32020-08-07 22:00:26 +02001507
1508 lines =<< trim END
1509 vim9script
1510 def Foo(): string
1511 return 'foo'
1512 enddef
1513 def Func()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001514 var Foo = {-> 'lambda'}
Bram Moolenaarfa211f32020-08-07 22:00:26 +02001515 enddef
1516 defcompile
1517 END
1518 CheckScriptFailure(lines, 'E1073:')
Bram Moolenaarb9a2cac2020-08-01 22:23:20 +02001519enddef
1520
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001521def Test_fixed_size_list()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001522 # will be allocated as one piece of memory, check that changes work
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001523 var l = [1, 2, 3, 4]
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001524 l->remove(0)
1525 l->add(5)
1526 l->insert(99, 1)
Bram Moolenaar0f18b6d2020-02-02 17:22:27 +01001527 assert_equal([2, 99, 3, 4, 5], l)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001528enddef
1529
Bram Moolenaarae616492020-07-28 20:07:27 +02001530def Test_no_insert_xit()
Bram Moolenaard2c61702020-09-06 15:58:36 +02001531 CheckDefExecFailure(['a = 1'], 'E1100:')
1532 CheckDefExecFailure(['c = 1'], 'E1100:')
1533 CheckDefExecFailure(['i = 1'], 'E1100:')
1534 CheckDefExecFailure(['t = 1'], 'E1100:')
1535 CheckDefExecFailure(['x = 1'], 'E1100:')
Bram Moolenaarae616492020-07-28 20:07:27 +02001536
Bram Moolenaarae616492020-07-28 20:07:27 +02001537 CheckScriptFailure(['vim9script', 'a = 1'], 'E488:')
1538 CheckScriptFailure(['vim9script', 'a'], 'E1100:')
Bram Moolenaarae616492020-07-28 20:07:27 +02001539 CheckScriptFailure(['vim9script', 'c = 1'], 'E488:')
1540 CheckScriptFailure(['vim9script', 'c'], 'E1100:')
Bram Moolenaarf5a48012020-08-01 17:00:03 +02001541 CheckScriptFailure(['vim9script', 'i = 1'], 'E488:')
1542 CheckScriptFailure(['vim9script', 'i'], 'E1100:')
1543 CheckScriptFailure(['vim9script', 't'], 'E1100:')
1544 CheckScriptFailure(['vim9script', 't = 1'], 'E1100:')
1545 CheckScriptFailure(['vim9script', 'x = 1'], 'E1100:')
Bram Moolenaarae616492020-07-28 20:07:27 +02001546enddef
1547
Bram Moolenaar158906c2020-02-06 20:39:45 +01001548def IfElse(what: number): string
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001549 var res = ''
Bram Moolenaar158906c2020-02-06 20:39:45 +01001550 if what == 1
1551 res = "one"
1552 elseif what == 2
1553 res = "two"
Bram Moolenaara259d8d2020-01-31 20:10:50 +01001554 else
Bram Moolenaar158906c2020-02-06 20:39:45 +01001555 res = "three"
Bram Moolenaara259d8d2020-01-31 20:10:50 +01001556 endif
Bram Moolenaar158906c2020-02-06 20:39:45 +01001557 return res
Bram Moolenaara259d8d2020-01-31 20:10:50 +01001558enddef
1559
Bram Moolenaar158906c2020-02-06 20:39:45 +01001560def Test_if_elseif_else()
1561 assert_equal('one', IfElse(1))
1562 assert_equal('two', IfElse(2))
1563 assert_equal('three', IfElse(3))
Bram Moolenaar0f18b6d2020-02-02 17:22:27 +01001564enddef
1565
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001566def Test_if_elseif_else_fails()
Bram Moolenaard2c61702020-09-06 15:58:36 +02001567 CheckDefFailure(['elseif true'], 'E582:')
1568 CheckDefFailure(['else'], 'E581:')
1569 CheckDefFailure(['endif'], 'E580:')
1570 CheckDefFailure(['if true', 'elseif xxx'], 'E1001:')
1571 CheckDefFailure(['if true', 'echo 1'], 'E171:')
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001572enddef
1573
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001574let g:bool_true = v:true
1575let g:bool_false = v:false
1576
1577def Test_if_const_expr()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001578 var res = false
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001579 if true ? true : false
1580 res = true
1581 endif
1582 assert_equal(true, res)
1583
Bram Moolenaar585fea72020-04-02 22:33:21 +02001584 g:glob = 2
1585 if false
Bram Moolenaar67979662020-06-20 22:50:47 +02001586 execute('g:glob = 3')
Bram Moolenaar585fea72020-04-02 22:33:21 +02001587 endif
1588 assert_equal(2, g:glob)
1589 if true
Bram Moolenaar67979662020-06-20 22:50:47 +02001590 execute('g:glob = 3')
Bram Moolenaar585fea72020-04-02 22:33:21 +02001591 endif
1592 assert_equal(3, g:glob)
1593
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001594 res = false
1595 if g:bool_true ? true : false
1596 res = true
1597 endif
1598 assert_equal(true, res)
1599
1600 res = false
1601 if true ? g:bool_true : false
1602 res = true
1603 endif
1604 assert_equal(true, res)
1605
1606 res = false
1607 if true ? true : g:bool_false
1608 res = true
1609 endif
1610 assert_equal(true, res)
1611
1612 res = false
1613 if true ? false : true
1614 res = true
1615 endif
1616 assert_equal(false, res)
1617
1618 res = false
1619 if false ? false : true
1620 res = true
1621 endif
1622 assert_equal(true, res)
1623
1624 res = false
1625 if false ? true : false
1626 res = true
1627 endif
1628 assert_equal(false, res)
1629
1630 res = false
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001631 if has('xyz') ? true : false
1632 res = true
1633 endif
1634 assert_equal(false, res)
1635
1636 res = false
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001637 if true && true
1638 res = true
1639 endif
1640 assert_equal(true, res)
1641
1642 res = false
1643 if true && false
1644 res = true
1645 endif
1646 assert_equal(false, res)
1647
1648 res = false
1649 if g:bool_true && false
1650 res = true
1651 endif
1652 assert_equal(false, res)
1653
1654 res = false
1655 if true && g:bool_false
1656 res = true
1657 endif
1658 assert_equal(false, res)
1659
1660 res = false
1661 if false && false
1662 res = true
1663 endif
1664 assert_equal(false, res)
1665
1666 res = false
1667 if true || false
1668 res = true
1669 endif
1670 assert_equal(true, res)
1671
1672 res = false
1673 if g:bool_true || false
1674 res = true
1675 endif
1676 assert_equal(true, res)
1677
1678 res = false
1679 if true || g:bool_false
1680 res = true
1681 endif
1682 assert_equal(true, res)
1683
1684 res = false
1685 if false || false
1686 res = true
1687 endif
1688 assert_equal(false, res)
Bram Moolenaar3988f642020-08-27 22:43:03 +02001689
1690 # with constant "false" expression may be invalid so long as the syntax is OK
1691 if false | eval 0 | endif
1692 if false | eval burp + 234 | endif
1693 if false | echo burp 234 'asd' | endif
1694 if false
1695 burp
1696 endif
Bram Moolenaar80c34ca2020-04-01 23:05:18 +02001697enddef
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001698
Bram Moolenaar80c34ca2020-04-01 23:05:18 +02001699def Test_if_const_expr_fails()
Bram Moolenaard2c61702020-09-06 15:58:36 +02001700 CheckDefFailure(['if "aaa" == "bbb'], 'E114:')
1701 CheckDefFailure(["if 'aaa' == 'bbb"], 'E115:')
1702 CheckDefFailure(["if has('aaa'"], 'E110:')
1703 CheckDefFailure(["if has('aaa') ? true false"], 'E109:')
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001704enddef
1705
Bram Moolenaar72abcf42020-06-18 18:26:24 +02001706def RunNested(i: number): number
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001707 var x: number = 0
Bram Moolenaar72abcf42020-06-18 18:26:24 +02001708 if i % 2
1709 if 1
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001710 # comment
Bram Moolenaar72abcf42020-06-18 18:26:24 +02001711 else
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001712 # comment
Bram Moolenaar72abcf42020-06-18 18:26:24 +02001713 endif
1714 x += 1
1715 else
1716 x += 1000
1717 endif
1718 return x
1719enddef
1720
1721def Test_nested_if()
1722 assert_equal(1, RunNested(1))
1723 assert_equal(1000, RunNested(2))
1724enddef
1725
Bram Moolenaarad39c092020-02-26 18:23:43 +01001726def Test_execute_cmd()
Bram Moolenaare4984292020-12-13 14:19:25 +01001727 # missing argument is ignored
1728 execute
1729 execute # comment
1730
Bram Moolenaarad39c092020-02-26 18:23:43 +01001731 new
1732 setline(1, 'default')
Bram Moolenaard2c61702020-09-06 15:58:36 +02001733 execute 'setline(1, "execute-string")'
Bram Moolenaarad39c092020-02-26 18:23:43 +01001734 assert_equal('execute-string', getline(1))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001735
Bram Moolenaard2c61702020-09-06 15:58:36 +02001736 execute "setline(1, 'execute-string')"
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001737 assert_equal('execute-string', getline(1))
1738
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001739 var cmd1 = 'setline(1,'
1740 var cmd2 = '"execute-var")'
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001741 execute cmd1 cmd2 # comment
Bram Moolenaarad39c092020-02-26 18:23:43 +01001742 assert_equal('execute-var', getline(1))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001743
Bram Moolenaard2c61702020-09-06 15:58:36 +02001744 execute cmd1 cmd2 '|setline(1, "execute-var-string")'
Bram Moolenaarad39c092020-02-26 18:23:43 +01001745 assert_equal('execute-var-string', getline(1))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001746
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001747 var cmd_first = 'call '
1748 var cmd_last = 'setline(1, "execute-var-var")'
Bram Moolenaarad39c092020-02-26 18:23:43 +01001749 execute cmd_first .. cmd_last
1750 assert_equal('execute-var-var', getline(1))
1751 bwipe!
Bram Moolenaar585fea72020-04-02 22:33:21 +02001752
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001753 var n = true
Bram Moolenaar2d6b20d2020-07-25 19:30:59 +02001754 execute 'echomsg' (n ? '"true"' : '"no"')
1755 assert_match('^true$', Screenline(&lines))
1756
Bram Moolenaare0de1712020-12-02 17:36:54 +01001757 echomsg [1, 2, 3] {a: 1, b: 2}
Bram Moolenaare5abf7a2020-08-16 18:29:35 +02001758 assert_match('^\[1, 2, 3\] {''a'': 1, ''b'': 2}$', Screenline(&lines))
1759
Bram Moolenaard2c61702020-09-06 15:58:36 +02001760 CheckDefFailure(['execute xxx'], 'E1001:', 1)
1761 CheckDefExecFailure(['execute "tabnext " .. 8'], 'E475:', 1)
1762 CheckDefFailure(['execute "cmd"# comment'], 'E488:', 1)
Bram Moolenaarad39c092020-02-26 18:23:43 +01001763enddef
1764
Bram Moolenaar47e880d2020-06-30 22:02:02 +02001765def Test_execute_cmd_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001766 # only checks line continuation
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001767 var lines =<< trim END
Bram Moolenaar47e880d2020-06-30 22:02:02 +02001768 vim9script
1769 execute 'g:someVar'
1770 .. ' = ' ..
1771 '28'
1772 assert_equal(28, g:someVar)
1773 unlet g:someVar
1774 END
1775 CheckScriptSuccess(lines)
1776enddef
1777
Bram Moolenaarad39c092020-02-26 18:23:43 +01001778def Test_echo_cmd()
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001779 echo 'some' # comment
Bram Moolenaar585fea72020-04-02 22:33:21 +02001780 echon 'thing'
Bram Moolenaarad39c092020-02-26 18:23:43 +01001781 assert_match('^something$', Screenline(&lines))
1782
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001783 echo "some" # comment
1784 echon "thing"
1785 assert_match('^something$', Screenline(&lines))
1786
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001787 var str1 = 'some'
1788 var str2 = 'more'
Bram Moolenaarad39c092020-02-26 18:23:43 +01001789 echo str1 str2
1790 assert_match('^some more$', Screenline(&lines))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001791
Bram Moolenaard2c61702020-09-06 15:58:36 +02001792 CheckDefFailure(['echo "xxx"# comment'], 'E488:')
Bram Moolenaarad39c092020-02-26 18:23:43 +01001793enddef
1794
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001795def Test_echomsg_cmd()
1796 echomsg 'some' 'more' # comment
1797 assert_match('^some more$', Screenline(&lines))
1798 echo 'clear'
Bram Moolenaardf069ee2020-06-22 23:02:51 +02001799 :1messages
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001800 assert_match('^some more$', Screenline(&lines))
1801
Bram Moolenaard2c61702020-09-06 15:58:36 +02001802 CheckDefFailure(['echomsg "xxx"# comment'], 'E488:')
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001803enddef
1804
Bram Moolenaar47e880d2020-06-30 22:02:02 +02001805def Test_echomsg_cmd_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001806 # only checks line continuation
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001807 var lines =<< trim END
Bram Moolenaar47e880d2020-06-30 22:02:02 +02001808 vim9script
1809 echomsg 'here'
1810 .. ' is ' ..
1811 'a message'
1812 assert_match('^here is a message$', Screenline(&lines))
1813 END
1814 CheckScriptSuccess(lines)
1815enddef
1816
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001817def Test_echoerr_cmd()
Bram Moolenaar40ee4662020-05-05 22:08:26 +02001818 try
1819 echoerr 'something' 'wrong' # comment
1820 catch
1821 assert_match('something wrong', v:exception)
1822 endtry
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001823enddef
1824
Bram Moolenaar47e880d2020-06-30 22:02:02 +02001825def Test_echoerr_cmd_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001826 # only checks line continuation
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001827 var lines =<< trim END
Bram Moolenaar47e880d2020-06-30 22:02:02 +02001828 vim9script
1829 try
1830 echoerr 'this'
1831 .. ' is ' ..
1832 'wrong'
1833 catch
1834 assert_match('this is wrong', v:exception)
1835 endtry
1836 END
1837 CheckScriptSuccess(lines)
1838enddef
1839
Bram Moolenaar41fe0612020-03-01 16:22:40 +01001840def Test_for_outside_of_function()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001841 var lines =<< trim END
Bram Moolenaar41fe0612020-03-01 16:22:40 +01001842 vim9script
1843 new
1844 for var in range(0, 3)
1845 append(line('$'), var)
1846 endfor
1847 assert_equal(['', '0', '1', '2', '3'], getline(1, '$'))
1848 bwipe!
1849 END
1850 writefile(lines, 'Xvim9for.vim')
1851 source Xvim9for.vim
1852 delete('Xvim9for.vim')
1853enddef
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001854
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001855def Test_for_loop()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001856 var result = ''
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001857 for cnt in range(7)
1858 if cnt == 4
1859 break
1860 endif
1861 if cnt == 2
1862 continue
1863 endif
1864 result ..= cnt .. '_'
1865 endfor
1866 assert_equal('0_1_3_', result)
Bram Moolenaar0ad3e892020-07-05 21:38:11 +02001867
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001868 var concat = ''
Bram Moolenaar0ad3e892020-07-05 21:38:11 +02001869 for str in eval('["one", "two"]')
1870 concat ..= str
1871 endfor
1872 assert_equal('onetwo', concat)
Bram Moolenaar38bd8de2020-12-02 13:23:36 +01001873
1874 var total = 0
1875 for nr in
1876 [1, 2, 3]
1877 total += nr
1878 endfor
1879 assert_equal(6, total)
1880
1881 total = 0
1882 for nr
1883 in [1, 2, 3]
1884 total += nr
1885 endfor
1886 assert_equal(6, total)
1887
1888 total = 0
1889 for nr
1890 in
1891 [1, 2, 3]
1892 total += nr
1893 endfor
1894 assert_equal(6, total)
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001895enddef
1896
1897def Test_for_loop_fails()
Bram Moolenaar025cb1c2020-12-14 18:31:27 +01001898 CheckDefFailure(['for '], 'E1097:')
1899 CheckDefFailure(['for x'], 'E1097:')
1900 CheckDefFailure(['for x in'], 'E1097:')
Bram Moolenaar675f7162020-04-12 22:53:54 +02001901 CheckDefFailure(['for # in range(5)'], 'E690:')
1902 CheckDefFailure(['for i In range(5)'], 'E690:')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001903 CheckDefFailure(['var x = 5', 'for x in range(5)'], 'E1017:')
Bram Moolenaar822ba242020-05-24 23:00:18 +02001904 CheckScriptFailure(['def Func(arg: any)', 'for arg in range(5)', 'enddef', 'defcompile'], 'E1006:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001905 delfunc! g:Func
Bram Moolenaar451c2e32020-08-15 16:33:28 +02001906 CheckDefFailure(['for i in "text"'], 'E1012:')
Bram Moolenaar675f7162020-04-12 22:53:54 +02001907 CheckDefFailure(['for i in xxx'], 'E1001:')
1908 CheckDefFailure(['endfor'], 'E588:')
1909 CheckDefFailure(['for i in range(3)', 'echo 3'], 'E170:')
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001910enddef
1911
Bram Moolenaarea870692020-12-02 14:24:30 +01001912def Test_for_loop_script_var()
1913 # cannot use s:var in a :def function
1914 CheckDefFailure(['for s:var in range(3)', 'echo 3'], 'E1101:')
1915
1916 # can use s:var in Vim9 script, with or without s:
1917 var lines =<< trim END
1918 vim9script
1919 var total = 0
1920 for s:var in [1, 2, 3]
1921 total += s:var
1922 endfor
1923 assert_equal(6, total)
1924
1925 total = 0
1926 for var in [1, 2, 3]
1927 total += var
1928 endfor
1929 assert_equal(6, total)
1930 END
1931enddef
1932
Bram Moolenaar792f7862020-11-23 08:31:18 +01001933def Test_for_loop_unpack()
Bram Moolenaar792f7862020-11-23 08:31:18 +01001934 var lines =<< trim END
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01001935 var result = []
1936 for [v1, v2] in [[1, 2], [3, 4]]
1937 result->add(v1)
1938 result->add(v2)
1939 endfor
1940 assert_equal([1, 2, 3, 4], result)
1941
1942 result = []
1943 for [v1, v2; v3] in [[1, 2], [3, 4, 5, 6]]
1944 result->add(v1)
1945 result->add(v2)
1946 result->add(v3)
1947 endfor
1948 assert_equal([1, 2, [], 3, 4, [5, 6]], result)
1949
1950 result = []
1951 for [&ts, &sw] in [[1, 2], [3, 4]]
1952 result->add(&ts)
1953 result->add(&sw)
1954 endfor
1955 assert_equal([1, 2, 3, 4], result)
1956
1957 var slist: list<string>
1958 for [$LOOPVAR, @r, v:errmsg] in [['a', 'b', 'c'], ['d', 'e', 'f']]
1959 slist->add($LOOPVAR)
1960 slist->add(@r)
1961 slist->add(v:errmsg)
1962 endfor
1963 assert_equal(['a', 'b', 'c', 'd', 'e', 'f'], slist)
1964
1965 slist = []
1966 for [g:globalvar, b:bufvar, w:winvar, t:tabvar] in [['global', 'buf', 'win', 'tab'], ['1', '2', '3', '4']]
1967 slist->add(g:globalvar)
1968 slist->add(b:bufvar)
1969 slist->add(w:winvar)
1970 slist->add(t:tabvar)
1971 endfor
1972 assert_equal(['global', 'buf', 'win', 'tab', '1', '2', '3', '4'], slist)
Bram Moolenaarf6c177a2020-12-04 17:38:00 +01001973 unlet! g:globalvar b:bufvar w:winvar t:tabvar
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01001974 END
1975 CheckDefAndScriptSuccess(lines)
1976
1977 lines =<< trim END
Bram Moolenaar792f7862020-11-23 08:31:18 +01001978 for [v1, v2] in [[1, 2, 3], [3, 4]]
1979 echo v1 v2
1980 endfor
1981 END
1982 CheckDefExecFailure(lines, 'E710:', 1)
1983
1984 lines =<< trim END
1985 for [v1, v2] in [[1], [3, 4]]
1986 echo v1 v2
1987 endfor
1988 END
1989 CheckDefExecFailure(lines, 'E711:', 1)
1990
1991 lines =<< trim END
1992 for [v1, v1] in [[1, 2], [3, 4]]
1993 echo v1
1994 endfor
1995 END
1996 CheckDefExecFailure(lines, 'E1017:', 1)
1997enddef
1998
Bram Moolenaard0df1aa2020-03-04 21:50:46 +01001999def Test_while_loop()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002000 var result = ''
2001 var cnt = 0
Bram Moolenaard0df1aa2020-03-04 21:50:46 +01002002 while cnt < 555
2003 if cnt == 3
2004 break
2005 endif
2006 cnt += 1
2007 if cnt == 2
2008 continue
2009 endif
2010 result ..= cnt .. '_'
2011 endwhile
2012 assert_equal('1_3_', result)
2013enddef
2014
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02002015def Test_while_loop_fails()
Bram Moolenaar675f7162020-04-12 22:53:54 +02002016 CheckDefFailure(['while xxx'], 'E1001:')
2017 CheckDefFailure(['endwhile'], 'E588:')
2018 CheckDefFailure(['continue'], 'E586:')
2019 CheckDefFailure(['if true', 'continue'], 'E586:')
2020 CheckDefFailure(['break'], 'E587:')
2021 CheckDefFailure(['if true', 'break'], 'E587:')
2022 CheckDefFailure(['while 1', 'echo 3'], 'E170:')
Bram Moolenaarbd5da372020-03-31 23:13:10 +02002023enddef
2024
Bram Moolenaar9645e2d2020-03-20 20:48:49 +01002025def Test_interrupt_loop()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002026 var caught = false
2027 var x = 0
Bram Moolenaar97acfc72020-03-22 13:44:28 +01002028 try
2029 while 1
2030 x += 1
2031 if x == 100
2032 feedkeys("\<C-C>", 'Lt')
2033 endif
2034 endwhile
2035 catch
2036 caught = true
2037 assert_equal(100, x)
2038 endtry
2039 assert_true(caught, 'should have caught an exception')
Bram Moolenaar25859dd2020-08-30 12:54:53 +02002040 # consume the CTRL-C
2041 getchar(0)
Bram Moolenaar9645e2d2020-03-20 20:48:49 +01002042enddef
Bram Moolenaar20431c92020-03-20 18:39:46 +01002043
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002044def Test_automatic_line_continuation()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002045 var mylist = [
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002046 'one',
2047 'two',
2048 'three',
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002049 ] # comment
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002050 assert_equal(['one', 'two', 'three'], mylist)
2051
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002052 var mydict = {
Bram Moolenaare0de1712020-12-02 17:36:54 +01002053 ['one']: 1,
2054 ['two']: 2,
2055 ['three']:
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002056 3,
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002057 } # comment
Bram Moolenaare0de1712020-12-02 17:36:54 +01002058 assert_equal({one: 1, two: 2, three: 3}, mydict)
2059 mydict = {
Bram Moolenaar2c330432020-04-13 14:41:35 +02002060 one: 1, # comment
2061 two: # comment
2062 2, # comment
2063 three: 3 # comment
2064 }
Bram Moolenaare0de1712020-12-02 17:36:54 +01002065 assert_equal({one: 1, two: 2, three: 3}, mydict)
2066 mydict = {
Bram Moolenaar2c330432020-04-13 14:41:35 +02002067 one: 1,
2068 two:
2069 2,
2070 three: 3
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002071 }
Bram Moolenaare0de1712020-12-02 17:36:54 +01002072 assert_equal({one: 1, two: 2, three: 3}, mydict)
Bram Moolenaare6085c52020-04-12 20:19:16 +02002073
2074 assert_equal(
2075 ['one', 'two', 'three'],
2076 split('one two three')
2077 )
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002078enddef
2079
Bram Moolenaar7a092242020-04-16 22:10:49 +02002080def Test_vim9_comment()
2081 CheckScriptSuccess([
2082 'vim9script',
2083 '# something',
Bram Moolenaar93f82cb2020-12-12 21:25:56 +01002084 '#something',
2085 '#{something',
Bram Moolenaar7a092242020-04-16 22:10:49 +02002086 ])
Bram Moolenaar93f82cb2020-12-12 21:25:56 +01002087
2088 split Xfile
2089 CheckScriptSuccess([
2090 'vim9script',
2091 'edit #something',
2092 ])
2093 CheckScriptSuccess([
2094 'vim9script',
2095 'edit #{something',
2096 ])
2097 close
2098
Bram Moolenaar7a092242020-04-16 22:10:49 +02002099 CheckScriptFailure([
2100 'vim9script',
2101 ':# something',
2102 ], 'E488:')
2103 CheckScriptFailure([
2104 '# something',
2105 ], 'E488:')
2106 CheckScriptFailure([
2107 ':# something',
2108 ], 'E488:')
2109
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02002110 { # block start
2111 } # block end
2112 CheckDefFailure([
2113 '{# comment',
2114 ], 'E488:')
2115 CheckDefFailure([
2116 '{',
2117 '}# comment',
2118 ], 'E488:')
2119
2120 echo "yes" # comment
2121 CheckDefFailure([
2122 'echo "yes"# comment',
2123 ], 'E488:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02002124 CheckScriptSuccess([
2125 'vim9script',
2126 'echo "yes" # something',
2127 ])
2128 CheckScriptFailure([
2129 'vim9script',
2130 'echo "yes"# something',
2131 ], 'E121:')
2132 CheckScriptFailure([
2133 'vim9script',
2134 'echo# something',
2135 ], 'E121:')
2136 CheckScriptFailure([
2137 'echo "yes" # something',
2138 ], 'E121:')
2139
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02002140 exe "echo" # comment
2141 CheckDefFailure([
2142 'exe "echo"# comment',
2143 ], 'E488:')
2144 CheckScriptSuccess([
2145 'vim9script',
2146 'exe "echo" # something',
2147 ])
2148 CheckScriptFailure([
2149 'vim9script',
2150 'exe "echo"# something',
2151 ], 'E121:')
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02002152 CheckScriptFailure([
2153 'vim9script',
2154 'exe# something',
2155 ], 'E121:')
2156 CheckScriptFailure([
2157 'exe "echo" # something',
2158 ], 'E121:')
2159
Bram Moolenaar7a092242020-04-16 22:10:49 +02002160 CheckDefFailure([
2161 'try# comment',
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002162 ' echo "yes"',
Bram Moolenaar7a092242020-04-16 22:10:49 +02002163 'catch',
2164 'endtry',
2165 ], 'E488:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002166 CheckScriptFailure([
2167 'vim9script',
2168 'try# comment',
2169 'echo "yes"',
2170 ], 'E488:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02002171 CheckDefFailure([
2172 'try',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002173 ' throw#comment',
2174 'catch',
2175 'endtry',
Bram Moolenaare4984292020-12-13 14:19:25 +01002176 ], 'E1143:')
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002177 CheckDefFailure([
2178 'try',
2179 ' throw "yes"#comment',
2180 'catch',
2181 'endtry',
2182 ], 'E488:')
2183 CheckDefFailure([
2184 'try',
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002185 ' echo "yes"',
Bram Moolenaar7a092242020-04-16 22:10:49 +02002186 'catch# comment',
2187 'endtry',
2188 ], 'E488:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002189 CheckScriptFailure([
2190 'vim9script',
2191 'try',
2192 ' echo "yes"',
2193 'catch# comment',
2194 'endtry',
2195 ], 'E654:')
2196 CheckDefFailure([
2197 'try',
2198 ' echo "yes"',
2199 'catch /pat/# comment',
2200 'endtry',
2201 ], 'E488:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02002202 CheckDefFailure([
2203 'try',
2204 'echo "yes"',
2205 'catch',
2206 'endtry# comment',
2207 ], 'E488:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002208 CheckScriptFailure([
2209 'vim9script',
2210 'try',
2211 ' echo "yes"',
2212 'catch',
2213 'endtry# comment',
Bram Moolenaar9b7bf9e2020-07-11 22:14:59 +02002214 ], 'E488:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002215
2216 CheckScriptSuccess([
2217 'vim9script',
2218 'hi # comment',
2219 ])
2220 CheckScriptFailure([
2221 'vim9script',
2222 'hi# comment',
2223 ], 'E416:')
Bram Moolenaar1966c242020-04-20 22:42:32 +02002224 CheckScriptSuccess([
2225 'vim9script',
2226 'hi Search # comment',
2227 ])
2228 CheckScriptFailure([
2229 'vim9script',
2230 'hi Search# comment',
2231 ], 'E416:')
2232 CheckScriptSuccess([
2233 'vim9script',
2234 'hi link This Search # comment',
2235 ])
2236 CheckScriptFailure([
2237 'vim9script',
2238 'hi link This That# comment',
2239 ], 'E413:')
2240 CheckScriptSuccess([
2241 'vim9script',
2242 'hi clear This # comment',
2243 'hi clear # comment',
2244 ])
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002245 # not tested, because it doesn't give an error but a warning:
2246 # hi clear This# comment',
Bram Moolenaar1966c242020-04-20 22:42:32 +02002247 CheckScriptFailure([
2248 'vim9script',
2249 'hi clear# comment',
2250 ], 'E416:')
2251
2252 CheckScriptSuccess([
2253 'vim9script',
2254 'hi Group term=bold',
2255 'match Group /todo/ # comment',
2256 ])
2257 CheckScriptFailure([
2258 'vim9script',
2259 'hi Group term=bold',
2260 'match Group /todo/# comment',
2261 ], 'E488:')
2262 CheckScriptSuccess([
2263 'vim9script',
2264 'match # comment',
2265 ])
2266 CheckScriptFailure([
2267 'vim9script',
2268 'match# comment',
2269 ], 'E475:')
2270 CheckScriptSuccess([
2271 'vim9script',
2272 'match none # comment',
2273 ])
2274 CheckScriptFailure([
2275 'vim9script',
2276 'match none# comment',
2277 ], 'E475:')
2278
2279 CheckScriptSuccess([
2280 'vim9script',
2281 'menutrans clear # comment',
2282 ])
2283 CheckScriptFailure([
2284 'vim9script',
2285 'menutrans clear# comment text',
2286 ], 'E474:')
2287
2288 CheckScriptSuccess([
2289 'vim9script',
2290 'syntax clear # comment',
2291 ])
2292 CheckScriptFailure([
2293 'vim9script',
2294 'syntax clear# comment text',
2295 ], 'E28:')
2296 CheckScriptSuccess([
2297 'vim9script',
2298 'syntax keyword Word some',
2299 'syntax clear Word # comment',
2300 ])
2301 CheckScriptFailure([
2302 'vim9script',
2303 'syntax keyword Word some',
2304 'syntax clear Word# comment text',
2305 ], 'E28:')
2306
2307 CheckScriptSuccess([
2308 'vim9script',
2309 'syntax list # comment',
2310 ])
2311 CheckScriptFailure([
2312 'vim9script',
2313 'syntax list# comment text',
2314 ], 'E28:')
2315
2316 CheckScriptSuccess([
2317 'vim9script',
2318 'syntax match Word /pat/ oneline # comment',
2319 ])
2320 CheckScriptFailure([
2321 'vim9script',
2322 'syntax match Word /pat/ oneline# comment',
2323 ], 'E475:')
2324
2325 CheckScriptSuccess([
2326 'vim9script',
2327 'syntax keyword Word word # comm[ent',
2328 ])
2329 CheckScriptFailure([
2330 'vim9script',
2331 'syntax keyword Word word# comm[ent',
2332 ], 'E789:')
2333
2334 CheckScriptSuccess([
2335 'vim9script',
2336 'syntax match Word /pat/ # comment',
2337 ])
2338 CheckScriptFailure([
2339 'vim9script',
2340 'syntax match Word /pat/# comment',
2341 ], 'E402:')
2342
2343 CheckScriptSuccess([
2344 'vim9script',
2345 'syntax match Word /pat/ contains=Something # comment',
2346 ])
2347 CheckScriptFailure([
2348 'vim9script',
2349 'syntax match Word /pat/ contains=Something# comment',
2350 ], 'E475:')
2351 CheckScriptFailure([
2352 'vim9script',
2353 'syntax match Word /pat/ contains= # comment',
2354 ], 'E406:')
2355 CheckScriptFailure([
2356 'vim9script',
2357 'syntax match Word /pat/ contains=# comment',
2358 ], 'E475:')
2359
2360 CheckScriptSuccess([
2361 'vim9script',
2362 'syntax region Word start=/pat/ end=/pat/ # comment',
2363 ])
2364 CheckScriptFailure([
2365 'vim9script',
2366 'syntax region Word start=/pat/ end=/pat/# comment',
Bram Moolenaard032f342020-07-18 18:13:02 +02002367 ], 'E402:')
Bram Moolenaar1966c242020-04-20 22:42:32 +02002368
2369 CheckScriptSuccess([
2370 'vim9script',
2371 'syntax sync # comment',
2372 ])
2373 CheckScriptFailure([
2374 'vim9script',
2375 'syntax sync# comment',
2376 ], 'E404:')
2377 CheckScriptSuccess([
2378 'vim9script',
2379 'syntax sync ccomment # comment',
2380 ])
2381 CheckScriptFailure([
2382 'vim9script',
2383 'syntax sync ccomment# comment',
2384 ], 'E404:')
2385
2386 CheckScriptSuccess([
2387 'vim9script',
2388 'syntax cluster Some contains=Word # comment',
2389 ])
2390 CheckScriptFailure([
2391 'vim9script',
2392 'syntax cluster Some contains=Word# comment',
2393 ], 'E475:')
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002394
2395 CheckScriptSuccess([
2396 'vim9script',
2397 'command Echo echo # comment',
2398 'command Echo # comment',
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002399 'delcommand Echo',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002400 ])
2401 CheckScriptFailure([
2402 'vim9script',
2403 'command Echo echo# comment',
2404 'Echo',
2405 ], 'E121:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002406 delcommand Echo
Bram Moolenaar70249ee2020-12-10 21:01:30 +01002407
2408 var curdir = getcwd()
2409 CheckScriptSuccess([
2410 'command Echo cd " comment',
2411 'Echo',
2412 'delcommand Echo',
2413 ])
2414 CheckScriptSuccess([
Bram Moolenaar090728a2020-12-20 15:43:31 +01002415 'vim9script',
Bram Moolenaar70249ee2020-12-10 21:01:30 +01002416 'command Echo cd # comment',
2417 'Echo',
2418 'delcommand Echo',
2419 ])
2420 CheckScriptFailure([
2421 'vim9script',
2422 'command Echo cd " comment',
2423 'Echo',
2424 ], 'E344:')
2425 delcommand Echo
2426 chdir(curdir)
2427
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002428 CheckScriptFailure([
2429 'vim9script',
2430 'command Echo# comment',
2431 ], 'E182:')
2432 CheckScriptFailure([
2433 'vim9script',
2434 'command Echo echo',
2435 'command Echo# comment',
2436 ], 'E182:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002437 delcommand Echo
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002438
2439 CheckScriptSuccess([
2440 'vim9script',
2441 'function # comment',
2442 ])
2443 CheckScriptFailure([
2444 'vim9script',
Bram Moolenaar98981072020-07-29 14:40:25 +02002445 'function " comment',
2446 ], 'E129:')
2447 CheckScriptFailure([
2448 'vim9script',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002449 'function# comment',
2450 ], 'E129:')
2451 CheckScriptSuccess([
2452 'vim9script',
2453 'function CheckScriptSuccess # comment',
2454 ])
2455 CheckScriptFailure([
2456 'vim9script',
2457 'function CheckScriptSuccess# comment',
2458 ], 'E488:')
2459
2460 CheckScriptSuccess([
2461 'vim9script',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02002462 'func g:DeleteMeA()',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002463 'endfunc',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02002464 'delfunction g:DeleteMeA # comment',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002465 ])
2466 CheckScriptFailure([
2467 'vim9script',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02002468 'func g:DeleteMeB()',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002469 'endfunc',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02002470 'delfunction g:DeleteMeB# comment',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002471 ], 'E488:')
2472
2473 CheckScriptSuccess([
2474 'vim9script',
2475 'call execute("ls") # comment',
2476 ])
2477 CheckScriptFailure([
2478 'vim9script',
2479 'call execute("ls")# comment',
2480 ], 'E488:')
Bram Moolenaare7e48382020-07-22 18:17:08 +02002481
2482 CheckScriptFailure([
2483 'def Test() " comment',
2484 'enddef',
2485 ], 'E488:')
2486 CheckScriptFailure([
2487 'vim9script',
2488 'def Test() " comment',
2489 'enddef',
2490 ], 'E488:')
2491
2492 CheckScriptSuccess([
2493 'func Test() " comment',
2494 'endfunc',
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002495 'delfunc Test',
Bram Moolenaare7e48382020-07-22 18:17:08 +02002496 ])
Bram Moolenaar98981072020-07-29 14:40:25 +02002497 CheckScriptSuccess([
Bram Moolenaare7e48382020-07-22 18:17:08 +02002498 'vim9script',
2499 'func Test() " comment',
2500 'endfunc',
Bram Moolenaar98981072020-07-29 14:40:25 +02002501 ])
Bram Moolenaare7e48382020-07-22 18:17:08 +02002502
2503 CheckScriptSuccess([
2504 'def Test() # comment',
2505 'enddef',
2506 ])
2507 CheckScriptFailure([
2508 'func Test() # comment',
2509 'endfunc',
2510 ], 'E488:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002511enddef
2512
2513def Test_vim9_comment_gui()
2514 CheckCanRunGui
2515
2516 CheckScriptFailure([
2517 'vim9script',
2518 'gui#comment'
2519 ], 'E499:')
2520 CheckScriptFailure([
2521 'vim9script',
2522 'gui -f#comment'
2523 ], 'E499:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02002524enddef
2525
Bram Moolenaara26b9702020-04-18 19:53:28 +02002526def Test_vim9_comment_not_compiled()
Bram Moolenaar67979662020-06-20 22:50:47 +02002527 au TabEnter *.vim g:entered = 1
2528 au TabEnter *.x g:entered = 2
Bram Moolenaara26b9702020-04-18 19:53:28 +02002529
2530 edit test.vim
2531 doautocmd TabEnter #comment
2532 assert_equal(1, g:entered)
2533
2534 doautocmd TabEnter f.x
2535 assert_equal(2, g:entered)
2536
2537 g:entered = 0
2538 doautocmd TabEnter f.x #comment
2539 assert_equal(2, g:entered)
2540
2541 assert_fails('doautocmd Syntax#comment', 'E216:')
2542
2543 au! TabEnter
2544 unlet g:entered
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02002545
2546 CheckScriptSuccess([
2547 'vim9script',
Bram Moolenaar67979662020-06-20 22:50:47 +02002548 'g:var = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02002549 'b:var = 456',
2550 'w:var = 777',
2551 't:var = 888',
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02002552 'unlet g:var w:var # something',
2553 ])
2554
2555 CheckScriptFailure([
2556 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002557 'let var = 123',
2558 ], 'E1126: Cannot use :let in Vim9 script')
2559
2560 CheckScriptFailure([
2561 'vim9script',
2562 'var g:var = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02002563 ], 'E1016: Cannot declare a global variable:')
2564
2565 CheckScriptFailure([
2566 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002567 'var b:var = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02002568 ], 'E1016: Cannot declare a buffer variable:')
2569
2570 CheckScriptFailure([
2571 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002572 'var w:var = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02002573 ], 'E1016: Cannot declare a window variable:')
2574
2575 CheckScriptFailure([
2576 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002577 'var t:var = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02002578 ], 'E1016: Cannot declare a tab variable:')
2579
2580 CheckScriptFailure([
2581 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002582 'var v:version = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02002583 ], 'E1016: Cannot declare a v: variable:')
2584
2585 CheckScriptFailure([
2586 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002587 'var $VARIABLE = "text"',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02002588 ], 'E1016: Cannot declare an environment variable:')
Bram Moolenaar67979662020-06-20 22:50:47 +02002589
2590 CheckScriptFailure([
2591 'vim9script',
2592 'g:var = 123',
Bram Moolenaar32e35112020-05-14 22:41:15 +02002593 'unlet g:var# comment1',
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02002594 ], 'E108:')
2595
2596 CheckScriptFailure([
2597 'let g:var = 123',
2598 'unlet g:var # something',
2599 ], 'E488:')
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002600
2601 CheckScriptSuccess([
2602 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02002603 'if 1 # comment2',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002604 ' echo "yes"',
2605 'elseif 2 #comment',
2606 ' echo "no"',
2607 'endif',
2608 ])
2609
2610 CheckScriptFailure([
2611 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02002612 'if 1# comment3',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002613 ' echo "yes"',
2614 'endif',
2615 ], 'E15:')
2616
2617 CheckScriptFailure([
2618 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02002619 'if 0 # comment4',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002620 ' echo "yes"',
2621 'elseif 2#comment',
2622 ' echo "no"',
2623 'endif',
2624 ], 'E15:')
2625
2626 CheckScriptSuccess([
2627 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002628 'var v = 1 # comment5',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002629 ])
2630
2631 CheckScriptFailure([
2632 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002633 'var v = 1# comment6',
Bram Moolenaar32e35112020-05-14 22:41:15 +02002634 ], 'E15:')
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002635
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002636 CheckScriptSuccess([
2637 'vim9script',
2638 'new'
Bram Moolenaard2c61702020-09-06 15:58:36 +02002639 'setline(1, ["# define pat", "last"])',
Bram Moolenaardf069ee2020-06-22 23:02:51 +02002640 ':$',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002641 'dsearch /pat/ #comment',
2642 'bwipe!',
2643 ])
2644
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002645 CheckScriptFailure([
2646 'vim9script',
2647 'new'
Bram Moolenaard2c61702020-09-06 15:58:36 +02002648 'setline(1, ["# define pat", "last"])',
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002649 ':$',
2650 'dsearch /pat/#comment',
2651 'bwipe!',
2652 ], 'E488:')
2653
2654 CheckScriptFailure([
2655 'vim9script',
2656 'func! SomeFunc()',
2657 ], 'E477:')
Bram Moolenaara26b9702020-04-18 19:53:28 +02002658enddef
2659
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02002660def Test_finish()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002661 var lines =<< trim END
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02002662 vim9script
Bram Moolenaar67979662020-06-20 22:50:47 +02002663 g:res = 'one'
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02002664 if v:false | finish | endif
Bram Moolenaar67979662020-06-20 22:50:47 +02002665 g:res = 'two'
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02002666 finish
Bram Moolenaar67979662020-06-20 22:50:47 +02002667 g:res = 'three'
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02002668 END
2669 writefile(lines, 'Xfinished')
2670 source Xfinished
2671 assert_equal('two', g:res)
2672
2673 unlet g:res
2674 delete('Xfinished')
2675enddef
2676
Bram Moolenaara5d00772020-05-14 23:20:55 +02002677def Test_forward_declaration()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002678 var lines =<< trim END
Bram Moolenaara5d00772020-05-14 23:20:55 +02002679 vim9script
Bram Moolenaara5d00772020-05-14 23:20:55 +02002680 def GetValue(): string
2681 return theVal
2682 enddef
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002683 var theVal = 'something'
Bram Moolenaar822ba242020-05-24 23:00:18 +02002684 g:initVal = GetValue()
Bram Moolenaara5d00772020-05-14 23:20:55 +02002685 theVal = 'else'
2686 g:laterVal = GetValue()
2687 END
2688 writefile(lines, 'Xforward')
2689 source Xforward
2690 assert_equal('something', g:initVal)
2691 assert_equal('else', g:laterVal)
2692
2693 unlet g:initVal
2694 unlet g:laterVal
2695 delete('Xforward')
2696enddef
2697
Bram Moolenaar9721fb42020-06-11 23:10:46 +02002698def Test_source_vim9_from_legacy()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002699 var legacy_lines =<< trim END
Bram Moolenaar9721fb42020-06-11 23:10:46 +02002700 source Xvim9_script.vim
2701
2702 call assert_false(exists('local'))
2703 call assert_false(exists('exported'))
2704 call assert_false(exists('s:exported'))
2705 call assert_equal('global', global)
2706 call assert_equal('global', g:global)
2707
2708 " imported variable becomes script-local
2709 import exported from './Xvim9_script.vim'
2710 call assert_equal('exported', s:exported)
2711 call assert_false(exists('exported'))
2712
2713 " imported function becomes script-local
2714 import GetText from './Xvim9_script.vim'
2715 call assert_equal('text', s:GetText())
2716 call assert_false(exists('*GetText'))
2717 END
2718 writefile(legacy_lines, 'Xlegacy_script.vim')
2719
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002720 var vim9_lines =<< trim END
Bram Moolenaar9721fb42020-06-11 23:10:46 +02002721 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002722 var local = 'local'
Bram Moolenaar9721fb42020-06-11 23:10:46 +02002723 g:global = 'global'
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002724 export var exported = 'exported'
Bram Moolenaar9721fb42020-06-11 23:10:46 +02002725 export def GetText(): string
2726 return 'text'
2727 enddef
2728 END
2729 writefile(vim9_lines, 'Xvim9_script.vim')
2730
2731 source Xlegacy_script.vim
2732
2733 assert_equal('global', g:global)
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002734 unlet g:global
Bram Moolenaar9721fb42020-06-11 23:10:46 +02002735
2736 delete('Xlegacy_script.vim')
2737 delete('Xvim9_script.vim')
2738enddef
Bram Moolenaara5d00772020-05-14 23:20:55 +02002739
Bram Moolenaar7d699702020-08-14 20:52:28 +02002740func Test_vim9script_not_global()
2741 " check that items defined in Vim9 script are script-local, not global
2742 let vim9lines =<< trim END
2743 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002744 var name = 'local'
Bram Moolenaar7d699702020-08-14 20:52:28 +02002745 func TheFunc()
2746 echo 'local'
2747 endfunc
2748 def DefFunc()
2749 echo 'local'
2750 enddef
2751 END
2752 call writefile(vim9lines, 'Xvim9script.vim')
2753 source Xvim9script.vim
2754 try
2755 echo g:var
2756 assert_report('did not fail')
2757 catch /E121:/
2758 " caught
2759 endtry
2760 try
2761 call TheFunc()
2762 assert_report('did not fail')
2763 catch /E117:/
2764 " caught
2765 endtry
2766 try
2767 call DefFunc()
2768 assert_report('did not fail')
2769 catch /E117:/
2770 " caught
2771 endtry
2772
Bram Moolenaar25859dd2020-08-30 12:54:53 +02002773 call delete('Xvim9script.vim')
Bram Moolenaar7d699702020-08-14 20:52:28 +02002774endfunc
2775
Bram Moolenaareeb27bf2020-07-04 17:39:10 +02002776def Test_vim9_copen()
2777 # this was giving an error for setting w:quickfix_title
2778 copen
2779 quit
2780enddef
2781
Bram Moolenaar03290b82020-12-19 16:30:44 +01002782" test using an auto-loaded function and variable
Bram Moolenaar2d6b20d2020-07-25 19:30:59 +02002783def Test_vim9_autoload()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002784 var lines =<< trim END
Bram Moolenaar2d6b20d2020-07-25 19:30:59 +02002785 vim9script
Bram Moolenaar03290b82020-12-19 16:30:44 +01002786 def some#gettest(): string
2787 return 'test'
2788 enddef
2789 g:some#name = 'name'
2790 END
2791
2792 mkdir('Xdir/autoload', 'p')
2793 writefile(lines, 'Xdir/autoload/some.vim')
2794 var save_rtp = &rtp
2795 exe 'set rtp^=' .. getcwd() .. '/Xdir'
2796
2797 assert_equal('test', g:some#gettest())
2798 assert_equal('name', g:some#name)
2799 g:some#other = 'other'
2800 assert_equal('other', g:some#other)
2801
Bram Moolenaar17f700a2020-12-19 21:23:42 +01002802 # upper case script name works
2803 lines =<< trim END
2804 vim9script
2805 def Other#getOther(): string
2806 return 'other'
2807 enddef
2808 END
2809 writefile(lines, 'Xdir/autoload/Other.vim')
2810 assert_equal('other', g:Other#getOther())
2811
Bram Moolenaar03290b82020-12-19 16:30:44 +01002812 delete('Xdir', 'rf')
2813 &rtp = save_rtp
2814enddef
2815
2816" test using a vim9script that is auto-loaded from an autocmd
2817def Test_vim9_aucmd_autoload()
2818 var lines =<< trim END
2819 vim9script
Bram Moolenaar2d6b20d2020-07-25 19:30:59 +02002820 def foo#test()
2821 echomsg getreg('"')
2822 enddef
2823 END
2824
2825 mkdir('Xdir/autoload', 'p')
2826 writefile(lines, 'Xdir/autoload/foo.vim')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002827 var save_rtp = &rtp
Bram Moolenaar2d6b20d2020-07-25 19:30:59 +02002828 exe 'set rtp^=' .. getcwd() .. '/Xdir'
2829 augroup test
2830 autocmd TextYankPost * call foo#test()
2831 augroup END
2832
2833 normal Y
2834
2835 augroup test
2836 autocmd!
2837 augroup END
2838 delete('Xdir', 'rf')
2839 &rtp = save_rtp
2840enddef
2841
Bram Moolenaar77e5dcc2020-09-17 21:29:03 +02002842" This was causing a crash because suppress_errthrow wasn't reset.
2843def Test_vim9_autoload_error()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002844 var lines =<< trim END
Bram Moolenaar77e5dcc2020-09-17 21:29:03 +02002845 vim9script
2846 def crash#func()
2847 try
2848 for x in List()
2849 endfor
2850 catch
2851 endtry
2852 g:ok = true
2853 enddef
2854 fu List()
2855 invalid
2856 endfu
2857 try
2858 invalid
2859 catch /wontmatch/
2860 endtry
2861 END
2862 call mkdir('Xruntime/autoload', 'p')
2863 call writefile(lines, 'Xruntime/autoload/crash.vim')
2864
2865 # run in a separate Vim to avoid the side effects of assert_fails()
2866 lines =<< trim END
2867 exe 'set rtp^=' .. getcwd() .. '/Xruntime'
2868 call crash#func()
2869 call writefile(['ok'], 'Xdidit')
Bram Moolenaar9c4f5522020-09-25 21:47:28 +02002870 qall!
Bram Moolenaar77e5dcc2020-09-17 21:29:03 +02002871 END
2872 writefile(lines, 'Xscript')
2873 RunVim([], [], '-S Xscript')
2874 assert_equal(['ok'], readfile('Xdidit'))
2875
2876 delete('Xdidit')
2877 delete('Xscript')
2878 delete('Xruntime', 'rf')
Bram Moolenaar03290b82020-12-19 16:30:44 +01002879
2880 lines =<< trim END
2881 vim9script
2882 var foo#bar = 'asdf'
2883 END
2884 CheckScriptFailure(lines, 'E461: Illegal variable name: foo#bar', 2)
Bram Moolenaar77e5dcc2020-09-17 21:29:03 +02002885enddef
2886
Bram Moolenaar81e17fb2020-08-21 21:55:43 +02002887def Test_script_var_in_autocmd()
2888 # using a script variable from an autocommand, defined in a :def function in a
2889 # legacy Vim script, cannot check the variable type.
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002890 var lines =<< trim END
Bram Moolenaar81e17fb2020-08-21 21:55:43 +02002891 let s:counter = 1
2892 def s:Func()
2893 au! CursorHold
2894 au CursorHold * s:counter += 1
2895 enddef
2896 call s:Func()
2897 doau CursorHold
2898 call assert_equal(2, s:counter)
2899 au! CursorHold
2900 END
2901 CheckScriptSuccess(lines)
2902enddef
2903
Bram Moolenaar3896a102020-08-09 14:33:55 +02002904def Test_cmdline_win()
2905 # if the Vim syntax highlighting uses Vim9 constructs they can be used from
2906 # the command line window.
2907 mkdir('rtp/syntax', 'p')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002908 var export_lines =<< trim END
Bram Moolenaar3896a102020-08-09 14:33:55 +02002909 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002910 export var That = 'yes'
Bram Moolenaar3896a102020-08-09 14:33:55 +02002911 END
2912 writefile(export_lines, 'rtp/syntax/Xexport.vim')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002913 var import_lines =<< trim END
Bram Moolenaar3896a102020-08-09 14:33:55 +02002914 vim9script
2915 import That from './Xexport.vim'
2916 END
2917 writefile(import_lines, 'rtp/syntax/vim.vim')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002918 var save_rtp = &rtp
Bram Moolenaar3896a102020-08-09 14:33:55 +02002919 &rtp = getcwd() .. '/rtp' .. ',' .. &rtp
2920 syntax on
2921 augroup CmdWin
2922 autocmd CmdwinEnter * g:got_there = 'yes'
2923 augroup END
2924 # this will open and also close the cmdline window
2925 feedkeys('q:', 'xt')
2926 assert_equal('yes', g:got_there)
2927
2928 augroup CmdWin
2929 au!
2930 augroup END
2931 &rtp = save_rtp
2932 delete('rtp', 'rf')
2933enddef
2934
Bram Moolenaare3d46852020-08-29 13:39:17 +02002935def Test_invalid_sid()
2936 assert_fails('func <SNR>1234_func', 'E123:')
Bram Moolenaar25859dd2020-08-30 12:54:53 +02002937
Bram Moolenaar9c4f5522020-09-25 21:47:28 +02002938 if RunVim([], ['wq! Xdidit'], '+"func <SNR>1_func"')
Bram Moolenaard2c61702020-09-06 15:58:36 +02002939 assert_equal([], readfile('Xdidit'))
Bram Moolenaare3d46852020-08-29 13:39:17 +02002940 endif
2941 delete('Xdidit')
2942enddef
2943
Bram Moolenaar9ec70262020-12-09 17:16:59 +01002944def Test_restoring_cpo()
2945 writefile(['vim9script', 'set nocp'], 'Xsourced')
2946 writefile(['call writefile(["done"], "Xdone")', 'quit!'], 'Xclose')
2947 if RunVim([], [], '-u NONE +"set cpo+=a" -S Xsourced -S Xclose')
2948 assert_equal(['done'], readfile('Xdone'))
2949 endif
2950 delete('Xsourced')
2951 delete('Xclose')
Bram Moolenaar090728a2020-12-20 15:43:31 +01002952 delete('Xdone')
Bram Moolenaar9ec70262020-12-09 17:16:59 +01002953enddef
2954
2955
Bram Moolenaarf0afd9e2020-09-13 18:57:47 +02002956def Test_unset_any_variable()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002957 var lines =<< trim END
2958 var name: any
2959 assert_equal(0, name)
Bram Moolenaarf0afd9e2020-09-13 18:57:47 +02002960 END
2961 CheckDefAndScriptSuccess(lines)
2962enddef
2963
Bram Moolenaar7e9210e2020-09-25 23:12:51 +02002964func Test_define_func_at_command_line()
Bram Moolenaar58dbef32020-09-25 22:13:05 +02002965 CheckRunVimInTerminal
2966
Bram Moolenaar7e9210e2020-09-25 23:12:51 +02002967 " call indirectly to avoid compilation error for missing functions
2968 call Run_Test_define_func_at_command_line()
2969endfunc
2970
2971def Run_Test_define_func_at_command_line()
Bram Moolenaar9c4f5522020-09-25 21:47:28 +02002972 # run in a separate Vim instance to avoid the script context
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002973 var lines =<< trim END
Bram Moolenaar9c4f5522020-09-25 21:47:28 +02002974 func CheckAndQuit()
2975 call assert_fails('call Afunc()', 'E117: Unknown function: Bfunc')
2976 call writefile(['errors: ' .. string(v:errors)], 'Xdidcmd')
2977 endfunc
2978 END
2979 writefile([''], 'Xdidcmd')
2980 writefile(lines, 'XcallFunc')
Bram Moolenaare0de1712020-12-02 17:36:54 +01002981 var buf = RunVimInTerminal('-S XcallFunc', {rows: 6})
Bram Moolenaar9c4f5522020-09-25 21:47:28 +02002982 # define Afunc() on the command line
2983 term_sendkeys(buf, ":def Afunc()\<CR>Bfunc()\<CR>enddef\<CR>")
2984 term_sendkeys(buf, ":call CheckAndQuit()\<CR>")
2985 WaitForAssert({-> assert_equal(['errors: []'], readfile('Xdidcmd'))})
2986
2987 call StopVimInTerminal(buf)
2988 delete('XcallFunc')
2989 delete('Xdidcmd')
2990enddef
2991
Bram Moolenaarfcdc5d82020-10-10 19:07:09 +02002992def Test_script_var_scope()
2993 var lines =<< trim END
2994 vim9script
2995 if true
2996 if true
2997 var one = 'one'
2998 echo one
2999 endif
3000 echo one
3001 endif
3002 END
3003 CheckScriptFailure(lines, 'E121:', 7)
3004
3005 lines =<< trim END
3006 vim9script
3007 if true
3008 if false
3009 var one = 'one'
3010 echo one
3011 else
3012 var one = 'one'
3013 echo one
3014 endif
3015 echo one
3016 endif
3017 END
3018 CheckScriptFailure(lines, 'E121:', 10)
3019
3020 lines =<< trim END
3021 vim9script
3022 while true
3023 var one = 'one'
3024 echo one
3025 break
3026 endwhile
3027 echo one
3028 END
3029 CheckScriptFailure(lines, 'E121:', 7)
3030
3031 lines =<< trim END
3032 vim9script
3033 for i in range(1)
3034 var one = 'one'
3035 echo one
3036 endfor
3037 echo one
3038 END
3039 CheckScriptFailure(lines, 'E121:', 6)
Bram Moolenaar9becdf22020-10-10 21:33:48 +02003040
3041 lines =<< trim END
3042 vim9script
3043 {
3044 var one = 'one'
3045 assert_equal('one', one)
3046 }
3047 assert_false(exists('one'))
3048 assert_false(exists('s:one'))
3049 END
3050 CheckScriptSuccess(lines)
3051
3052 lines =<< trim END
3053 vim9script
3054 {
3055 var one = 'one'
3056 echo one
3057 }
3058 echo one
3059 END
3060 CheckScriptFailure(lines, 'E121:', 6)
Bram Moolenaarfcdc5d82020-10-10 19:07:09 +02003061enddef
3062
Bram Moolenaar352134b2020-10-17 22:04:08 +02003063def Test_catch_exception_in_callback()
3064 var lines =<< trim END
3065 vim9script
3066 def Callback(...l: any)
3067 try
3068 var x: string
3069 var y: string
3070 # this error should be caught with CHECKLEN
3071 [x, y] = ['']
3072 catch
3073 g:caught = 'yes'
3074 endtry
3075 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +01003076 popup_menu('popup', {callback: Callback})
Bram Moolenaar352134b2020-10-17 22:04:08 +02003077 feedkeys("\r", 'xt')
3078 END
3079 CheckScriptSuccess(lines)
3080
3081 unlet g:caught
3082enddef
3083
Bram Moolenaar631e8f92020-11-04 15:07:16 +01003084def Test_no_unknown_error_after_error()
3085 if !has('unix') || !has('job')
3086 throw 'Skipped: not unix of missing +job feature'
3087 endif
3088 var lines =<< trim END
3089 vim9script
3090 var source: list<number>
3091 def Out_cb(...l: any)
3092 eval [][0]
3093 enddef
3094 def Exit_cb(...l: any)
3095 sleep 1m
3096 source += l
3097 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +01003098 var myjob = job_start('echo burp', {out_cb: Out_cb, exit_cb: Exit_cb, mode: 'raw'})
Bram Moolenaar6f17a3f2020-12-21 18:11:24 +01003099 while job_status(myjob) == 'run'
3100 sleep 10m
3101 endwhile
3102 sleep 10m
Bram Moolenaar631e8f92020-11-04 15:07:16 +01003103 END
3104 writefile(lines, 'Xdef')
3105 assert_fails('so Xdef', ['E684:', 'E1012:'])
3106 delete('Xdef')
3107enddef
3108
Bram Moolenaar4324d872020-12-01 20:12:24 +01003109def InvokeNormal()
3110 exe "norm! :m+1\r"
3111enddef
3112
3113def Test_invoke_normal_in_visual_mode()
3114 xnoremap <F3> <Cmd>call <SID>InvokeNormal()<CR>
3115 new
3116 setline(1, ['aaa', 'bbb'])
3117 feedkeys("V\<F3>", 'xt')
3118 assert_equal(['bbb', 'aaa'], getline(1, 2))
3119 xunmap <F3>
3120enddef
3121
Bram Moolenaarb5b94802020-12-13 17:50:20 +01003122def Test_white_space_after_command()
3123 var lines =<< trim END
3124 exit_cb: Func})
3125 END
3126 CheckDefAndScriptFailure(lines, 'E1144:', 1)
3127enddef
3128
Bram Moolenaar585fea72020-04-02 22:33:21 +02003129" Keep this last, it messes up highlighting.
3130def Test_substitute_cmd()
3131 new
3132 setline(1, 'something')
3133 :substitute(some(other(
3134 assert_equal('otherthing', getline(1))
3135 bwipe!
3136
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02003137 # also when the context is Vim9 script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003138 var lines =<< trim END
Bram Moolenaar585fea72020-04-02 22:33:21 +02003139 vim9script
3140 new
3141 setline(1, 'something')
3142 :substitute(some(other(
3143 assert_equal('otherthing', getline(1))
3144 bwipe!
3145 END
3146 writefile(lines, 'Xvim9lines')
3147 source Xvim9lines
3148
3149 delete('Xvim9lines')
3150enddef
3151
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003152" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker