blob: 3fbf1bc32fd3905245ab81a67c1a05d6fd566ba1 [file] [log] [blame]
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001" Test various aspects of the Vim9 script language.
2
Bram Moolenaar673660a2020-01-26 16:50:05 +01003source check.vim
Bram Moolenaar101f4812020-06-16 23:18:51 +02004source term_util.vim
Bram Moolenaarad39c092020-02-26 18:23:43 +01005source view_util.vim
Bram Moolenaarcfe435d2020-04-25 20:02:55 +02006source vim9.vim
Bram Moolenaare3d46852020-08-29 13:39:17 +02007source shared.vim
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008
Bram Moolenaar5d72ce62020-08-20 23:04:06 +02009def Test_range_only()
10 new
11 setline(1, ['blah', 'Blah'])
12 :/Blah/
13 assert_equal(2, getcurpos()[1])
Bram Moolenaarc2af0af2020-08-23 21:06:02 +020014 bwipe!
15
16 # without range commands use current line
17 new
18 setline(1, ['one', 'two', 'three'])
19 :2
20 print
21 assert_equal('two', Screenline(&lines))
22 :3
23 list
24 assert_equal('three$', Screenline(&lines))
25 bwipe!
Bram Moolenaar025cb1c2020-12-14 18:31:27 +010026
27 # won't generate anything
28 if false
29 :123
30 endif
Bram Moolenaar5d72ce62020-08-20 23:04:06 +020031enddef
32
Bram Moolenaara6e67e42020-05-15 23:36:40 +020033let g:alist = [7]
34let g:astring = 'text'
Bram Moolenaarf0b9f432020-07-17 23:03:17 +020035let g:anumber = 123
Bram Moolenaar6e587dc2020-02-06 13:15:52 +010036
Bram Moolenaar4c17ad92020-04-27 22:47:51 +020037def Test_delfunction()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +020038 # Check function is defined in script namespace
Bram Moolenaar4c17ad92020-04-27 22:47:51 +020039 CheckScriptSuccess([
40 'vim9script',
41 'func CheckMe()',
42 ' return 123',
43 'endfunc',
44 'assert_equal(123, s:CheckMe())',
45 ])
46
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +020047 # Check function in script namespace cannot be deleted
Bram Moolenaar4c17ad92020-04-27 22:47:51 +020048 CheckScriptFailure([
49 'vim9script',
50 'func DeleteMe1()',
51 'endfunc',
52 'delfunction DeleteMe1',
53 ], 'E1084:')
54 CheckScriptFailure([
55 'vim9script',
56 'func DeleteMe2()',
57 'endfunc',
58 'def DoThat()',
59 ' delfunction DeleteMe2',
60 'enddef',
61 'DoThat()',
62 ], 'E1084:')
63 CheckScriptFailure([
64 'vim9script',
65 'def DeleteMe3()',
66 'enddef',
67 'delfunction DeleteMe3',
68 ], 'E1084:')
69 CheckScriptFailure([
70 'vim9script',
71 'def DeleteMe4()',
72 'enddef',
73 'def DoThat()',
74 ' delfunction DeleteMe4',
75 'enddef',
76 'DoThat()',
77 ], 'E1084:')
Bram Moolenaar925e9fd2020-07-25 15:41:11 +020078
79 # Check that global :def function can be replaced and deleted
Bram Moolenaarcfcd0112020-09-27 15:19:27 +020080 var lines =<< trim END
Bram Moolenaar925e9fd2020-07-25 15:41:11 +020081 vim9script
82 def g:Global(): string
83 return "yes"
84 enddef
85 assert_equal("yes", g:Global())
86 def! g:Global(): string
87 return "no"
88 enddef
89 assert_equal("no", g:Global())
90 delfunc g:Global
91 assert_false(exists('*g:Global'))
92 END
93 CheckScriptSuccess(lines)
94
95 # Check that global function can be replaced by a :def function and deleted
96 lines =<< trim END
97 vim9script
98 func g:Global()
99 return "yes"
100 endfunc
101 assert_equal("yes", g:Global())
102 def! g:Global(): string
103 return "no"
104 enddef
105 assert_equal("no", g:Global())
106 delfunc g:Global
107 assert_false(exists('*g:Global'))
108 END
109 CheckScriptSuccess(lines)
110
111 # Check that global :def function can be replaced by a function and deleted
112 lines =<< trim END
113 vim9script
114 def g:Global(): string
115 return "yes"
116 enddef
117 assert_equal("yes", g:Global())
118 func! g:Global()
119 return "no"
120 endfunc
121 assert_equal("no", g:Global())
122 delfunc g:Global
123 assert_false(exists('*g:Global'))
124 END
125 CheckScriptSuccess(lines)
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200126enddef
127
Bram Moolenaar08052222020-09-14 17:04:31 +0200128def Test_wrong_type()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200129 CheckDefFailure(['var name: list<nothing>'], 'E1010:')
130 CheckDefFailure(['var name: list<list<nothing>>'], 'E1010:')
131 CheckDefFailure(['var name: dict<nothing>'], 'E1010:')
132 CheckDefFailure(['var name: dict<dict<nothing>>'], 'E1010:')
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100133
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200134 CheckDefFailure(['var name: dict<number'], 'E1009:')
135 CheckDefFailure(['var name: dict<list<number>'], 'E1009:')
Bram Moolenaar42a480b2020-02-29 23:23:47 +0100136
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200137 CheckDefFailure(['var name: ally'], 'E1010:')
138 CheckDefFailure(['var name: bram'], 'E1010:')
139 CheckDefFailure(['var name: cathy'], 'E1010:')
140 CheckDefFailure(['var name: dom'], 'E1010:')
141 CheckDefFailure(['var name: freddy'], 'E1010:')
142 CheckDefFailure(['var name: john'], 'E1010:')
143 CheckDefFailure(['var name: larry'], 'E1010:')
144 CheckDefFailure(['var name: ned'], 'E1010:')
145 CheckDefFailure(['var name: pam'], 'E1010:')
146 CheckDefFailure(['var name: sam'], 'E1010:')
147 CheckDefFailure(['var name: vim'], 'E1010:')
Bram Moolenaara0a9f432020-04-28 21:29:34 +0200148
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200149 CheckDefFailure(['var Ref: number', 'Ref()'], 'E1085:')
150 CheckDefFailure(['var Ref: string', 'var res = Ref()'], 'E1085:')
Bram Moolenaar08052222020-09-14 17:04:31 +0200151enddef
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100152
Bram Moolenaar10c65862020-10-08 21:16:42 +0200153def Test_script_wrong_type()
154 var lines =<< trim END
155 vim9script
156 var s:dict: dict<string>
157 s:dict['a'] = ['x']
158 END
159 CheckScriptFailure(lines, 'E1012: Type mismatch; expected string but got list<string>', 3)
160enddef
161
Bram Moolenaar08052222020-09-14 17:04:31 +0200162def Test_const()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200163 CheckDefFailure(['final name = 234', 'name = 99'], 'E1018:')
164 CheckDefFailure(['final one = 234', 'var one = 99'], 'E1017:')
165 CheckDefFailure(['final list = [1, 2]', 'var list = [3, 4]'], 'E1017:')
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200166 CheckDefFailure(['final two'], 'E1125:')
167 CheckDefFailure(['final &option'], 'E996:')
Bram Moolenaardbeecb22020-09-14 18:15:09 +0200168
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200169 var lines =<< trim END
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200170 final list = [1, 2, 3]
Bram Moolenaardbeecb22020-09-14 18:15:09 +0200171 list[0] = 4
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200172 list->assert_equal([4, 2, 3])
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200173 const other = [5, 6, 7]
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200174 other->assert_equal([5, 6, 7])
Bram Moolenaar71abe482020-09-14 22:28:30 +0200175
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200176 var varlist = [7, 8]
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200177 const constlist = [1, varlist, 3]
Bram Moolenaar71abe482020-09-14 22:28:30 +0200178 varlist[0] = 77
179 # TODO: does not work yet
180 # constlist[1][1] = 88
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200181 var cl = constlist[1]
Bram Moolenaar71abe482020-09-14 22:28:30 +0200182 cl[1] = 88
183 constlist->assert_equal([1, [77, 88], 3])
184
Bram Moolenaare0de1712020-12-02 17:36:54 +0100185 var vardict = {five: 5, six: 6}
186 const constdict = {one: 1, two: vardict, three: 3}
Bram Moolenaar71abe482020-09-14 22:28:30 +0200187 vardict['five'] = 55
188 # TODO: does not work yet
189 # constdict['two']['six'] = 66
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200190 var cd = constdict['two']
Bram Moolenaar71abe482020-09-14 22:28:30 +0200191 cd['six'] = 66
Bram Moolenaare0de1712020-12-02 17:36:54 +0100192 constdict->assert_equal({one: 1, two: {five: 55, six: 66}, three: 3})
Bram Moolenaardbeecb22020-09-14 18:15:09 +0200193 END
194 CheckDefAndScriptSuccess(lines)
Bram Moolenaar08052222020-09-14 17:04:31 +0200195enddef
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100196
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200197def Test_const_bang()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200198 var lines =<< trim END
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200199 const var = 234
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200200 var = 99
201 END
202 CheckDefExecFailure(lines, 'E1018:', 2)
203 CheckScriptFailure(['vim9script'] + lines, 'E46:', 3)
204
205 lines =<< trim END
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200206 const ll = [2, 3, 4]
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200207 ll[0] = 99
208 END
209 CheckDefExecFailure(lines, 'E1119:', 2)
210 CheckScriptFailure(['vim9script'] + lines, 'E741:', 3)
211
212 lines =<< trim END
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200213 const ll = [2, 3, 4]
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200214 ll[3] = 99
215 END
216 CheckDefExecFailure(lines, 'E1118:', 2)
217 CheckScriptFailure(['vim9script'] + lines, 'E684:', 3)
218
219 lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +0100220 const dd = {one: 1, two: 2}
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200221 dd["one"] = 99
222 END
223 CheckDefExecFailure(lines, 'E1121:', 2)
224 CheckScriptFailure(['vim9script'] + lines, 'E741:', 3)
225
226 lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +0100227 const dd = {one: 1, two: 2}
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200228 dd["three"] = 99
229 END
230 CheckDefExecFailure(lines, 'E1120:')
231 CheckScriptFailure(['vim9script'] + lines, 'E741:', 3)
232enddef
233
Bram Moolenaardf069ee2020-06-22 23:02:51 +0200234def Test_range_no_colon()
Bram Moolenaard2c61702020-09-06 15:58:36 +0200235 CheckDefFailure(['%s/a/b/'], 'E1050:')
236 CheckDefFailure(['+ s/a/b/'], 'E1050:')
237 CheckDefFailure(['- s/a/b/'], 'E1050:')
238 CheckDefFailure(['. s/a/b/'], 'E1050:')
Bram Moolenaardf069ee2020-06-22 23:02:51 +0200239enddef
240
241
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100242def Test_block()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200243 var outer = 1
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100244 {
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200245 var inner = 2
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100246 assert_equal(1, outer)
247 assert_equal(2, inner)
248 }
249 assert_equal(1, outer)
250enddef
251
Bram Moolenaar08052222020-09-14 17:04:31 +0200252def Test_block_failure()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200253 CheckDefFailure(['{', 'var inner = 1', '}', 'echo inner'], 'E1001:')
Bram Moolenaar08052222020-09-14 17:04:31 +0200254 CheckDefFailure(['}'], 'E1025:')
255 CheckDefFailure(['{', 'echo 1'], 'E1026:')
256enddef
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100257
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200258def Test_block_local_vars()
259 var lines =<< trim END
260 vim9script
Bram Moolenaared234f22020-10-15 20:42:20 +0200261 v:testing = 1
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200262 if true
Bram Moolenaared234f22020-10-15 20:42:20 +0200263 var text = ['hello']
264 def SayHello(): list<string>
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200265 return text
266 enddef
267 def SetText(v: string)
Bram Moolenaared234f22020-10-15 20:42:20 +0200268 text = [v]
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200269 enddef
270 endif
271
272 if true
Bram Moolenaared234f22020-10-15 20:42:20 +0200273 var text = ['again']
274 def SayAgain(): list<string>
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200275 return text
276 enddef
277 endif
Bram Moolenaared234f22020-10-15 20:42:20 +0200278
279 # test that the "text" variables are not cleaned up
280 test_garbagecollect_now()
281
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200282 defcompile
283
Bram Moolenaared234f22020-10-15 20:42:20 +0200284 assert_equal(['hello'], SayHello())
285 assert_equal(['again'], SayAgain())
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200286
287 SetText('foobar')
Bram Moolenaared234f22020-10-15 20:42:20 +0200288 assert_equal(['foobar'], SayHello())
289
290 call writefile(['ok'], 'Xdidit')
291 qall!
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200292 END
Bram Moolenaared234f22020-10-15 20:42:20 +0200293
294 # need to execute this with a separate Vim instance to avoid the current
295 # context gets garbage collected.
296 writefile(lines, 'Xscript')
297 RunVim([], [], '-S Xscript')
298 assert_equal(['ok'], readfile('Xdidit'))
299
300 delete('Xscript')
301 delete('Xdidit')
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200302enddef
303
Bram Moolenaar39ca4122020-10-20 14:25:07 +0200304def Test_block_local_vars_with_func()
305 var lines =<< trim END
306 vim9script
307 if true
308 var foo = 'foo'
309 if true
310 var bar = 'bar'
311 def Func(): list<string>
312 return [foo, bar]
313 enddef
314 endif
315 endif
316 # function is compiled here, after blocks have finished, can still access
317 # "foo" and "bar"
318 assert_equal(['foo', 'bar'], Func())
319 END
320 CheckScriptSuccess(lines)
321enddef
322
Bram Moolenaard032f342020-07-18 18:13:02 +0200323func g:NoSuchFunc()
324 echo 'none'
325endfunc
326
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100327def Test_try_catch()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200328 var l = []
Bram Moolenaar7a092242020-04-16 22:10:49 +0200329 try # comment
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100330 add(l, '1')
331 throw 'wrong'
332 add(l, '2')
Bram Moolenaar7a092242020-04-16 22:10:49 +0200333 catch # comment
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100334 add(l, v:exception)
Bram Moolenaar7a092242020-04-16 22:10:49 +0200335 finally # comment
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100336 add(l, '3')
Bram Moolenaar7a092242020-04-16 22:10:49 +0200337 endtry # comment
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100338 assert_equal(['1', 'wrong', '3'], l)
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200339
Bram Moolenaare8593122020-07-18 15:17:02 +0200340 l = []
341 try
342 try
343 add(l, '1')
344 throw 'wrong'
345 add(l, '2')
346 catch /right/
347 add(l, v:exception)
348 endtry
349 catch /wrong/
350 add(l, 'caught')
Bram Moolenaar373863e2020-09-26 17:20:53 +0200351 fina
Bram Moolenaare8593122020-07-18 15:17:02 +0200352 add(l, 'finally')
353 endtry
354 assert_equal(['1', 'caught', 'finally'], l)
355
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200356 var n: number
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200357 try
358 n = l[3]
359 catch /E684:/
360 n = 99
361 endtry
362 assert_equal(99, n)
363
364 try
Bram Moolenaarcc673e72020-08-16 17:33:35 +0200365 # string slice returns a string, not a number
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200366 n = g:astring[3]
Bram Moolenaar5e654232020-09-16 15:22:00 +0200367 catch /E1012:/
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200368 n = 77
369 endtry
370 assert_equal(77, n)
371
372 try
373 n = l[g:astring]
Bram Moolenaar5e654232020-09-16 15:22:00 +0200374 catch /E1012:/
Bram Moolenaar56acb092020-08-16 14:48:19 +0200375 n = 88
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200376 endtry
Bram Moolenaar56acb092020-08-16 14:48:19 +0200377 assert_equal(88, n)
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200378
379 try
380 n = s:does_not_exist
381 catch /E121:/
Bram Moolenaarf0b9f432020-07-17 23:03:17 +0200382 n = 111
383 endtry
384 assert_equal(111, n)
385
386 try
387 n = g:does_not_exist
388 catch /E121:/
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200389 n = 121
390 endtry
391 assert_equal(121, n)
392
Bram Moolenaare0de1712020-12-02 17:36:54 +0100393 var d = {one: 1}
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200394 try
395 n = d[g:astring]
396 catch /E716:/
397 n = 222
398 endtry
399 assert_equal(222, n)
Bram Moolenaarf0b9f432020-07-17 23:03:17 +0200400
401 try
402 n = -g:astring
403 catch /E39:/
404 n = 233
405 endtry
406 assert_equal(233, n)
407
408 try
409 n = +g:astring
410 catch /E1030:/
411 n = 244
412 endtry
413 assert_equal(244, n)
414
415 try
416 n = +g:alist
417 catch /E745:/
418 n = 255
419 endtry
420 assert_equal(255, n)
421
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200422 var nd: dict<any>
Bram Moolenaarf0b9f432020-07-17 23:03:17 +0200423 try
Bram Moolenaar2bede172020-11-19 18:53:18 +0100424 nd = {[g:anumber]: 1}
Bram Moolenaar5e654232020-09-16 15:22:00 +0200425 catch /E1012:/
Bram Moolenaarf0b9f432020-07-17 23:03:17 +0200426 n = 266
427 endtry
428 assert_equal(266, n)
429
430 try
431 [n] = [1, 2, 3]
432 catch /E1093:/
433 n = 277
434 endtry
435 assert_equal(277, n)
436
Bram Moolenaare8593122020-07-18 15:17:02 +0200437 try
438 &ts = g:astring
Bram Moolenaar5e654232020-09-16 15:22:00 +0200439 catch /E1012:/
Bram Moolenaare8593122020-07-18 15:17:02 +0200440 n = 288
441 endtry
442 assert_equal(288, n)
443
444 try
445 &backspace = 'asdf'
446 catch /E474:/
447 n = 299
448 endtry
449 assert_equal(299, n)
450
451 l = [1]
452 try
453 l[3] = 3
454 catch /E684:/
455 n = 300
456 endtry
457 assert_equal(300, n)
458
459 try
Bram Moolenaare8593122020-07-18 15:17:02 +0200460 unlet g:does_not_exist
461 catch /E108:/
462 n = 322
463 endtry
464 assert_equal(322, n)
465
466 try
Bram Moolenaar2bede172020-11-19 18:53:18 +0100467 d = {text: 1, [g:astring]: 2}
Bram Moolenaare8593122020-07-18 15:17:02 +0200468 catch /E721:/
469 n = 333
470 endtry
471 assert_equal(333, n)
472
473 try
474 l = DeletedFunc()
475 catch /E933:/
476 n = 344
477 endtry
478 assert_equal(344, n)
Bram Moolenaard032f342020-07-18 18:13:02 +0200479
480 try
481 echo len(v:true)
482 catch /E701:/
483 n = 355
484 endtry
485 assert_equal(355, n)
486
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200487 var P = function('g:NoSuchFunc')
Bram Moolenaard032f342020-07-18 18:13:02 +0200488 delfunc g:NoSuchFunc
489 try
490 echo P()
491 catch /E117:/
492 n = 366
493 endtry
494 assert_equal(366, n)
495
496 try
497 echo g:NoSuchFunc()
498 catch /E117:/
499 n = 377
500 endtry
501 assert_equal(377, n)
502
503 try
504 echo g:alist + 4
505 catch /E745:/
506 n = 388
507 endtry
508 assert_equal(388, n)
509
510 try
511 echo 4 + g:alist
512 catch /E745:/
513 n = 399
514 endtry
515 assert_equal(399, n)
516
517 try
518 echo g:alist.member
519 catch /E715:/
520 n = 400
521 endtry
522 assert_equal(400, n)
523
524 try
525 echo d.member
526 catch /E716:/
527 n = 411
528 endtry
529 assert_equal(411, n)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100530enddef
531
Bram Moolenaare8593122020-07-18 15:17:02 +0200532def DeletedFunc(): list<any>
533 return ['delete me']
534enddef
535defcompile
536delfunc DeletedFunc
537
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100538def ThrowFromDef()
Bram Moolenaara72cfb82020-04-23 17:07:30 +0200539 throw "getout" # comment
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100540enddef
541
542func CatchInFunc()
543 try
544 call ThrowFromDef()
545 catch
546 let g:thrown_func = v:exception
547 endtry
548endfunc
549
550def CatchInDef()
551 try
552 ThrowFromDef()
553 catch
554 g:thrown_def = v:exception
555 endtry
556enddef
557
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100558def ReturnFinally(): string
559 try
560 return 'intry'
Bram Moolenaar373863e2020-09-26 17:20:53 +0200561 finall
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100562 g:in_finally = 'finally'
563 endtry
564 return 'end'
565enddef
566
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100567def Test_try_catch_nested()
568 CatchInFunc()
569 assert_equal('getout', g:thrown_func)
570
571 CatchInDef()
572 assert_equal('getout', g:thrown_def)
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100573
574 assert_equal('intry', ReturnFinally())
575 assert_equal('finally', g:in_finally)
576enddef
577
Bram Moolenaar9939f572020-09-16 22:29:52 +0200578def TryOne(): number
579 try
580 return 0
581 catch
582 endtry
583 return 0
584enddef
585
586def TryTwo(n: number): string
587 try
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200588 var x = {}
Bram Moolenaar9939f572020-09-16 22:29:52 +0200589 catch
590 endtry
591 return 'text'
592enddef
593
594def Test_try_catch_twice()
595 assert_equal('text', TryOne()->TryTwo())
596enddef
597
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100598def Test_try_catch_match()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200599 var seq = 'a'
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100600 try
601 throw 'something'
602 catch /nothing/
603 seq ..= 'x'
604 catch /some/
605 seq ..= 'b'
606 catch /asdf/
607 seq ..= 'x'
Bram Moolenaare8c4abb2020-04-02 21:13:25 +0200608 catch ?a\?sdf?
609 seq ..= 'y'
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100610 finally
611 seq ..= 'c'
612 endtry
613 assert_equal('abc', seq)
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100614enddef
615
Bram Moolenaare8c4abb2020-04-02 21:13:25 +0200616def Test_try_catch_fails()
Bram Moolenaard2c61702020-09-06 15:58:36 +0200617 CheckDefFailure(['catch'], 'E603:')
618 CheckDefFailure(['try', 'echo 0', 'catch', 'catch'], 'E1033:')
619 CheckDefFailure(['try', 'echo 0', 'catch /pat'], 'E1067:')
620 CheckDefFailure(['finally'], 'E606:')
621 CheckDefFailure(['try', 'echo 0', 'finally', 'echo 1', 'finally'], 'E607:')
622 CheckDefFailure(['endtry'], 'E602:')
623 CheckDefFailure(['while 1', 'endtry'], 'E170:')
624 CheckDefFailure(['for i in range(5)', 'endtry'], 'E170:')
Bram Moolenaar13106602020-10-04 16:06:05 +0200625 CheckDefFailure(['if 1', 'endtry'], 'E171:')
Bram Moolenaard2c61702020-09-06 15:58:36 +0200626 CheckDefFailure(['try', 'echo 1', 'endtry'], 'E1032:')
Bram Moolenaar585fea72020-04-02 22:33:21 +0200627
Bram Moolenaare4984292020-12-13 14:19:25 +0100628 CheckDefFailure(['throw'], 'E1143:')
Bram Moolenaard2c61702020-09-06 15:58:36 +0200629 CheckDefFailure(['throw xxx'], 'E1001:')
Bram Moolenaare8c4abb2020-04-02 21:13:25 +0200630enddef
631
Bram Moolenaar006ad482020-06-30 20:55:15 +0200632def Test_throw_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200633 # only checks line continuation
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200634 var lines =<< trim END
Bram Moolenaar006ad482020-06-30 20:55:15 +0200635 vim9script
636 try
637 throw 'one'
638 .. 'two'
639 catch
640 assert_equal('onetwo', v:exception)
641 endtry
642 END
643 CheckScriptSuccess(lines)
Bram Moolenaar1e021e62020-10-16 20:25:23 +0200644
645 lines =<< trim END
646 vim9script
Bram Moolenaar352134b2020-10-17 22:04:08 +0200647 @r = ''
Bram Moolenaar1e021e62020-10-16 20:25:23 +0200648 def Func()
649 throw @r
650 enddef
651 var result = ''
652 try
653 Func()
654 catch /E1129:/
655 result = 'caught'
656 endtry
657 assert_equal('caught', result)
658 END
659 CheckScriptSuccess(lines)
Bram Moolenaar006ad482020-06-30 20:55:15 +0200660enddef
661
Bram Moolenaared677f52020-08-12 16:38:10 +0200662def Test_error_in_nested_function()
663 # an error in a nested :function aborts executin in the calling :def function
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200664 var lines =<< trim END
Bram Moolenaared677f52020-08-12 16:38:10 +0200665 vim9script
666 def Func()
667 Error()
668 g:test_var = 1
669 enddef
670 func Error() abort
671 eval [][0]
672 endfunc
673 Func()
674 END
675 g:test_var = 0
676 CheckScriptFailure(lines, 'E684:')
677 assert_equal(0, g:test_var)
678enddef
679
Bram Moolenaar37c83712020-06-30 21:18:36 +0200680def Test_cexpr_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200681 # only checks line continuation
Bram Moolenaar37c83712020-06-30 21:18:36 +0200682 set errorformat=File\ %f\ line\ %l
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200683 var lines =<< trim END
Bram Moolenaar37c83712020-06-30 21:18:36 +0200684 vim9script
685 cexpr 'File'
686 .. ' someFile' ..
687 ' line 19'
688 assert_equal(19, getqflist()[0].lnum)
689 END
690 CheckScriptSuccess(lines)
691 set errorformat&
692enddef
693
Bram Moolenaarc9edd6b2020-08-12 22:18:23 +0200694def Test_statusline_syntax()
695 # legacy syntax is used for 'statusline'
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200696 var lines =<< trim END
Bram Moolenaarc9edd6b2020-08-12 22:18:23 +0200697 vim9script
698 func g:Status()
699 return '%{"x" is# "x"}'
700 endfunc
701 set laststatus=2 statusline=%!Status()
702 redrawstatus
703 set laststatus statusline=
704 END
705 CheckScriptSuccess(lines)
706enddef
707
Bram Moolenaarb2097502020-07-19 17:17:02 +0200708def Test_list_vimscript()
709 # checks line continuation and comments
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200710 var lines =<< trim END
Bram Moolenaarb2097502020-07-19 17:17:02 +0200711 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200712 var mylist = [
Bram Moolenaarb2097502020-07-19 17:17:02 +0200713 'one',
714 # comment
715 'two', # empty line follows
716
717 'three',
718 ]
719 assert_equal(['one', 'two', 'three'], mylist)
720 END
721 CheckScriptSuccess(lines)
Bram Moolenaar66250c92020-08-20 15:02:42 +0200722
723 # check all lines from heredoc are kept
724 lines =<< trim END
725 # comment 1
726 two
727 # comment 3
728
729 five
730 # comment 6
731 END
732 assert_equal(['# comment 1', 'two', '# comment 3', '', 'five', '# comment 6'], lines)
Bram Moolenaarb2097502020-07-19 17:17:02 +0200733enddef
734
Bram Moolenaar2a1381c2020-05-05 23:32:58 +0200735if has('channel')
736 let someJob = test_null_job()
Bram Moolenaar40ee4662020-05-05 22:08:26 +0200737
Bram Moolenaar2a1381c2020-05-05 23:32:58 +0200738 def FuncWithError()
739 echomsg g:someJob
740 enddef
Bram Moolenaar40ee4662020-05-05 22:08:26 +0200741
Bram Moolenaar2a1381c2020-05-05 23:32:58 +0200742 func Test_convert_emsg_to_exception()
743 try
744 call FuncWithError()
745 catch
746 call assert_match('Vim:E908:', v:exception)
747 endtry
748 endfunc
749endif
Bram Moolenaar40ee4662020-05-05 22:08:26 +0200750
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100751let s:export_script_lines =<< trim END
752 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200753 var name: string = 'bob'
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100754 def Concat(arg: string): string
755 return name .. arg
756 enddef
Bram Moolenaar227a69d2020-05-15 18:17:28 +0200757 g:result = Concat('bie')
758 g:localname = name
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100759
760 export const CONST = 1234
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200761 export var exported = 9876
762 export var exp_name = 'John'
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100763 export def Exported(): string
764 return 'Exported'
765 enddef
766END
767
Bram Moolenaarb3ca9822020-08-09 14:43:58 +0200768def Undo_export_script_lines()
769 unlet g:result
770 unlet g:localname
771enddef
772
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100773def Test_vim9_import_export()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200774 var import_script_lines =<< trim END
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100775 vim9script
776 import {exported, Exported} from './Xexport.vim'
777 g:imported = exported
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100778 exported += 3
779 g:imported_added = exported
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100780 g:imported_func = Exported()
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100781
Bram Moolenaar40f4f7a2020-07-23 22:41:43 +0200782 def GetExported(): string
Bram Moolenaare0de1712020-12-02 17:36:54 +0100783 var local_dict = {ref: Exported}
Bram Moolenaar40f4f7a2020-07-23 22:41:43 +0200784 return local_dict.ref()
785 enddef
786 g:funcref_result = GetExported()
787
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100788 import {exp_name} from './Xexport.vim'
789 g:imported_name = exp_name
790 exp_name ..= ' Doe'
791 g:imported_name_appended = exp_name
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100792 g:imported_later = exported
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100793 END
794
795 writefile(import_script_lines, 'Ximport.vim')
796 writefile(s:export_script_lines, 'Xexport.vim')
797
798 source Ximport.vim
799
800 assert_equal('bobbie', g:result)
801 assert_equal('bob', g:localname)
802 assert_equal(9876, g:imported)
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100803 assert_equal(9879, g:imported_added)
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100804 assert_equal(9879, g:imported_later)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100805 assert_equal('Exported', g:imported_func)
Bram Moolenaar40f4f7a2020-07-23 22:41:43 +0200806 assert_equal('Exported', g:funcref_result)
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100807 assert_equal('John', g:imported_name)
808 assert_equal('John Doe', g:imported_name_appended)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100809 assert_false(exists('g:name'))
810
Bram Moolenaarb3ca9822020-08-09 14:43:58 +0200811 Undo_export_script_lines()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100812 unlet g:imported
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100813 unlet g:imported_added
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100814 unlet g:imported_later
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100815 unlet g:imported_func
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100816 unlet g:imported_name g:imported_name_appended
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100817 delete('Ximport.vim')
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100818
Bram Moolenaar1c991142020-07-04 13:15:31 +0200819 # similar, with line breaks
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200820 var import_line_break_script_lines =<< trim END
Bram Moolenaar1c991142020-07-04 13:15:31 +0200821 vim9script
822 import {
823 exported,
824 Exported,
825 }
826 from
827 './Xexport.vim'
828 g:imported = exported
829 exported += 5
830 g:imported_added = exported
831 g:imported_func = Exported()
832 END
833 writefile(import_line_break_script_lines, 'Ximport_lbr.vim')
834 source Ximport_lbr.vim
835
836 assert_equal(9876, g:imported)
837 assert_equal(9881, g:imported_added)
838 assert_equal('Exported', g:imported_func)
839
840 # exported script not sourced again
841 assert_false(exists('g:result'))
842 unlet g:imported
843 unlet g:imported_added
844 unlet g:imported_func
845 delete('Ximport_lbr.vim')
846
847 # import inside :def function
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200848 var import_in_def_lines =<< trim END
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100849 vim9script
850 def ImportInDef()
851 import exported from './Xexport.vim'
852 g:imported = exported
853 exported += 7
854 g:imported_added = exported
855 enddef
856 ImportInDef()
857 END
858 writefile(import_in_def_lines, 'Ximport2.vim')
859 source Ximport2.vim
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200860 # TODO: this should be 9879
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100861 assert_equal(9876, g:imported)
862 assert_equal(9883, g:imported_added)
863 unlet g:imported
864 unlet g:imported_added
865 delete('Ximport2.vim')
866
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200867 var import_star_as_lines =<< trim END
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100868 vim9script
869 import * as Export from './Xexport.vim'
870 def UseExport()
871 g:imported = Export.exported
872 enddef
873 UseExport()
874 END
875 writefile(import_star_as_lines, 'Ximport.vim')
876 source Ximport.vim
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100877 assert_equal(9883, g:imported)
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100878
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200879 var import_star_as_lines_no_dot =<< trim END
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100880 vim9script
881 import * as Export from './Xexport.vim'
882 def Func()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200883 var dummy = 1
884 var imported = Export + dummy
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100885 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +0200886 defcompile
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100887 END
888 writefile(import_star_as_lines_no_dot, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +0200889 assert_fails('source Ximport.vim', 'E1060:', '', 2, 'Func')
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100890
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200891 var import_star_as_lines_dot_space =<< trim END
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100892 vim9script
893 import * as Export from './Xexport.vim'
894 def Func()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200895 var imported = Export . exported
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100896 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +0200897 defcompile
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100898 END
899 writefile(import_star_as_lines_dot_space, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +0200900 assert_fails('source Ximport.vim', 'E1074:', '', 1, 'Func')
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100901
Bram Moolenaara6294952020-12-27 13:39:50 +0100902 var import_star_as_duplicated =<< trim END
903 vim9script
904 import * as Export from './Xexport.vim'
905 var some = 'other'
906 import * as Export from './Xexport.vim'
907 defcompile
908 END
909 writefile(import_star_as_duplicated, 'Ximport.vim')
910 assert_fails('source Ximport.vim', 'E1073:', '', 4, 'Ximport.vim')
911
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200912 var import_star_as_lines_missing_name =<< trim END
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100913 vim9script
914 import * as Export from './Xexport.vim'
915 def Func()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200916 var imported = Export.
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100917 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +0200918 defcompile
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100919 END
920 writefile(import_star_as_lines_missing_name, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +0200921 assert_fails('source Ximport.vim', 'E1048:', '', 1, 'Func')
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100922
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200923 var import_star_as_lbr_lines =<< trim END
Bram Moolenaar1c991142020-07-04 13:15:31 +0200924 vim9script
925 import *
926 as Export
927 from
928 './Xexport.vim'
929 def UseExport()
930 g:imported = Export.exported
931 enddef
932 UseExport()
933 END
934 writefile(import_star_as_lbr_lines, 'Ximport.vim')
935 source Ximport.vim
936 assert_equal(9883, g:imported)
937
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200938 var import_star_lines =<< trim END
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100939 vim9script
940 import * from './Xexport.vim'
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100941 END
942 writefile(import_star_lines, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +0200943 assert_fails('source Ximport.vim', 'E1045:', '', 2, 'Ximport.vim')
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100944
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200945 # try to import something that exists but is not exported
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200946 var import_not_exported_lines =<< trim END
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +0100947 vim9script
948 import name from './Xexport.vim'
949 END
950 writefile(import_not_exported_lines, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +0200951 assert_fails('source Ximport.vim', 'E1049:', '', 2, 'Ximport.vim')
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +0100952
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200953 # try to import something that is already defined
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200954 var import_already_defined =<< trim END
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100955 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200956 var exported = 'something'
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100957 import exported from './Xexport.vim'
958 END
959 writefile(import_already_defined, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +0200960 assert_fails('source Ximport.vim', 'E1073:', '', 3, 'Ximport.vim')
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100961
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200962 # try to import something that is already defined
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100963 import_already_defined =<< trim END
964 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200965 var exported = 'something'
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100966 import * as exported from './Xexport.vim'
967 END
968 writefile(import_already_defined, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +0200969 assert_fails('source Ximport.vim', 'E1073:', '', 3, 'Ximport.vim')
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100970
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200971 # try to import something that is already defined
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100972 import_already_defined =<< trim END
973 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200974 var exported = 'something'
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100975 import {exported} from './Xexport.vim'
976 END
977 writefile(import_already_defined, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +0200978 assert_fails('source Ximport.vim', 'E1073:', '', 3, 'Ximport.vim')
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100979
Bram Moolenaar918a4242020-12-06 14:37:08 +0100980 # try changing an imported const
981 var import_assign_to_const =<< trim END
982 vim9script
983 import CONST from './Xexport.vim'
984 def Assign()
985 CONST = 987
986 enddef
987 defcompile
988 END
989 writefile(import_assign_to_const, 'Ximport.vim')
990 assert_fails('source Ximport.vim', 'E46:', '', 1, '_Assign')
991
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200992 # import a very long name, requires making a copy
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200993 var import_long_name_lines =<< trim END
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +0100994 vim9script
995 import name012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789 from './Xexport.vim'
996 END
997 writefile(import_long_name_lines, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +0200998 assert_fails('source Ximport.vim', 'E1048:', '', 2, 'Ximport.vim')
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +0100999
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001000 var import_no_from_lines =<< trim END
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001001 vim9script
1002 import name './Xexport.vim'
1003 END
1004 writefile(import_no_from_lines, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001005 assert_fails('source Ximport.vim', 'E1070:', '', 2, 'Ximport.vim')
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001006
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001007 var import_invalid_string_lines =<< trim END
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001008 vim9script
1009 import name from Xexport.vim
1010 END
1011 writefile(import_invalid_string_lines, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001012 assert_fails('source Ximport.vim', 'E1071:', '', 2, 'Ximport.vim')
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001013
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001014 var import_wrong_name_lines =<< trim END
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001015 vim9script
1016 import name from './XnoExport.vim'
1017 END
1018 writefile(import_wrong_name_lines, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001019 assert_fails('source Ximport.vim', 'E1053:', '', 2, 'Ximport.vim')
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001020
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001021 var import_missing_comma_lines =<< trim END
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001022 vim9script
1023 import {exported name} from './Xexport.vim'
1024 END
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001025 writefile(import_missing_comma_lines, 'Ximport3.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001026 assert_fails('source Ximport3.vim', 'E1046:', '', 2, 'Ximport3.vim')
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001027
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01001028 delete('Ximport.vim')
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001029 delete('Ximport3.vim')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001030 delete('Xexport.vim')
1031
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001032 # Check that in a Vim9 script 'cpo' is set to the Vim default.
Bram Moolenaar750802b2020-02-23 18:08:33 +01001033 set cpo&vi
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001034 var cpo_before = &cpo
1035 var lines =<< trim END
Bram Moolenaar750802b2020-02-23 18:08:33 +01001036 vim9script
1037 g:cpo_in_vim9script = &cpo
1038 END
1039 writefile(lines, 'Xvim9_script')
1040 source Xvim9_script
1041 assert_equal(cpo_before, &cpo)
1042 set cpo&vim
1043 assert_equal(&cpo, g:cpo_in_vim9script)
1044 delete('Xvim9_script')
1045enddef
1046
Bram Moolenaar803af682020-08-05 16:20:03 +02001047func g:Trigger()
1048 source Ximport.vim
1049 return "echo 'yes'\<CR>"
1050endfunc
1051
1052def Test_import_export_expr_map()
1053 # check that :import and :export work when buffer is locked
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001054 var export_lines =<< trim END
Bram Moolenaar803af682020-08-05 16:20:03 +02001055 vim9script
1056 export def That(): string
1057 return 'yes'
1058 enddef
1059 END
1060 writefile(export_lines, 'Xexport_that.vim')
1061
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001062 var import_lines =<< trim END
Bram Moolenaar803af682020-08-05 16:20:03 +02001063 vim9script
1064 import That from './Xexport_that.vim'
1065 assert_equal('yes', That())
1066 END
1067 writefile(import_lines, 'Ximport.vim')
1068
1069 nnoremap <expr> trigger g:Trigger()
1070 feedkeys('trigger', "xt")
1071
Bram Moolenaar730b2482020-08-09 13:02:10 +02001072 delete('Xexport_that.vim')
Bram Moolenaar803af682020-08-05 16:20:03 +02001073 delete('Ximport.vim')
1074 nunmap trigger
1075enddef
1076
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001077def Test_import_in_filetype()
1078 # check that :import works when the buffer is locked
1079 mkdir('ftplugin', 'p')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001080 var export_lines =<< trim END
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001081 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001082 export var That = 'yes'
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001083 END
Bram Moolenaar730b2482020-08-09 13:02:10 +02001084 writefile(export_lines, 'ftplugin/Xexport_ft.vim')
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001085
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001086 var import_lines =<< trim END
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001087 vim9script
Bram Moolenaar730b2482020-08-09 13:02:10 +02001088 import That from './Xexport_ft.vim'
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001089 assert_equal('yes', That)
1090 g:did_load_mytpe = 1
1091 END
1092 writefile(import_lines, 'ftplugin/qf.vim')
1093
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001094 var save_rtp = &rtp
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001095 &rtp = getcwd() .. ',' .. &rtp
1096
1097 filetype plugin on
1098 copen
1099 assert_equal(1, g:did_load_mytpe)
1100
1101 quit!
Bram Moolenaar730b2482020-08-09 13:02:10 +02001102 delete('Xexport_ft.vim')
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001103 delete('ftplugin', 'rf')
1104 &rtp = save_rtp
1105enddef
1106
Bram Moolenaarefa94442020-08-08 22:16:00 +02001107def Test_use_import_in_mapping()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001108 var lines =<< trim END
Bram Moolenaarefa94442020-08-08 22:16:00 +02001109 vim9script
1110 export def Funcx()
1111 g:result = 42
1112 enddef
1113 END
1114 writefile(lines, 'XsomeExport.vim')
1115 lines =<< trim END
1116 vim9script
1117 import Funcx from './XsomeExport.vim'
Bram Moolenaarb3ca9822020-08-09 14:43:58 +02001118 nnoremap <F3> :call <sid>Funcx()<cr>
Bram Moolenaarefa94442020-08-08 22:16:00 +02001119 END
1120 writefile(lines, 'Xmapscript.vim')
1121
1122 source Xmapscript.vim
Bram Moolenaarb3ca9822020-08-09 14:43:58 +02001123 feedkeys("\<F3>", "xt")
Bram Moolenaarefa94442020-08-08 22:16:00 +02001124 assert_equal(42, g:result)
1125
1126 unlet g:result
1127 delete('XsomeExport.vim')
1128 delete('Xmapscript.vim')
Bram Moolenaarb3ca9822020-08-09 14:43:58 +02001129 nunmap <F3>
Bram Moolenaarefa94442020-08-08 22:16:00 +02001130enddef
1131
Bram Moolenaar750802b2020-02-23 18:08:33 +01001132def Test_vim9script_fails()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001133 CheckScriptFailure(['scriptversion 2', 'vim9script'], 'E1039:')
1134 CheckScriptFailure(['vim9script', 'scriptversion 2'], 'E1040:')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001135 CheckScriptFailure(['export var some = 123'], 'E1042:')
Bram Moolenaar9721fb42020-06-11 23:10:46 +02001136 CheckScriptFailure(['import some from "./Xexport.vim"'], 'E1048:')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001137 CheckScriptFailure(['vim9script', 'export var g:some'], 'E1022:')
Bram Moolenaar750802b2020-02-23 18:08:33 +01001138 CheckScriptFailure(['vim9script', 'export echo 134'], 'E1043:')
1139
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001140 CheckScriptFailure(['vim9script', 'var str: string', 'str = 1234'], 'E1012:')
Bram Moolenaarc785b9a2020-06-19 18:34:15 +02001141 CheckScriptFailure(['vim9script', 'const str = "asdf"', 'str = "xxx"'], 'E46:')
1142
Bram Moolenaare2e40752020-09-04 21:18:46 +02001143 assert_fails('vim9script', 'E1038:')
1144 assert_fails('export something', 'E1043:')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001145enddef
1146
Bram Moolenaarf7d267e2020-06-17 12:04:54 +02001147func Test_import_fails_without_script()
Bram Moolenaar101f4812020-06-16 23:18:51 +02001148 CheckRunVimInTerminal
1149
Bram Moolenaar9bb3eb32020-06-17 20:03:36 +02001150 " call indirectly to avoid compilation error for missing functions
Bram Moolenaarc620c052020-07-08 15:16:19 +02001151 call Run_Test_import_fails_on_command_line()
Bram Moolenaar9bb3eb32020-06-17 20:03:36 +02001152endfunc
1153
Bram Moolenaarc620c052020-07-08 15:16:19 +02001154def Run_Test_import_fails_on_command_line()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001155 var export =<< trim END
Bram Moolenaar101f4812020-06-16 23:18:51 +02001156 vim9script
1157 export def Foo(): number
1158 return 0
1159 enddef
1160 END
Bram Moolenaar730b2482020-08-09 13:02:10 +02001161 writefile(export, 'XexportCmd.vim')
Bram Moolenaar101f4812020-06-16 23:18:51 +02001162
Bram Moolenaare0de1712020-12-02 17:36:54 +01001163 var buf = RunVimInTerminal('-c "import Foo from ''./XexportCmd.vim''"', {
Bram Moolenaar9bb3eb32020-06-17 20:03:36 +02001164 rows: 6, wait_for_ruler: 0})
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001165 WaitForAssert(() => assert_match('^E1094:', term_getline(buf, 5)))
Bram Moolenaar101f4812020-06-16 23:18:51 +02001166
Bram Moolenaar730b2482020-08-09 13:02:10 +02001167 delete('XexportCmd.vim')
Bram Moolenaar9bb3eb32020-06-17 20:03:36 +02001168 StopVimInTerminal(buf)
1169enddef
Bram Moolenaar101f4812020-06-16 23:18:51 +02001170
Bram Moolenaar2b327002020-12-26 15:39:31 +01001171def Test_vim9script_reload_noclear()
1172 var lines =<< trim END
Bram Moolenaara6294952020-12-27 13:39:50 +01001173 vim9script
1174 export var exported = 'thexport'
1175 END
1176 writefile(lines, 'XExportReload')
1177 lines =<< trim END
Bram Moolenaar2b327002020-12-26 15:39:31 +01001178 vim9script noclear
1179 g:loadCount += 1
1180 var s:reloaded = 'init'
Bram Moolenaara6294952020-12-27 13:39:50 +01001181 import exported from './XExportReload'
Bram Moolenaar2b327002020-12-26 15:39:31 +01001182
1183 def Again(): string
1184 return 'again'
1185 enddef
1186
1187 if exists('s:loaded') | finish | endif
1188 var s:loaded = true
1189
1190 var s:notReloaded = 'yes'
1191 s:reloaded = 'first'
1192 def g:Values(): list<string>
Bram Moolenaara6294952020-12-27 13:39:50 +01001193 return [s:reloaded, s:notReloaded, Again(), Once(), exported]
Bram Moolenaar2b327002020-12-26 15:39:31 +01001194 enddef
1195
1196 def Once(): string
1197 return 'once'
1198 enddef
1199 END
1200 writefile(lines, 'XReloaded')
1201 g:loadCount = 0
1202 source XReloaded
1203 assert_equal(1, g:loadCount)
Bram Moolenaara6294952020-12-27 13:39:50 +01001204 assert_equal(['first', 'yes', 'again', 'once', 'thexport'], g:Values())
Bram Moolenaar2b327002020-12-26 15:39:31 +01001205 source XReloaded
1206 assert_equal(2, g:loadCount)
Bram Moolenaara6294952020-12-27 13:39:50 +01001207 assert_equal(['init', 'yes', 'again', 'once', 'thexport'], g:Values())
Bram Moolenaar2b327002020-12-26 15:39:31 +01001208 source XReloaded
1209 assert_equal(3, g:loadCount)
Bram Moolenaara6294952020-12-27 13:39:50 +01001210 assert_equal(['init', 'yes', 'again', 'once', 'thexport'], g:Values())
Bram Moolenaar2b327002020-12-26 15:39:31 +01001211
1212 delete('Xreloaded')
Bram Moolenaara6294952020-12-27 13:39:50 +01001213 delete('XExportReload')
Bram Moolenaar2b327002020-12-26 15:39:31 +01001214 delfunc g:Values
Bram Moolenaar2b327002020-12-26 15:39:31 +01001215 unlet g:loadCount
1216enddef
1217
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001218def Test_vim9script_reload_import()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001219 var lines =<< trim END
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001220 vim9script
1221 const var = ''
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001222 var valone = 1234
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001223 def MyFunc(arg: string)
1224 valone = 5678
1225 enddef
1226 END
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001227 var morelines =<< trim END
1228 var valtwo = 222
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001229 export def GetValtwo(): number
1230 return valtwo
1231 enddef
1232 END
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001233 writefile(lines + morelines, 'Xreload.vim')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001234 source Xreload.vim
1235 source Xreload.vim
1236 source Xreload.vim
1237
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001238 var testlines =<< trim END
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001239 vim9script
1240 def TheFunc()
1241 import GetValtwo from './Xreload.vim'
1242 assert_equal(222, GetValtwo())
1243 enddef
1244 TheFunc()
1245 END
1246 writefile(testlines, 'Ximport.vim')
1247 source Ximport.vim
1248
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001249 # Test that when not using "morelines" GetValtwo() and valtwo are still
1250 # defined, because import doesn't reload a script.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001251 writefile(lines, 'Xreload.vim')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001252 source Ximport.vim
1253
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001254 # cannot declare a var twice
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001255 lines =<< trim END
1256 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001257 var valone = 1234
1258 var valone = 5678
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001259 END
1260 writefile(lines, 'Xreload.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001261 assert_fails('source Xreload.vim', 'E1041:', '', 3, 'Xreload.vim')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001262
1263 delete('Xreload.vim')
1264 delete('Ximport.vim')
1265enddef
1266
Bram Moolenaar07a65d22020-12-26 20:09:15 +01001267" if a script is reloaded with a script-local variable that changed its type, a
1268" compiled function using that variable must fail.
1269def Test_script_reload_change_type()
1270 var lines =<< trim END
1271 vim9script noclear
1272 var str = 'string'
1273 def g:GetStr(): string
1274 return str .. 'xxx'
1275 enddef
1276 END
1277 writefile(lines, 'Xreload.vim')
1278 source Xreload.vim
1279 echo g:GetStr()
1280
1281 lines =<< trim END
1282 vim9script noclear
1283 var str = 1234
1284 END
1285 writefile(lines, 'Xreload.vim')
1286 source Xreload.vim
1287 assert_fails('echo g:GetStr()', 'E1150:')
1288
1289 delfunc g:GetStr
1290 delete('Xreload.vim')
1291enddef
1292
Bram Moolenaar95006e32020-08-29 17:47:08 +02001293def s:RetSome(): string
1294 return 'some'
1295enddef
1296
Bram Moolenaarfe465a02020-07-07 22:50:12 +02001297" Not exported function that is referenced needs to be accessed by the
1298" script-local name.
1299def Test_vim9script_funcref()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001300 var sortlines =<< trim END
Bram Moolenaarfe465a02020-07-07 22:50:12 +02001301 vim9script
1302 def Compare(i1: number, i2: number): number
Bram Moolenaarbed36b92020-07-07 23:31:36 +02001303 return i2 - i1
Bram Moolenaarfe465a02020-07-07 22:50:12 +02001304 enddef
1305
1306 export def FastSort(): list<number>
1307 return range(5)->sort(Compare)
1308 enddef
1309 END
1310 writefile(sortlines, 'Xsort.vim')
1311
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001312 var lines =<< trim END
Bram Moolenaarfe465a02020-07-07 22:50:12 +02001313 vim9script
1314 import FastSort from './Xsort.vim'
1315 def Test()
1316 g:result = FastSort()
1317 enddef
1318 Test()
1319 END
1320 writefile(lines, 'Xscript.vim')
1321
1322 source Xscript.vim
1323 assert_equal([4, 3, 2, 1, 0], g:result)
1324
1325 unlet g:result
1326 delete('Xsort.vim')
1327 delete('Xscript.vim')
Bram Moolenaar95006e32020-08-29 17:47:08 +02001328
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001329 var Funcref = function('s:RetSome')
Bram Moolenaar95006e32020-08-29 17:47:08 +02001330 assert_equal('some', Funcref())
Bram Moolenaarfe465a02020-07-07 22:50:12 +02001331enddef
1332
Bram Moolenaar601e76a2020-08-27 21:33:10 +02001333" Check that when searching for "FilterFunc" it finds the import in the
1334" script where FastFilter() is called from, both as a string and as a direct
1335" function reference.
Bram Moolenaarc620c052020-07-08 15:16:19 +02001336def Test_vim9script_funcref_other_script()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001337 var filterLines =<< trim END
Bram Moolenaarc620c052020-07-08 15:16:19 +02001338 vim9script
1339 export def FilterFunc(idx: number, val: number): bool
1340 return idx % 2 == 1
1341 enddef
1342 export def FastFilter(): list<number>
1343 return range(10)->filter('FilterFunc')
1344 enddef
Bram Moolenaar601e76a2020-08-27 21:33:10 +02001345 export def FastFilterDirect(): list<number>
1346 return range(10)->filter(FilterFunc)
1347 enddef
Bram Moolenaarc620c052020-07-08 15:16:19 +02001348 END
1349 writefile(filterLines, 'Xfilter.vim')
1350
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001351 var lines =<< trim END
Bram Moolenaarc620c052020-07-08 15:16:19 +02001352 vim9script
Bram Moolenaar601e76a2020-08-27 21:33:10 +02001353 import {FilterFunc, FastFilter, FastFilterDirect} from './Xfilter.vim'
Bram Moolenaarc620c052020-07-08 15:16:19 +02001354 def Test()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001355 var x: list<number> = FastFilter()
Bram Moolenaarc620c052020-07-08 15:16:19 +02001356 enddef
1357 Test()
Bram Moolenaar601e76a2020-08-27 21:33:10 +02001358 def TestDirect()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001359 var x: list<number> = FastFilterDirect()
Bram Moolenaar601e76a2020-08-27 21:33:10 +02001360 enddef
1361 TestDirect()
Bram Moolenaarc620c052020-07-08 15:16:19 +02001362 END
Bram Moolenaar601e76a2020-08-27 21:33:10 +02001363 CheckScriptSuccess(lines)
Bram Moolenaarc620c052020-07-08 15:16:19 +02001364 delete('Xfilter.vim')
Bram Moolenaarc620c052020-07-08 15:16:19 +02001365enddef
1366
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001367def Test_vim9script_reload_delfunc()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001368 var first_lines =<< trim END
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001369 vim9script
1370 def FuncYes(): string
1371 return 'yes'
1372 enddef
1373 END
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001374 var withno_lines =<< trim END
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001375 def FuncNo(): string
1376 return 'no'
1377 enddef
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001378 def g:DoCheck(no_exists: bool)
1379 assert_equal('yes', FuncYes())
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001380 assert_equal('no', FuncNo())
1381 enddef
1382 END
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001383 var nono_lines =<< trim END
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001384 def g:DoCheck(no_exists: bool)
1385 assert_equal('yes', FuncYes())
Bram Moolenaar44d66522020-09-06 22:26:57 +02001386 assert_fails('FuncNo()', 'E117:', '', 2, 'DoCheck')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001387 enddef
1388 END
1389
1390 # FuncNo() is defined
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001391 writefile(first_lines + withno_lines, 'Xreloaded.vim')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001392 source Xreloaded.vim
1393 g:DoCheck(true)
1394
1395 # FuncNo() is not redefined
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001396 writefile(first_lines + nono_lines, 'Xreloaded.vim')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001397 source Xreloaded.vim
Bram Moolenaar50824712020-12-20 21:10:17 +01001398 g:DoCheck(false)
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001399
1400 # FuncNo() is back
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001401 writefile(first_lines + withno_lines, 'Xreloaded.vim')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001402 source Xreloaded.vim
Bram Moolenaar50824712020-12-20 21:10:17 +01001403 g:DoCheck(false)
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001404
1405 delete('Xreloaded.vim')
1406enddef
1407
Bram Moolenaar89483d42020-05-10 15:24:44 +02001408def Test_vim9script_reload_delvar()
1409 # write the script with a script-local variable
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001410 var lines =<< trim END
Bram Moolenaar89483d42020-05-10 15:24:44 +02001411 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001412 var name = 'string'
Bram Moolenaar89483d42020-05-10 15:24:44 +02001413 END
1414 writefile(lines, 'XreloadVar.vim')
1415 source XreloadVar.vim
1416
1417 # now write the script using the same variable locally - works
1418 lines =<< trim END
1419 vim9script
1420 def Func()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001421 var name = 'string'
Bram Moolenaar89483d42020-05-10 15:24:44 +02001422 enddef
1423 END
1424 writefile(lines, 'XreloadVar.vim')
1425 source XreloadVar.vim
1426
1427 delete('XreloadVar.vim')
1428enddef
1429
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001430def Test_import_absolute()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001431 var import_lines = [
Bram Moolenaare6085c52020-04-12 20:19:16 +02001432 'vim9script',
1433 'import exported from "' .. escape(getcwd(), '\') .. '/Xexport_abs.vim"',
1434 'def UseExported()',
1435 ' g:imported_abs = exported',
1436 ' exported = 8888',
1437 ' g:imported_after = exported',
1438 'enddef',
1439 'UseExported()',
1440 'g:import_disassembled = execute("disass UseExported")',
1441 ]
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001442 writefile(import_lines, 'Ximport_abs.vim')
1443 writefile(s:export_script_lines, 'Xexport_abs.vim')
1444
1445 source Ximport_abs.vim
1446
1447 assert_equal(9876, g:imported_abs)
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +01001448 assert_equal(8888, g:imported_after)
Bram Moolenaarfbbcd002020-10-15 12:46:44 +02001449 assert_match('<SNR>\d\+_UseExported\_s*' ..
1450 'g:imported_abs = exported\_s*' ..
1451 '0 LOADSCRIPT exported-2 from .*Xexport_abs.vim\_s*' ..
1452 '1 STOREG g:imported_abs\_s*' ..
1453 'exported = 8888\_s*' ..
1454 '2 PUSHNR 8888\_s*' ..
1455 '3 STORESCRIPT exported-2 in .*Xexport_abs.vim\_s*' ..
1456 'g:imported_after = exported\_s*' ..
1457 '4 LOADSCRIPT exported-2 from .*Xexport_abs.vim\_s*' ..
1458 '5 STOREG g:imported_after',
Bram Moolenaare6085c52020-04-12 20:19:16 +02001459 g:import_disassembled)
Bram Moolenaarb3ca9822020-08-09 14:43:58 +02001460
1461 Undo_export_script_lines()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001462 unlet g:imported_abs
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +01001463 unlet g:import_disassembled
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001464
1465 delete('Ximport_abs.vim')
1466 delete('Xexport_abs.vim')
1467enddef
1468
1469def Test_import_rtp()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001470 var import_lines = [
Bram Moolenaare6085c52020-04-12 20:19:16 +02001471 'vim9script',
1472 'import exported from "Xexport_rtp.vim"',
1473 'g:imported_rtp = exported',
1474 ]
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001475 writefile(import_lines, 'Ximport_rtp.vim')
1476 mkdir('import')
1477 writefile(s:export_script_lines, 'import/Xexport_rtp.vim')
1478
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001479 var save_rtp = &rtp
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001480 &rtp = getcwd()
1481 source Ximport_rtp.vim
1482 &rtp = save_rtp
1483
1484 assert_equal(9876, g:imported_rtp)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001485
Bram Moolenaarb3ca9822020-08-09 14:43:58 +02001486 Undo_export_script_lines()
1487 unlet g:imported_rtp
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001488 delete('Ximport_rtp.vim')
Bram Moolenaar89483d42020-05-10 15:24:44 +02001489 delete('import', 'rf')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001490enddef
1491
Bram Moolenaar25e0f582020-05-25 22:36:50 +02001492def Test_import_compile_error()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001493 var export_lines = [
Bram Moolenaar25e0f582020-05-25 22:36:50 +02001494 'vim9script',
1495 'export def ExpFunc(): string',
1496 ' return notDefined',
1497 'enddef',
1498 ]
1499 writefile(export_lines, 'Xexported.vim')
1500
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001501 var import_lines = [
Bram Moolenaar25e0f582020-05-25 22:36:50 +02001502 'vim9script',
1503 'import ExpFunc from "./Xexported.vim"',
1504 'def ImpFunc()',
1505 ' echo ExpFunc()',
1506 'enddef',
1507 'defcompile',
1508 ]
1509 writefile(import_lines, 'Ximport.vim')
1510
1511 try
1512 source Ximport.vim
1513 catch /E1001/
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001514 # Error should be fore the Xexported.vim file.
Bram Moolenaar77072282020-09-16 17:55:40 +02001515 assert_match('E1001: Variable not found: notDefined', v:exception)
Bram Moolenaar25e0f582020-05-25 22:36:50 +02001516 assert_match('function <SNR>\d\+_ImpFunc\[1\]..<SNR>\d\+_ExpFunc, line 1', v:throwpoint)
1517 endtry
1518
1519 delete('Xexported.vim')
1520 delete('Ximport.vim')
1521enddef
1522
Bram Moolenaarc4ce36d2020-08-14 17:08:15 +02001523def Test_func_redefine_error()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001524 var lines = [
Bram Moolenaarc4ce36d2020-08-14 17:08:15 +02001525 'vim9script',
1526 'def Func()',
1527 ' eval [][0]',
1528 'enddef',
1529 'Func()',
1530 ]
1531 writefile(lines, 'Xtestscript.vim')
1532
1533 for count in range(3)
1534 try
1535 source Xtestscript.vim
1536 catch /E684/
1537 # function name should contain <SNR> every time
1538 assert_match('E684: list index out of range', v:exception)
1539 assert_match('function <SNR>\d\+_Func, line 1', v:throwpoint)
1540 endtry
1541 endfor
1542
1543 delete('Xtestscript.vim')
1544enddef
1545
Bram Moolenaareef21022020-08-01 22:16:43 +02001546def Test_func_overrules_import_fails()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001547 var export_lines =<< trim END
Bram Moolenaareef21022020-08-01 22:16:43 +02001548 vim9script
1549 export def Func()
1550 echo 'imported'
1551 enddef
1552 END
1553 writefile(export_lines, 'XexportedFunc.vim')
1554
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001555 var lines =<< trim END
Bram Moolenaareef21022020-08-01 22:16:43 +02001556 vim9script
1557 import Func from './XexportedFunc.vim'
1558 def Func()
1559 echo 'local to function'
1560 enddef
1561 END
1562 CheckScriptFailure(lines, 'E1073:')
1563
1564 lines =<< trim END
1565 vim9script
1566 import Func from './XexportedFunc.vim'
1567 def Outer()
1568 def Func()
1569 echo 'local to function'
1570 enddef
1571 enddef
1572 defcompile
1573 END
1574 CheckScriptFailure(lines, 'E1073:')
1575
1576 delete('XexportedFunc.vim')
1577enddef
1578
Bram Moolenaarb9a2cac2020-08-01 22:23:20 +02001579def Test_func_redefine_fails()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001580 var lines =<< trim END
Bram Moolenaarb9a2cac2020-08-01 22:23:20 +02001581 vim9script
1582 def Func()
1583 echo 'one'
1584 enddef
1585 def Func()
1586 echo 'two'
1587 enddef
1588 END
1589 CheckScriptFailure(lines, 'E1073:')
Bram Moolenaarfa211f32020-08-07 22:00:26 +02001590
1591 lines =<< trim END
1592 vim9script
1593 def Foo(): string
1594 return 'foo'
1595 enddef
1596 def Func()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001597 var Foo = {-> 'lambda'}
Bram Moolenaarfa211f32020-08-07 22:00:26 +02001598 enddef
1599 defcompile
1600 END
1601 CheckScriptFailure(lines, 'E1073:')
Bram Moolenaarb9a2cac2020-08-01 22:23:20 +02001602enddef
1603
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001604def Test_fixed_size_list()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001605 # will be allocated as one piece of memory, check that changes work
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001606 var l = [1, 2, 3, 4]
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001607 l->remove(0)
1608 l->add(5)
1609 l->insert(99, 1)
Bram Moolenaar0f18b6d2020-02-02 17:22:27 +01001610 assert_equal([2, 99, 3, 4, 5], l)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001611enddef
1612
Bram Moolenaarae616492020-07-28 20:07:27 +02001613def Test_no_insert_xit()
Bram Moolenaard2c61702020-09-06 15:58:36 +02001614 CheckDefExecFailure(['a = 1'], 'E1100:')
1615 CheckDefExecFailure(['c = 1'], 'E1100:')
1616 CheckDefExecFailure(['i = 1'], 'E1100:')
1617 CheckDefExecFailure(['t = 1'], 'E1100:')
1618 CheckDefExecFailure(['x = 1'], 'E1100:')
Bram Moolenaarae616492020-07-28 20:07:27 +02001619
Bram Moolenaarae616492020-07-28 20:07:27 +02001620 CheckScriptFailure(['vim9script', 'a = 1'], 'E488:')
1621 CheckScriptFailure(['vim9script', 'a'], 'E1100:')
Bram Moolenaarae616492020-07-28 20:07:27 +02001622 CheckScriptFailure(['vim9script', 'c = 1'], 'E488:')
1623 CheckScriptFailure(['vim9script', 'c'], 'E1100:')
Bram Moolenaarf5a48012020-08-01 17:00:03 +02001624 CheckScriptFailure(['vim9script', 'i = 1'], 'E488:')
1625 CheckScriptFailure(['vim9script', 'i'], 'E1100:')
1626 CheckScriptFailure(['vim9script', 't'], 'E1100:')
1627 CheckScriptFailure(['vim9script', 't = 1'], 'E1100:')
1628 CheckScriptFailure(['vim9script', 'x = 1'], 'E1100:')
Bram Moolenaarae616492020-07-28 20:07:27 +02001629enddef
1630
Bram Moolenaar158906c2020-02-06 20:39:45 +01001631def IfElse(what: number): string
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001632 var res = ''
Bram Moolenaar158906c2020-02-06 20:39:45 +01001633 if what == 1
1634 res = "one"
1635 elseif what == 2
1636 res = "two"
Bram Moolenaara259d8d2020-01-31 20:10:50 +01001637 else
Bram Moolenaar158906c2020-02-06 20:39:45 +01001638 res = "three"
Bram Moolenaara259d8d2020-01-31 20:10:50 +01001639 endif
Bram Moolenaar158906c2020-02-06 20:39:45 +01001640 return res
Bram Moolenaara259d8d2020-01-31 20:10:50 +01001641enddef
1642
Bram Moolenaar158906c2020-02-06 20:39:45 +01001643def Test_if_elseif_else()
1644 assert_equal('one', IfElse(1))
1645 assert_equal('two', IfElse(2))
1646 assert_equal('three', IfElse(3))
Bram Moolenaar0f18b6d2020-02-02 17:22:27 +01001647enddef
1648
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001649def Test_if_elseif_else_fails()
Bram Moolenaard2c61702020-09-06 15:58:36 +02001650 CheckDefFailure(['elseif true'], 'E582:')
1651 CheckDefFailure(['else'], 'E581:')
1652 CheckDefFailure(['endif'], 'E580:')
1653 CheckDefFailure(['if true', 'elseif xxx'], 'E1001:')
1654 CheckDefFailure(['if true', 'echo 1'], 'E171:')
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001655enddef
1656
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001657let g:bool_true = v:true
1658let g:bool_false = v:false
1659
1660def Test_if_const_expr()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001661 var res = false
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001662 if true ? true : false
1663 res = true
1664 endif
1665 assert_equal(true, res)
1666
Bram Moolenaar585fea72020-04-02 22:33:21 +02001667 g:glob = 2
1668 if false
Bram Moolenaar67979662020-06-20 22:50:47 +02001669 execute('g:glob = 3')
Bram Moolenaar585fea72020-04-02 22:33:21 +02001670 endif
1671 assert_equal(2, g:glob)
1672 if true
Bram Moolenaar67979662020-06-20 22:50:47 +02001673 execute('g:glob = 3')
Bram Moolenaar585fea72020-04-02 22:33:21 +02001674 endif
1675 assert_equal(3, g:glob)
1676
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001677 res = false
1678 if g:bool_true ? true : false
1679 res = true
1680 endif
1681 assert_equal(true, res)
1682
1683 res = false
1684 if true ? g:bool_true : false
1685 res = true
1686 endif
1687 assert_equal(true, res)
1688
1689 res = false
1690 if true ? true : g:bool_false
1691 res = true
1692 endif
1693 assert_equal(true, res)
1694
1695 res = false
1696 if true ? false : true
1697 res = true
1698 endif
1699 assert_equal(false, res)
1700
1701 res = false
1702 if false ? false : true
1703 res = true
1704 endif
1705 assert_equal(true, res)
1706
1707 res = false
1708 if false ? true : false
1709 res = true
1710 endif
1711 assert_equal(false, res)
1712
1713 res = false
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001714 if has('xyz') ? true : false
1715 res = true
1716 endif
1717 assert_equal(false, res)
1718
1719 res = false
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001720 if true && true
1721 res = true
1722 endif
1723 assert_equal(true, res)
1724
1725 res = false
1726 if true && false
1727 res = true
1728 endif
1729 assert_equal(false, res)
1730
1731 res = false
1732 if g:bool_true && false
1733 res = true
1734 endif
1735 assert_equal(false, res)
1736
1737 res = false
1738 if true && g:bool_false
1739 res = true
1740 endif
1741 assert_equal(false, res)
1742
1743 res = false
1744 if false && false
1745 res = true
1746 endif
1747 assert_equal(false, res)
1748
1749 res = false
1750 if true || false
1751 res = true
1752 endif
1753 assert_equal(true, res)
1754
1755 res = false
1756 if g:bool_true || false
1757 res = true
1758 endif
1759 assert_equal(true, res)
1760
1761 res = false
1762 if true || g:bool_false
1763 res = true
1764 endif
1765 assert_equal(true, res)
1766
1767 res = false
1768 if false || false
1769 res = true
1770 endif
1771 assert_equal(false, res)
Bram Moolenaar3988f642020-08-27 22:43:03 +02001772
1773 # with constant "false" expression may be invalid so long as the syntax is OK
1774 if false | eval 0 | endif
1775 if false | eval burp + 234 | endif
1776 if false | echo burp 234 'asd' | endif
1777 if false
1778 burp
1779 endif
Bram Moolenaar80c34ca2020-04-01 23:05:18 +02001780enddef
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001781
Bram Moolenaar80c34ca2020-04-01 23:05:18 +02001782def Test_if_const_expr_fails()
Bram Moolenaard2c61702020-09-06 15:58:36 +02001783 CheckDefFailure(['if "aaa" == "bbb'], 'E114:')
1784 CheckDefFailure(["if 'aaa' == 'bbb"], 'E115:')
1785 CheckDefFailure(["if has('aaa'"], 'E110:')
1786 CheckDefFailure(["if has('aaa') ? true false"], 'E109:')
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001787enddef
1788
Bram Moolenaar72abcf42020-06-18 18:26:24 +02001789def RunNested(i: number): number
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001790 var x: number = 0
Bram Moolenaar72abcf42020-06-18 18:26:24 +02001791 if i % 2
1792 if 1
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001793 # comment
Bram Moolenaar72abcf42020-06-18 18:26:24 +02001794 else
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001795 # comment
Bram Moolenaar72abcf42020-06-18 18:26:24 +02001796 endif
1797 x += 1
1798 else
1799 x += 1000
1800 endif
1801 return x
1802enddef
1803
1804def Test_nested_if()
1805 assert_equal(1, RunNested(1))
1806 assert_equal(1000, RunNested(2))
1807enddef
1808
Bram Moolenaarad39c092020-02-26 18:23:43 +01001809def Test_execute_cmd()
Bram Moolenaare4984292020-12-13 14:19:25 +01001810 # missing argument is ignored
1811 execute
1812 execute # comment
1813
Bram Moolenaarad39c092020-02-26 18:23:43 +01001814 new
1815 setline(1, 'default')
Bram Moolenaard2c61702020-09-06 15:58:36 +02001816 execute 'setline(1, "execute-string")'
Bram Moolenaarad39c092020-02-26 18:23:43 +01001817 assert_equal('execute-string', getline(1))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001818
Bram Moolenaard2c61702020-09-06 15:58:36 +02001819 execute "setline(1, 'execute-string')"
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001820 assert_equal('execute-string', getline(1))
1821
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001822 var cmd1 = 'setline(1,'
1823 var cmd2 = '"execute-var")'
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001824 execute cmd1 cmd2 # comment
Bram Moolenaarad39c092020-02-26 18:23:43 +01001825 assert_equal('execute-var', getline(1))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001826
Bram Moolenaard2c61702020-09-06 15:58:36 +02001827 execute cmd1 cmd2 '|setline(1, "execute-var-string")'
Bram Moolenaarad39c092020-02-26 18:23:43 +01001828 assert_equal('execute-var-string', getline(1))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001829
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001830 var cmd_first = 'call '
1831 var cmd_last = 'setline(1, "execute-var-var")'
Bram Moolenaarad39c092020-02-26 18:23:43 +01001832 execute cmd_first .. cmd_last
1833 assert_equal('execute-var-var', getline(1))
1834 bwipe!
Bram Moolenaar585fea72020-04-02 22:33:21 +02001835
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001836 var n = true
Bram Moolenaar2d6b20d2020-07-25 19:30:59 +02001837 execute 'echomsg' (n ? '"true"' : '"no"')
1838 assert_match('^true$', Screenline(&lines))
1839
Bram Moolenaare0de1712020-12-02 17:36:54 +01001840 echomsg [1, 2, 3] {a: 1, b: 2}
Bram Moolenaare5abf7a2020-08-16 18:29:35 +02001841 assert_match('^\[1, 2, 3\] {''a'': 1, ''b'': 2}$', Screenline(&lines))
1842
Bram Moolenaard2c61702020-09-06 15:58:36 +02001843 CheckDefFailure(['execute xxx'], 'E1001:', 1)
1844 CheckDefExecFailure(['execute "tabnext " .. 8'], 'E475:', 1)
1845 CheckDefFailure(['execute "cmd"# comment'], 'E488:', 1)
Bram Moolenaarad39c092020-02-26 18:23:43 +01001846enddef
1847
Bram Moolenaar47e880d2020-06-30 22:02:02 +02001848def Test_execute_cmd_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001849 # only checks line continuation
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001850 var lines =<< trim END
Bram Moolenaar47e880d2020-06-30 22:02:02 +02001851 vim9script
1852 execute 'g:someVar'
1853 .. ' = ' ..
1854 '28'
1855 assert_equal(28, g:someVar)
1856 unlet g:someVar
1857 END
1858 CheckScriptSuccess(lines)
1859enddef
1860
Bram Moolenaarad39c092020-02-26 18:23:43 +01001861def Test_echo_cmd()
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001862 echo 'some' # comment
Bram Moolenaar585fea72020-04-02 22:33:21 +02001863 echon 'thing'
Bram Moolenaarad39c092020-02-26 18:23:43 +01001864 assert_match('^something$', Screenline(&lines))
1865
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001866 echo "some" # comment
1867 echon "thing"
1868 assert_match('^something$', Screenline(&lines))
1869
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001870 var str1 = 'some'
1871 var str2 = 'more'
Bram Moolenaarad39c092020-02-26 18:23:43 +01001872 echo str1 str2
1873 assert_match('^some more$', Screenline(&lines))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001874
Bram Moolenaard2c61702020-09-06 15:58:36 +02001875 CheckDefFailure(['echo "xxx"# comment'], 'E488:')
Bram Moolenaarad39c092020-02-26 18:23:43 +01001876enddef
1877
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001878def Test_echomsg_cmd()
1879 echomsg 'some' 'more' # comment
1880 assert_match('^some more$', Screenline(&lines))
1881 echo 'clear'
Bram Moolenaardf069ee2020-06-22 23:02:51 +02001882 :1messages
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001883 assert_match('^some more$', Screenline(&lines))
1884
Bram Moolenaard2c61702020-09-06 15:58:36 +02001885 CheckDefFailure(['echomsg "xxx"# comment'], 'E488:')
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001886enddef
1887
Bram Moolenaar47e880d2020-06-30 22:02:02 +02001888def Test_echomsg_cmd_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001889 # only checks line continuation
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001890 var lines =<< trim END
Bram Moolenaar47e880d2020-06-30 22:02:02 +02001891 vim9script
1892 echomsg 'here'
1893 .. ' is ' ..
1894 'a message'
1895 assert_match('^here is a message$', Screenline(&lines))
1896 END
1897 CheckScriptSuccess(lines)
1898enddef
1899
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001900def Test_echoerr_cmd()
Bram Moolenaar40ee4662020-05-05 22:08:26 +02001901 try
1902 echoerr 'something' 'wrong' # comment
1903 catch
1904 assert_match('something wrong', v:exception)
1905 endtry
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001906enddef
1907
Bram Moolenaar47e880d2020-06-30 22:02:02 +02001908def Test_echoerr_cmd_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001909 # only checks line continuation
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001910 var lines =<< trim END
Bram Moolenaar47e880d2020-06-30 22:02:02 +02001911 vim9script
1912 try
1913 echoerr 'this'
1914 .. ' is ' ..
1915 'wrong'
1916 catch
1917 assert_match('this is wrong', v:exception)
1918 endtry
1919 END
1920 CheckScriptSuccess(lines)
1921enddef
1922
Bram Moolenaar41fe0612020-03-01 16:22:40 +01001923def Test_for_outside_of_function()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001924 var lines =<< trim END
Bram Moolenaar41fe0612020-03-01 16:22:40 +01001925 vim9script
1926 new
1927 for var in range(0, 3)
1928 append(line('$'), var)
1929 endfor
1930 assert_equal(['', '0', '1', '2', '3'], getline(1, '$'))
1931 bwipe!
1932 END
1933 writefile(lines, 'Xvim9for.vim')
1934 source Xvim9for.vim
1935 delete('Xvim9for.vim')
1936enddef
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001937
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001938def Test_for_loop()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001939 var result = ''
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001940 for cnt in range(7)
1941 if cnt == 4
1942 break
1943 endif
1944 if cnt == 2
1945 continue
1946 endif
1947 result ..= cnt .. '_'
1948 endfor
1949 assert_equal('0_1_3_', result)
Bram Moolenaar0ad3e892020-07-05 21:38:11 +02001950
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001951 var concat = ''
Bram Moolenaar0ad3e892020-07-05 21:38:11 +02001952 for str in eval('["one", "two"]')
1953 concat ..= str
1954 endfor
1955 assert_equal('onetwo', concat)
Bram Moolenaar38bd8de2020-12-02 13:23:36 +01001956
1957 var total = 0
1958 for nr in
1959 [1, 2, 3]
1960 total += nr
1961 endfor
1962 assert_equal(6, total)
1963
1964 total = 0
1965 for nr
1966 in [1, 2, 3]
1967 total += nr
1968 endfor
1969 assert_equal(6, total)
1970
1971 total = 0
1972 for nr
1973 in
1974 [1, 2, 3]
1975 total += nr
1976 endfor
1977 assert_equal(6, total)
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001978enddef
1979
1980def Test_for_loop_fails()
Bram Moolenaar025cb1c2020-12-14 18:31:27 +01001981 CheckDefFailure(['for '], 'E1097:')
1982 CheckDefFailure(['for x'], 'E1097:')
1983 CheckDefFailure(['for x in'], 'E1097:')
Bram Moolenaar675f7162020-04-12 22:53:54 +02001984 CheckDefFailure(['for # in range(5)'], 'E690:')
1985 CheckDefFailure(['for i In range(5)'], 'E690:')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001986 CheckDefFailure(['var x = 5', 'for x in range(5)'], 'E1017:')
Bram Moolenaar822ba242020-05-24 23:00:18 +02001987 CheckScriptFailure(['def Func(arg: any)', 'for arg in range(5)', 'enddef', 'defcompile'], 'E1006:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01001988 delfunc! g:Func
Bram Moolenaar451c2e32020-08-15 16:33:28 +02001989 CheckDefFailure(['for i in "text"'], 'E1012:')
Bram Moolenaar675f7162020-04-12 22:53:54 +02001990 CheckDefFailure(['for i in xxx'], 'E1001:')
1991 CheckDefFailure(['endfor'], 'E588:')
1992 CheckDefFailure(['for i in range(3)', 'echo 3'], 'E170:')
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001993enddef
1994
Bram Moolenaarea870692020-12-02 14:24:30 +01001995def Test_for_loop_script_var()
1996 # cannot use s:var in a :def function
1997 CheckDefFailure(['for s:var in range(3)', 'echo 3'], 'E1101:')
1998
1999 # can use s:var in Vim9 script, with or without s:
2000 var lines =<< trim END
2001 vim9script
2002 var total = 0
2003 for s:var in [1, 2, 3]
2004 total += s:var
2005 endfor
2006 assert_equal(6, total)
2007
2008 total = 0
2009 for var in [1, 2, 3]
2010 total += var
2011 endfor
2012 assert_equal(6, total)
2013 END
2014enddef
2015
Bram Moolenaar792f7862020-11-23 08:31:18 +01002016def Test_for_loop_unpack()
Bram Moolenaar792f7862020-11-23 08:31:18 +01002017 var lines =<< trim END
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01002018 var result = []
2019 for [v1, v2] in [[1, 2], [3, 4]]
2020 result->add(v1)
2021 result->add(v2)
2022 endfor
2023 assert_equal([1, 2, 3, 4], result)
2024
2025 result = []
2026 for [v1, v2; v3] in [[1, 2], [3, 4, 5, 6]]
2027 result->add(v1)
2028 result->add(v2)
2029 result->add(v3)
2030 endfor
2031 assert_equal([1, 2, [], 3, 4, [5, 6]], result)
2032
2033 result = []
2034 for [&ts, &sw] in [[1, 2], [3, 4]]
2035 result->add(&ts)
2036 result->add(&sw)
2037 endfor
2038 assert_equal([1, 2, 3, 4], result)
2039
2040 var slist: list<string>
2041 for [$LOOPVAR, @r, v:errmsg] in [['a', 'b', 'c'], ['d', 'e', 'f']]
2042 slist->add($LOOPVAR)
2043 slist->add(@r)
2044 slist->add(v:errmsg)
2045 endfor
2046 assert_equal(['a', 'b', 'c', 'd', 'e', 'f'], slist)
2047
2048 slist = []
2049 for [g:globalvar, b:bufvar, w:winvar, t:tabvar] in [['global', 'buf', 'win', 'tab'], ['1', '2', '3', '4']]
2050 slist->add(g:globalvar)
2051 slist->add(b:bufvar)
2052 slist->add(w:winvar)
2053 slist->add(t:tabvar)
2054 endfor
2055 assert_equal(['global', 'buf', 'win', 'tab', '1', '2', '3', '4'], slist)
Bram Moolenaarf6c177a2020-12-04 17:38:00 +01002056 unlet! g:globalvar b:bufvar w:winvar t:tabvar
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01002057 END
2058 CheckDefAndScriptSuccess(lines)
2059
2060 lines =<< trim END
Bram Moolenaar792f7862020-11-23 08:31:18 +01002061 for [v1, v2] in [[1, 2, 3], [3, 4]]
2062 echo v1 v2
2063 endfor
2064 END
2065 CheckDefExecFailure(lines, 'E710:', 1)
2066
2067 lines =<< trim END
2068 for [v1, v2] in [[1], [3, 4]]
2069 echo v1 v2
2070 endfor
2071 END
2072 CheckDefExecFailure(lines, 'E711:', 1)
2073
2074 lines =<< trim END
2075 for [v1, v1] in [[1, 2], [3, 4]]
2076 echo v1
2077 endfor
2078 END
2079 CheckDefExecFailure(lines, 'E1017:', 1)
2080enddef
2081
Bram Moolenaard0df1aa2020-03-04 21:50:46 +01002082def Test_while_loop()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002083 var result = ''
2084 var cnt = 0
Bram Moolenaard0df1aa2020-03-04 21:50:46 +01002085 while cnt < 555
2086 if cnt == 3
2087 break
2088 endif
2089 cnt += 1
2090 if cnt == 2
2091 continue
2092 endif
2093 result ..= cnt .. '_'
2094 endwhile
2095 assert_equal('1_3_', result)
2096enddef
2097
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02002098def Test_while_loop_fails()
Bram Moolenaar675f7162020-04-12 22:53:54 +02002099 CheckDefFailure(['while xxx'], 'E1001:')
2100 CheckDefFailure(['endwhile'], 'E588:')
2101 CheckDefFailure(['continue'], 'E586:')
2102 CheckDefFailure(['if true', 'continue'], 'E586:')
2103 CheckDefFailure(['break'], 'E587:')
2104 CheckDefFailure(['if true', 'break'], 'E587:')
2105 CheckDefFailure(['while 1', 'echo 3'], 'E170:')
Bram Moolenaarbd5da372020-03-31 23:13:10 +02002106enddef
2107
Bram Moolenaar9645e2d2020-03-20 20:48:49 +01002108def Test_interrupt_loop()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002109 var caught = false
2110 var x = 0
Bram Moolenaar97acfc72020-03-22 13:44:28 +01002111 try
2112 while 1
2113 x += 1
2114 if x == 100
2115 feedkeys("\<C-C>", 'Lt')
2116 endif
2117 endwhile
2118 catch
2119 caught = true
2120 assert_equal(100, x)
2121 endtry
2122 assert_true(caught, 'should have caught an exception')
Bram Moolenaar25859dd2020-08-30 12:54:53 +02002123 # consume the CTRL-C
2124 getchar(0)
Bram Moolenaar9645e2d2020-03-20 20:48:49 +01002125enddef
Bram Moolenaar20431c92020-03-20 18:39:46 +01002126
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002127def Test_automatic_line_continuation()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002128 var mylist = [
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002129 'one',
2130 'two',
2131 'three',
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002132 ] # comment
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002133 assert_equal(['one', 'two', 'three'], mylist)
2134
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002135 var mydict = {
Bram Moolenaare0de1712020-12-02 17:36:54 +01002136 ['one']: 1,
2137 ['two']: 2,
2138 ['three']:
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002139 3,
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002140 } # comment
Bram Moolenaare0de1712020-12-02 17:36:54 +01002141 assert_equal({one: 1, two: 2, three: 3}, mydict)
2142 mydict = {
Bram Moolenaar2c330432020-04-13 14:41:35 +02002143 one: 1, # comment
2144 two: # comment
2145 2, # comment
2146 three: 3 # comment
2147 }
Bram Moolenaare0de1712020-12-02 17:36:54 +01002148 assert_equal({one: 1, two: 2, three: 3}, mydict)
2149 mydict = {
Bram Moolenaar2c330432020-04-13 14:41:35 +02002150 one: 1,
2151 two:
2152 2,
2153 three: 3
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002154 }
Bram Moolenaare0de1712020-12-02 17:36:54 +01002155 assert_equal({one: 1, two: 2, three: 3}, mydict)
Bram Moolenaare6085c52020-04-12 20:19:16 +02002156
2157 assert_equal(
2158 ['one', 'two', 'three'],
2159 split('one two three')
2160 )
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002161enddef
2162
Bram Moolenaar7a092242020-04-16 22:10:49 +02002163def Test_vim9_comment()
2164 CheckScriptSuccess([
2165 'vim9script',
2166 '# something',
Bram Moolenaar93f82cb2020-12-12 21:25:56 +01002167 '#something',
2168 '#{something',
Bram Moolenaar7a092242020-04-16 22:10:49 +02002169 ])
Bram Moolenaar93f82cb2020-12-12 21:25:56 +01002170
2171 split Xfile
2172 CheckScriptSuccess([
2173 'vim9script',
2174 'edit #something',
2175 ])
2176 CheckScriptSuccess([
2177 'vim9script',
2178 'edit #{something',
2179 ])
2180 close
2181
Bram Moolenaar7a092242020-04-16 22:10:49 +02002182 CheckScriptFailure([
2183 'vim9script',
2184 ':# something',
2185 ], 'E488:')
2186 CheckScriptFailure([
2187 '# something',
2188 ], 'E488:')
2189 CheckScriptFailure([
2190 ':# something',
2191 ], 'E488:')
2192
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02002193 { # block start
2194 } # block end
2195 CheckDefFailure([
2196 '{# comment',
2197 ], 'E488:')
2198 CheckDefFailure([
2199 '{',
2200 '}# comment',
2201 ], 'E488:')
2202
2203 echo "yes" # comment
2204 CheckDefFailure([
2205 'echo "yes"# comment',
2206 ], 'E488:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02002207 CheckScriptSuccess([
2208 'vim9script',
2209 'echo "yes" # something',
2210 ])
2211 CheckScriptFailure([
2212 'vim9script',
2213 'echo "yes"# something',
2214 ], 'E121:')
2215 CheckScriptFailure([
2216 'vim9script',
2217 'echo# something',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002218 ], 'E1144:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02002219 CheckScriptFailure([
2220 'echo "yes" # something',
2221 ], 'E121:')
2222
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02002223 exe "echo" # comment
2224 CheckDefFailure([
2225 'exe "echo"# comment',
2226 ], 'E488:')
2227 CheckScriptSuccess([
2228 'vim9script',
2229 'exe "echo" # something',
2230 ])
2231 CheckScriptFailure([
2232 'vim9script',
2233 'exe "echo"# something',
2234 ], 'E121:')
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02002235 CheckScriptFailure([
2236 'vim9script',
2237 'exe# something',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002238 ], 'E1144:')
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02002239 CheckScriptFailure([
2240 'exe "echo" # something',
2241 ], 'E121:')
2242
Bram Moolenaar7a092242020-04-16 22:10:49 +02002243 CheckDefFailure([
2244 'try# comment',
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002245 ' echo "yes"',
Bram Moolenaar7a092242020-04-16 22:10:49 +02002246 'catch',
2247 'endtry',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002248 ], 'E1144:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002249 CheckScriptFailure([
2250 'vim9script',
2251 'try# comment',
2252 'echo "yes"',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002253 ], 'E1144:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02002254 CheckDefFailure([
2255 'try',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002256 ' throw#comment',
2257 'catch',
2258 'endtry',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002259 ], 'E1144:')
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002260 CheckDefFailure([
2261 'try',
2262 ' throw "yes"#comment',
2263 'catch',
2264 'endtry',
2265 ], 'E488:')
2266 CheckDefFailure([
2267 'try',
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002268 ' echo "yes"',
Bram Moolenaar7a092242020-04-16 22:10:49 +02002269 'catch# comment',
2270 'endtry',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002271 ], 'E1144:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002272 CheckScriptFailure([
2273 'vim9script',
2274 'try',
2275 ' echo "yes"',
2276 'catch# comment',
2277 'endtry',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002278 ], 'E1144:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002279 CheckDefFailure([
2280 'try',
2281 ' echo "yes"',
2282 'catch /pat/# comment',
2283 'endtry',
2284 ], 'E488:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02002285 CheckDefFailure([
2286 'try',
2287 'echo "yes"',
2288 'catch',
2289 'endtry# comment',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002290 ], 'E1144:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002291 CheckScriptFailure([
2292 'vim9script',
2293 'try',
2294 ' echo "yes"',
2295 'catch',
2296 'endtry# comment',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002297 ], 'E1144:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002298
2299 CheckScriptSuccess([
2300 'vim9script',
2301 'hi # comment',
2302 ])
2303 CheckScriptFailure([
2304 'vim9script',
2305 'hi# comment',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002306 ], 'E1144:')
Bram Moolenaar1966c242020-04-20 22:42:32 +02002307 CheckScriptSuccess([
2308 'vim9script',
2309 'hi Search # comment',
2310 ])
2311 CheckScriptFailure([
2312 'vim9script',
2313 'hi Search# comment',
2314 ], 'E416:')
2315 CheckScriptSuccess([
2316 'vim9script',
2317 'hi link This Search # comment',
2318 ])
2319 CheckScriptFailure([
2320 'vim9script',
2321 'hi link This That# comment',
2322 ], 'E413:')
2323 CheckScriptSuccess([
2324 'vim9script',
2325 'hi clear This # comment',
2326 'hi clear # comment',
2327 ])
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002328 # not tested, because it doesn't give an error but a warning:
2329 # hi clear This# comment',
Bram Moolenaar1966c242020-04-20 22:42:32 +02002330 CheckScriptFailure([
2331 'vim9script',
2332 'hi clear# comment',
2333 ], 'E416:')
2334
2335 CheckScriptSuccess([
2336 'vim9script',
2337 'hi Group term=bold',
2338 'match Group /todo/ # comment',
2339 ])
2340 CheckScriptFailure([
2341 'vim9script',
2342 'hi Group term=bold',
2343 'match Group /todo/# comment',
2344 ], 'E488:')
2345 CheckScriptSuccess([
2346 'vim9script',
2347 'match # comment',
2348 ])
2349 CheckScriptFailure([
2350 'vim9script',
2351 'match# comment',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002352 ], 'E1144:')
Bram Moolenaar1966c242020-04-20 22:42:32 +02002353 CheckScriptSuccess([
2354 'vim9script',
2355 'match none # comment',
2356 ])
2357 CheckScriptFailure([
2358 'vim9script',
2359 'match none# comment',
2360 ], 'E475:')
2361
2362 CheckScriptSuccess([
2363 'vim9script',
2364 'menutrans clear # comment',
2365 ])
2366 CheckScriptFailure([
2367 'vim9script',
2368 'menutrans clear# comment text',
2369 ], 'E474:')
2370
2371 CheckScriptSuccess([
2372 'vim9script',
2373 'syntax clear # comment',
2374 ])
2375 CheckScriptFailure([
2376 'vim9script',
2377 'syntax clear# comment text',
2378 ], 'E28:')
2379 CheckScriptSuccess([
2380 'vim9script',
2381 'syntax keyword Word some',
2382 'syntax clear Word # comment',
2383 ])
2384 CheckScriptFailure([
2385 'vim9script',
2386 'syntax keyword Word some',
2387 'syntax clear Word# comment text',
2388 ], 'E28:')
2389
2390 CheckScriptSuccess([
2391 'vim9script',
2392 'syntax list # comment',
2393 ])
2394 CheckScriptFailure([
2395 'vim9script',
2396 'syntax list# comment text',
2397 ], 'E28:')
2398
2399 CheckScriptSuccess([
2400 'vim9script',
2401 'syntax match Word /pat/ oneline # comment',
2402 ])
2403 CheckScriptFailure([
2404 'vim9script',
2405 'syntax match Word /pat/ oneline# comment',
2406 ], 'E475:')
2407
2408 CheckScriptSuccess([
2409 'vim9script',
2410 'syntax keyword Word word # comm[ent',
2411 ])
2412 CheckScriptFailure([
2413 'vim9script',
2414 'syntax keyword Word word# comm[ent',
2415 ], 'E789:')
2416
2417 CheckScriptSuccess([
2418 'vim9script',
2419 'syntax match Word /pat/ # comment',
2420 ])
2421 CheckScriptFailure([
2422 'vim9script',
2423 'syntax match Word /pat/# comment',
2424 ], 'E402:')
2425
2426 CheckScriptSuccess([
2427 'vim9script',
2428 'syntax match Word /pat/ contains=Something # comment',
2429 ])
2430 CheckScriptFailure([
2431 'vim9script',
2432 'syntax match Word /pat/ contains=Something# comment',
2433 ], 'E475:')
2434 CheckScriptFailure([
2435 'vim9script',
2436 'syntax match Word /pat/ contains= # comment',
2437 ], 'E406:')
2438 CheckScriptFailure([
2439 'vim9script',
2440 'syntax match Word /pat/ contains=# comment',
2441 ], 'E475:')
2442
2443 CheckScriptSuccess([
2444 'vim9script',
2445 'syntax region Word start=/pat/ end=/pat/ # comment',
2446 ])
2447 CheckScriptFailure([
2448 'vim9script',
2449 'syntax region Word start=/pat/ end=/pat/# comment',
Bram Moolenaard032f342020-07-18 18:13:02 +02002450 ], 'E402:')
Bram Moolenaar1966c242020-04-20 22:42:32 +02002451
2452 CheckScriptSuccess([
2453 'vim9script',
2454 'syntax sync # comment',
2455 ])
2456 CheckScriptFailure([
2457 'vim9script',
2458 'syntax sync# comment',
2459 ], 'E404:')
2460 CheckScriptSuccess([
2461 'vim9script',
2462 'syntax sync ccomment # comment',
2463 ])
2464 CheckScriptFailure([
2465 'vim9script',
2466 'syntax sync ccomment# comment',
2467 ], 'E404:')
2468
2469 CheckScriptSuccess([
2470 'vim9script',
2471 'syntax cluster Some contains=Word # comment',
2472 ])
2473 CheckScriptFailure([
2474 'vim9script',
2475 'syntax cluster Some contains=Word# comment',
2476 ], 'E475:')
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002477
2478 CheckScriptSuccess([
2479 'vim9script',
2480 'command Echo echo # comment',
2481 'command Echo # comment',
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002482 'delcommand Echo',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002483 ])
2484 CheckScriptFailure([
2485 'vim9script',
2486 'command Echo echo# comment',
2487 'Echo',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002488 ], 'E1144:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002489 delcommand Echo
Bram Moolenaar70249ee2020-12-10 21:01:30 +01002490
2491 var curdir = getcwd()
2492 CheckScriptSuccess([
2493 'command Echo cd " comment',
2494 'Echo',
2495 'delcommand Echo',
2496 ])
2497 CheckScriptSuccess([
Bram Moolenaar090728a2020-12-20 15:43:31 +01002498 'vim9script',
Bram Moolenaar70249ee2020-12-10 21:01:30 +01002499 'command Echo cd # comment',
2500 'Echo',
2501 'delcommand Echo',
2502 ])
2503 CheckScriptFailure([
2504 'vim9script',
2505 'command Echo cd " comment',
2506 'Echo',
2507 ], 'E344:')
2508 delcommand Echo
2509 chdir(curdir)
2510
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002511 CheckScriptFailure([
2512 'vim9script',
2513 'command Echo# comment',
2514 ], 'E182:')
2515 CheckScriptFailure([
2516 'vim9script',
2517 'command Echo echo',
2518 'command Echo# comment',
2519 ], 'E182:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002520 delcommand Echo
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002521
2522 CheckScriptSuccess([
2523 'vim9script',
2524 'function # comment',
2525 ])
2526 CheckScriptFailure([
2527 'vim9script',
Bram Moolenaar98981072020-07-29 14:40:25 +02002528 'function " comment',
2529 ], 'E129:')
2530 CheckScriptFailure([
2531 'vim9script',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002532 'function# comment',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002533 ], 'E1144:')
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002534 CheckScriptSuccess([
2535 'vim9script',
2536 'function CheckScriptSuccess # comment',
2537 ])
2538 CheckScriptFailure([
2539 'vim9script',
2540 'function CheckScriptSuccess# comment',
2541 ], 'E488:')
2542
2543 CheckScriptSuccess([
2544 'vim9script',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02002545 'func g:DeleteMeA()',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002546 'endfunc',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02002547 'delfunction g:DeleteMeA # comment',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002548 ])
2549 CheckScriptFailure([
2550 'vim9script',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02002551 'func g:DeleteMeB()',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002552 'endfunc',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02002553 'delfunction g:DeleteMeB# comment',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002554 ], 'E488:')
2555
2556 CheckScriptSuccess([
2557 'vim9script',
2558 'call execute("ls") # comment',
2559 ])
2560 CheckScriptFailure([
2561 'vim9script',
2562 'call execute("ls")# comment',
2563 ], 'E488:')
Bram Moolenaare7e48382020-07-22 18:17:08 +02002564
2565 CheckScriptFailure([
2566 'def Test() " comment',
2567 'enddef',
2568 ], 'E488:')
2569 CheckScriptFailure([
2570 'vim9script',
2571 'def Test() " comment',
2572 'enddef',
2573 ], 'E488:')
2574
2575 CheckScriptSuccess([
2576 'func Test() " comment',
2577 'endfunc',
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002578 'delfunc Test',
Bram Moolenaare7e48382020-07-22 18:17:08 +02002579 ])
Bram Moolenaar98981072020-07-29 14:40:25 +02002580 CheckScriptSuccess([
Bram Moolenaare7e48382020-07-22 18:17:08 +02002581 'vim9script',
2582 'func Test() " comment',
2583 'endfunc',
Bram Moolenaar98981072020-07-29 14:40:25 +02002584 ])
Bram Moolenaare7e48382020-07-22 18:17:08 +02002585
2586 CheckScriptSuccess([
2587 'def Test() # comment',
2588 'enddef',
2589 ])
2590 CheckScriptFailure([
2591 'func Test() # comment',
2592 'endfunc',
2593 ], 'E488:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002594enddef
2595
2596def Test_vim9_comment_gui()
2597 CheckCanRunGui
2598
2599 CheckScriptFailure([
2600 'vim9script',
2601 'gui#comment'
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002602 ], 'E1144:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002603 CheckScriptFailure([
2604 'vim9script',
2605 'gui -f#comment'
2606 ], 'E499:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02002607enddef
2608
Bram Moolenaara26b9702020-04-18 19:53:28 +02002609def Test_vim9_comment_not_compiled()
Bram Moolenaar67979662020-06-20 22:50:47 +02002610 au TabEnter *.vim g:entered = 1
2611 au TabEnter *.x g:entered = 2
Bram Moolenaara26b9702020-04-18 19:53:28 +02002612
2613 edit test.vim
2614 doautocmd TabEnter #comment
2615 assert_equal(1, g:entered)
2616
2617 doautocmd TabEnter f.x
2618 assert_equal(2, g:entered)
2619
2620 g:entered = 0
2621 doautocmd TabEnter f.x #comment
2622 assert_equal(2, g:entered)
2623
2624 assert_fails('doautocmd Syntax#comment', 'E216:')
2625
2626 au! TabEnter
2627 unlet g:entered
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02002628
2629 CheckScriptSuccess([
2630 'vim9script',
Bram Moolenaar67979662020-06-20 22:50:47 +02002631 'g:var = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02002632 'b:var = 456',
2633 'w:var = 777',
2634 't:var = 888',
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02002635 'unlet g:var w:var # something',
2636 ])
2637
2638 CheckScriptFailure([
2639 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002640 'let var = 123',
2641 ], 'E1126: Cannot use :let in Vim9 script')
2642
2643 CheckScriptFailure([
2644 'vim9script',
2645 'var g:var = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02002646 ], 'E1016: Cannot declare a global variable:')
2647
2648 CheckScriptFailure([
2649 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002650 'var b:var = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02002651 ], 'E1016: Cannot declare a buffer variable:')
2652
2653 CheckScriptFailure([
2654 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002655 'var w:var = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02002656 ], 'E1016: Cannot declare a window variable:')
2657
2658 CheckScriptFailure([
2659 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002660 'var t:var = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02002661 ], 'E1016: Cannot declare a tab variable:')
2662
2663 CheckScriptFailure([
2664 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002665 'var v:version = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02002666 ], 'E1016: Cannot declare a v: variable:')
2667
2668 CheckScriptFailure([
2669 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002670 'var $VARIABLE = "text"',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02002671 ], 'E1016: Cannot declare an environment variable:')
Bram Moolenaar67979662020-06-20 22:50:47 +02002672
2673 CheckScriptFailure([
2674 'vim9script',
2675 'g:var = 123',
Bram Moolenaar32e35112020-05-14 22:41:15 +02002676 'unlet g:var# comment1',
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02002677 ], 'E108:')
2678
2679 CheckScriptFailure([
2680 'let g:var = 123',
2681 'unlet g:var # something',
2682 ], 'E488:')
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002683
2684 CheckScriptSuccess([
2685 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02002686 'if 1 # comment2',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002687 ' echo "yes"',
2688 'elseif 2 #comment',
2689 ' echo "no"',
2690 'endif',
2691 ])
2692
2693 CheckScriptFailure([
2694 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02002695 'if 1# comment3',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002696 ' echo "yes"',
2697 'endif',
2698 ], 'E15:')
2699
2700 CheckScriptFailure([
2701 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02002702 'if 0 # comment4',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002703 ' echo "yes"',
2704 'elseif 2#comment',
2705 ' echo "no"',
2706 'endif',
2707 ], 'E15:')
2708
2709 CheckScriptSuccess([
2710 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002711 'var v = 1 # comment5',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002712 ])
2713
2714 CheckScriptFailure([
2715 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002716 'var v = 1# comment6',
Bram Moolenaar32e35112020-05-14 22:41:15 +02002717 ], 'E15:')
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002718
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002719 CheckScriptSuccess([
2720 'vim9script',
2721 'new'
Bram Moolenaard2c61702020-09-06 15:58:36 +02002722 'setline(1, ["# define pat", "last"])',
Bram Moolenaardf069ee2020-06-22 23:02:51 +02002723 ':$',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002724 'dsearch /pat/ #comment',
2725 'bwipe!',
2726 ])
2727
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002728 CheckScriptFailure([
2729 'vim9script',
2730 'new'
Bram Moolenaard2c61702020-09-06 15:58:36 +02002731 'setline(1, ["# define pat", "last"])',
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002732 ':$',
2733 'dsearch /pat/#comment',
2734 'bwipe!',
2735 ], 'E488:')
2736
2737 CheckScriptFailure([
2738 'vim9script',
2739 'func! SomeFunc()',
2740 ], 'E477:')
Bram Moolenaara26b9702020-04-18 19:53:28 +02002741enddef
2742
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02002743def Test_finish()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002744 var lines =<< trim END
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02002745 vim9script
Bram Moolenaar67979662020-06-20 22:50:47 +02002746 g:res = 'one'
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02002747 if v:false | finish | endif
Bram Moolenaar67979662020-06-20 22:50:47 +02002748 g:res = 'two'
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02002749 finish
Bram Moolenaar67979662020-06-20 22:50:47 +02002750 g:res = 'three'
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02002751 END
2752 writefile(lines, 'Xfinished')
2753 source Xfinished
2754 assert_equal('two', g:res)
2755
2756 unlet g:res
2757 delete('Xfinished')
2758enddef
2759
Bram Moolenaara5d00772020-05-14 23:20:55 +02002760def Test_forward_declaration()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002761 var lines =<< trim END
Bram Moolenaara5d00772020-05-14 23:20:55 +02002762 vim9script
Bram Moolenaara5d00772020-05-14 23:20:55 +02002763 def GetValue(): string
2764 return theVal
2765 enddef
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002766 var theVal = 'something'
Bram Moolenaar822ba242020-05-24 23:00:18 +02002767 g:initVal = GetValue()
Bram Moolenaara5d00772020-05-14 23:20:55 +02002768 theVal = 'else'
2769 g:laterVal = GetValue()
2770 END
2771 writefile(lines, 'Xforward')
2772 source Xforward
2773 assert_equal('something', g:initVal)
2774 assert_equal('else', g:laterVal)
2775
2776 unlet g:initVal
2777 unlet g:laterVal
2778 delete('Xforward')
2779enddef
2780
Bram Moolenaar9721fb42020-06-11 23:10:46 +02002781def Test_source_vim9_from_legacy()
Bram Moolenaara6294952020-12-27 13:39:50 +01002782 var vim9_lines =<< trim END
2783 vim9script
2784 var local = 'local'
2785 g:global = 'global'
2786 export var exported = 'exported'
2787 export def GetText(): string
2788 return 'text'
2789 enddef
2790 END
2791 writefile(vim9_lines, 'Xvim9_script.vim')
2792
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002793 var legacy_lines =<< trim END
Bram Moolenaar9721fb42020-06-11 23:10:46 +02002794 source Xvim9_script.vim
2795
2796 call assert_false(exists('local'))
2797 call assert_false(exists('exported'))
2798 call assert_false(exists('s:exported'))
2799 call assert_equal('global', global)
2800 call assert_equal('global', g:global)
2801
2802 " imported variable becomes script-local
2803 import exported from './Xvim9_script.vim'
2804 call assert_equal('exported', s:exported)
2805 call assert_false(exists('exported'))
2806
2807 " imported function becomes script-local
2808 import GetText from './Xvim9_script.vim'
2809 call assert_equal('text', s:GetText())
2810 call assert_false(exists('*GetText'))
2811 END
2812 writefile(legacy_lines, 'Xlegacy_script.vim')
2813
Bram Moolenaar9721fb42020-06-11 23:10:46 +02002814 source Xlegacy_script.vim
Bram Moolenaar9721fb42020-06-11 23:10:46 +02002815 assert_equal('global', g:global)
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002816 unlet g:global
Bram Moolenaar9721fb42020-06-11 23:10:46 +02002817
2818 delete('Xlegacy_script.vim')
2819 delete('Xvim9_script.vim')
2820enddef
Bram Moolenaara5d00772020-05-14 23:20:55 +02002821
Bram Moolenaar7d699702020-08-14 20:52:28 +02002822func Test_vim9script_not_global()
2823 " check that items defined in Vim9 script are script-local, not global
2824 let vim9lines =<< trim END
2825 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002826 var name = 'local'
Bram Moolenaar7d699702020-08-14 20:52:28 +02002827 func TheFunc()
2828 echo 'local'
2829 endfunc
2830 def DefFunc()
2831 echo 'local'
2832 enddef
2833 END
2834 call writefile(vim9lines, 'Xvim9script.vim')
2835 source Xvim9script.vim
2836 try
2837 echo g:var
2838 assert_report('did not fail')
2839 catch /E121:/
2840 " caught
2841 endtry
2842 try
2843 call TheFunc()
2844 assert_report('did not fail')
2845 catch /E117:/
2846 " caught
2847 endtry
2848 try
2849 call DefFunc()
2850 assert_report('did not fail')
2851 catch /E117:/
2852 " caught
2853 endtry
2854
Bram Moolenaar25859dd2020-08-30 12:54:53 +02002855 call delete('Xvim9script.vim')
Bram Moolenaar7d699702020-08-14 20:52:28 +02002856endfunc
2857
Bram Moolenaareeb27bf2020-07-04 17:39:10 +02002858def Test_vim9_copen()
2859 # this was giving an error for setting w:quickfix_title
2860 copen
2861 quit
2862enddef
2863
Bram Moolenaar03290b82020-12-19 16:30:44 +01002864" test using an auto-loaded function and variable
Bram Moolenaar2d6b20d2020-07-25 19:30:59 +02002865def Test_vim9_autoload()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002866 var lines =<< trim END
Bram Moolenaar2d6b20d2020-07-25 19:30:59 +02002867 vim9script
Bram Moolenaar03290b82020-12-19 16:30:44 +01002868 def some#gettest(): string
2869 return 'test'
2870 enddef
2871 g:some#name = 'name'
2872 END
2873
2874 mkdir('Xdir/autoload', 'p')
2875 writefile(lines, 'Xdir/autoload/some.vim')
2876 var save_rtp = &rtp
2877 exe 'set rtp^=' .. getcwd() .. '/Xdir'
2878
2879 assert_equal('test', g:some#gettest())
2880 assert_equal('name', g:some#name)
2881 g:some#other = 'other'
2882 assert_equal('other', g:some#other)
2883
Bram Moolenaar17f700a2020-12-19 21:23:42 +01002884 # upper case script name works
2885 lines =<< trim END
2886 vim9script
2887 def Other#getOther(): string
2888 return 'other'
2889 enddef
2890 END
2891 writefile(lines, 'Xdir/autoload/Other.vim')
2892 assert_equal('other', g:Other#getOther())
2893
Bram Moolenaar03290b82020-12-19 16:30:44 +01002894 delete('Xdir', 'rf')
2895 &rtp = save_rtp
2896enddef
2897
2898" test using a vim9script that is auto-loaded from an autocmd
2899def Test_vim9_aucmd_autoload()
2900 var lines =<< trim END
2901 vim9script
Bram Moolenaar2d6b20d2020-07-25 19:30:59 +02002902 def foo#test()
2903 echomsg getreg('"')
2904 enddef
2905 END
2906
2907 mkdir('Xdir/autoload', 'p')
2908 writefile(lines, 'Xdir/autoload/foo.vim')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002909 var save_rtp = &rtp
Bram Moolenaar2d6b20d2020-07-25 19:30:59 +02002910 exe 'set rtp^=' .. getcwd() .. '/Xdir'
2911 augroup test
2912 autocmd TextYankPost * call foo#test()
2913 augroup END
2914
2915 normal Y
2916
2917 augroup test
2918 autocmd!
2919 augroup END
2920 delete('Xdir', 'rf')
2921 &rtp = save_rtp
2922enddef
2923
Bram Moolenaar77e5dcc2020-09-17 21:29:03 +02002924" This was causing a crash because suppress_errthrow wasn't reset.
2925def Test_vim9_autoload_error()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002926 var lines =<< trim END
Bram Moolenaar77e5dcc2020-09-17 21:29:03 +02002927 vim9script
2928 def crash#func()
2929 try
2930 for x in List()
2931 endfor
2932 catch
2933 endtry
2934 g:ok = true
2935 enddef
2936 fu List()
2937 invalid
2938 endfu
2939 try
2940 invalid
2941 catch /wontmatch/
2942 endtry
2943 END
2944 call mkdir('Xruntime/autoload', 'p')
2945 call writefile(lines, 'Xruntime/autoload/crash.vim')
2946
2947 # run in a separate Vim to avoid the side effects of assert_fails()
2948 lines =<< trim END
2949 exe 'set rtp^=' .. getcwd() .. '/Xruntime'
2950 call crash#func()
2951 call writefile(['ok'], 'Xdidit')
Bram Moolenaar9c4f5522020-09-25 21:47:28 +02002952 qall!
Bram Moolenaar77e5dcc2020-09-17 21:29:03 +02002953 END
2954 writefile(lines, 'Xscript')
2955 RunVim([], [], '-S Xscript')
2956 assert_equal(['ok'], readfile('Xdidit'))
2957
2958 delete('Xdidit')
2959 delete('Xscript')
2960 delete('Xruntime', 'rf')
Bram Moolenaar03290b82020-12-19 16:30:44 +01002961
2962 lines =<< trim END
2963 vim9script
2964 var foo#bar = 'asdf'
2965 END
2966 CheckScriptFailure(lines, 'E461: Illegal variable name: foo#bar', 2)
Bram Moolenaar77e5dcc2020-09-17 21:29:03 +02002967enddef
2968
Bram Moolenaar81e17fb2020-08-21 21:55:43 +02002969def Test_script_var_in_autocmd()
2970 # using a script variable from an autocommand, defined in a :def function in a
2971 # legacy Vim script, cannot check the variable type.
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002972 var lines =<< trim END
Bram Moolenaar81e17fb2020-08-21 21:55:43 +02002973 let s:counter = 1
2974 def s:Func()
2975 au! CursorHold
2976 au CursorHold * s:counter += 1
2977 enddef
2978 call s:Func()
2979 doau CursorHold
2980 call assert_equal(2, s:counter)
2981 au! CursorHold
2982 END
2983 CheckScriptSuccess(lines)
2984enddef
2985
Bram Moolenaar3896a102020-08-09 14:33:55 +02002986def Test_cmdline_win()
2987 # if the Vim syntax highlighting uses Vim9 constructs they can be used from
2988 # the command line window.
2989 mkdir('rtp/syntax', 'p')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002990 var export_lines =<< trim END
Bram Moolenaar3896a102020-08-09 14:33:55 +02002991 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002992 export var That = 'yes'
Bram Moolenaar3896a102020-08-09 14:33:55 +02002993 END
2994 writefile(export_lines, 'rtp/syntax/Xexport.vim')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002995 var import_lines =<< trim END
Bram Moolenaar3896a102020-08-09 14:33:55 +02002996 vim9script
2997 import That from './Xexport.vim'
2998 END
2999 writefile(import_lines, 'rtp/syntax/vim.vim')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003000 var save_rtp = &rtp
Bram Moolenaar3896a102020-08-09 14:33:55 +02003001 &rtp = getcwd() .. '/rtp' .. ',' .. &rtp
3002 syntax on
3003 augroup CmdWin
3004 autocmd CmdwinEnter * g:got_there = 'yes'
3005 augroup END
3006 # this will open and also close the cmdline window
3007 feedkeys('q:', 'xt')
3008 assert_equal('yes', g:got_there)
3009
3010 augroup CmdWin
3011 au!
3012 augroup END
3013 &rtp = save_rtp
3014 delete('rtp', 'rf')
3015enddef
3016
Bram Moolenaare3d46852020-08-29 13:39:17 +02003017def Test_invalid_sid()
3018 assert_fails('func <SNR>1234_func', 'E123:')
Bram Moolenaar25859dd2020-08-30 12:54:53 +02003019
Bram Moolenaar9c4f5522020-09-25 21:47:28 +02003020 if RunVim([], ['wq! Xdidit'], '+"func <SNR>1_func"')
Bram Moolenaard2c61702020-09-06 15:58:36 +02003021 assert_equal([], readfile('Xdidit'))
Bram Moolenaare3d46852020-08-29 13:39:17 +02003022 endif
3023 delete('Xdidit')
3024enddef
3025
Bram Moolenaar9ec70262020-12-09 17:16:59 +01003026def Test_restoring_cpo()
3027 writefile(['vim9script', 'set nocp'], 'Xsourced')
3028 writefile(['call writefile(["done"], "Xdone")', 'quit!'], 'Xclose')
3029 if RunVim([], [], '-u NONE +"set cpo+=a" -S Xsourced -S Xclose')
3030 assert_equal(['done'], readfile('Xdone'))
3031 endif
3032 delete('Xsourced')
3033 delete('Xclose')
Bram Moolenaar090728a2020-12-20 15:43:31 +01003034 delete('Xdone')
Bram Moolenaar9ec70262020-12-09 17:16:59 +01003035enddef
3036
3037
Bram Moolenaarf0afd9e2020-09-13 18:57:47 +02003038def Test_unset_any_variable()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003039 var lines =<< trim END
3040 var name: any
3041 assert_equal(0, name)
Bram Moolenaarf0afd9e2020-09-13 18:57:47 +02003042 END
3043 CheckDefAndScriptSuccess(lines)
3044enddef
3045
Bram Moolenaar7e9210e2020-09-25 23:12:51 +02003046func Test_define_func_at_command_line()
Bram Moolenaar58dbef32020-09-25 22:13:05 +02003047 CheckRunVimInTerminal
3048
Bram Moolenaar7e9210e2020-09-25 23:12:51 +02003049 " call indirectly to avoid compilation error for missing functions
3050 call Run_Test_define_func_at_command_line()
3051endfunc
3052
3053def Run_Test_define_func_at_command_line()
Bram Moolenaar9c4f5522020-09-25 21:47:28 +02003054 # run in a separate Vim instance to avoid the script context
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003055 var lines =<< trim END
Bram Moolenaar9c4f5522020-09-25 21:47:28 +02003056 func CheckAndQuit()
3057 call assert_fails('call Afunc()', 'E117: Unknown function: Bfunc')
3058 call writefile(['errors: ' .. string(v:errors)], 'Xdidcmd')
3059 endfunc
3060 END
3061 writefile([''], 'Xdidcmd')
3062 writefile(lines, 'XcallFunc')
Bram Moolenaare0de1712020-12-02 17:36:54 +01003063 var buf = RunVimInTerminal('-S XcallFunc', {rows: 6})
Bram Moolenaar9c4f5522020-09-25 21:47:28 +02003064 # define Afunc() on the command line
3065 term_sendkeys(buf, ":def Afunc()\<CR>Bfunc()\<CR>enddef\<CR>")
3066 term_sendkeys(buf, ":call CheckAndQuit()\<CR>")
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01003067 WaitForAssert(() => assert_equal(['errors: []'], readfile('Xdidcmd')))
Bram Moolenaar9c4f5522020-09-25 21:47:28 +02003068
3069 call StopVimInTerminal(buf)
3070 delete('XcallFunc')
3071 delete('Xdidcmd')
3072enddef
3073
Bram Moolenaarfcdc5d82020-10-10 19:07:09 +02003074def Test_script_var_scope()
3075 var lines =<< trim END
3076 vim9script
3077 if true
3078 if true
3079 var one = 'one'
3080 echo one
3081 endif
3082 echo one
3083 endif
3084 END
3085 CheckScriptFailure(lines, 'E121:', 7)
3086
3087 lines =<< trim END
3088 vim9script
3089 if true
3090 if false
3091 var one = 'one'
3092 echo one
3093 else
3094 var one = 'one'
3095 echo one
3096 endif
3097 echo one
3098 endif
3099 END
3100 CheckScriptFailure(lines, 'E121:', 10)
3101
3102 lines =<< trim END
3103 vim9script
3104 while true
3105 var one = 'one'
3106 echo one
3107 break
3108 endwhile
3109 echo one
3110 END
3111 CheckScriptFailure(lines, 'E121:', 7)
3112
3113 lines =<< trim END
3114 vim9script
3115 for i in range(1)
3116 var one = 'one'
3117 echo one
3118 endfor
3119 echo one
3120 END
3121 CheckScriptFailure(lines, 'E121:', 6)
Bram Moolenaar9becdf22020-10-10 21:33:48 +02003122
3123 lines =<< trim END
3124 vim9script
3125 {
3126 var one = 'one'
3127 assert_equal('one', one)
3128 }
3129 assert_false(exists('one'))
3130 assert_false(exists('s:one'))
3131 END
3132 CheckScriptSuccess(lines)
3133
3134 lines =<< trim END
3135 vim9script
3136 {
3137 var one = 'one'
3138 echo one
3139 }
3140 echo one
3141 END
3142 CheckScriptFailure(lines, 'E121:', 6)
Bram Moolenaarfcdc5d82020-10-10 19:07:09 +02003143enddef
3144
Bram Moolenaar352134b2020-10-17 22:04:08 +02003145def Test_catch_exception_in_callback()
3146 var lines =<< trim END
3147 vim9script
3148 def Callback(...l: any)
3149 try
3150 var x: string
3151 var y: string
3152 # this error should be caught with CHECKLEN
3153 [x, y] = ['']
3154 catch
3155 g:caught = 'yes'
3156 endtry
3157 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +01003158 popup_menu('popup', {callback: Callback})
Bram Moolenaar352134b2020-10-17 22:04:08 +02003159 feedkeys("\r", 'xt')
3160 END
3161 CheckScriptSuccess(lines)
3162
3163 unlet g:caught
3164enddef
3165
Bram Moolenaar631e8f92020-11-04 15:07:16 +01003166def Test_no_unknown_error_after_error()
3167 if !has('unix') || !has('job')
3168 throw 'Skipped: not unix of missing +job feature'
3169 endif
3170 var lines =<< trim END
3171 vim9script
3172 var source: list<number>
3173 def Out_cb(...l: any)
3174 eval [][0]
3175 enddef
3176 def Exit_cb(...l: any)
3177 sleep 1m
3178 source += l
3179 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +01003180 var myjob = job_start('echo burp', {out_cb: Out_cb, exit_cb: Exit_cb, mode: 'raw'})
Bram Moolenaar6f17a3f2020-12-21 18:11:24 +01003181 while job_status(myjob) == 'run'
3182 sleep 10m
3183 endwhile
3184 sleep 10m
Bram Moolenaar631e8f92020-11-04 15:07:16 +01003185 END
3186 writefile(lines, 'Xdef')
3187 assert_fails('so Xdef', ['E684:', 'E1012:'])
3188 delete('Xdef')
3189enddef
3190
Bram Moolenaar4324d872020-12-01 20:12:24 +01003191def InvokeNormal()
3192 exe "norm! :m+1\r"
3193enddef
3194
3195def Test_invoke_normal_in_visual_mode()
3196 xnoremap <F3> <Cmd>call <SID>InvokeNormal()<CR>
3197 new
3198 setline(1, ['aaa', 'bbb'])
3199 feedkeys("V\<F3>", 'xt')
3200 assert_equal(['bbb', 'aaa'], getline(1, 2))
3201 xunmap <F3>
3202enddef
3203
Bram Moolenaarb5b94802020-12-13 17:50:20 +01003204def Test_white_space_after_command()
3205 var lines =<< trim END
3206 exit_cb: Func})
3207 END
3208 CheckDefAndScriptFailure(lines, 'E1144:', 1)
Bram Moolenaarf8103f22020-12-25 17:36:27 +01003209
3210 lines =<< trim END
3211 e#
3212 END
3213 CheckDefAndScriptFailure(lines, 'E1144:', 1)
Bram Moolenaarb5b94802020-12-13 17:50:20 +01003214enddef
3215
Bram Moolenaar4aab88d2020-12-24 21:56:41 +01003216def Test_script_var_gone_when_sourced_twice()
3217 var lines =<< trim END
3218 vim9script
3219 if exists('g:guard')
3220 finish
3221 endif
3222 g:guard = 1
3223 var name = 'thename'
3224 def g:GetName(): string
3225 return name
3226 enddef
3227 def g:SetName(arg: string)
3228 name = arg
3229 enddef
3230 END
3231 writefile(lines, 'XscriptTwice.vim')
3232 so XscriptTwice.vim
3233 assert_equal('thename', g:GetName())
3234 g:SetName('newname')
3235 assert_equal('newname', g:GetName())
3236 so XscriptTwice.vim
3237 assert_fails('call g:GetName()', 'E1149:')
3238 assert_fails('call g:SetName("x")', 'E1149:')
3239
3240 delfunc g:GetName
3241 delfunc g:SetName
3242 delete('XscriptTwice.vim')
3243 unlet g:guard
3244enddef
3245
3246def Test_import_gone_when_sourced_twice()
3247 var exportlines =<< trim END
3248 vim9script
3249 if exists('g:guard')
3250 finish
3251 endif
3252 g:guard = 1
3253 export var name = 'someName'
3254 END
3255 writefile(exportlines, 'XexportScript.vim')
3256
3257 var lines =<< trim END
3258 vim9script
3259 import name from './XexportScript.vim'
3260 def g:GetName(): string
3261 return name
3262 enddef
3263 END
3264 writefile(lines, 'XscriptImport.vim')
3265 so XscriptImport.vim
3266 assert_equal('someName', g:GetName())
3267
3268 so XexportScript.vim
3269 assert_fails('call g:GetName()', 'E1149:')
3270
3271 delfunc g:GetName
3272 delete('XexportScript.vim')
3273 delete('XscriptImport.vim')
3274 unlet g:guard
3275enddef
3276
Bram Moolenaar585fea72020-04-02 22:33:21 +02003277" Keep this last, it messes up highlighting.
3278def Test_substitute_cmd()
3279 new
3280 setline(1, 'something')
3281 :substitute(some(other(
3282 assert_equal('otherthing', getline(1))
3283 bwipe!
3284
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02003285 # also when the context is Vim9 script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003286 var lines =<< trim END
Bram Moolenaar585fea72020-04-02 22:33:21 +02003287 vim9script
3288 new
3289 setline(1, 'something')
3290 :substitute(some(other(
3291 assert_equal('otherthing', getline(1))
3292 bwipe!
3293 END
3294 writefile(lines, 'Xvim9lines')
3295 source Xvim9lines
3296
3297 delete('Xvim9lines')
3298enddef
3299
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003300" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker