blob: 9dadf1edaa8b22e6a5484a524accdb780a9c7616 [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 Moolenaar9e1d9e32021-01-11 20:17:34 +0100327def Test_try_catch_throw()
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
Bram Moolenaar69f70502021-01-01 16:10:46 +0100364 var done = 'no'
365 if 0
366 try | catch | endtry
367 else
368 done = 'yes'
369 endif
370 assert_equal('yes', done)
371
372 done = 'no'
373 if 1
374 done = 'yes'
375 else
376 try | catch | endtry
377 done = 'never'
378 endif
379 assert_equal('yes', done)
380
381 if 1
382 else
383 try | catch /pat/ | endtry
384 try | catch /pat/
385 endtry
386 try
387 catch /pat/ | endtry
388 try
389 catch /pat/
390 endtry
391 endif
392
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200393 try
Bram Moolenaarcc673e72020-08-16 17:33:35 +0200394 # string slice returns a string, not a number
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200395 n = g:astring[3]
Bram Moolenaar5e654232020-09-16 15:22:00 +0200396 catch /E1012:/
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200397 n = 77
398 endtry
399 assert_equal(77, n)
400
401 try
402 n = l[g:astring]
Bram Moolenaar5e654232020-09-16 15:22:00 +0200403 catch /E1012:/
Bram Moolenaar56acb092020-08-16 14:48:19 +0200404 n = 88
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200405 endtry
Bram Moolenaar56acb092020-08-16 14:48:19 +0200406 assert_equal(88, n)
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200407
408 try
409 n = s:does_not_exist
410 catch /E121:/
Bram Moolenaarf0b9f432020-07-17 23:03:17 +0200411 n = 111
412 endtry
413 assert_equal(111, n)
414
415 try
416 n = g:does_not_exist
417 catch /E121:/
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200418 n = 121
419 endtry
420 assert_equal(121, n)
421
Bram Moolenaare0de1712020-12-02 17:36:54 +0100422 var d = {one: 1}
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200423 try
424 n = d[g:astring]
425 catch /E716:/
426 n = 222
427 endtry
428 assert_equal(222, n)
Bram Moolenaarf0b9f432020-07-17 23:03:17 +0200429
430 try
431 n = -g:astring
432 catch /E39:/
433 n = 233
434 endtry
435 assert_equal(233, n)
436
437 try
438 n = +g:astring
439 catch /E1030:/
440 n = 244
441 endtry
442 assert_equal(244, n)
443
444 try
445 n = +g:alist
446 catch /E745:/
447 n = 255
448 endtry
449 assert_equal(255, n)
450
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200451 var nd: dict<any>
Bram Moolenaarf0b9f432020-07-17 23:03:17 +0200452 try
Bram Moolenaar2bede172020-11-19 18:53:18 +0100453 nd = {[g:anumber]: 1}
Bram Moolenaar5e654232020-09-16 15:22:00 +0200454 catch /E1012:/
Bram Moolenaarf0b9f432020-07-17 23:03:17 +0200455 n = 266
456 endtry
457 assert_equal(266, n)
458
459 try
460 [n] = [1, 2, 3]
461 catch /E1093:/
462 n = 277
463 endtry
464 assert_equal(277, n)
465
Bram Moolenaare8593122020-07-18 15:17:02 +0200466 try
467 &ts = g:astring
Bram Moolenaar5e654232020-09-16 15:22:00 +0200468 catch /E1012:/
Bram Moolenaare8593122020-07-18 15:17:02 +0200469 n = 288
470 endtry
471 assert_equal(288, n)
472
473 try
474 &backspace = 'asdf'
475 catch /E474:/
476 n = 299
477 endtry
478 assert_equal(299, n)
479
480 l = [1]
481 try
482 l[3] = 3
483 catch /E684:/
484 n = 300
485 endtry
486 assert_equal(300, n)
487
488 try
Bram Moolenaare8593122020-07-18 15:17:02 +0200489 unlet g:does_not_exist
490 catch /E108:/
491 n = 322
492 endtry
493 assert_equal(322, n)
494
495 try
Bram Moolenaar2bede172020-11-19 18:53:18 +0100496 d = {text: 1, [g:astring]: 2}
Bram Moolenaare8593122020-07-18 15:17:02 +0200497 catch /E721:/
498 n = 333
499 endtry
500 assert_equal(333, n)
501
502 try
503 l = DeletedFunc()
504 catch /E933:/
505 n = 344
506 endtry
507 assert_equal(344, n)
Bram Moolenaard032f342020-07-18 18:13:02 +0200508
509 try
510 echo len(v:true)
511 catch /E701:/
512 n = 355
513 endtry
514 assert_equal(355, n)
515
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200516 var P = function('g:NoSuchFunc')
Bram Moolenaard032f342020-07-18 18:13:02 +0200517 delfunc g:NoSuchFunc
518 try
519 echo P()
520 catch /E117:/
521 n = 366
522 endtry
523 assert_equal(366, n)
524
525 try
526 echo g:NoSuchFunc()
527 catch /E117:/
528 n = 377
529 endtry
530 assert_equal(377, n)
531
532 try
533 echo g:alist + 4
534 catch /E745:/
535 n = 388
536 endtry
537 assert_equal(388, n)
538
539 try
540 echo 4 + g:alist
541 catch /E745:/
542 n = 399
543 endtry
544 assert_equal(399, n)
545
546 try
547 echo g:alist.member
548 catch /E715:/
549 n = 400
550 endtry
551 assert_equal(400, n)
552
553 try
554 echo d.member
555 catch /E716:/
556 n = 411
557 endtry
558 assert_equal(411, n)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100559enddef
560
Bram Moolenaar1430cee2021-01-17 19:20:32 +0100561def Test_cnext_works_in_catch()
562 var lines =<< trim END
563 vim9script
564 au BufEnter * eval 0
565 writefile(['text'], 'Xfile1')
566 writefile(['text'], 'Xfile2')
567 var items = [
568 {lnum: 1, filename: 'Xfile1', valid: true},
569 {lnum: 1, filename: 'Xfile2', valid: true}
570 ]
571 setqflist([], ' ', {items: items})
572 cwindow
573
574 def CnextOrCfirst()
575 # if cnext fails, cfirst is used
576 try
577 cnext
578 catch
579 cfirst
580 endtry
581 enddef
582
583 CnextOrCfirst()
584 CnextOrCfirst()
585 writefile([getqflist({idx: 0}).idx], 'Xresult')
586 qall
587 END
588 writefile(lines, 'XCatchCnext')
589 RunVim([], [], '--clean -S XCatchCnext')
590 assert_equal(['1'], readfile('Xresult'))
591
592 delete('Xfile1')
593 delete('Xfile2')
594 delete('XCatchCnext')
595 delete('Xresult')
596enddef
597
Bram Moolenaar9e1d9e32021-01-11 20:17:34 +0100598def Test_throw_skipped()
599 if 0
600 throw dontgethere
601 endif
602enddef
603
Bram Moolenaar8f81b222021-01-14 21:47:06 +0100604def Test_nocatch_throw_silenced()
605 var lines =<< trim END
606 vim9script
607 def Func()
608 throw 'error'
609 enddef
610 silent! Func()
611 END
612 writefile(lines, 'XthrowSilenced')
613 source XthrowSilenced
614 delete('XthrowSilenced')
615enddef
616
Bram Moolenaare8593122020-07-18 15:17:02 +0200617def DeletedFunc(): list<any>
618 return ['delete me']
619enddef
620defcompile
621delfunc DeletedFunc
622
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100623def ThrowFromDef()
Bram Moolenaara72cfb82020-04-23 17:07:30 +0200624 throw "getout" # comment
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100625enddef
626
627func CatchInFunc()
628 try
629 call ThrowFromDef()
630 catch
631 let g:thrown_func = v:exception
632 endtry
633endfunc
634
635def CatchInDef()
636 try
637 ThrowFromDef()
638 catch
639 g:thrown_def = v:exception
640 endtry
641enddef
642
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100643def ReturnFinally(): string
644 try
645 return 'intry'
Bram Moolenaar373863e2020-09-26 17:20:53 +0200646 finall
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100647 g:in_finally = 'finally'
648 endtry
649 return 'end'
650enddef
651
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100652def Test_try_catch_nested()
653 CatchInFunc()
654 assert_equal('getout', g:thrown_func)
655
656 CatchInDef()
657 assert_equal('getout', g:thrown_def)
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100658
659 assert_equal('intry', ReturnFinally())
660 assert_equal('finally', g:in_finally)
661enddef
662
Bram Moolenaar9939f572020-09-16 22:29:52 +0200663def TryOne(): number
664 try
665 return 0
666 catch
667 endtry
668 return 0
669enddef
670
671def TryTwo(n: number): string
672 try
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200673 var x = {}
Bram Moolenaar9939f572020-09-16 22:29:52 +0200674 catch
675 endtry
676 return 'text'
677enddef
678
679def Test_try_catch_twice()
680 assert_equal('text', TryOne()->TryTwo())
681enddef
682
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100683def Test_try_catch_match()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200684 var seq = 'a'
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100685 try
686 throw 'something'
687 catch /nothing/
688 seq ..= 'x'
689 catch /some/
690 seq ..= 'b'
691 catch /asdf/
692 seq ..= 'x'
Bram Moolenaare8c4abb2020-04-02 21:13:25 +0200693 catch ?a\?sdf?
694 seq ..= 'y'
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100695 finally
696 seq ..= 'c'
697 endtry
698 assert_equal('abc', seq)
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100699enddef
700
Bram Moolenaare8c4abb2020-04-02 21:13:25 +0200701def Test_try_catch_fails()
Bram Moolenaard2c61702020-09-06 15:58:36 +0200702 CheckDefFailure(['catch'], 'E603:')
703 CheckDefFailure(['try', 'echo 0', 'catch', 'catch'], 'E1033:')
704 CheckDefFailure(['try', 'echo 0', 'catch /pat'], 'E1067:')
705 CheckDefFailure(['finally'], 'E606:')
706 CheckDefFailure(['try', 'echo 0', 'finally', 'echo 1', 'finally'], 'E607:')
707 CheckDefFailure(['endtry'], 'E602:')
708 CheckDefFailure(['while 1', 'endtry'], 'E170:')
709 CheckDefFailure(['for i in range(5)', 'endtry'], 'E170:')
Bram Moolenaar13106602020-10-04 16:06:05 +0200710 CheckDefFailure(['if 1', 'endtry'], 'E171:')
Bram Moolenaard2c61702020-09-06 15:58:36 +0200711 CheckDefFailure(['try', 'echo 1', 'endtry'], 'E1032:')
Bram Moolenaar585fea72020-04-02 22:33:21 +0200712
Bram Moolenaare4984292020-12-13 14:19:25 +0100713 CheckDefFailure(['throw'], 'E1143:')
Bram Moolenaard2c61702020-09-06 15:58:36 +0200714 CheckDefFailure(['throw xxx'], 'E1001:')
Bram Moolenaare8c4abb2020-04-02 21:13:25 +0200715enddef
716
Bram Moolenaar006ad482020-06-30 20:55:15 +0200717def Test_throw_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200718 # only checks line continuation
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200719 var lines =<< trim END
Bram Moolenaar006ad482020-06-30 20:55:15 +0200720 vim9script
721 try
722 throw 'one'
723 .. 'two'
724 catch
725 assert_equal('onetwo', v:exception)
726 endtry
727 END
728 CheckScriptSuccess(lines)
Bram Moolenaar1e021e62020-10-16 20:25:23 +0200729
730 lines =<< trim END
731 vim9script
Bram Moolenaar352134b2020-10-17 22:04:08 +0200732 @r = ''
Bram Moolenaar1e021e62020-10-16 20:25:23 +0200733 def Func()
734 throw @r
735 enddef
736 var result = ''
737 try
738 Func()
739 catch /E1129:/
740 result = 'caught'
741 endtry
742 assert_equal('caught', result)
743 END
744 CheckScriptSuccess(lines)
Bram Moolenaar006ad482020-06-30 20:55:15 +0200745enddef
746
Bram Moolenaared677f52020-08-12 16:38:10 +0200747def Test_error_in_nested_function()
748 # an error in a nested :function aborts executin in the calling :def function
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200749 var lines =<< trim END
Bram Moolenaared677f52020-08-12 16:38:10 +0200750 vim9script
751 def Func()
752 Error()
753 g:test_var = 1
754 enddef
755 func Error() abort
756 eval [][0]
757 endfunc
758 Func()
759 END
760 g:test_var = 0
761 CheckScriptFailure(lines, 'E684:')
762 assert_equal(0, g:test_var)
763enddef
764
Bram Moolenaar37c83712020-06-30 21:18:36 +0200765def Test_cexpr_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200766 # only checks line continuation
Bram Moolenaar37c83712020-06-30 21:18:36 +0200767 set errorformat=File\ %f\ line\ %l
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200768 var lines =<< trim END
Bram Moolenaar37c83712020-06-30 21:18:36 +0200769 vim9script
770 cexpr 'File'
771 .. ' someFile' ..
772 ' line 19'
773 assert_equal(19, getqflist()[0].lnum)
774 END
775 CheckScriptSuccess(lines)
776 set errorformat&
777enddef
778
Bram Moolenaarc9edd6b2020-08-12 22:18:23 +0200779def Test_statusline_syntax()
780 # legacy syntax is used for 'statusline'
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200781 var lines =<< trim END
Bram Moolenaarc9edd6b2020-08-12 22:18:23 +0200782 vim9script
783 func g:Status()
784 return '%{"x" is# "x"}'
785 endfunc
786 set laststatus=2 statusline=%!Status()
787 redrawstatus
788 set laststatus statusline=
789 END
790 CheckScriptSuccess(lines)
791enddef
792
Bram Moolenaarb2097502020-07-19 17:17:02 +0200793def Test_list_vimscript()
794 # checks line continuation and comments
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200795 var lines =<< trim END
Bram Moolenaarb2097502020-07-19 17:17:02 +0200796 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200797 var mylist = [
Bram Moolenaarb2097502020-07-19 17:17:02 +0200798 'one',
799 # comment
800 'two', # empty line follows
801
802 'three',
803 ]
804 assert_equal(['one', 'two', 'three'], mylist)
805 END
806 CheckScriptSuccess(lines)
Bram Moolenaar66250c92020-08-20 15:02:42 +0200807
808 # check all lines from heredoc are kept
809 lines =<< trim END
810 # comment 1
811 two
812 # comment 3
813
814 five
815 # comment 6
816 END
817 assert_equal(['# comment 1', 'two', '# comment 3', '', 'five', '# comment 6'], lines)
Bram Moolenaar4bce26b2021-01-22 22:06:56 +0100818
819 lines =<< trim END
820 [{
821 a: 0}]->string()->assert_equal("[{'a': 0}]")
822 END
823 CheckDefAndScriptSuccess(lines)
Bram Moolenaarb2097502020-07-19 17:17:02 +0200824enddef
825
Bram Moolenaar2a1381c2020-05-05 23:32:58 +0200826if has('channel')
827 let someJob = test_null_job()
Bram Moolenaar40ee4662020-05-05 22:08:26 +0200828
Bram Moolenaar2a1381c2020-05-05 23:32:58 +0200829 def FuncWithError()
830 echomsg g:someJob
831 enddef
Bram Moolenaar40ee4662020-05-05 22:08:26 +0200832
Bram Moolenaar2a1381c2020-05-05 23:32:58 +0200833 func Test_convert_emsg_to_exception()
834 try
835 call FuncWithError()
836 catch
837 call assert_match('Vim:E908:', v:exception)
838 endtry
839 endfunc
840endif
Bram Moolenaar40ee4662020-05-05 22:08:26 +0200841
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100842let s:export_script_lines =<< trim END
843 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200844 var name: string = 'bob'
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100845 def Concat(arg: string): string
846 return name .. arg
847 enddef
Bram Moolenaar227a69d2020-05-15 18:17:28 +0200848 g:result = Concat('bie')
849 g:localname = name
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100850
851 export const CONST = 1234
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200852 export var exported = 9876
853 export var exp_name = 'John'
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100854 export def Exported(): string
855 return 'Exported'
856 enddef
857END
858
Bram Moolenaarb3ca9822020-08-09 14:43:58 +0200859def Undo_export_script_lines()
860 unlet g:result
861 unlet g:localname
862enddef
863
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100864def Test_vim9_import_export()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200865 var import_script_lines =<< trim END
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100866 vim9script
867 import {exported, Exported} from './Xexport.vim'
868 g:imported = exported
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100869 exported += 3
870 g:imported_added = exported
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100871 g:imported_func = Exported()
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100872
Bram Moolenaar40f4f7a2020-07-23 22:41:43 +0200873 def GetExported(): string
Bram Moolenaare0de1712020-12-02 17:36:54 +0100874 var local_dict = {ref: Exported}
Bram Moolenaar40f4f7a2020-07-23 22:41:43 +0200875 return local_dict.ref()
876 enddef
877 g:funcref_result = GetExported()
878
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100879 import {exp_name} from './Xexport.vim'
880 g:imported_name = exp_name
881 exp_name ..= ' Doe'
882 g:imported_name_appended = exp_name
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100883 g:imported_later = exported
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100884 END
885
886 writefile(import_script_lines, 'Ximport.vim')
887 writefile(s:export_script_lines, 'Xexport.vim')
888
889 source Ximport.vim
890
891 assert_equal('bobbie', g:result)
892 assert_equal('bob', g:localname)
893 assert_equal(9876, g:imported)
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100894 assert_equal(9879, g:imported_added)
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100895 assert_equal(9879, g:imported_later)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100896 assert_equal('Exported', g:imported_func)
Bram Moolenaar40f4f7a2020-07-23 22:41:43 +0200897 assert_equal('Exported', g:funcref_result)
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100898 assert_equal('John', g:imported_name)
899 assert_equal('John Doe', g:imported_name_appended)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100900 assert_false(exists('g:name'))
901
Bram Moolenaarb3ca9822020-08-09 14:43:58 +0200902 Undo_export_script_lines()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100903 unlet g:imported
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100904 unlet g:imported_added
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100905 unlet g:imported_later
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100906 unlet g:imported_func
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100907 unlet g:imported_name g:imported_name_appended
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100908 delete('Ximport.vim')
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100909
Bram Moolenaar1c991142020-07-04 13:15:31 +0200910 # similar, with line breaks
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200911 var import_line_break_script_lines =<< trim END
Bram Moolenaar1c991142020-07-04 13:15:31 +0200912 vim9script
913 import {
914 exported,
915 Exported,
916 }
917 from
918 './Xexport.vim'
919 g:imported = exported
920 exported += 5
921 g:imported_added = exported
922 g:imported_func = Exported()
923 END
924 writefile(import_line_break_script_lines, 'Ximport_lbr.vim')
925 source Ximport_lbr.vim
926
927 assert_equal(9876, g:imported)
928 assert_equal(9881, g:imported_added)
929 assert_equal('Exported', g:imported_func)
930
931 # exported script not sourced again
932 assert_false(exists('g:result'))
933 unlet g:imported
934 unlet g:imported_added
935 unlet g:imported_func
936 delete('Ximport_lbr.vim')
937
938 # import inside :def function
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200939 var import_in_def_lines =<< trim END
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100940 vim9script
941 def ImportInDef()
942 import exported from './Xexport.vim'
943 g:imported = exported
944 exported += 7
945 g:imported_added = exported
946 enddef
947 ImportInDef()
948 END
949 writefile(import_in_def_lines, 'Ximport2.vim')
950 source Ximport2.vim
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200951 # TODO: this should be 9879
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100952 assert_equal(9876, g:imported)
953 assert_equal(9883, g:imported_added)
954 unlet g:imported
955 unlet g:imported_added
956 delete('Ximport2.vim')
957
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200958 var import_star_as_lines =<< trim END
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100959 vim9script
960 import * as Export from './Xexport.vim'
961 def UseExport()
962 g:imported = Export.exported
963 enddef
964 UseExport()
965 END
966 writefile(import_star_as_lines, 'Ximport.vim')
967 source Ximport.vim
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100968 assert_equal(9883, g:imported)
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100969
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200970 var import_star_as_lines_no_dot =<< trim END
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100971 vim9script
972 import * as Export from './Xexport.vim'
973 def Func()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200974 var dummy = 1
975 var imported = Export + dummy
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100976 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +0200977 defcompile
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100978 END
979 writefile(import_star_as_lines_no_dot, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +0200980 assert_fails('source Ximport.vim', 'E1060:', '', 2, 'Func')
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100981
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200982 var import_star_as_lines_dot_space =<< trim END
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100983 vim9script
984 import * as Export from './Xexport.vim'
985 def Func()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200986 var imported = Export . exported
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100987 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +0200988 defcompile
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100989 END
990 writefile(import_star_as_lines_dot_space, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +0200991 assert_fails('source Ximport.vim', 'E1074:', '', 1, 'Func')
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100992
Bram Moolenaara6294952020-12-27 13:39:50 +0100993 var import_star_as_duplicated =<< trim END
994 vim9script
995 import * as Export from './Xexport.vim'
996 var some = 'other'
997 import * as Export from './Xexport.vim'
998 defcompile
999 END
1000 writefile(import_star_as_duplicated, 'Ximport.vim')
1001 assert_fails('source Ximport.vim', 'E1073:', '', 4, 'Ximport.vim')
1002
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001003 var import_star_as_lines_missing_name =<< trim END
Bram Moolenaar599c89c2020-03-28 14:53:20 +01001004 vim9script
1005 import * as Export from './Xexport.vim'
1006 def Func()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001007 var imported = Export.
Bram Moolenaar599c89c2020-03-28 14:53:20 +01001008 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +02001009 defcompile
Bram Moolenaar599c89c2020-03-28 14:53:20 +01001010 END
1011 writefile(import_star_as_lines_missing_name, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001012 assert_fails('source Ximport.vim', 'E1048:', '', 1, 'Func')
Bram Moolenaar599c89c2020-03-28 14:53:20 +01001013
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001014 var import_star_as_lbr_lines =<< trim END
Bram Moolenaar1c991142020-07-04 13:15:31 +02001015 vim9script
1016 import *
1017 as Export
1018 from
1019 './Xexport.vim'
1020 def UseExport()
1021 g:imported = Export.exported
1022 enddef
1023 UseExport()
1024 END
1025 writefile(import_star_as_lbr_lines, 'Ximport.vim')
1026 source Ximport.vim
1027 assert_equal(9883, g:imported)
1028
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001029 var import_star_lines =<< trim END
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01001030 vim9script
1031 import * from './Xexport.vim'
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01001032 END
1033 writefile(import_star_lines, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001034 assert_fails('source Ximport.vim', 'E1045:', '', 2, 'Ximport.vim')
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01001035
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001036 # try to import something that exists but is not exported
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001037 var import_not_exported_lines =<< trim END
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001038 vim9script
1039 import name from './Xexport.vim'
1040 END
1041 writefile(import_not_exported_lines, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001042 assert_fails('source Ximport.vim', 'E1049:', '', 2, 'Ximport.vim')
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001043
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001044 # try to import something that is already defined
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001045 var import_already_defined =<< trim END
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001046 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001047 var exported = 'something'
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001048 import exported from './Xexport.vim'
1049 END
1050 writefile(import_already_defined, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001051 assert_fails('source Ximport.vim', 'E1073:', '', 3, 'Ximport.vim')
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001052
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001053 # try to import something that is already defined
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001054 import_already_defined =<< trim END
1055 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001056 var exported = 'something'
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001057 import * as exported from './Xexport.vim'
1058 END
1059 writefile(import_already_defined, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001060 assert_fails('source Ximport.vim', 'E1073:', '', 3, 'Ximport.vim')
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001061
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001062 # try to import something that is already defined
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001063 import_already_defined =<< trim END
1064 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001065 var exported = 'something'
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001066 import {exported} from './Xexport.vim'
1067 END
1068 writefile(import_already_defined, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001069 assert_fails('source Ximport.vim', 'E1073:', '', 3, 'Ximport.vim')
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001070
Bram Moolenaar918a4242020-12-06 14:37:08 +01001071 # try changing an imported const
1072 var import_assign_to_const =<< trim END
1073 vim9script
1074 import CONST from './Xexport.vim'
1075 def Assign()
1076 CONST = 987
1077 enddef
1078 defcompile
1079 END
1080 writefile(import_assign_to_const, 'Ximport.vim')
1081 assert_fails('source Ximport.vim', 'E46:', '', 1, '_Assign')
1082
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001083 # import a very long name, requires making a copy
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001084 var import_long_name_lines =<< trim END
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001085 vim9script
1086 import name012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789 from './Xexport.vim'
1087 END
1088 writefile(import_long_name_lines, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001089 assert_fails('source Ximport.vim', 'E1048:', '', 2, 'Ximport.vim')
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001090
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001091 var import_no_from_lines =<< trim END
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001092 vim9script
1093 import name './Xexport.vim'
1094 END
1095 writefile(import_no_from_lines, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001096 assert_fails('source Ximport.vim', 'E1070:', '', 2, 'Ximport.vim')
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001097
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001098 var import_invalid_string_lines =<< trim END
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001099 vim9script
1100 import name from Xexport.vim
1101 END
1102 writefile(import_invalid_string_lines, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001103 assert_fails('source Ximport.vim', 'E1071:', '', 2, 'Ximport.vim')
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001104
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001105 var import_wrong_name_lines =<< trim END
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001106 vim9script
1107 import name from './XnoExport.vim'
1108 END
1109 writefile(import_wrong_name_lines, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001110 assert_fails('source Ximport.vim', 'E1053:', '', 2, 'Ximport.vim')
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001111
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001112 var import_missing_comma_lines =<< trim END
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001113 vim9script
1114 import {exported name} from './Xexport.vim'
1115 END
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001116 writefile(import_missing_comma_lines, 'Ximport3.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001117 assert_fails('source Ximport3.vim', 'E1046:', '', 2, 'Ximport3.vim')
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001118
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01001119 delete('Ximport.vim')
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001120 delete('Ximport3.vim')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001121 delete('Xexport.vim')
1122
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001123 # Check that in a Vim9 script 'cpo' is set to the Vim default.
Bram Moolenaar750802b2020-02-23 18:08:33 +01001124 set cpo&vi
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001125 var cpo_before = &cpo
1126 var lines =<< trim END
Bram Moolenaar750802b2020-02-23 18:08:33 +01001127 vim9script
1128 g:cpo_in_vim9script = &cpo
1129 END
1130 writefile(lines, 'Xvim9_script')
1131 source Xvim9_script
1132 assert_equal(cpo_before, &cpo)
1133 set cpo&vim
1134 assert_equal(&cpo, g:cpo_in_vim9script)
1135 delete('Xvim9_script')
1136enddef
1137
Bram Moolenaar803af682020-08-05 16:20:03 +02001138func g:Trigger()
1139 source Ximport.vim
1140 return "echo 'yes'\<CR>"
1141endfunc
1142
1143def Test_import_export_expr_map()
1144 # check that :import and :export work when buffer is locked
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001145 var export_lines =<< trim END
Bram Moolenaar803af682020-08-05 16:20:03 +02001146 vim9script
1147 export def That(): string
1148 return 'yes'
1149 enddef
1150 END
1151 writefile(export_lines, 'Xexport_that.vim')
1152
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001153 var import_lines =<< trim END
Bram Moolenaar803af682020-08-05 16:20:03 +02001154 vim9script
1155 import That from './Xexport_that.vim'
1156 assert_equal('yes', That())
1157 END
1158 writefile(import_lines, 'Ximport.vim')
1159
1160 nnoremap <expr> trigger g:Trigger()
1161 feedkeys('trigger', "xt")
1162
Bram Moolenaar730b2482020-08-09 13:02:10 +02001163 delete('Xexport_that.vim')
Bram Moolenaar803af682020-08-05 16:20:03 +02001164 delete('Ximport.vim')
1165 nunmap trigger
1166enddef
1167
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001168def Test_import_in_filetype()
1169 # check that :import works when the buffer is locked
1170 mkdir('ftplugin', 'p')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001171 var export_lines =<< trim END
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001172 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001173 export var That = 'yes'
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001174 END
Bram Moolenaar730b2482020-08-09 13:02:10 +02001175 writefile(export_lines, 'ftplugin/Xexport_ft.vim')
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001176
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001177 var import_lines =<< trim END
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001178 vim9script
Bram Moolenaar730b2482020-08-09 13:02:10 +02001179 import That from './Xexport_ft.vim'
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001180 assert_equal('yes', That)
1181 g:did_load_mytpe = 1
1182 END
1183 writefile(import_lines, 'ftplugin/qf.vim')
1184
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001185 var save_rtp = &rtp
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001186 &rtp = getcwd() .. ',' .. &rtp
1187
1188 filetype plugin on
1189 copen
1190 assert_equal(1, g:did_load_mytpe)
1191
1192 quit!
Bram Moolenaar730b2482020-08-09 13:02:10 +02001193 delete('Xexport_ft.vim')
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001194 delete('ftplugin', 'rf')
1195 &rtp = save_rtp
1196enddef
1197
Bram Moolenaarefa94442020-08-08 22:16:00 +02001198def Test_use_import_in_mapping()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001199 var lines =<< trim END
Bram Moolenaarefa94442020-08-08 22:16:00 +02001200 vim9script
1201 export def Funcx()
1202 g:result = 42
1203 enddef
1204 END
1205 writefile(lines, 'XsomeExport.vim')
1206 lines =<< trim END
1207 vim9script
1208 import Funcx from './XsomeExport.vim'
Bram Moolenaarb3ca9822020-08-09 14:43:58 +02001209 nnoremap <F3> :call <sid>Funcx()<cr>
Bram Moolenaarefa94442020-08-08 22:16:00 +02001210 END
1211 writefile(lines, 'Xmapscript.vim')
1212
1213 source Xmapscript.vim
Bram Moolenaarb3ca9822020-08-09 14:43:58 +02001214 feedkeys("\<F3>", "xt")
Bram Moolenaarefa94442020-08-08 22:16:00 +02001215 assert_equal(42, g:result)
1216
1217 unlet g:result
1218 delete('XsomeExport.vim')
1219 delete('Xmapscript.vim')
Bram Moolenaarb3ca9822020-08-09 14:43:58 +02001220 nunmap <F3>
Bram Moolenaarefa94442020-08-08 22:16:00 +02001221enddef
1222
Bram Moolenaar750802b2020-02-23 18:08:33 +01001223def Test_vim9script_fails()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001224 CheckScriptFailure(['scriptversion 2', 'vim9script'], 'E1039:')
1225 CheckScriptFailure(['vim9script', 'scriptversion 2'], 'E1040:')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001226 CheckScriptFailure(['export var some = 123'], 'E1042:')
Bram Moolenaar9721fb42020-06-11 23:10:46 +02001227 CheckScriptFailure(['import some from "./Xexport.vim"'], 'E1048:')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001228 CheckScriptFailure(['vim9script', 'export var g:some'], 'E1022:')
Bram Moolenaar750802b2020-02-23 18:08:33 +01001229 CheckScriptFailure(['vim9script', 'export echo 134'], 'E1043:')
1230
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001231 CheckScriptFailure(['vim9script', 'var str: string', 'str = 1234'], 'E1012:')
Bram Moolenaarc785b9a2020-06-19 18:34:15 +02001232 CheckScriptFailure(['vim9script', 'const str = "asdf"', 'str = "xxx"'], 'E46:')
1233
Bram Moolenaare2e40752020-09-04 21:18:46 +02001234 assert_fails('vim9script', 'E1038:')
1235 assert_fails('export something', 'E1043:')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001236enddef
1237
Bram Moolenaarf7d267e2020-06-17 12:04:54 +02001238func Test_import_fails_without_script()
Bram Moolenaar101f4812020-06-16 23:18:51 +02001239 CheckRunVimInTerminal
1240
Bram Moolenaar9bb3eb32020-06-17 20:03:36 +02001241 " call indirectly to avoid compilation error for missing functions
Bram Moolenaarc620c052020-07-08 15:16:19 +02001242 call Run_Test_import_fails_on_command_line()
Bram Moolenaar9bb3eb32020-06-17 20:03:36 +02001243endfunc
1244
Bram Moolenaarc620c052020-07-08 15:16:19 +02001245def Run_Test_import_fails_on_command_line()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001246 var export =<< trim END
Bram Moolenaar101f4812020-06-16 23:18:51 +02001247 vim9script
1248 export def Foo(): number
1249 return 0
1250 enddef
1251 END
Bram Moolenaar730b2482020-08-09 13:02:10 +02001252 writefile(export, 'XexportCmd.vim')
Bram Moolenaar101f4812020-06-16 23:18:51 +02001253
Bram Moolenaare0de1712020-12-02 17:36:54 +01001254 var buf = RunVimInTerminal('-c "import Foo from ''./XexportCmd.vim''"', {
Bram Moolenaar9bb3eb32020-06-17 20:03:36 +02001255 rows: 6, wait_for_ruler: 0})
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001256 WaitForAssert(() => assert_match('^E1094:', term_getline(buf, 5)))
Bram Moolenaar101f4812020-06-16 23:18:51 +02001257
Bram Moolenaar730b2482020-08-09 13:02:10 +02001258 delete('XexportCmd.vim')
Bram Moolenaar9bb3eb32020-06-17 20:03:36 +02001259 StopVimInTerminal(buf)
1260enddef
Bram Moolenaar101f4812020-06-16 23:18:51 +02001261
Bram Moolenaar2b327002020-12-26 15:39:31 +01001262def Test_vim9script_reload_noclear()
1263 var lines =<< trim END
Bram Moolenaara6294952020-12-27 13:39:50 +01001264 vim9script
1265 export var exported = 'thexport'
1266 END
1267 writefile(lines, 'XExportReload')
1268 lines =<< trim END
Bram Moolenaar2b327002020-12-26 15:39:31 +01001269 vim9script noclear
1270 g:loadCount += 1
1271 var s:reloaded = 'init'
Bram Moolenaara6294952020-12-27 13:39:50 +01001272 import exported from './XExportReload'
Bram Moolenaar2b327002020-12-26 15:39:31 +01001273
1274 def Again(): string
1275 return 'again'
1276 enddef
1277
1278 if exists('s:loaded') | finish | endif
1279 var s:loaded = true
1280
1281 var s:notReloaded = 'yes'
1282 s:reloaded = 'first'
1283 def g:Values(): list<string>
Bram Moolenaara6294952020-12-27 13:39:50 +01001284 return [s:reloaded, s:notReloaded, Again(), Once(), exported]
Bram Moolenaar2b327002020-12-26 15:39:31 +01001285 enddef
1286
1287 def Once(): string
1288 return 'once'
1289 enddef
1290 END
1291 writefile(lines, 'XReloaded')
1292 g:loadCount = 0
1293 source XReloaded
1294 assert_equal(1, g:loadCount)
Bram Moolenaara6294952020-12-27 13:39:50 +01001295 assert_equal(['first', 'yes', 'again', 'once', 'thexport'], g:Values())
Bram Moolenaar2b327002020-12-26 15:39:31 +01001296 source XReloaded
1297 assert_equal(2, g:loadCount)
Bram Moolenaara6294952020-12-27 13:39:50 +01001298 assert_equal(['init', 'yes', 'again', 'once', 'thexport'], g:Values())
Bram Moolenaar2b327002020-12-26 15:39:31 +01001299 source XReloaded
1300 assert_equal(3, g:loadCount)
Bram Moolenaara6294952020-12-27 13:39:50 +01001301 assert_equal(['init', 'yes', 'again', 'once', 'thexport'], g:Values())
Bram Moolenaar2b327002020-12-26 15:39:31 +01001302
Bram Moolenaar48e11c12021-01-11 18:47:00 +01001303 delete('XReloaded')
Bram Moolenaara6294952020-12-27 13:39:50 +01001304 delete('XExportReload')
Bram Moolenaar2b327002020-12-26 15:39:31 +01001305 delfunc g:Values
Bram Moolenaar2b327002020-12-26 15:39:31 +01001306 unlet g:loadCount
1307enddef
1308
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001309def Test_vim9script_reload_import()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001310 var lines =<< trim END
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001311 vim9script
1312 const var = ''
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001313 var valone = 1234
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001314 def MyFunc(arg: string)
1315 valone = 5678
1316 enddef
1317 END
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001318 var morelines =<< trim END
1319 var valtwo = 222
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001320 export def GetValtwo(): number
1321 return valtwo
1322 enddef
1323 END
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001324 writefile(lines + morelines, 'Xreload.vim')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001325 source Xreload.vim
1326 source Xreload.vim
1327 source Xreload.vim
1328
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001329 var testlines =<< trim END
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001330 vim9script
1331 def TheFunc()
1332 import GetValtwo from './Xreload.vim'
1333 assert_equal(222, GetValtwo())
1334 enddef
1335 TheFunc()
1336 END
1337 writefile(testlines, 'Ximport.vim')
1338 source Ximport.vim
1339
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001340 # Test that when not using "morelines" GetValtwo() and valtwo are still
1341 # defined, because import doesn't reload a script.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001342 writefile(lines, 'Xreload.vim')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001343 source Ximport.vim
1344
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001345 # cannot declare a var twice
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001346 lines =<< trim END
1347 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001348 var valone = 1234
1349 var valone = 5678
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001350 END
1351 writefile(lines, 'Xreload.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001352 assert_fails('source Xreload.vim', 'E1041:', '', 3, 'Xreload.vim')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001353
1354 delete('Xreload.vim')
1355 delete('Ximport.vim')
1356enddef
1357
Bram Moolenaar07a65d22020-12-26 20:09:15 +01001358" if a script is reloaded with a script-local variable that changed its type, a
1359" compiled function using that variable must fail.
1360def Test_script_reload_change_type()
1361 var lines =<< trim END
1362 vim9script noclear
1363 var str = 'string'
1364 def g:GetStr(): string
1365 return str .. 'xxx'
1366 enddef
1367 END
1368 writefile(lines, 'Xreload.vim')
1369 source Xreload.vim
1370 echo g:GetStr()
1371
1372 lines =<< trim END
1373 vim9script noclear
1374 var str = 1234
1375 END
1376 writefile(lines, 'Xreload.vim')
1377 source Xreload.vim
1378 assert_fails('echo g:GetStr()', 'E1150:')
1379
1380 delfunc g:GetStr
1381 delete('Xreload.vim')
1382enddef
1383
Bram Moolenaar95006e32020-08-29 17:47:08 +02001384def s:RetSome(): string
1385 return 'some'
1386enddef
1387
Bram Moolenaarfe465a02020-07-07 22:50:12 +02001388" Not exported function that is referenced needs to be accessed by the
1389" script-local name.
1390def Test_vim9script_funcref()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001391 var sortlines =<< trim END
Bram Moolenaarfe465a02020-07-07 22:50:12 +02001392 vim9script
1393 def Compare(i1: number, i2: number): number
Bram Moolenaarbed36b92020-07-07 23:31:36 +02001394 return i2 - i1
Bram Moolenaarfe465a02020-07-07 22:50:12 +02001395 enddef
1396
1397 export def FastSort(): list<number>
1398 return range(5)->sort(Compare)
1399 enddef
1400 END
1401 writefile(sortlines, 'Xsort.vim')
1402
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001403 var lines =<< trim END
Bram Moolenaarfe465a02020-07-07 22:50:12 +02001404 vim9script
1405 import FastSort from './Xsort.vim'
1406 def Test()
1407 g:result = FastSort()
1408 enddef
1409 Test()
1410 END
1411 writefile(lines, 'Xscript.vim')
1412
1413 source Xscript.vim
1414 assert_equal([4, 3, 2, 1, 0], g:result)
1415
1416 unlet g:result
1417 delete('Xsort.vim')
1418 delete('Xscript.vim')
Bram Moolenaar95006e32020-08-29 17:47:08 +02001419
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001420 var Funcref = function('s:RetSome')
Bram Moolenaar95006e32020-08-29 17:47:08 +02001421 assert_equal('some', Funcref())
Bram Moolenaarfe465a02020-07-07 22:50:12 +02001422enddef
1423
Bram Moolenaar601e76a2020-08-27 21:33:10 +02001424" Check that when searching for "FilterFunc" it finds the import in the
1425" script where FastFilter() is called from, both as a string and as a direct
1426" function reference.
Bram Moolenaarc620c052020-07-08 15:16:19 +02001427def Test_vim9script_funcref_other_script()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001428 var filterLines =<< trim END
Bram Moolenaarc620c052020-07-08 15:16:19 +02001429 vim9script
1430 export def FilterFunc(idx: number, val: number): bool
1431 return idx % 2 == 1
1432 enddef
1433 export def FastFilter(): list<number>
1434 return range(10)->filter('FilterFunc')
1435 enddef
Bram Moolenaar601e76a2020-08-27 21:33:10 +02001436 export def FastFilterDirect(): list<number>
1437 return range(10)->filter(FilterFunc)
1438 enddef
Bram Moolenaarc620c052020-07-08 15:16:19 +02001439 END
1440 writefile(filterLines, 'Xfilter.vim')
1441
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001442 var lines =<< trim END
Bram Moolenaarc620c052020-07-08 15:16:19 +02001443 vim9script
Bram Moolenaar601e76a2020-08-27 21:33:10 +02001444 import {FilterFunc, FastFilter, FastFilterDirect} from './Xfilter.vim'
Bram Moolenaarc620c052020-07-08 15:16:19 +02001445 def Test()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001446 var x: list<number> = FastFilter()
Bram Moolenaarc620c052020-07-08 15:16:19 +02001447 enddef
1448 Test()
Bram Moolenaar601e76a2020-08-27 21:33:10 +02001449 def TestDirect()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001450 var x: list<number> = FastFilterDirect()
Bram Moolenaar601e76a2020-08-27 21:33:10 +02001451 enddef
1452 TestDirect()
Bram Moolenaarc620c052020-07-08 15:16:19 +02001453 END
Bram Moolenaar601e76a2020-08-27 21:33:10 +02001454 CheckScriptSuccess(lines)
Bram Moolenaarc620c052020-07-08 15:16:19 +02001455 delete('Xfilter.vim')
Bram Moolenaarc620c052020-07-08 15:16:19 +02001456enddef
1457
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001458def Test_vim9script_reload_delfunc()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001459 var first_lines =<< trim END
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001460 vim9script
1461 def FuncYes(): string
1462 return 'yes'
1463 enddef
1464 END
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001465 var withno_lines =<< trim END
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001466 def FuncNo(): string
1467 return 'no'
1468 enddef
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001469 def g:DoCheck(no_exists: bool)
1470 assert_equal('yes', FuncYes())
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001471 assert_equal('no', FuncNo())
1472 enddef
1473 END
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001474 var nono_lines =<< trim END
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001475 def g:DoCheck(no_exists: bool)
1476 assert_equal('yes', FuncYes())
Bram Moolenaar44d66522020-09-06 22:26:57 +02001477 assert_fails('FuncNo()', 'E117:', '', 2, 'DoCheck')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001478 enddef
1479 END
1480
1481 # FuncNo() is defined
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001482 writefile(first_lines + withno_lines, 'Xreloaded.vim')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001483 source Xreloaded.vim
1484 g:DoCheck(true)
1485
1486 # FuncNo() is not redefined
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001487 writefile(first_lines + nono_lines, 'Xreloaded.vim')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001488 source Xreloaded.vim
Bram Moolenaar50824712020-12-20 21:10:17 +01001489 g:DoCheck(false)
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001490
1491 # FuncNo() is back
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001492 writefile(first_lines + withno_lines, 'Xreloaded.vim')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001493 source Xreloaded.vim
Bram Moolenaar50824712020-12-20 21:10:17 +01001494 g:DoCheck(false)
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001495
1496 delete('Xreloaded.vim')
1497enddef
1498
Bram Moolenaar89483d42020-05-10 15:24:44 +02001499def Test_vim9script_reload_delvar()
1500 # write the script with a script-local variable
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001501 var lines =<< trim END
Bram Moolenaar89483d42020-05-10 15:24:44 +02001502 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001503 var name = 'string'
Bram Moolenaar89483d42020-05-10 15:24:44 +02001504 END
1505 writefile(lines, 'XreloadVar.vim')
1506 source XreloadVar.vim
1507
1508 # now write the script using the same variable locally - works
1509 lines =<< trim END
1510 vim9script
1511 def Func()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001512 var name = 'string'
Bram Moolenaar89483d42020-05-10 15:24:44 +02001513 enddef
1514 END
1515 writefile(lines, 'XreloadVar.vim')
1516 source XreloadVar.vim
1517
1518 delete('XreloadVar.vim')
1519enddef
1520
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001521def Test_import_absolute()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001522 var import_lines = [
Bram Moolenaare6085c52020-04-12 20:19:16 +02001523 'vim9script',
1524 'import exported from "' .. escape(getcwd(), '\') .. '/Xexport_abs.vim"',
1525 'def UseExported()',
1526 ' g:imported_abs = exported',
1527 ' exported = 8888',
1528 ' g:imported_after = exported',
1529 'enddef',
1530 'UseExported()',
1531 'g:import_disassembled = execute("disass UseExported")',
1532 ]
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001533 writefile(import_lines, 'Ximport_abs.vim')
1534 writefile(s:export_script_lines, 'Xexport_abs.vim')
1535
1536 source Ximport_abs.vim
1537
1538 assert_equal(9876, g:imported_abs)
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +01001539 assert_equal(8888, g:imported_after)
Bram Moolenaarfbbcd002020-10-15 12:46:44 +02001540 assert_match('<SNR>\d\+_UseExported\_s*' ..
1541 'g:imported_abs = exported\_s*' ..
1542 '0 LOADSCRIPT exported-2 from .*Xexport_abs.vim\_s*' ..
1543 '1 STOREG g:imported_abs\_s*' ..
1544 'exported = 8888\_s*' ..
1545 '2 PUSHNR 8888\_s*' ..
1546 '3 STORESCRIPT exported-2 in .*Xexport_abs.vim\_s*' ..
1547 'g:imported_after = exported\_s*' ..
1548 '4 LOADSCRIPT exported-2 from .*Xexport_abs.vim\_s*' ..
1549 '5 STOREG g:imported_after',
Bram Moolenaare6085c52020-04-12 20:19:16 +02001550 g:import_disassembled)
Bram Moolenaarb3ca9822020-08-09 14:43:58 +02001551
1552 Undo_export_script_lines()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001553 unlet g:imported_abs
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +01001554 unlet g:import_disassembled
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001555
1556 delete('Ximport_abs.vim')
1557 delete('Xexport_abs.vim')
1558enddef
1559
1560def Test_import_rtp()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001561 var import_lines = [
Bram Moolenaare6085c52020-04-12 20:19:16 +02001562 'vim9script',
1563 'import exported from "Xexport_rtp.vim"',
1564 'g:imported_rtp = exported',
1565 ]
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001566 writefile(import_lines, 'Ximport_rtp.vim')
1567 mkdir('import')
1568 writefile(s:export_script_lines, 'import/Xexport_rtp.vim')
1569
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001570 var save_rtp = &rtp
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001571 &rtp = getcwd()
1572 source Ximport_rtp.vim
1573 &rtp = save_rtp
1574
1575 assert_equal(9876, g:imported_rtp)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001576
Bram Moolenaarb3ca9822020-08-09 14:43:58 +02001577 Undo_export_script_lines()
1578 unlet g:imported_rtp
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001579 delete('Ximport_rtp.vim')
Bram Moolenaar89483d42020-05-10 15:24:44 +02001580 delete('import', 'rf')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001581enddef
1582
Bram Moolenaar25e0f582020-05-25 22:36:50 +02001583def Test_import_compile_error()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001584 var export_lines = [
Bram Moolenaar25e0f582020-05-25 22:36:50 +02001585 'vim9script',
1586 'export def ExpFunc(): string',
1587 ' return notDefined',
1588 'enddef',
1589 ]
1590 writefile(export_lines, 'Xexported.vim')
1591
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001592 var import_lines = [
Bram Moolenaar25e0f582020-05-25 22:36:50 +02001593 'vim9script',
1594 'import ExpFunc from "./Xexported.vim"',
1595 'def ImpFunc()',
1596 ' echo ExpFunc()',
1597 'enddef',
1598 'defcompile',
1599 ]
1600 writefile(import_lines, 'Ximport.vim')
1601
1602 try
1603 source Ximport.vim
1604 catch /E1001/
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001605 # Error should be fore the Xexported.vim file.
Bram Moolenaar77072282020-09-16 17:55:40 +02001606 assert_match('E1001: Variable not found: notDefined', v:exception)
Bram Moolenaar25e0f582020-05-25 22:36:50 +02001607 assert_match('function <SNR>\d\+_ImpFunc\[1\]..<SNR>\d\+_ExpFunc, line 1', v:throwpoint)
1608 endtry
1609
1610 delete('Xexported.vim')
1611 delete('Ximport.vim')
1612enddef
1613
Bram Moolenaarc4ce36d2020-08-14 17:08:15 +02001614def Test_func_redefine_error()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001615 var lines = [
Bram Moolenaarc4ce36d2020-08-14 17:08:15 +02001616 'vim9script',
1617 'def Func()',
1618 ' eval [][0]',
1619 'enddef',
1620 'Func()',
1621 ]
1622 writefile(lines, 'Xtestscript.vim')
1623
1624 for count in range(3)
1625 try
1626 source Xtestscript.vim
1627 catch /E684/
1628 # function name should contain <SNR> every time
1629 assert_match('E684: list index out of range', v:exception)
1630 assert_match('function <SNR>\d\+_Func, line 1', v:throwpoint)
1631 endtry
1632 endfor
1633
1634 delete('Xtestscript.vim')
1635enddef
1636
Bram Moolenaareef21022020-08-01 22:16:43 +02001637def Test_func_overrules_import_fails()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001638 var export_lines =<< trim END
Bram Moolenaareef21022020-08-01 22:16:43 +02001639 vim9script
1640 export def Func()
1641 echo 'imported'
1642 enddef
1643 END
1644 writefile(export_lines, 'XexportedFunc.vim')
1645
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001646 var lines =<< trim END
Bram Moolenaareef21022020-08-01 22:16:43 +02001647 vim9script
1648 import Func from './XexportedFunc.vim'
1649 def Func()
1650 echo 'local to function'
1651 enddef
1652 END
1653 CheckScriptFailure(lines, 'E1073:')
1654
1655 lines =<< trim END
1656 vim9script
1657 import Func from './XexportedFunc.vim'
1658 def Outer()
1659 def Func()
1660 echo 'local to function'
1661 enddef
1662 enddef
1663 defcompile
1664 END
1665 CheckScriptFailure(lines, 'E1073:')
1666
1667 delete('XexportedFunc.vim')
1668enddef
1669
Bram Moolenaarb9a2cac2020-08-01 22:23:20 +02001670def Test_func_redefine_fails()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001671 var lines =<< trim END
Bram Moolenaarb9a2cac2020-08-01 22:23:20 +02001672 vim9script
1673 def Func()
1674 echo 'one'
1675 enddef
1676 def Func()
1677 echo 'two'
1678 enddef
1679 END
1680 CheckScriptFailure(lines, 'E1073:')
Bram Moolenaarfa211f32020-08-07 22:00:26 +02001681
1682 lines =<< trim END
1683 vim9script
1684 def Foo(): string
1685 return 'foo'
1686 enddef
1687 def Func()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001688 var Foo = {-> 'lambda'}
Bram Moolenaarfa211f32020-08-07 22:00:26 +02001689 enddef
1690 defcompile
1691 END
1692 CheckScriptFailure(lines, 'E1073:')
Bram Moolenaarb9a2cac2020-08-01 22:23:20 +02001693enddef
1694
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001695def Test_fixed_size_list()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001696 # will be allocated as one piece of memory, check that changes work
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001697 var l = [1, 2, 3, 4]
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001698 l->remove(0)
1699 l->add(5)
1700 l->insert(99, 1)
Bram Moolenaar0f18b6d2020-02-02 17:22:27 +01001701 assert_equal([2, 99, 3, 4, 5], l)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001702enddef
1703
Bram Moolenaarae616492020-07-28 20:07:27 +02001704def Test_no_insert_xit()
Bram Moolenaard2c61702020-09-06 15:58:36 +02001705 CheckDefExecFailure(['a = 1'], 'E1100:')
1706 CheckDefExecFailure(['c = 1'], 'E1100:')
1707 CheckDefExecFailure(['i = 1'], 'E1100:')
1708 CheckDefExecFailure(['t = 1'], 'E1100:')
1709 CheckDefExecFailure(['x = 1'], 'E1100:')
Bram Moolenaarae616492020-07-28 20:07:27 +02001710
Bram Moolenaarae616492020-07-28 20:07:27 +02001711 CheckScriptFailure(['vim9script', 'a = 1'], 'E488:')
1712 CheckScriptFailure(['vim9script', 'a'], 'E1100:')
Bram Moolenaarae616492020-07-28 20:07:27 +02001713 CheckScriptFailure(['vim9script', 'c = 1'], 'E488:')
1714 CheckScriptFailure(['vim9script', 'c'], 'E1100:')
Bram Moolenaarf5a48012020-08-01 17:00:03 +02001715 CheckScriptFailure(['vim9script', 'i = 1'], 'E488:')
1716 CheckScriptFailure(['vim9script', 'i'], 'E1100:')
1717 CheckScriptFailure(['vim9script', 't'], 'E1100:')
1718 CheckScriptFailure(['vim9script', 't = 1'], 'E1100:')
1719 CheckScriptFailure(['vim9script', 'x = 1'], 'E1100:')
Bram Moolenaarae616492020-07-28 20:07:27 +02001720enddef
1721
Bram Moolenaar158906c2020-02-06 20:39:45 +01001722def IfElse(what: number): string
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001723 var res = ''
Bram Moolenaar158906c2020-02-06 20:39:45 +01001724 if what == 1
1725 res = "one"
1726 elseif what == 2
1727 res = "two"
Bram Moolenaara259d8d2020-01-31 20:10:50 +01001728 else
Bram Moolenaar158906c2020-02-06 20:39:45 +01001729 res = "three"
Bram Moolenaara259d8d2020-01-31 20:10:50 +01001730 endif
Bram Moolenaar158906c2020-02-06 20:39:45 +01001731 return res
Bram Moolenaara259d8d2020-01-31 20:10:50 +01001732enddef
1733
Bram Moolenaar158906c2020-02-06 20:39:45 +01001734def Test_if_elseif_else()
1735 assert_equal('one', IfElse(1))
1736 assert_equal('two', IfElse(2))
1737 assert_equal('three', IfElse(3))
Bram Moolenaar0f18b6d2020-02-02 17:22:27 +01001738enddef
1739
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001740def Test_if_elseif_else_fails()
Bram Moolenaard2c61702020-09-06 15:58:36 +02001741 CheckDefFailure(['elseif true'], 'E582:')
1742 CheckDefFailure(['else'], 'E581:')
1743 CheckDefFailure(['endif'], 'E580:')
1744 CheckDefFailure(['if true', 'elseif xxx'], 'E1001:')
1745 CheckDefFailure(['if true', 'echo 1'], 'E171:')
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001746enddef
1747
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001748let g:bool_true = v:true
1749let g:bool_false = v:false
1750
1751def Test_if_const_expr()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001752 var res = false
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001753 if true ? true : false
1754 res = true
1755 endif
1756 assert_equal(true, res)
1757
Bram Moolenaar585fea72020-04-02 22:33:21 +02001758 g:glob = 2
1759 if false
Bram Moolenaar67979662020-06-20 22:50:47 +02001760 execute('g:glob = 3')
Bram Moolenaar585fea72020-04-02 22:33:21 +02001761 endif
1762 assert_equal(2, g:glob)
1763 if true
Bram Moolenaar67979662020-06-20 22:50:47 +02001764 execute('g:glob = 3')
Bram Moolenaar585fea72020-04-02 22:33:21 +02001765 endif
1766 assert_equal(3, g:glob)
1767
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001768 res = false
1769 if g:bool_true ? true : false
1770 res = true
1771 endif
1772 assert_equal(true, res)
1773
1774 res = false
1775 if true ? g:bool_true : false
1776 res = true
1777 endif
1778 assert_equal(true, res)
1779
1780 res = false
1781 if true ? true : g:bool_false
1782 res = true
1783 endif
1784 assert_equal(true, res)
1785
1786 res = false
1787 if true ? false : true
1788 res = true
1789 endif
1790 assert_equal(false, res)
1791
1792 res = false
1793 if false ? false : true
1794 res = true
1795 endif
1796 assert_equal(true, res)
1797
1798 res = false
1799 if false ? true : false
1800 res = true
1801 endif
1802 assert_equal(false, res)
1803
1804 res = false
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001805 if has('xyz') ? true : false
1806 res = true
1807 endif
1808 assert_equal(false, res)
1809
1810 res = false
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001811 if true && true
1812 res = true
1813 endif
1814 assert_equal(true, res)
1815
1816 res = false
1817 if true && false
1818 res = true
1819 endif
1820 assert_equal(false, res)
1821
1822 res = false
1823 if g:bool_true && false
1824 res = true
1825 endif
1826 assert_equal(false, res)
1827
1828 res = false
1829 if true && g:bool_false
1830 res = true
1831 endif
1832 assert_equal(false, res)
1833
1834 res = false
1835 if false && false
1836 res = true
1837 endif
1838 assert_equal(false, res)
1839
1840 res = false
1841 if true || false
1842 res = true
1843 endif
1844 assert_equal(true, res)
1845
1846 res = false
1847 if g:bool_true || false
1848 res = true
1849 endif
1850 assert_equal(true, res)
1851
1852 res = false
1853 if true || g:bool_false
1854 res = true
1855 endif
1856 assert_equal(true, res)
1857
1858 res = false
1859 if false || false
1860 res = true
1861 endif
1862 assert_equal(false, res)
Bram Moolenaar3988f642020-08-27 22:43:03 +02001863
1864 # with constant "false" expression may be invalid so long as the syntax is OK
1865 if false | eval 0 | endif
1866 if false | eval burp + 234 | endif
1867 if false | echo burp 234 'asd' | endif
1868 if false
1869 burp
1870 endif
Bram Moolenaar80c34ca2020-04-01 23:05:18 +02001871enddef
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001872
Bram Moolenaar80c34ca2020-04-01 23:05:18 +02001873def Test_if_const_expr_fails()
Bram Moolenaard2c61702020-09-06 15:58:36 +02001874 CheckDefFailure(['if "aaa" == "bbb'], 'E114:')
1875 CheckDefFailure(["if 'aaa' == 'bbb"], 'E115:')
1876 CheckDefFailure(["if has('aaa'"], 'E110:')
1877 CheckDefFailure(["if has('aaa') ? true false"], 'E109:')
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001878enddef
1879
Bram Moolenaar72abcf42020-06-18 18:26:24 +02001880def RunNested(i: number): number
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001881 var x: number = 0
Bram Moolenaar72abcf42020-06-18 18:26:24 +02001882 if i % 2
1883 if 1
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001884 # comment
Bram Moolenaar72abcf42020-06-18 18:26:24 +02001885 else
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001886 # comment
Bram Moolenaar72abcf42020-06-18 18:26:24 +02001887 endif
1888 x += 1
1889 else
1890 x += 1000
1891 endif
1892 return x
1893enddef
1894
1895def Test_nested_if()
1896 assert_equal(1, RunNested(1))
1897 assert_equal(1000, RunNested(2))
1898enddef
1899
Bram Moolenaarad39c092020-02-26 18:23:43 +01001900def Test_execute_cmd()
Bram Moolenaare4984292020-12-13 14:19:25 +01001901 # missing argument is ignored
1902 execute
1903 execute # comment
1904
Bram Moolenaarad39c092020-02-26 18:23:43 +01001905 new
1906 setline(1, 'default')
Bram Moolenaard2c61702020-09-06 15:58:36 +02001907 execute 'setline(1, "execute-string")'
Bram Moolenaarad39c092020-02-26 18:23:43 +01001908 assert_equal('execute-string', getline(1))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001909
Bram Moolenaard2c61702020-09-06 15:58:36 +02001910 execute "setline(1, 'execute-string')"
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001911 assert_equal('execute-string', getline(1))
1912
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001913 var cmd1 = 'setline(1,'
1914 var cmd2 = '"execute-var")'
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001915 execute cmd1 cmd2 # comment
Bram Moolenaarad39c092020-02-26 18:23:43 +01001916 assert_equal('execute-var', getline(1))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001917
Bram Moolenaard2c61702020-09-06 15:58:36 +02001918 execute cmd1 cmd2 '|setline(1, "execute-var-string")'
Bram Moolenaarad39c092020-02-26 18:23:43 +01001919 assert_equal('execute-var-string', getline(1))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001920
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001921 var cmd_first = 'call '
1922 var cmd_last = 'setline(1, "execute-var-var")'
Bram Moolenaarad39c092020-02-26 18:23:43 +01001923 execute cmd_first .. cmd_last
1924 assert_equal('execute-var-var', getline(1))
1925 bwipe!
Bram Moolenaar585fea72020-04-02 22:33:21 +02001926
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001927 var n = true
Bram Moolenaar2d6b20d2020-07-25 19:30:59 +02001928 execute 'echomsg' (n ? '"true"' : '"no"')
1929 assert_match('^true$', Screenline(&lines))
1930
Bram Moolenaare0de1712020-12-02 17:36:54 +01001931 echomsg [1, 2, 3] {a: 1, b: 2}
Bram Moolenaare5abf7a2020-08-16 18:29:35 +02001932 assert_match('^\[1, 2, 3\] {''a'': 1, ''b'': 2}$', Screenline(&lines))
1933
Bram Moolenaard2c61702020-09-06 15:58:36 +02001934 CheckDefFailure(['execute xxx'], 'E1001:', 1)
1935 CheckDefExecFailure(['execute "tabnext " .. 8'], 'E475:', 1)
1936 CheckDefFailure(['execute "cmd"# comment'], 'E488:', 1)
Bram Moolenaarad39c092020-02-26 18:23:43 +01001937enddef
1938
Bram Moolenaar47e880d2020-06-30 22:02:02 +02001939def Test_execute_cmd_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001940 # only checks line continuation
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001941 var lines =<< trim END
Bram Moolenaar47e880d2020-06-30 22:02:02 +02001942 vim9script
1943 execute 'g:someVar'
1944 .. ' = ' ..
1945 '28'
1946 assert_equal(28, g:someVar)
1947 unlet g:someVar
1948 END
1949 CheckScriptSuccess(lines)
1950enddef
1951
Bram Moolenaarad39c092020-02-26 18:23:43 +01001952def Test_echo_cmd()
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001953 echo 'some' # comment
Bram Moolenaar585fea72020-04-02 22:33:21 +02001954 echon 'thing'
Bram Moolenaarad39c092020-02-26 18:23:43 +01001955 assert_match('^something$', Screenline(&lines))
1956
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001957 echo "some" # comment
1958 echon "thing"
1959 assert_match('^something$', Screenline(&lines))
1960
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001961 var str1 = 'some'
1962 var str2 = 'more'
Bram Moolenaarad39c092020-02-26 18:23:43 +01001963 echo str1 str2
1964 assert_match('^some more$', Screenline(&lines))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001965
Bram Moolenaard2c61702020-09-06 15:58:36 +02001966 CheckDefFailure(['echo "xxx"# comment'], 'E488:')
Bram Moolenaarad39c092020-02-26 18:23:43 +01001967enddef
1968
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001969def Test_echomsg_cmd()
1970 echomsg 'some' 'more' # comment
1971 assert_match('^some more$', Screenline(&lines))
1972 echo 'clear'
Bram Moolenaardf069ee2020-06-22 23:02:51 +02001973 :1messages
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001974 assert_match('^some more$', Screenline(&lines))
1975
Bram Moolenaard2c61702020-09-06 15:58:36 +02001976 CheckDefFailure(['echomsg "xxx"# comment'], 'E488:')
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001977enddef
1978
Bram Moolenaar47e880d2020-06-30 22:02:02 +02001979def Test_echomsg_cmd_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001980 # only checks line continuation
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001981 var lines =<< trim END
Bram Moolenaar47e880d2020-06-30 22:02:02 +02001982 vim9script
1983 echomsg 'here'
1984 .. ' is ' ..
1985 'a message'
1986 assert_match('^here is a message$', Screenline(&lines))
1987 END
1988 CheckScriptSuccess(lines)
1989enddef
1990
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001991def Test_echoerr_cmd()
Bram Moolenaar40ee4662020-05-05 22:08:26 +02001992 try
1993 echoerr 'something' 'wrong' # comment
1994 catch
1995 assert_match('something wrong', v:exception)
1996 endtry
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001997enddef
1998
Bram Moolenaar47e880d2020-06-30 22:02:02 +02001999def Test_echoerr_cmd_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002000 # only checks line continuation
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002001 var lines =<< trim END
Bram Moolenaar47e880d2020-06-30 22:02:02 +02002002 vim9script
2003 try
2004 echoerr 'this'
2005 .. ' is ' ..
2006 'wrong'
2007 catch
2008 assert_match('this is wrong', v:exception)
2009 endtry
2010 END
2011 CheckScriptSuccess(lines)
2012enddef
2013
Bram Moolenaar41fe0612020-03-01 16:22:40 +01002014def Test_for_outside_of_function()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002015 var lines =<< trim END
Bram Moolenaar41fe0612020-03-01 16:22:40 +01002016 vim9script
2017 new
2018 for var in range(0, 3)
2019 append(line('$'), var)
2020 endfor
2021 assert_equal(['', '0', '1', '2', '3'], getline(1, '$'))
2022 bwipe!
2023 END
2024 writefile(lines, 'Xvim9for.vim')
2025 source Xvim9for.vim
2026 delete('Xvim9for.vim')
2027enddef
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002028
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02002029def Test_for_loop()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002030 var result = ''
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02002031 for cnt in range(7)
2032 if cnt == 4
2033 break
2034 endif
2035 if cnt == 2
2036 continue
2037 endif
2038 result ..= cnt .. '_'
2039 endfor
2040 assert_equal('0_1_3_', result)
Bram Moolenaar0ad3e892020-07-05 21:38:11 +02002041
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002042 var concat = ''
Bram Moolenaar0ad3e892020-07-05 21:38:11 +02002043 for str in eval('["one", "two"]')
2044 concat ..= str
2045 endfor
2046 assert_equal('onetwo', concat)
Bram Moolenaar38bd8de2020-12-02 13:23:36 +01002047
2048 var total = 0
2049 for nr in
2050 [1, 2, 3]
2051 total += nr
2052 endfor
2053 assert_equal(6, total)
2054
2055 total = 0
2056 for nr
2057 in [1, 2, 3]
2058 total += nr
2059 endfor
2060 assert_equal(6, total)
2061
2062 total = 0
2063 for nr
2064 in
2065 [1, 2, 3]
2066 total += nr
2067 endfor
2068 assert_equal(6, total)
Bram Moolenaar036d0712021-01-17 20:23:38 +01002069
2070 var res = ""
2071 for [n: number, s: string] in [[1, 'a'], [2, 'b']]
2072 res ..= n .. s
2073 endfor
2074 assert_equal('1a2b', res)
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02002075enddef
2076
2077def Test_for_loop_fails()
Bram Moolenaar025cb1c2020-12-14 18:31:27 +01002078 CheckDefFailure(['for '], 'E1097:')
2079 CheckDefFailure(['for x'], 'E1097:')
2080 CheckDefFailure(['for x in'], 'E1097:')
Bram Moolenaar675f7162020-04-12 22:53:54 +02002081 CheckDefFailure(['for # in range(5)'], 'E690:')
2082 CheckDefFailure(['for i In range(5)'], 'E690:')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002083 CheckDefFailure(['var x = 5', 'for x in range(5)'], 'E1017:')
Bram Moolenaar822ba242020-05-24 23:00:18 +02002084 CheckScriptFailure(['def Func(arg: any)', 'for arg in range(5)', 'enddef', 'defcompile'], 'E1006:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002085 delfunc! g:Func
Bram Moolenaar451c2e32020-08-15 16:33:28 +02002086 CheckDefFailure(['for i in "text"'], 'E1012:')
Bram Moolenaar675f7162020-04-12 22:53:54 +02002087 CheckDefFailure(['for i in xxx'], 'E1001:')
2088 CheckDefFailure(['endfor'], 'E588:')
2089 CheckDefFailure(['for i in range(3)', 'echo 3'], 'E170:')
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02002090enddef
2091
Bram Moolenaarea870692020-12-02 14:24:30 +01002092def Test_for_loop_script_var()
2093 # cannot use s:var in a :def function
2094 CheckDefFailure(['for s:var in range(3)', 'echo 3'], 'E1101:')
2095
2096 # can use s:var in Vim9 script, with or without s:
2097 var lines =<< trim END
2098 vim9script
2099 var total = 0
2100 for s:var in [1, 2, 3]
2101 total += s:var
2102 endfor
2103 assert_equal(6, total)
2104
2105 total = 0
2106 for var in [1, 2, 3]
2107 total += var
2108 endfor
2109 assert_equal(6, total)
2110 END
2111enddef
2112
Bram Moolenaar792f7862020-11-23 08:31:18 +01002113def Test_for_loop_unpack()
Bram Moolenaar792f7862020-11-23 08:31:18 +01002114 var lines =<< trim END
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01002115 var result = []
2116 for [v1, v2] in [[1, 2], [3, 4]]
2117 result->add(v1)
2118 result->add(v2)
2119 endfor
2120 assert_equal([1, 2, 3, 4], result)
2121
2122 result = []
2123 for [v1, v2; v3] in [[1, 2], [3, 4, 5, 6]]
2124 result->add(v1)
2125 result->add(v2)
2126 result->add(v3)
2127 endfor
2128 assert_equal([1, 2, [], 3, 4, [5, 6]], result)
2129
2130 result = []
2131 for [&ts, &sw] in [[1, 2], [3, 4]]
2132 result->add(&ts)
2133 result->add(&sw)
2134 endfor
2135 assert_equal([1, 2, 3, 4], result)
2136
2137 var slist: list<string>
2138 for [$LOOPVAR, @r, v:errmsg] in [['a', 'b', 'c'], ['d', 'e', 'f']]
2139 slist->add($LOOPVAR)
2140 slist->add(@r)
2141 slist->add(v:errmsg)
2142 endfor
2143 assert_equal(['a', 'b', 'c', 'd', 'e', 'f'], slist)
2144
2145 slist = []
2146 for [g:globalvar, b:bufvar, w:winvar, t:tabvar] in [['global', 'buf', 'win', 'tab'], ['1', '2', '3', '4']]
2147 slist->add(g:globalvar)
2148 slist->add(b:bufvar)
2149 slist->add(w:winvar)
2150 slist->add(t:tabvar)
2151 endfor
2152 assert_equal(['global', 'buf', 'win', 'tab', '1', '2', '3', '4'], slist)
Bram Moolenaarf6c177a2020-12-04 17:38:00 +01002153 unlet! g:globalvar b:bufvar w:winvar t:tabvar
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01002154 END
2155 CheckDefAndScriptSuccess(lines)
2156
2157 lines =<< trim END
Bram Moolenaar792f7862020-11-23 08:31:18 +01002158 for [v1, v2] in [[1, 2, 3], [3, 4]]
2159 echo v1 v2
2160 endfor
2161 END
2162 CheckDefExecFailure(lines, 'E710:', 1)
2163
2164 lines =<< trim END
2165 for [v1, v2] in [[1], [3, 4]]
2166 echo v1 v2
2167 endfor
2168 END
2169 CheckDefExecFailure(lines, 'E711:', 1)
2170
2171 lines =<< trim END
2172 for [v1, v1] in [[1, 2], [3, 4]]
2173 echo v1
2174 endfor
2175 END
2176 CheckDefExecFailure(lines, 'E1017:', 1)
2177enddef
2178
Bram Moolenaard0df1aa2020-03-04 21:50:46 +01002179def Test_while_loop()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002180 var result = ''
2181 var cnt = 0
Bram Moolenaard0df1aa2020-03-04 21:50:46 +01002182 while cnt < 555
2183 if cnt == 3
2184 break
2185 endif
2186 cnt += 1
2187 if cnt == 2
2188 continue
2189 endif
2190 result ..= cnt .. '_'
2191 endwhile
2192 assert_equal('1_3_', result)
2193enddef
2194
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02002195def Test_while_loop_fails()
Bram Moolenaar675f7162020-04-12 22:53:54 +02002196 CheckDefFailure(['while xxx'], 'E1001:')
2197 CheckDefFailure(['endwhile'], 'E588:')
2198 CheckDefFailure(['continue'], 'E586:')
2199 CheckDefFailure(['if true', 'continue'], 'E586:')
2200 CheckDefFailure(['break'], 'E587:')
2201 CheckDefFailure(['if true', 'break'], 'E587:')
2202 CheckDefFailure(['while 1', 'echo 3'], 'E170:')
Bram Moolenaarbd5da372020-03-31 23:13:10 +02002203enddef
2204
Bram Moolenaar9645e2d2020-03-20 20:48:49 +01002205def Test_interrupt_loop()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002206 var caught = false
2207 var x = 0
Bram Moolenaar97acfc72020-03-22 13:44:28 +01002208 try
2209 while 1
2210 x += 1
2211 if x == 100
2212 feedkeys("\<C-C>", 'Lt')
2213 endif
2214 endwhile
2215 catch
2216 caught = true
2217 assert_equal(100, x)
2218 endtry
2219 assert_true(caught, 'should have caught an exception')
Bram Moolenaar25859dd2020-08-30 12:54:53 +02002220 # consume the CTRL-C
2221 getchar(0)
Bram Moolenaar9645e2d2020-03-20 20:48:49 +01002222enddef
Bram Moolenaar20431c92020-03-20 18:39:46 +01002223
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002224def Test_automatic_line_continuation()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002225 var mylist = [
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002226 'one',
2227 'two',
2228 'three',
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002229 ] # comment
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002230 assert_equal(['one', 'two', 'three'], mylist)
2231
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002232 var mydict = {
Bram Moolenaare0de1712020-12-02 17:36:54 +01002233 ['one']: 1,
2234 ['two']: 2,
2235 ['three']:
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002236 3,
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002237 } # comment
Bram Moolenaare0de1712020-12-02 17:36:54 +01002238 assert_equal({one: 1, two: 2, three: 3}, mydict)
2239 mydict = {
Bram Moolenaar2c330432020-04-13 14:41:35 +02002240 one: 1, # comment
2241 two: # comment
2242 2, # comment
2243 three: 3 # comment
2244 }
Bram Moolenaare0de1712020-12-02 17:36:54 +01002245 assert_equal({one: 1, two: 2, three: 3}, mydict)
2246 mydict = {
Bram Moolenaar2c330432020-04-13 14:41:35 +02002247 one: 1,
2248 two:
2249 2,
2250 three: 3
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002251 }
Bram Moolenaare0de1712020-12-02 17:36:54 +01002252 assert_equal({one: 1, two: 2, three: 3}, mydict)
Bram Moolenaare6085c52020-04-12 20:19:16 +02002253
2254 assert_equal(
2255 ['one', 'two', 'three'],
2256 split('one two three')
2257 )
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002258enddef
2259
Bram Moolenaar7a092242020-04-16 22:10:49 +02002260def Test_vim9_comment()
2261 CheckScriptSuccess([
2262 'vim9script',
2263 '# something',
Bram Moolenaar93f82cb2020-12-12 21:25:56 +01002264 '#something',
2265 '#{something',
Bram Moolenaar7a092242020-04-16 22:10:49 +02002266 ])
Bram Moolenaar93f82cb2020-12-12 21:25:56 +01002267
2268 split Xfile
2269 CheckScriptSuccess([
2270 'vim9script',
2271 'edit #something',
2272 ])
2273 CheckScriptSuccess([
2274 'vim9script',
2275 'edit #{something',
2276 ])
2277 close
2278
Bram Moolenaar7a092242020-04-16 22:10:49 +02002279 CheckScriptFailure([
2280 'vim9script',
2281 ':# something',
2282 ], 'E488:')
2283 CheckScriptFailure([
2284 '# something',
2285 ], 'E488:')
2286 CheckScriptFailure([
2287 ':# something',
2288 ], 'E488:')
2289
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02002290 { # block start
2291 } # block end
2292 CheckDefFailure([
2293 '{# comment',
2294 ], 'E488:')
2295 CheckDefFailure([
2296 '{',
2297 '}# comment',
2298 ], 'E488:')
2299
2300 echo "yes" # comment
2301 CheckDefFailure([
2302 'echo "yes"# comment',
2303 ], 'E488:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02002304 CheckScriptSuccess([
2305 'vim9script',
2306 'echo "yes" # something',
2307 ])
2308 CheckScriptFailure([
2309 'vim9script',
2310 'echo "yes"# something',
2311 ], 'E121:')
2312 CheckScriptFailure([
2313 'vim9script',
2314 'echo# something',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002315 ], 'E1144:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02002316 CheckScriptFailure([
2317 'echo "yes" # something',
2318 ], 'E121:')
2319
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02002320 exe "echo" # comment
2321 CheckDefFailure([
2322 'exe "echo"# comment',
2323 ], 'E488:')
2324 CheckScriptSuccess([
2325 'vim9script',
2326 'exe "echo" # something',
2327 ])
2328 CheckScriptFailure([
2329 'vim9script',
2330 'exe "echo"# something',
2331 ], 'E121:')
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02002332 CheckScriptFailure([
2333 'vim9script',
2334 'exe# something',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002335 ], 'E1144:')
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02002336 CheckScriptFailure([
2337 'exe "echo" # something',
2338 ], 'E121:')
2339
Bram Moolenaar7a092242020-04-16 22:10:49 +02002340 CheckDefFailure([
2341 'try# comment',
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002342 ' echo "yes"',
Bram Moolenaar7a092242020-04-16 22:10:49 +02002343 'catch',
2344 'endtry',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002345 ], 'E1144:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002346 CheckScriptFailure([
2347 'vim9script',
2348 'try# comment',
2349 'echo "yes"',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002350 ], 'E1144:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02002351 CheckDefFailure([
2352 'try',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002353 ' throw#comment',
2354 'catch',
2355 'endtry',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002356 ], 'E1144:')
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002357 CheckDefFailure([
2358 'try',
2359 ' throw "yes"#comment',
2360 'catch',
2361 'endtry',
2362 ], 'E488:')
2363 CheckDefFailure([
2364 'try',
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002365 ' echo "yes"',
Bram Moolenaar7a092242020-04-16 22:10:49 +02002366 'catch# comment',
2367 'endtry',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002368 ], 'E1144:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002369 CheckScriptFailure([
2370 'vim9script',
2371 'try',
2372 ' echo "yes"',
2373 'catch# comment',
2374 'endtry',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002375 ], 'E1144:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002376 CheckDefFailure([
2377 'try',
2378 ' echo "yes"',
2379 'catch /pat/# comment',
2380 'endtry',
2381 ], 'E488:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02002382 CheckDefFailure([
2383 'try',
2384 'echo "yes"',
2385 'catch',
2386 'endtry# comment',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002387 ], 'E1144:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002388 CheckScriptFailure([
2389 'vim9script',
2390 'try',
2391 ' echo "yes"',
2392 'catch',
2393 'endtry# comment',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002394 ], 'E1144:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002395
2396 CheckScriptSuccess([
2397 'vim9script',
2398 'hi # comment',
2399 ])
2400 CheckScriptFailure([
2401 'vim9script',
2402 'hi# comment',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002403 ], 'E1144:')
Bram Moolenaar1966c242020-04-20 22:42:32 +02002404 CheckScriptSuccess([
2405 'vim9script',
2406 'hi Search # comment',
2407 ])
2408 CheckScriptFailure([
2409 'vim9script',
2410 'hi Search# comment',
2411 ], 'E416:')
2412 CheckScriptSuccess([
2413 'vim9script',
2414 'hi link This Search # comment',
2415 ])
2416 CheckScriptFailure([
2417 'vim9script',
2418 'hi link This That# comment',
2419 ], 'E413:')
2420 CheckScriptSuccess([
2421 'vim9script',
2422 'hi clear This # comment',
2423 'hi clear # comment',
2424 ])
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002425 # not tested, because it doesn't give an error but a warning:
2426 # hi clear This# comment',
Bram Moolenaar1966c242020-04-20 22:42:32 +02002427 CheckScriptFailure([
2428 'vim9script',
2429 'hi clear# comment',
2430 ], 'E416:')
2431
2432 CheckScriptSuccess([
2433 'vim9script',
2434 'hi Group term=bold',
2435 'match Group /todo/ # comment',
2436 ])
2437 CheckScriptFailure([
2438 'vim9script',
2439 'hi Group term=bold',
2440 'match Group /todo/# comment',
2441 ], 'E488:')
2442 CheckScriptSuccess([
2443 'vim9script',
2444 'match # comment',
2445 ])
2446 CheckScriptFailure([
2447 'vim9script',
2448 'match# comment',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002449 ], 'E1144:')
Bram Moolenaar1966c242020-04-20 22:42:32 +02002450 CheckScriptSuccess([
2451 'vim9script',
2452 'match none # comment',
2453 ])
2454 CheckScriptFailure([
2455 'vim9script',
2456 'match none# comment',
2457 ], 'E475:')
2458
2459 CheckScriptSuccess([
2460 'vim9script',
2461 'menutrans clear # comment',
2462 ])
2463 CheckScriptFailure([
2464 'vim9script',
2465 'menutrans clear# comment text',
2466 ], 'E474:')
2467
2468 CheckScriptSuccess([
2469 'vim9script',
2470 'syntax clear # comment',
2471 ])
2472 CheckScriptFailure([
2473 'vim9script',
2474 'syntax clear# comment text',
2475 ], 'E28:')
2476 CheckScriptSuccess([
2477 'vim9script',
2478 'syntax keyword Word some',
2479 'syntax clear Word # comment',
2480 ])
2481 CheckScriptFailure([
2482 'vim9script',
2483 'syntax keyword Word some',
2484 'syntax clear Word# comment text',
2485 ], 'E28:')
2486
2487 CheckScriptSuccess([
2488 'vim9script',
2489 'syntax list # comment',
2490 ])
2491 CheckScriptFailure([
2492 'vim9script',
2493 'syntax list# comment text',
2494 ], 'E28:')
2495
2496 CheckScriptSuccess([
2497 'vim9script',
2498 'syntax match Word /pat/ oneline # comment',
2499 ])
2500 CheckScriptFailure([
2501 'vim9script',
2502 'syntax match Word /pat/ oneline# comment',
2503 ], 'E475:')
2504
2505 CheckScriptSuccess([
2506 'vim9script',
2507 'syntax keyword Word word # comm[ent',
2508 ])
2509 CheckScriptFailure([
2510 'vim9script',
2511 'syntax keyword Word word# comm[ent',
2512 ], 'E789:')
2513
2514 CheckScriptSuccess([
2515 'vim9script',
2516 'syntax match Word /pat/ # comment',
2517 ])
2518 CheckScriptFailure([
2519 'vim9script',
2520 'syntax match Word /pat/# comment',
2521 ], 'E402:')
2522
2523 CheckScriptSuccess([
2524 'vim9script',
2525 'syntax match Word /pat/ contains=Something # comment',
2526 ])
2527 CheckScriptFailure([
2528 'vim9script',
2529 'syntax match Word /pat/ contains=Something# comment',
2530 ], 'E475:')
2531 CheckScriptFailure([
2532 'vim9script',
2533 'syntax match Word /pat/ contains= # comment',
2534 ], 'E406:')
2535 CheckScriptFailure([
2536 'vim9script',
2537 'syntax match Word /pat/ contains=# comment',
2538 ], 'E475:')
2539
2540 CheckScriptSuccess([
2541 'vim9script',
2542 'syntax region Word start=/pat/ end=/pat/ # comment',
2543 ])
2544 CheckScriptFailure([
2545 'vim9script',
2546 'syntax region Word start=/pat/ end=/pat/# comment',
Bram Moolenaard032f342020-07-18 18:13:02 +02002547 ], 'E402:')
Bram Moolenaar1966c242020-04-20 22:42:32 +02002548
2549 CheckScriptSuccess([
2550 'vim9script',
2551 'syntax sync # comment',
2552 ])
2553 CheckScriptFailure([
2554 'vim9script',
2555 'syntax sync# comment',
2556 ], 'E404:')
2557 CheckScriptSuccess([
2558 'vim9script',
2559 'syntax sync ccomment # comment',
2560 ])
2561 CheckScriptFailure([
2562 'vim9script',
2563 'syntax sync ccomment# comment',
2564 ], 'E404:')
2565
2566 CheckScriptSuccess([
2567 'vim9script',
2568 'syntax cluster Some contains=Word # comment',
2569 ])
2570 CheckScriptFailure([
2571 'vim9script',
2572 'syntax cluster Some contains=Word# comment',
2573 ], 'E475:')
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002574
2575 CheckScriptSuccess([
2576 'vim9script',
2577 'command Echo echo # comment',
2578 'command Echo # comment',
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002579 'delcommand Echo',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002580 ])
2581 CheckScriptFailure([
2582 'vim9script',
2583 'command Echo echo# comment',
2584 'Echo',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002585 ], 'E1144:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002586 delcommand Echo
Bram Moolenaar70249ee2020-12-10 21:01:30 +01002587
2588 var curdir = getcwd()
2589 CheckScriptSuccess([
2590 'command Echo cd " comment',
2591 'Echo',
2592 'delcommand Echo',
2593 ])
2594 CheckScriptSuccess([
Bram Moolenaar090728a2020-12-20 15:43:31 +01002595 'vim9script',
Bram Moolenaar70249ee2020-12-10 21:01:30 +01002596 'command Echo cd # comment',
2597 'Echo',
2598 'delcommand Echo',
2599 ])
2600 CheckScriptFailure([
2601 'vim9script',
2602 'command Echo cd " comment',
2603 'Echo',
2604 ], 'E344:')
2605 delcommand Echo
2606 chdir(curdir)
2607
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002608 CheckScriptFailure([
2609 'vim9script',
2610 'command Echo# comment',
2611 ], 'E182:')
2612 CheckScriptFailure([
2613 'vim9script',
2614 'command Echo echo',
2615 'command Echo# comment',
2616 ], 'E182:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002617 delcommand Echo
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002618
2619 CheckScriptSuccess([
2620 'vim9script',
2621 'function # comment',
2622 ])
2623 CheckScriptFailure([
2624 'vim9script',
Bram Moolenaar98981072020-07-29 14:40:25 +02002625 'function " comment',
2626 ], 'E129:')
2627 CheckScriptFailure([
2628 'vim9script',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002629 'function# comment',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002630 ], 'E1144:')
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002631 CheckScriptSuccess([
2632 'vim9script',
2633 'function CheckScriptSuccess # comment',
2634 ])
2635 CheckScriptFailure([
2636 'vim9script',
2637 'function CheckScriptSuccess# comment',
2638 ], 'E488:')
2639
2640 CheckScriptSuccess([
2641 'vim9script',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02002642 'func g:DeleteMeA()',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002643 'endfunc',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02002644 'delfunction g:DeleteMeA # comment',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002645 ])
2646 CheckScriptFailure([
2647 'vim9script',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02002648 'func g:DeleteMeB()',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002649 'endfunc',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02002650 'delfunction g:DeleteMeB# comment',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002651 ], 'E488:')
2652
2653 CheckScriptSuccess([
2654 'vim9script',
2655 'call execute("ls") # comment',
2656 ])
2657 CheckScriptFailure([
2658 'vim9script',
2659 'call execute("ls")# comment',
2660 ], 'E488:')
Bram Moolenaare7e48382020-07-22 18:17:08 +02002661
2662 CheckScriptFailure([
2663 'def Test() " comment',
2664 'enddef',
2665 ], 'E488:')
2666 CheckScriptFailure([
2667 'vim9script',
2668 'def Test() " comment',
2669 'enddef',
2670 ], 'E488:')
2671
2672 CheckScriptSuccess([
2673 'func Test() " comment',
2674 'endfunc',
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002675 'delfunc Test',
Bram Moolenaare7e48382020-07-22 18:17:08 +02002676 ])
Bram Moolenaar98981072020-07-29 14:40:25 +02002677 CheckScriptSuccess([
Bram Moolenaare7e48382020-07-22 18:17:08 +02002678 'vim9script',
2679 'func Test() " comment',
2680 'endfunc',
Bram Moolenaar98981072020-07-29 14:40:25 +02002681 ])
Bram Moolenaare7e48382020-07-22 18:17:08 +02002682
2683 CheckScriptSuccess([
2684 'def Test() # comment',
2685 'enddef',
2686 ])
2687 CheckScriptFailure([
2688 'func Test() # comment',
2689 'endfunc',
2690 ], 'E488:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002691enddef
2692
2693def Test_vim9_comment_gui()
2694 CheckCanRunGui
2695
2696 CheckScriptFailure([
2697 'vim9script',
2698 'gui#comment'
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002699 ], 'E1144:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002700 CheckScriptFailure([
2701 'vim9script',
2702 'gui -f#comment'
2703 ], 'E499:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02002704enddef
2705
Bram Moolenaara26b9702020-04-18 19:53:28 +02002706def Test_vim9_comment_not_compiled()
Bram Moolenaar67979662020-06-20 22:50:47 +02002707 au TabEnter *.vim g:entered = 1
2708 au TabEnter *.x g:entered = 2
Bram Moolenaara26b9702020-04-18 19:53:28 +02002709
2710 edit test.vim
2711 doautocmd TabEnter #comment
2712 assert_equal(1, g:entered)
2713
2714 doautocmd TabEnter f.x
2715 assert_equal(2, g:entered)
2716
2717 g:entered = 0
2718 doautocmd TabEnter f.x #comment
2719 assert_equal(2, g:entered)
2720
2721 assert_fails('doautocmd Syntax#comment', 'E216:')
2722
2723 au! TabEnter
2724 unlet g:entered
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02002725
2726 CheckScriptSuccess([
2727 'vim9script',
Bram Moolenaar67979662020-06-20 22:50:47 +02002728 'g:var = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02002729 'b:var = 456',
2730 'w:var = 777',
2731 't:var = 888',
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02002732 'unlet g:var w:var # something',
2733 ])
2734
2735 CheckScriptFailure([
2736 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002737 'let var = 123',
2738 ], 'E1126: Cannot use :let in Vim9 script')
2739
2740 CheckScriptFailure([
2741 'vim9script',
2742 'var g:var = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02002743 ], 'E1016: Cannot declare a global variable:')
2744
2745 CheckScriptFailure([
2746 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002747 'var b:var = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02002748 ], 'E1016: Cannot declare a buffer variable:')
2749
2750 CheckScriptFailure([
2751 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002752 'var w:var = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02002753 ], 'E1016: Cannot declare a window variable:')
2754
2755 CheckScriptFailure([
2756 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002757 'var t:var = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02002758 ], 'E1016: Cannot declare a tab variable:')
2759
2760 CheckScriptFailure([
2761 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002762 'var v:version = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02002763 ], 'E1016: Cannot declare a v: variable:')
2764
2765 CheckScriptFailure([
2766 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002767 'var $VARIABLE = "text"',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02002768 ], 'E1016: Cannot declare an environment variable:')
Bram Moolenaar67979662020-06-20 22:50:47 +02002769
2770 CheckScriptFailure([
2771 'vim9script',
2772 'g:var = 123',
Bram Moolenaar32e35112020-05-14 22:41:15 +02002773 'unlet g:var# comment1',
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02002774 ], 'E108:')
2775
2776 CheckScriptFailure([
2777 'let g:var = 123',
2778 'unlet g:var # something',
2779 ], 'E488:')
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002780
2781 CheckScriptSuccess([
2782 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02002783 'if 1 # comment2',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002784 ' echo "yes"',
2785 'elseif 2 #comment',
2786 ' echo "no"',
2787 'endif',
2788 ])
2789
2790 CheckScriptFailure([
2791 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02002792 'if 1# comment3',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002793 ' echo "yes"',
2794 'endif',
2795 ], 'E15:')
2796
2797 CheckScriptFailure([
2798 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02002799 'if 0 # comment4',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002800 ' echo "yes"',
2801 'elseif 2#comment',
2802 ' echo "no"',
2803 'endif',
2804 ], 'E15:')
2805
2806 CheckScriptSuccess([
2807 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002808 'var v = 1 # comment5',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002809 ])
2810
2811 CheckScriptFailure([
2812 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002813 'var v = 1# comment6',
Bram Moolenaar32e35112020-05-14 22:41:15 +02002814 ], 'E15:')
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002815
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002816 CheckScriptSuccess([
2817 'vim9script',
2818 'new'
Bram Moolenaard2c61702020-09-06 15:58:36 +02002819 'setline(1, ["# define pat", "last"])',
Bram Moolenaardf069ee2020-06-22 23:02:51 +02002820 ':$',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002821 'dsearch /pat/ #comment',
2822 'bwipe!',
2823 ])
2824
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002825 CheckScriptFailure([
2826 'vim9script',
2827 'new'
Bram Moolenaard2c61702020-09-06 15:58:36 +02002828 'setline(1, ["# define pat", "last"])',
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002829 ':$',
2830 'dsearch /pat/#comment',
2831 'bwipe!',
2832 ], 'E488:')
2833
2834 CheckScriptFailure([
2835 'vim9script',
2836 'func! SomeFunc()',
2837 ], 'E477:')
Bram Moolenaara26b9702020-04-18 19:53:28 +02002838enddef
2839
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02002840def Test_finish()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002841 var lines =<< trim END
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02002842 vim9script
Bram Moolenaar67979662020-06-20 22:50:47 +02002843 g:res = 'one'
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02002844 if v:false | finish | endif
Bram Moolenaar67979662020-06-20 22:50:47 +02002845 g:res = 'two'
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02002846 finish
Bram Moolenaar67979662020-06-20 22:50:47 +02002847 g:res = 'three'
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02002848 END
2849 writefile(lines, 'Xfinished')
2850 source Xfinished
2851 assert_equal('two', g:res)
2852
2853 unlet g:res
2854 delete('Xfinished')
2855enddef
2856
Bram Moolenaara5d00772020-05-14 23:20:55 +02002857def Test_forward_declaration()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002858 var lines =<< trim END
Bram Moolenaara5d00772020-05-14 23:20:55 +02002859 vim9script
Bram Moolenaara5d00772020-05-14 23:20:55 +02002860 def GetValue(): string
2861 return theVal
2862 enddef
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002863 var theVal = 'something'
Bram Moolenaar822ba242020-05-24 23:00:18 +02002864 g:initVal = GetValue()
Bram Moolenaara5d00772020-05-14 23:20:55 +02002865 theVal = 'else'
2866 g:laterVal = GetValue()
2867 END
2868 writefile(lines, 'Xforward')
2869 source Xforward
2870 assert_equal('something', g:initVal)
2871 assert_equal('else', g:laterVal)
2872
2873 unlet g:initVal
2874 unlet g:laterVal
2875 delete('Xforward')
2876enddef
2877
Bram Moolenaar9721fb42020-06-11 23:10:46 +02002878def Test_source_vim9_from_legacy()
Bram Moolenaara6294952020-12-27 13:39:50 +01002879 var vim9_lines =<< trim END
2880 vim9script
2881 var local = 'local'
2882 g:global = 'global'
2883 export var exported = 'exported'
2884 export def GetText(): string
2885 return 'text'
2886 enddef
2887 END
2888 writefile(vim9_lines, 'Xvim9_script.vim')
2889
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002890 var legacy_lines =<< trim END
Bram Moolenaar9721fb42020-06-11 23:10:46 +02002891 source Xvim9_script.vim
2892
2893 call assert_false(exists('local'))
2894 call assert_false(exists('exported'))
2895 call assert_false(exists('s:exported'))
2896 call assert_equal('global', global)
2897 call assert_equal('global', g:global)
2898
2899 " imported variable becomes script-local
2900 import exported from './Xvim9_script.vim'
2901 call assert_equal('exported', s:exported)
2902 call assert_false(exists('exported'))
2903
2904 " imported function becomes script-local
2905 import GetText from './Xvim9_script.vim'
2906 call assert_equal('text', s:GetText())
2907 call assert_false(exists('*GetText'))
2908 END
2909 writefile(legacy_lines, 'Xlegacy_script.vim')
2910
Bram Moolenaar9721fb42020-06-11 23:10:46 +02002911 source Xlegacy_script.vim
Bram Moolenaar9721fb42020-06-11 23:10:46 +02002912 assert_equal('global', g:global)
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002913 unlet g:global
Bram Moolenaar9721fb42020-06-11 23:10:46 +02002914
2915 delete('Xlegacy_script.vim')
2916 delete('Xvim9_script.vim')
2917enddef
Bram Moolenaara5d00772020-05-14 23:20:55 +02002918
Bram Moolenaar7d699702020-08-14 20:52:28 +02002919func Test_vim9script_not_global()
2920 " check that items defined in Vim9 script are script-local, not global
2921 let vim9lines =<< trim END
2922 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002923 var name = 'local'
Bram Moolenaar7d699702020-08-14 20:52:28 +02002924 func TheFunc()
2925 echo 'local'
2926 endfunc
2927 def DefFunc()
2928 echo 'local'
2929 enddef
2930 END
2931 call writefile(vim9lines, 'Xvim9script.vim')
2932 source Xvim9script.vim
2933 try
2934 echo g:var
2935 assert_report('did not fail')
2936 catch /E121:/
2937 " caught
2938 endtry
2939 try
2940 call TheFunc()
2941 assert_report('did not fail')
2942 catch /E117:/
2943 " caught
2944 endtry
2945 try
2946 call DefFunc()
2947 assert_report('did not fail')
2948 catch /E117:/
2949 " caught
2950 endtry
2951
Bram Moolenaar25859dd2020-08-30 12:54:53 +02002952 call delete('Xvim9script.vim')
Bram Moolenaar7d699702020-08-14 20:52:28 +02002953endfunc
2954
Bram Moolenaareeb27bf2020-07-04 17:39:10 +02002955def Test_vim9_copen()
2956 # this was giving an error for setting w:quickfix_title
2957 copen
2958 quit
2959enddef
2960
Bram Moolenaar03290b82020-12-19 16:30:44 +01002961" test using an auto-loaded function and variable
Bram Moolenaar2d6b20d2020-07-25 19:30:59 +02002962def Test_vim9_autoload()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002963 var lines =<< trim END
Bram Moolenaar2d6b20d2020-07-25 19:30:59 +02002964 vim9script
Bram Moolenaar03290b82020-12-19 16:30:44 +01002965 def some#gettest(): string
2966 return 'test'
2967 enddef
2968 g:some#name = 'name'
2969 END
2970
2971 mkdir('Xdir/autoload', 'p')
2972 writefile(lines, 'Xdir/autoload/some.vim')
2973 var save_rtp = &rtp
2974 exe 'set rtp^=' .. getcwd() .. '/Xdir'
2975
2976 assert_equal('test', g:some#gettest())
2977 assert_equal('name', g:some#name)
2978 g:some#other = 'other'
2979 assert_equal('other', g:some#other)
2980
Bram Moolenaar17f700a2020-12-19 21:23:42 +01002981 # upper case script name works
2982 lines =<< trim END
2983 vim9script
2984 def Other#getOther(): string
2985 return 'other'
2986 enddef
2987 END
2988 writefile(lines, 'Xdir/autoload/Other.vim')
2989 assert_equal('other', g:Other#getOther())
2990
Bram Moolenaar03290b82020-12-19 16:30:44 +01002991 delete('Xdir', 'rf')
2992 &rtp = save_rtp
2993enddef
2994
2995" test using a vim9script that is auto-loaded from an autocmd
2996def Test_vim9_aucmd_autoload()
2997 var lines =<< trim END
2998 vim9script
Bram Moolenaar2d6b20d2020-07-25 19:30:59 +02002999 def foo#test()
3000 echomsg getreg('"')
3001 enddef
3002 END
3003
3004 mkdir('Xdir/autoload', 'p')
3005 writefile(lines, 'Xdir/autoload/foo.vim')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003006 var save_rtp = &rtp
Bram Moolenaar2d6b20d2020-07-25 19:30:59 +02003007 exe 'set rtp^=' .. getcwd() .. '/Xdir'
3008 augroup test
3009 autocmd TextYankPost * call foo#test()
3010 augroup END
3011
3012 normal Y
3013
3014 augroup test
3015 autocmd!
3016 augroup END
3017 delete('Xdir', 'rf')
3018 &rtp = save_rtp
3019enddef
3020
Bram Moolenaar77e5dcc2020-09-17 21:29:03 +02003021" This was causing a crash because suppress_errthrow wasn't reset.
3022def Test_vim9_autoload_error()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003023 var lines =<< trim END
Bram Moolenaar77e5dcc2020-09-17 21:29:03 +02003024 vim9script
3025 def crash#func()
3026 try
3027 for x in List()
3028 endfor
3029 catch
3030 endtry
3031 g:ok = true
3032 enddef
3033 fu List()
3034 invalid
3035 endfu
3036 try
Bram Moolenaar48e11c12021-01-11 18:47:00 +01003037 alsoinvalid
Bram Moolenaar77e5dcc2020-09-17 21:29:03 +02003038 catch /wontmatch/
3039 endtry
3040 END
3041 call mkdir('Xruntime/autoload', 'p')
3042 call writefile(lines, 'Xruntime/autoload/crash.vim')
3043
3044 # run in a separate Vim to avoid the side effects of assert_fails()
3045 lines =<< trim END
3046 exe 'set rtp^=' .. getcwd() .. '/Xruntime'
3047 call crash#func()
3048 call writefile(['ok'], 'Xdidit')
Bram Moolenaar9c4f5522020-09-25 21:47:28 +02003049 qall!
Bram Moolenaar77e5dcc2020-09-17 21:29:03 +02003050 END
3051 writefile(lines, 'Xscript')
3052 RunVim([], [], '-S Xscript')
3053 assert_equal(['ok'], readfile('Xdidit'))
3054
3055 delete('Xdidit')
3056 delete('Xscript')
3057 delete('Xruntime', 'rf')
Bram Moolenaar03290b82020-12-19 16:30:44 +01003058
3059 lines =<< trim END
3060 vim9script
3061 var foo#bar = 'asdf'
3062 END
3063 CheckScriptFailure(lines, 'E461: Illegal variable name: foo#bar', 2)
Bram Moolenaar77e5dcc2020-09-17 21:29:03 +02003064enddef
3065
Bram Moolenaar81e17fb2020-08-21 21:55:43 +02003066def Test_script_var_in_autocmd()
3067 # using a script variable from an autocommand, defined in a :def function in a
3068 # legacy Vim script, cannot check the variable type.
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003069 var lines =<< trim END
Bram Moolenaar81e17fb2020-08-21 21:55:43 +02003070 let s:counter = 1
3071 def s:Func()
3072 au! CursorHold
3073 au CursorHold * s:counter += 1
3074 enddef
3075 call s:Func()
3076 doau CursorHold
3077 call assert_equal(2, s:counter)
3078 au! CursorHold
3079 END
3080 CheckScriptSuccess(lines)
3081enddef
3082
Bram Moolenaar3896a102020-08-09 14:33:55 +02003083def Test_cmdline_win()
3084 # if the Vim syntax highlighting uses Vim9 constructs they can be used from
3085 # the command line window.
3086 mkdir('rtp/syntax', 'p')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003087 var export_lines =<< trim END
Bram Moolenaar3896a102020-08-09 14:33:55 +02003088 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003089 export var That = 'yes'
Bram Moolenaar3896a102020-08-09 14:33:55 +02003090 END
3091 writefile(export_lines, 'rtp/syntax/Xexport.vim')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003092 var import_lines =<< trim END
Bram Moolenaar3896a102020-08-09 14:33:55 +02003093 vim9script
3094 import That from './Xexport.vim'
3095 END
3096 writefile(import_lines, 'rtp/syntax/vim.vim')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003097 var save_rtp = &rtp
Bram Moolenaar3896a102020-08-09 14:33:55 +02003098 &rtp = getcwd() .. '/rtp' .. ',' .. &rtp
3099 syntax on
3100 augroup CmdWin
3101 autocmd CmdwinEnter * g:got_there = 'yes'
3102 augroup END
3103 # this will open and also close the cmdline window
3104 feedkeys('q:', 'xt')
3105 assert_equal('yes', g:got_there)
3106
3107 augroup CmdWin
3108 au!
3109 augroup END
3110 &rtp = save_rtp
3111 delete('rtp', 'rf')
3112enddef
3113
Bram Moolenaare3d46852020-08-29 13:39:17 +02003114def Test_invalid_sid()
3115 assert_fails('func <SNR>1234_func', 'E123:')
Bram Moolenaar25859dd2020-08-30 12:54:53 +02003116
Bram Moolenaar9c4f5522020-09-25 21:47:28 +02003117 if RunVim([], ['wq! Xdidit'], '+"func <SNR>1_func"')
Bram Moolenaard2c61702020-09-06 15:58:36 +02003118 assert_equal([], readfile('Xdidit'))
Bram Moolenaare3d46852020-08-29 13:39:17 +02003119 endif
3120 delete('Xdidit')
3121enddef
3122
Bram Moolenaar9ec70262020-12-09 17:16:59 +01003123def Test_restoring_cpo()
3124 writefile(['vim9script', 'set nocp'], 'Xsourced')
3125 writefile(['call writefile(["done"], "Xdone")', 'quit!'], 'Xclose')
3126 if RunVim([], [], '-u NONE +"set cpo+=a" -S Xsourced -S Xclose')
3127 assert_equal(['done'], readfile('Xdone'))
3128 endif
3129 delete('Xsourced')
3130 delete('Xclose')
Bram Moolenaar090728a2020-12-20 15:43:31 +01003131 delete('Xdone')
Bram Moolenaar9ec70262020-12-09 17:16:59 +01003132enddef
3133
3134
Bram Moolenaarf0afd9e2020-09-13 18:57:47 +02003135def Test_unset_any_variable()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003136 var lines =<< trim END
3137 var name: any
3138 assert_equal(0, name)
Bram Moolenaarf0afd9e2020-09-13 18:57:47 +02003139 END
3140 CheckDefAndScriptSuccess(lines)
3141enddef
3142
Bram Moolenaar7e9210e2020-09-25 23:12:51 +02003143func Test_define_func_at_command_line()
Bram Moolenaar58dbef32020-09-25 22:13:05 +02003144 CheckRunVimInTerminal
3145
Bram Moolenaar7e9210e2020-09-25 23:12:51 +02003146 " call indirectly to avoid compilation error for missing functions
3147 call Run_Test_define_func_at_command_line()
3148endfunc
3149
3150def Run_Test_define_func_at_command_line()
Bram Moolenaar9c4f5522020-09-25 21:47:28 +02003151 # run in a separate Vim instance to avoid the script context
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003152 var lines =<< trim END
Bram Moolenaar9c4f5522020-09-25 21:47:28 +02003153 func CheckAndQuit()
3154 call assert_fails('call Afunc()', 'E117: Unknown function: Bfunc')
3155 call writefile(['errors: ' .. string(v:errors)], 'Xdidcmd')
3156 endfunc
3157 END
3158 writefile([''], 'Xdidcmd')
3159 writefile(lines, 'XcallFunc')
Bram Moolenaare0de1712020-12-02 17:36:54 +01003160 var buf = RunVimInTerminal('-S XcallFunc', {rows: 6})
Bram Moolenaar9c4f5522020-09-25 21:47:28 +02003161 # define Afunc() on the command line
3162 term_sendkeys(buf, ":def Afunc()\<CR>Bfunc()\<CR>enddef\<CR>")
3163 term_sendkeys(buf, ":call CheckAndQuit()\<CR>")
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01003164 WaitForAssert(() => assert_equal(['errors: []'], readfile('Xdidcmd')))
Bram Moolenaar9c4f5522020-09-25 21:47:28 +02003165
3166 call StopVimInTerminal(buf)
3167 delete('XcallFunc')
3168 delete('Xdidcmd')
3169enddef
3170
Bram Moolenaarfcdc5d82020-10-10 19:07:09 +02003171def Test_script_var_scope()
3172 var lines =<< trim END
3173 vim9script
3174 if true
3175 if true
3176 var one = 'one'
3177 echo one
3178 endif
3179 echo one
3180 endif
3181 END
3182 CheckScriptFailure(lines, 'E121:', 7)
3183
3184 lines =<< trim END
3185 vim9script
3186 if true
3187 if false
3188 var one = 'one'
3189 echo one
3190 else
3191 var one = 'one'
3192 echo one
3193 endif
3194 echo one
3195 endif
3196 END
3197 CheckScriptFailure(lines, 'E121:', 10)
3198
3199 lines =<< trim END
3200 vim9script
3201 while true
3202 var one = 'one'
3203 echo one
3204 break
3205 endwhile
3206 echo one
3207 END
3208 CheckScriptFailure(lines, 'E121:', 7)
3209
3210 lines =<< trim END
3211 vim9script
3212 for i in range(1)
3213 var one = 'one'
3214 echo one
3215 endfor
3216 echo one
3217 END
3218 CheckScriptFailure(lines, 'E121:', 6)
Bram Moolenaar9becdf22020-10-10 21:33:48 +02003219
3220 lines =<< trim END
3221 vim9script
3222 {
3223 var one = 'one'
3224 assert_equal('one', one)
3225 }
3226 assert_false(exists('one'))
3227 assert_false(exists('s:one'))
3228 END
3229 CheckScriptSuccess(lines)
3230
3231 lines =<< trim END
3232 vim9script
3233 {
3234 var one = 'one'
3235 echo one
3236 }
3237 echo one
3238 END
3239 CheckScriptFailure(lines, 'E121:', 6)
Bram Moolenaarfcdc5d82020-10-10 19:07:09 +02003240enddef
3241
Bram Moolenaar352134b2020-10-17 22:04:08 +02003242def Test_catch_exception_in_callback()
3243 var lines =<< trim END
3244 vim9script
3245 def Callback(...l: any)
3246 try
3247 var x: string
3248 var y: string
3249 # this error should be caught with CHECKLEN
3250 [x, y] = ['']
3251 catch
3252 g:caught = 'yes'
3253 endtry
3254 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +01003255 popup_menu('popup', {callback: Callback})
Bram Moolenaar352134b2020-10-17 22:04:08 +02003256 feedkeys("\r", 'xt')
3257 END
3258 CheckScriptSuccess(lines)
3259
3260 unlet g:caught
3261enddef
3262
Bram Moolenaar631e8f92020-11-04 15:07:16 +01003263def Test_no_unknown_error_after_error()
3264 if !has('unix') || !has('job')
3265 throw 'Skipped: not unix of missing +job feature'
3266 endif
3267 var lines =<< trim END
3268 vim9script
3269 var source: list<number>
3270 def Out_cb(...l: any)
3271 eval [][0]
3272 enddef
3273 def Exit_cb(...l: any)
3274 sleep 1m
3275 source += l
3276 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +01003277 var myjob = job_start('echo burp', {out_cb: Out_cb, exit_cb: Exit_cb, mode: 'raw'})
Bram Moolenaar6f17a3f2020-12-21 18:11:24 +01003278 while job_status(myjob) == 'run'
3279 sleep 10m
3280 endwhile
3281 sleep 10m
Bram Moolenaar631e8f92020-11-04 15:07:16 +01003282 END
3283 writefile(lines, 'Xdef')
3284 assert_fails('so Xdef', ['E684:', 'E1012:'])
3285 delete('Xdef')
3286enddef
3287
Bram Moolenaar4324d872020-12-01 20:12:24 +01003288def InvokeNormal()
3289 exe "norm! :m+1\r"
3290enddef
3291
3292def Test_invoke_normal_in_visual_mode()
3293 xnoremap <F3> <Cmd>call <SID>InvokeNormal()<CR>
3294 new
3295 setline(1, ['aaa', 'bbb'])
3296 feedkeys("V\<F3>", 'xt')
3297 assert_equal(['bbb', 'aaa'], getline(1, 2))
3298 xunmap <F3>
3299enddef
3300
Bram Moolenaarb5b94802020-12-13 17:50:20 +01003301def Test_white_space_after_command()
3302 var lines =<< trim END
3303 exit_cb: Func})
3304 END
3305 CheckDefAndScriptFailure(lines, 'E1144:', 1)
Bram Moolenaarf8103f22020-12-25 17:36:27 +01003306
3307 lines =<< trim END
3308 e#
3309 END
3310 CheckDefAndScriptFailure(lines, 'E1144:', 1)
Bram Moolenaarb5b94802020-12-13 17:50:20 +01003311enddef
3312
Bram Moolenaar4aab88d2020-12-24 21:56:41 +01003313def Test_script_var_gone_when_sourced_twice()
3314 var lines =<< trim END
3315 vim9script
3316 if exists('g:guard')
3317 finish
3318 endif
3319 g:guard = 1
3320 var name = 'thename'
3321 def g:GetName(): string
3322 return name
3323 enddef
3324 def g:SetName(arg: string)
3325 name = arg
3326 enddef
3327 END
3328 writefile(lines, 'XscriptTwice.vim')
3329 so XscriptTwice.vim
3330 assert_equal('thename', g:GetName())
3331 g:SetName('newname')
3332 assert_equal('newname', g:GetName())
3333 so XscriptTwice.vim
3334 assert_fails('call g:GetName()', 'E1149:')
3335 assert_fails('call g:SetName("x")', 'E1149:')
3336
3337 delfunc g:GetName
3338 delfunc g:SetName
3339 delete('XscriptTwice.vim')
3340 unlet g:guard
3341enddef
3342
3343def Test_import_gone_when_sourced_twice()
3344 var exportlines =<< trim END
3345 vim9script
3346 if exists('g:guard')
3347 finish
3348 endif
3349 g:guard = 1
3350 export var name = 'someName'
3351 END
3352 writefile(exportlines, 'XexportScript.vim')
3353
3354 var lines =<< trim END
3355 vim9script
3356 import name from './XexportScript.vim'
3357 def g:GetName(): string
3358 return name
3359 enddef
3360 END
3361 writefile(lines, 'XscriptImport.vim')
3362 so XscriptImport.vim
3363 assert_equal('someName', g:GetName())
3364
3365 so XexportScript.vim
3366 assert_fails('call g:GetName()', 'E1149:')
3367
3368 delfunc g:GetName
3369 delete('XexportScript.vim')
3370 delete('XscriptImport.vim')
3371 unlet g:guard
3372enddef
3373
Bram Moolenaar585fea72020-04-02 22:33:21 +02003374" Keep this last, it messes up highlighting.
3375def Test_substitute_cmd()
3376 new
3377 setline(1, 'something')
3378 :substitute(some(other(
3379 assert_equal('otherthing', getline(1))
3380 bwipe!
3381
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02003382 # also when the context is Vim9 script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003383 var lines =<< trim END
Bram Moolenaar585fea72020-04-02 22:33:21 +02003384 vim9script
3385 new
3386 setline(1, 'something')
3387 :substitute(some(other(
3388 assert_equal('otherthing', getline(1))
3389 bwipe!
3390 END
3391 writefile(lines, 'Xvim9lines')
3392 source Xvim9lines
3393
3394 delete('Xvim9lines')
3395enddef
3396
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003397" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker