blob: 957671c53b03148a4b1bb471cff31c9026f5e807 [file] [log] [blame]
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001" Test various aspects of the Vim9 script language.
2
Bram Moolenaar673660a2020-01-26 16:50:05 +01003source check.vim
Bram Moolenaar101f4812020-06-16 23:18:51 +02004source term_util.vim
Bram Moolenaarad39c092020-02-26 18:23:43 +01005source view_util.vim
Bram Moolenaarcfe435d2020-04-25 20:02:55 +02006source vim9.vim
Bram Moolenaare3d46852020-08-29 13:39:17 +02007source shared.vim
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008
Bram Moolenaar5d72ce62020-08-20 23:04:06 +02009def Test_range_only()
10 new
11 setline(1, ['blah', 'Blah'])
12 :/Blah/
13 assert_equal(2, getcurpos()[1])
Bram Moolenaarc2af0af2020-08-23 21:06:02 +020014 bwipe!
15
16 # without range commands use current line
17 new
18 setline(1, ['one', 'two', 'three'])
19 :2
20 print
21 assert_equal('two', Screenline(&lines))
22 :3
23 list
24 assert_equal('three$', Screenline(&lines))
25 bwipe!
Bram Moolenaar025cb1c2020-12-14 18:31:27 +010026
27 # won't generate anything
28 if false
29 :123
30 endif
Bram Moolenaar5d72ce62020-08-20 23:04:06 +020031enddef
32
Bram Moolenaara6e67e42020-05-15 23:36:40 +020033let g:alist = [7]
34let g:astring = 'text'
Bram Moolenaarf0b9f432020-07-17 23:03:17 +020035let g:anumber = 123
Bram Moolenaar6e587dc2020-02-06 13:15:52 +010036
Bram Moolenaar4c17ad92020-04-27 22:47:51 +020037def Test_delfunction()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +020038 # Check function is defined in script namespace
Bram Moolenaar4c17ad92020-04-27 22:47:51 +020039 CheckScriptSuccess([
40 'vim9script',
41 'func CheckMe()',
42 ' return 123',
43 'endfunc',
44 'assert_equal(123, s:CheckMe())',
45 ])
46
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +020047 # Check function in script namespace cannot be deleted
Bram Moolenaar4c17ad92020-04-27 22:47:51 +020048 CheckScriptFailure([
49 'vim9script',
50 'func DeleteMe1()',
51 'endfunc',
52 'delfunction DeleteMe1',
53 ], 'E1084:')
54 CheckScriptFailure([
55 'vim9script',
56 'func DeleteMe2()',
57 'endfunc',
58 'def DoThat()',
59 ' delfunction DeleteMe2',
60 'enddef',
61 'DoThat()',
62 ], 'E1084:')
63 CheckScriptFailure([
64 'vim9script',
65 'def DeleteMe3()',
66 'enddef',
67 'delfunction DeleteMe3',
68 ], 'E1084:')
69 CheckScriptFailure([
70 'vim9script',
71 'def DeleteMe4()',
72 'enddef',
73 'def DoThat()',
74 ' delfunction DeleteMe4',
75 'enddef',
76 'DoThat()',
77 ], 'E1084:')
Bram Moolenaar925e9fd2020-07-25 15:41:11 +020078
79 # Check that global :def function can be replaced and deleted
Bram Moolenaarcfcd0112020-09-27 15:19:27 +020080 var lines =<< trim END
Bram Moolenaar925e9fd2020-07-25 15:41:11 +020081 vim9script
82 def g:Global(): string
83 return "yes"
84 enddef
85 assert_equal("yes", g:Global())
86 def! g:Global(): string
87 return "no"
88 enddef
89 assert_equal("no", g:Global())
90 delfunc g:Global
91 assert_false(exists('*g:Global'))
92 END
93 CheckScriptSuccess(lines)
94
95 # Check that global function can be replaced by a :def function and deleted
96 lines =<< trim END
97 vim9script
98 func g:Global()
99 return "yes"
100 endfunc
101 assert_equal("yes", g:Global())
102 def! g:Global(): string
103 return "no"
104 enddef
105 assert_equal("no", g:Global())
106 delfunc g:Global
107 assert_false(exists('*g:Global'))
108 END
109 CheckScriptSuccess(lines)
110
111 # Check that global :def function can be replaced by a function and deleted
112 lines =<< trim END
113 vim9script
114 def g:Global(): string
115 return "yes"
116 enddef
117 assert_equal("yes", g:Global())
118 func! g:Global()
119 return "no"
120 endfunc
121 assert_equal("no", g:Global())
122 delfunc g:Global
123 assert_false(exists('*g:Global'))
124 END
125 CheckScriptSuccess(lines)
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200126enddef
127
Bram Moolenaar08052222020-09-14 17:04:31 +0200128def Test_wrong_type()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200129 CheckDefFailure(['var name: list<nothing>'], 'E1010:')
130 CheckDefFailure(['var name: list<list<nothing>>'], 'E1010:')
131 CheckDefFailure(['var name: dict<nothing>'], 'E1010:')
132 CheckDefFailure(['var name: dict<dict<nothing>>'], 'E1010:')
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100133
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200134 CheckDefFailure(['var name: dict<number'], 'E1009:')
135 CheckDefFailure(['var name: dict<list<number>'], 'E1009:')
Bram Moolenaar42a480b2020-02-29 23:23:47 +0100136
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200137 CheckDefFailure(['var name: ally'], 'E1010:')
138 CheckDefFailure(['var name: bram'], 'E1010:')
139 CheckDefFailure(['var name: cathy'], 'E1010:')
140 CheckDefFailure(['var name: dom'], 'E1010:')
141 CheckDefFailure(['var name: freddy'], 'E1010:')
142 CheckDefFailure(['var name: john'], 'E1010:')
143 CheckDefFailure(['var name: larry'], 'E1010:')
144 CheckDefFailure(['var name: ned'], 'E1010:')
145 CheckDefFailure(['var name: pam'], 'E1010:')
146 CheckDefFailure(['var name: sam'], 'E1010:')
147 CheckDefFailure(['var name: vim'], 'E1010:')
Bram Moolenaara0a9f432020-04-28 21:29:34 +0200148
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200149 CheckDefFailure(['var Ref: number', 'Ref()'], 'E1085:')
150 CheckDefFailure(['var Ref: string', 'var res = Ref()'], 'E1085:')
Bram Moolenaar08052222020-09-14 17:04:31 +0200151enddef
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100152
Bram Moolenaar10c65862020-10-08 21:16:42 +0200153def Test_script_wrong_type()
154 var lines =<< trim END
155 vim9script
156 var s:dict: dict<string>
157 s:dict['a'] = ['x']
158 END
159 CheckScriptFailure(lines, 'E1012: Type mismatch; expected string but got list<string>', 3)
160enddef
161
Bram Moolenaar08052222020-09-14 17:04:31 +0200162def Test_const()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200163 CheckDefFailure(['final name = 234', 'name = 99'], 'E1018:')
164 CheckDefFailure(['final one = 234', 'var one = 99'], 'E1017:')
165 CheckDefFailure(['final list = [1, 2]', 'var list = [3, 4]'], 'E1017:')
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200166 CheckDefFailure(['final two'], 'E1125:')
167 CheckDefFailure(['final &option'], 'E996:')
Bram Moolenaardbeecb22020-09-14 18:15:09 +0200168
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200169 var lines =<< trim END
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200170 final list = [1, 2, 3]
Bram Moolenaardbeecb22020-09-14 18:15:09 +0200171 list[0] = 4
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200172 list->assert_equal([4, 2, 3])
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200173 const other = [5, 6, 7]
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200174 other->assert_equal([5, 6, 7])
Bram Moolenaar71abe482020-09-14 22:28:30 +0200175
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200176 var varlist = [7, 8]
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200177 const constlist = [1, varlist, 3]
Bram Moolenaar71abe482020-09-14 22:28:30 +0200178 varlist[0] = 77
179 # TODO: does not work yet
180 # constlist[1][1] = 88
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200181 var cl = constlist[1]
Bram Moolenaar71abe482020-09-14 22:28:30 +0200182 cl[1] = 88
183 constlist->assert_equal([1, [77, 88], 3])
184
Bram Moolenaare0de1712020-12-02 17:36:54 +0100185 var vardict = {five: 5, six: 6}
186 const constdict = {one: 1, two: vardict, three: 3}
Bram Moolenaar71abe482020-09-14 22:28:30 +0200187 vardict['five'] = 55
188 # TODO: does not work yet
189 # constdict['two']['six'] = 66
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200190 var cd = constdict['two']
Bram Moolenaar71abe482020-09-14 22:28:30 +0200191 cd['six'] = 66
Bram Moolenaare0de1712020-12-02 17:36:54 +0100192 constdict->assert_equal({one: 1, two: {five: 55, six: 66}, three: 3})
Bram Moolenaardbeecb22020-09-14 18:15:09 +0200193 END
194 CheckDefAndScriptSuccess(lines)
Bram Moolenaar08052222020-09-14 17:04:31 +0200195enddef
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100196
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200197def Test_const_bang()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200198 var lines =<< trim END
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200199 const var = 234
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200200 var = 99
201 END
202 CheckDefExecFailure(lines, 'E1018:', 2)
203 CheckScriptFailure(['vim9script'] + lines, 'E46:', 3)
204
205 lines =<< trim END
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200206 const ll = [2, 3, 4]
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200207 ll[0] = 99
208 END
209 CheckDefExecFailure(lines, 'E1119:', 2)
210 CheckScriptFailure(['vim9script'] + lines, 'E741:', 3)
211
212 lines =<< trim END
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200213 const ll = [2, 3, 4]
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200214 ll[3] = 99
215 END
216 CheckDefExecFailure(lines, 'E1118:', 2)
217 CheckScriptFailure(['vim9script'] + lines, 'E684:', 3)
218
219 lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +0100220 const dd = {one: 1, two: 2}
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200221 dd["one"] = 99
222 END
223 CheckDefExecFailure(lines, 'E1121:', 2)
224 CheckScriptFailure(['vim9script'] + lines, 'E741:', 3)
225
226 lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +0100227 const dd = {one: 1, two: 2}
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200228 dd["three"] = 99
229 END
230 CheckDefExecFailure(lines, 'E1120:')
231 CheckScriptFailure(['vim9script'] + lines, 'E741:', 3)
232enddef
233
Bram Moolenaardf069ee2020-06-22 23:02:51 +0200234def Test_range_no_colon()
Bram Moolenaard2c61702020-09-06 15:58:36 +0200235 CheckDefFailure(['%s/a/b/'], 'E1050:')
236 CheckDefFailure(['+ s/a/b/'], 'E1050:')
237 CheckDefFailure(['- s/a/b/'], 'E1050:')
238 CheckDefFailure(['. s/a/b/'], 'E1050:')
Bram Moolenaardf069ee2020-06-22 23:02:51 +0200239enddef
240
241
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100242def Test_block()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200243 var outer = 1
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100244 {
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200245 var inner = 2
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100246 assert_equal(1, outer)
247 assert_equal(2, inner)
248 }
249 assert_equal(1, outer)
250enddef
251
Bram Moolenaar08052222020-09-14 17:04:31 +0200252def Test_block_failure()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200253 CheckDefFailure(['{', 'var inner = 1', '}', 'echo inner'], 'E1001:')
Bram Moolenaar08052222020-09-14 17:04:31 +0200254 CheckDefFailure(['}'], 'E1025:')
255 CheckDefFailure(['{', 'echo 1'], 'E1026:')
256enddef
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100257
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200258def Test_block_local_vars()
259 var lines =<< trim END
260 vim9script
Bram Moolenaared234f22020-10-15 20:42:20 +0200261 v:testing = 1
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200262 if true
Bram Moolenaared234f22020-10-15 20:42:20 +0200263 var text = ['hello']
264 def SayHello(): list<string>
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200265 return text
266 enddef
267 def SetText(v: string)
Bram Moolenaared234f22020-10-15 20:42:20 +0200268 text = [v]
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200269 enddef
270 endif
271
272 if true
Bram Moolenaared234f22020-10-15 20:42:20 +0200273 var text = ['again']
274 def SayAgain(): list<string>
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200275 return text
276 enddef
277 endif
Bram Moolenaared234f22020-10-15 20:42:20 +0200278
279 # test that the "text" variables are not cleaned up
280 test_garbagecollect_now()
281
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200282 defcompile
283
Bram Moolenaared234f22020-10-15 20:42:20 +0200284 assert_equal(['hello'], SayHello())
285 assert_equal(['again'], SayAgain())
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200286
287 SetText('foobar')
Bram Moolenaared234f22020-10-15 20:42:20 +0200288 assert_equal(['foobar'], SayHello())
289
290 call writefile(['ok'], 'Xdidit')
291 qall!
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200292 END
Bram Moolenaared234f22020-10-15 20:42:20 +0200293
294 # need to execute this with a separate Vim instance to avoid the current
295 # context gets garbage collected.
296 writefile(lines, 'Xscript')
297 RunVim([], [], '-S Xscript')
298 assert_equal(['ok'], readfile('Xdidit'))
299
300 delete('Xscript')
301 delete('Xdidit')
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200302enddef
303
Bram Moolenaar39ca4122020-10-20 14:25:07 +0200304def Test_block_local_vars_with_func()
305 var lines =<< trim END
306 vim9script
307 if true
308 var foo = 'foo'
309 if true
310 var bar = 'bar'
311 def Func(): list<string>
312 return [foo, bar]
313 enddef
314 endif
315 endif
316 # function is compiled here, after blocks have finished, can still access
317 # "foo" and "bar"
318 assert_equal(['foo', 'bar'], Func())
319 END
320 CheckScriptSuccess(lines)
321enddef
322
Bram Moolenaard032f342020-07-18 18:13:02 +0200323func g:NoSuchFunc()
324 echo 'none'
325endfunc
326
Bram Moolenaar9e1d9e32021-01-11 20:17:34 +0100327def Test_try_catch_throw()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200328 var l = []
Bram Moolenaar7a092242020-04-16 22:10:49 +0200329 try # comment
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100330 add(l, '1')
331 throw 'wrong'
332 add(l, '2')
Bram Moolenaar7a092242020-04-16 22:10:49 +0200333 catch # comment
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100334 add(l, v:exception)
Bram Moolenaar7a092242020-04-16 22:10:49 +0200335 finally # comment
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100336 add(l, '3')
Bram Moolenaar7a092242020-04-16 22:10:49 +0200337 endtry # comment
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100338 assert_equal(['1', 'wrong', '3'], l)
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200339
Bram Moolenaare8593122020-07-18 15:17:02 +0200340 l = []
341 try
342 try
343 add(l, '1')
344 throw 'wrong'
345 add(l, '2')
346 catch /right/
347 add(l, v:exception)
348 endtry
349 catch /wrong/
350 add(l, 'caught')
Bram Moolenaar373863e2020-09-26 17:20:53 +0200351 fina
Bram Moolenaare8593122020-07-18 15:17:02 +0200352 add(l, 'finally')
353 endtry
354 assert_equal(['1', 'caught', 'finally'], l)
355
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200356 var n: number
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200357 try
358 n = l[3]
359 catch /E684:/
360 n = 99
361 endtry
362 assert_equal(99, n)
363
Bram Moolenaar69f70502021-01-01 16:10:46 +0100364 var done = 'no'
365 if 0
366 try | catch | endtry
367 else
368 done = 'yes'
369 endif
370 assert_equal('yes', done)
371
372 done = 'no'
373 if 1
374 done = 'yes'
375 else
376 try | catch | endtry
377 done = 'never'
378 endif
379 assert_equal('yes', done)
380
381 if 1
382 else
383 try | catch /pat/ | endtry
384 try | catch /pat/
385 endtry
386 try
387 catch /pat/ | endtry
388 try
389 catch /pat/
390 endtry
391 endif
392
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200393 try
Bram Moolenaarcc673e72020-08-16 17:33:35 +0200394 # string slice returns a string, not a number
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200395 n = g:astring[3]
Bram Moolenaar5e654232020-09-16 15:22:00 +0200396 catch /E1012:/
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200397 n = 77
398 endtry
399 assert_equal(77, n)
400
401 try
402 n = l[g:astring]
Bram Moolenaar5e654232020-09-16 15:22:00 +0200403 catch /E1012:/
Bram Moolenaar56acb092020-08-16 14:48:19 +0200404 n = 88
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200405 endtry
Bram Moolenaar56acb092020-08-16 14:48:19 +0200406 assert_equal(88, n)
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200407
408 try
409 n = s:does_not_exist
410 catch /E121:/
Bram Moolenaarf0b9f432020-07-17 23:03:17 +0200411 n = 111
412 endtry
413 assert_equal(111, n)
414
415 try
416 n = g:does_not_exist
417 catch /E121:/
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200418 n = 121
419 endtry
420 assert_equal(121, n)
421
Bram Moolenaare0de1712020-12-02 17:36:54 +0100422 var d = {one: 1}
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200423 try
424 n = d[g:astring]
425 catch /E716:/
426 n = 222
427 endtry
428 assert_equal(222, n)
Bram Moolenaarf0b9f432020-07-17 23:03:17 +0200429
430 try
431 n = -g:astring
432 catch /E39:/
433 n = 233
434 endtry
435 assert_equal(233, n)
436
437 try
438 n = +g:astring
439 catch /E1030:/
440 n = 244
441 endtry
442 assert_equal(244, n)
443
444 try
445 n = +g:alist
446 catch /E745:/
447 n = 255
448 endtry
449 assert_equal(255, n)
450
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200451 var nd: dict<any>
Bram Moolenaarf0b9f432020-07-17 23:03:17 +0200452 try
Bram Moolenaar2bede172020-11-19 18:53:18 +0100453 nd = {[g:anumber]: 1}
Bram Moolenaar5e654232020-09-16 15:22:00 +0200454 catch /E1012:/
Bram Moolenaarf0b9f432020-07-17 23:03:17 +0200455 n = 266
456 endtry
457 assert_equal(266, n)
458
459 try
460 [n] = [1, 2, 3]
461 catch /E1093:/
462 n = 277
463 endtry
464 assert_equal(277, n)
465
Bram Moolenaare8593122020-07-18 15:17:02 +0200466 try
467 &ts = g:astring
Bram Moolenaar5e654232020-09-16 15:22:00 +0200468 catch /E1012:/
Bram Moolenaare8593122020-07-18 15:17:02 +0200469 n = 288
470 endtry
471 assert_equal(288, n)
472
473 try
474 &backspace = 'asdf'
475 catch /E474:/
476 n = 299
477 endtry
478 assert_equal(299, n)
479
480 l = [1]
481 try
482 l[3] = 3
483 catch /E684:/
484 n = 300
485 endtry
486 assert_equal(300, n)
487
488 try
Bram Moolenaare8593122020-07-18 15:17:02 +0200489 unlet g:does_not_exist
490 catch /E108:/
491 n = 322
492 endtry
493 assert_equal(322, n)
494
495 try
Bram Moolenaar2bede172020-11-19 18:53:18 +0100496 d = {text: 1, [g:astring]: 2}
Bram Moolenaare8593122020-07-18 15:17:02 +0200497 catch /E721:/
498 n = 333
499 endtry
500 assert_equal(333, n)
501
502 try
503 l = DeletedFunc()
504 catch /E933:/
505 n = 344
506 endtry
507 assert_equal(344, n)
Bram Moolenaard032f342020-07-18 18:13:02 +0200508
509 try
510 echo len(v:true)
511 catch /E701:/
512 n = 355
513 endtry
514 assert_equal(355, n)
515
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200516 var P = function('g:NoSuchFunc')
Bram Moolenaard032f342020-07-18 18:13:02 +0200517 delfunc g:NoSuchFunc
518 try
519 echo P()
520 catch /E117:/
521 n = 366
522 endtry
523 assert_equal(366, n)
524
525 try
526 echo g:NoSuchFunc()
527 catch /E117:/
528 n = 377
529 endtry
530 assert_equal(377, n)
531
532 try
533 echo g:alist + 4
534 catch /E745:/
535 n = 388
536 endtry
537 assert_equal(388, n)
538
539 try
540 echo 4 + g:alist
541 catch /E745:/
542 n = 399
543 endtry
544 assert_equal(399, n)
545
546 try
547 echo g:alist.member
548 catch /E715:/
549 n = 400
550 endtry
551 assert_equal(400, n)
552
553 try
554 echo d.member
555 catch /E716:/
556 n = 411
557 endtry
558 assert_equal(411, n)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100559enddef
560
Bram Moolenaar1430cee2021-01-17 19:20:32 +0100561def Test_cnext_works_in_catch()
562 var lines =<< trim END
563 vim9script
564 au BufEnter * eval 0
565 writefile(['text'], 'Xfile1')
566 writefile(['text'], 'Xfile2')
567 var items = [
568 {lnum: 1, filename: 'Xfile1', valid: true},
569 {lnum: 1, filename: 'Xfile2', valid: true}
570 ]
571 setqflist([], ' ', {items: items})
572 cwindow
573
574 def CnextOrCfirst()
575 # if cnext fails, cfirst is used
576 try
577 cnext
578 catch
579 cfirst
580 endtry
581 enddef
582
583 CnextOrCfirst()
584 CnextOrCfirst()
585 writefile([getqflist({idx: 0}).idx], 'Xresult')
586 qall
587 END
588 writefile(lines, 'XCatchCnext')
589 RunVim([], [], '--clean -S XCatchCnext')
590 assert_equal(['1'], readfile('Xresult'))
591
592 delete('Xfile1')
593 delete('Xfile2')
594 delete('XCatchCnext')
595 delete('Xresult')
596enddef
597
Bram Moolenaar9e1d9e32021-01-11 20:17:34 +0100598def Test_throw_skipped()
599 if 0
600 throw dontgethere
601 endif
602enddef
603
Bram Moolenaar8f81b222021-01-14 21:47:06 +0100604def Test_nocatch_throw_silenced()
605 var lines =<< trim END
606 vim9script
607 def Func()
608 throw 'error'
609 enddef
610 silent! Func()
611 END
612 writefile(lines, 'XthrowSilenced')
613 source XthrowSilenced
614 delete('XthrowSilenced')
615enddef
616
Bram Moolenaare8593122020-07-18 15:17:02 +0200617def DeletedFunc(): list<any>
618 return ['delete me']
619enddef
620defcompile
621delfunc DeletedFunc
622
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100623def ThrowFromDef()
Bram Moolenaara72cfb82020-04-23 17:07:30 +0200624 throw "getout" # comment
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100625enddef
626
627func CatchInFunc()
628 try
629 call ThrowFromDef()
630 catch
631 let g:thrown_func = v:exception
632 endtry
633endfunc
634
635def CatchInDef()
636 try
637 ThrowFromDef()
638 catch
639 g:thrown_def = v:exception
640 endtry
641enddef
642
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100643def ReturnFinally(): string
644 try
645 return 'intry'
Bram Moolenaar373863e2020-09-26 17:20:53 +0200646 finall
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100647 g:in_finally = 'finally'
648 endtry
649 return 'end'
650enddef
651
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100652def Test_try_catch_nested()
653 CatchInFunc()
654 assert_equal('getout', g:thrown_func)
655
656 CatchInDef()
657 assert_equal('getout', g:thrown_def)
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100658
659 assert_equal('intry', ReturnFinally())
660 assert_equal('finally', g:in_finally)
661enddef
662
Bram Moolenaar9939f572020-09-16 22:29:52 +0200663def TryOne(): number
664 try
665 return 0
666 catch
667 endtry
668 return 0
669enddef
670
671def TryTwo(n: number): string
672 try
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200673 var x = {}
Bram Moolenaar9939f572020-09-16 22:29:52 +0200674 catch
675 endtry
676 return 'text'
677enddef
678
679def Test_try_catch_twice()
680 assert_equal('text', TryOne()->TryTwo())
681enddef
682
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100683def Test_try_catch_match()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200684 var seq = 'a'
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100685 try
686 throw 'something'
687 catch /nothing/
688 seq ..= 'x'
689 catch /some/
690 seq ..= 'b'
691 catch /asdf/
692 seq ..= 'x'
Bram Moolenaare8c4abb2020-04-02 21:13:25 +0200693 catch ?a\?sdf?
694 seq ..= 'y'
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100695 finally
696 seq ..= 'c'
697 endtry
698 assert_equal('abc', seq)
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100699enddef
700
Bram Moolenaare8c4abb2020-04-02 21:13:25 +0200701def Test_try_catch_fails()
Bram Moolenaard2c61702020-09-06 15:58:36 +0200702 CheckDefFailure(['catch'], 'E603:')
703 CheckDefFailure(['try', 'echo 0', 'catch', 'catch'], 'E1033:')
704 CheckDefFailure(['try', 'echo 0', 'catch /pat'], 'E1067:')
705 CheckDefFailure(['finally'], 'E606:')
706 CheckDefFailure(['try', 'echo 0', 'finally', 'echo 1', 'finally'], 'E607:')
707 CheckDefFailure(['endtry'], 'E602:')
708 CheckDefFailure(['while 1', 'endtry'], 'E170:')
709 CheckDefFailure(['for i in range(5)', 'endtry'], 'E170:')
Bram Moolenaar13106602020-10-04 16:06:05 +0200710 CheckDefFailure(['if 1', 'endtry'], 'E171:')
Bram Moolenaard2c61702020-09-06 15:58:36 +0200711 CheckDefFailure(['try', 'echo 1', 'endtry'], 'E1032:')
Bram Moolenaar585fea72020-04-02 22:33:21 +0200712
Bram Moolenaare4984292020-12-13 14:19:25 +0100713 CheckDefFailure(['throw'], 'E1143:')
Bram Moolenaard2c61702020-09-06 15:58:36 +0200714 CheckDefFailure(['throw xxx'], 'E1001:')
Bram Moolenaare8c4abb2020-04-02 21:13:25 +0200715enddef
716
Bram Moolenaar006ad482020-06-30 20:55:15 +0200717def Test_throw_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200718 # only checks line continuation
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200719 var lines =<< trim END
Bram Moolenaar006ad482020-06-30 20:55:15 +0200720 vim9script
721 try
722 throw 'one'
723 .. 'two'
724 catch
725 assert_equal('onetwo', v:exception)
726 endtry
727 END
728 CheckScriptSuccess(lines)
Bram Moolenaar1e021e62020-10-16 20:25:23 +0200729
730 lines =<< trim END
731 vim9script
Bram Moolenaar352134b2020-10-17 22:04:08 +0200732 @r = ''
Bram Moolenaar1e021e62020-10-16 20:25:23 +0200733 def Func()
734 throw @r
735 enddef
736 var result = ''
737 try
738 Func()
739 catch /E1129:/
740 result = 'caught'
741 endtry
742 assert_equal('caught', result)
743 END
744 CheckScriptSuccess(lines)
Bram Moolenaar006ad482020-06-30 20:55:15 +0200745enddef
746
Bram Moolenaared677f52020-08-12 16:38:10 +0200747def Test_error_in_nested_function()
748 # an error in a nested :function aborts executin in the calling :def function
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200749 var lines =<< trim END
Bram Moolenaared677f52020-08-12 16:38:10 +0200750 vim9script
751 def Func()
752 Error()
753 g:test_var = 1
754 enddef
755 func Error() abort
756 eval [][0]
757 endfunc
758 Func()
759 END
760 g:test_var = 0
761 CheckScriptFailure(lines, 'E684:')
762 assert_equal(0, g:test_var)
763enddef
764
Bram Moolenaar37c83712020-06-30 21:18:36 +0200765def Test_cexpr_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200766 # only checks line continuation
Bram Moolenaar37c83712020-06-30 21:18:36 +0200767 set errorformat=File\ %f\ line\ %l
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200768 var lines =<< trim END
Bram Moolenaar37c83712020-06-30 21:18:36 +0200769 vim9script
770 cexpr 'File'
771 .. ' someFile' ..
772 ' line 19'
773 assert_equal(19, getqflist()[0].lnum)
774 END
775 CheckScriptSuccess(lines)
776 set errorformat&
777enddef
778
Bram Moolenaarc9edd6b2020-08-12 22:18:23 +0200779def Test_statusline_syntax()
780 # legacy syntax is used for 'statusline'
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200781 var lines =<< trim END
Bram Moolenaarc9edd6b2020-08-12 22:18:23 +0200782 vim9script
783 func g:Status()
784 return '%{"x" is# "x"}'
785 endfunc
786 set laststatus=2 statusline=%!Status()
787 redrawstatus
788 set laststatus statusline=
789 END
790 CheckScriptSuccess(lines)
791enddef
792
Bram Moolenaarb2097502020-07-19 17:17:02 +0200793def Test_list_vimscript()
794 # checks line continuation and comments
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200795 var lines =<< trim END
Bram Moolenaarb2097502020-07-19 17:17:02 +0200796 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200797 var mylist = [
Bram Moolenaarb2097502020-07-19 17:17:02 +0200798 'one',
799 # comment
800 'two', # empty line follows
801
802 'three',
803 ]
804 assert_equal(['one', 'two', 'three'], mylist)
805 END
806 CheckScriptSuccess(lines)
Bram Moolenaar66250c92020-08-20 15:02:42 +0200807
808 # check all lines from heredoc are kept
809 lines =<< trim END
810 # comment 1
811 two
812 # comment 3
813
814 five
815 # comment 6
816 END
817 assert_equal(['# comment 1', 'two', '# comment 3', '', 'five', '# comment 6'], lines)
Bram Moolenaarb2097502020-07-19 17:17:02 +0200818enddef
819
Bram Moolenaar2a1381c2020-05-05 23:32:58 +0200820if has('channel')
821 let someJob = test_null_job()
Bram Moolenaar40ee4662020-05-05 22:08:26 +0200822
Bram Moolenaar2a1381c2020-05-05 23:32:58 +0200823 def FuncWithError()
824 echomsg g:someJob
825 enddef
Bram Moolenaar40ee4662020-05-05 22:08:26 +0200826
Bram Moolenaar2a1381c2020-05-05 23:32:58 +0200827 func Test_convert_emsg_to_exception()
828 try
829 call FuncWithError()
830 catch
831 call assert_match('Vim:E908:', v:exception)
832 endtry
833 endfunc
834endif
Bram Moolenaar40ee4662020-05-05 22:08:26 +0200835
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100836let s:export_script_lines =<< trim END
837 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200838 var name: string = 'bob'
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100839 def Concat(arg: string): string
840 return name .. arg
841 enddef
Bram Moolenaar227a69d2020-05-15 18:17:28 +0200842 g:result = Concat('bie')
843 g:localname = name
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100844
845 export const CONST = 1234
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200846 export var exported = 9876
847 export var exp_name = 'John'
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100848 export def Exported(): string
849 return 'Exported'
850 enddef
851END
852
Bram Moolenaarb3ca9822020-08-09 14:43:58 +0200853def Undo_export_script_lines()
854 unlet g:result
855 unlet g:localname
856enddef
857
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100858def Test_vim9_import_export()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200859 var import_script_lines =<< trim END
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100860 vim9script
861 import {exported, Exported} from './Xexport.vim'
862 g:imported = exported
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100863 exported += 3
864 g:imported_added = exported
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100865 g:imported_func = Exported()
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100866
Bram Moolenaar40f4f7a2020-07-23 22:41:43 +0200867 def GetExported(): string
Bram Moolenaare0de1712020-12-02 17:36:54 +0100868 var local_dict = {ref: Exported}
Bram Moolenaar40f4f7a2020-07-23 22:41:43 +0200869 return local_dict.ref()
870 enddef
871 g:funcref_result = GetExported()
872
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100873 import {exp_name} from './Xexport.vim'
874 g:imported_name = exp_name
875 exp_name ..= ' Doe'
876 g:imported_name_appended = exp_name
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100877 g:imported_later = exported
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100878 END
879
880 writefile(import_script_lines, 'Ximport.vim')
881 writefile(s:export_script_lines, 'Xexport.vim')
882
883 source Ximport.vim
884
885 assert_equal('bobbie', g:result)
886 assert_equal('bob', g:localname)
887 assert_equal(9876, g:imported)
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100888 assert_equal(9879, g:imported_added)
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100889 assert_equal(9879, g:imported_later)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100890 assert_equal('Exported', g:imported_func)
Bram Moolenaar40f4f7a2020-07-23 22:41:43 +0200891 assert_equal('Exported', g:funcref_result)
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100892 assert_equal('John', g:imported_name)
893 assert_equal('John Doe', g:imported_name_appended)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100894 assert_false(exists('g:name'))
895
Bram Moolenaarb3ca9822020-08-09 14:43:58 +0200896 Undo_export_script_lines()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100897 unlet g:imported
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100898 unlet g:imported_added
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100899 unlet g:imported_later
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100900 unlet g:imported_func
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100901 unlet g:imported_name g:imported_name_appended
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100902 delete('Ximport.vim')
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100903
Bram Moolenaar1c991142020-07-04 13:15:31 +0200904 # similar, with line breaks
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200905 var import_line_break_script_lines =<< trim END
Bram Moolenaar1c991142020-07-04 13:15:31 +0200906 vim9script
907 import {
908 exported,
909 Exported,
910 }
911 from
912 './Xexport.vim'
913 g:imported = exported
914 exported += 5
915 g:imported_added = exported
916 g:imported_func = Exported()
917 END
918 writefile(import_line_break_script_lines, 'Ximport_lbr.vim')
919 source Ximport_lbr.vim
920
921 assert_equal(9876, g:imported)
922 assert_equal(9881, g:imported_added)
923 assert_equal('Exported', g:imported_func)
924
925 # exported script not sourced again
926 assert_false(exists('g:result'))
927 unlet g:imported
928 unlet g:imported_added
929 unlet g:imported_func
930 delete('Ximport_lbr.vim')
931
932 # import inside :def function
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200933 var import_in_def_lines =<< trim END
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100934 vim9script
935 def ImportInDef()
936 import exported from './Xexport.vim'
937 g:imported = exported
938 exported += 7
939 g:imported_added = exported
940 enddef
941 ImportInDef()
942 END
943 writefile(import_in_def_lines, 'Ximport2.vim')
944 source Ximport2.vim
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200945 # TODO: this should be 9879
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100946 assert_equal(9876, g:imported)
947 assert_equal(9883, g:imported_added)
948 unlet g:imported
949 unlet g:imported_added
950 delete('Ximport2.vim')
951
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200952 var import_star_as_lines =<< trim END
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100953 vim9script
954 import * as Export from './Xexport.vim'
955 def UseExport()
956 g:imported = Export.exported
957 enddef
958 UseExport()
959 END
960 writefile(import_star_as_lines, 'Ximport.vim')
961 source Ximport.vim
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100962 assert_equal(9883, g:imported)
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100963
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200964 var import_star_as_lines_no_dot =<< trim END
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100965 vim9script
966 import * as Export from './Xexport.vim'
967 def Func()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200968 var dummy = 1
969 var imported = Export + dummy
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100970 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +0200971 defcompile
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100972 END
973 writefile(import_star_as_lines_no_dot, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +0200974 assert_fails('source Ximport.vim', 'E1060:', '', 2, 'Func')
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100975
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200976 var import_star_as_lines_dot_space =<< trim END
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100977 vim9script
978 import * as Export from './Xexport.vim'
979 def Func()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200980 var imported = Export . exported
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100981 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +0200982 defcompile
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100983 END
984 writefile(import_star_as_lines_dot_space, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +0200985 assert_fails('source Ximport.vim', 'E1074:', '', 1, 'Func')
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100986
Bram Moolenaara6294952020-12-27 13:39:50 +0100987 var import_star_as_duplicated =<< trim END
988 vim9script
989 import * as Export from './Xexport.vim'
990 var some = 'other'
991 import * as Export from './Xexport.vim'
992 defcompile
993 END
994 writefile(import_star_as_duplicated, 'Ximport.vim')
995 assert_fails('source Ximport.vim', 'E1073:', '', 4, 'Ximport.vim')
996
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200997 var import_star_as_lines_missing_name =<< trim END
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100998 vim9script
999 import * as Export from './Xexport.vim'
1000 def Func()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001001 var imported = Export.
Bram Moolenaar599c89c2020-03-28 14:53:20 +01001002 enddef
Bram Moolenaar822ba242020-05-24 23:00:18 +02001003 defcompile
Bram Moolenaar599c89c2020-03-28 14:53:20 +01001004 END
1005 writefile(import_star_as_lines_missing_name, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001006 assert_fails('source Ximport.vim', 'E1048:', '', 1, 'Func')
Bram Moolenaar599c89c2020-03-28 14:53:20 +01001007
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001008 var import_star_as_lbr_lines =<< trim END
Bram Moolenaar1c991142020-07-04 13:15:31 +02001009 vim9script
1010 import *
1011 as Export
1012 from
1013 './Xexport.vim'
1014 def UseExport()
1015 g:imported = Export.exported
1016 enddef
1017 UseExport()
1018 END
1019 writefile(import_star_as_lbr_lines, 'Ximport.vim')
1020 source Ximport.vim
1021 assert_equal(9883, g:imported)
1022
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001023 var import_star_lines =<< trim END
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01001024 vim9script
1025 import * from './Xexport.vim'
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01001026 END
1027 writefile(import_star_lines, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001028 assert_fails('source Ximport.vim', 'E1045:', '', 2, 'Ximport.vim')
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01001029
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001030 # try to import something that exists but is not exported
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001031 var import_not_exported_lines =<< trim END
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001032 vim9script
1033 import name from './Xexport.vim'
1034 END
1035 writefile(import_not_exported_lines, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001036 assert_fails('source Ximport.vim', 'E1049:', '', 2, 'Ximport.vim')
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001037
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001038 # try to import something that is already defined
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001039 var import_already_defined =<< trim END
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001040 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001041 var exported = 'something'
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001042 import exported from './Xexport.vim'
1043 END
1044 writefile(import_already_defined, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001045 assert_fails('source Ximport.vim', 'E1073:', '', 3, 'Ximport.vim')
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001046
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001047 # try to import something that is already defined
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001048 import_already_defined =<< trim END
1049 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001050 var exported = 'something'
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001051 import * as exported from './Xexport.vim'
1052 END
1053 writefile(import_already_defined, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001054 assert_fails('source Ximport.vim', 'E1073:', '', 3, 'Ximport.vim')
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001055
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001056 # try to import something that is already defined
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001057 import_already_defined =<< trim END
1058 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001059 var exported = 'something'
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001060 import {exported} from './Xexport.vim'
1061 END
1062 writefile(import_already_defined, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001063 assert_fails('source Ximport.vim', 'E1073:', '', 3, 'Ximport.vim')
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001064
Bram Moolenaar918a4242020-12-06 14:37:08 +01001065 # try changing an imported const
1066 var import_assign_to_const =<< trim END
1067 vim9script
1068 import CONST from './Xexport.vim'
1069 def Assign()
1070 CONST = 987
1071 enddef
1072 defcompile
1073 END
1074 writefile(import_assign_to_const, 'Ximport.vim')
1075 assert_fails('source Ximport.vim', 'E46:', '', 1, '_Assign')
1076
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001077 # import a very long name, requires making a copy
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001078 var import_long_name_lines =<< trim END
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001079 vim9script
1080 import name012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789 from './Xexport.vim'
1081 END
1082 writefile(import_long_name_lines, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001083 assert_fails('source Ximport.vim', 'E1048:', '', 2, 'Ximport.vim')
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001084
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001085 var import_no_from_lines =<< trim END
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001086 vim9script
1087 import name './Xexport.vim'
1088 END
1089 writefile(import_no_from_lines, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001090 assert_fails('source Ximport.vim', 'E1070:', '', 2, 'Ximport.vim')
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001091
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001092 var import_invalid_string_lines =<< trim END
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001093 vim9script
1094 import name from Xexport.vim
1095 END
1096 writefile(import_invalid_string_lines, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001097 assert_fails('source Ximport.vim', 'E1071:', '', 2, 'Ximport.vim')
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001098
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001099 var import_wrong_name_lines =<< trim END
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001100 vim9script
1101 import name from './XnoExport.vim'
1102 END
1103 writefile(import_wrong_name_lines, 'Ximport.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001104 assert_fails('source Ximport.vim', 'E1053:', '', 2, 'Ximport.vim')
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001105
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001106 var import_missing_comma_lines =<< trim END
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001107 vim9script
1108 import {exported name} from './Xexport.vim'
1109 END
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001110 writefile(import_missing_comma_lines, 'Ximport3.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001111 assert_fails('source Ximport3.vim', 'E1046:', '', 2, 'Ximport3.vim')
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +01001112
Bram Moolenaarf2d5c242020-02-23 21:25:54 +01001113 delete('Ximport.vim')
Bram Moolenaar5269bd22020-03-09 19:25:27 +01001114 delete('Ximport3.vim')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001115 delete('Xexport.vim')
1116
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001117 # Check that in a Vim9 script 'cpo' is set to the Vim default.
Bram Moolenaar750802b2020-02-23 18:08:33 +01001118 set cpo&vi
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001119 var cpo_before = &cpo
1120 var lines =<< trim END
Bram Moolenaar750802b2020-02-23 18:08:33 +01001121 vim9script
1122 g:cpo_in_vim9script = &cpo
1123 END
1124 writefile(lines, 'Xvim9_script')
1125 source Xvim9_script
1126 assert_equal(cpo_before, &cpo)
1127 set cpo&vim
1128 assert_equal(&cpo, g:cpo_in_vim9script)
1129 delete('Xvim9_script')
1130enddef
1131
Bram Moolenaar803af682020-08-05 16:20:03 +02001132func g:Trigger()
1133 source Ximport.vim
1134 return "echo 'yes'\<CR>"
1135endfunc
1136
1137def Test_import_export_expr_map()
1138 # check that :import and :export work when buffer is locked
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001139 var export_lines =<< trim END
Bram Moolenaar803af682020-08-05 16:20:03 +02001140 vim9script
1141 export def That(): string
1142 return 'yes'
1143 enddef
1144 END
1145 writefile(export_lines, 'Xexport_that.vim')
1146
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001147 var import_lines =<< trim END
Bram Moolenaar803af682020-08-05 16:20:03 +02001148 vim9script
1149 import That from './Xexport_that.vim'
1150 assert_equal('yes', That())
1151 END
1152 writefile(import_lines, 'Ximport.vim')
1153
1154 nnoremap <expr> trigger g:Trigger()
1155 feedkeys('trigger', "xt")
1156
Bram Moolenaar730b2482020-08-09 13:02:10 +02001157 delete('Xexport_that.vim')
Bram Moolenaar803af682020-08-05 16:20:03 +02001158 delete('Ximport.vim')
1159 nunmap trigger
1160enddef
1161
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001162def Test_import_in_filetype()
1163 # check that :import works when the buffer is locked
1164 mkdir('ftplugin', 'p')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001165 var export_lines =<< trim END
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001166 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001167 export var That = 'yes'
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001168 END
Bram Moolenaar730b2482020-08-09 13:02:10 +02001169 writefile(export_lines, 'ftplugin/Xexport_ft.vim')
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001170
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001171 var import_lines =<< trim END
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001172 vim9script
Bram Moolenaar730b2482020-08-09 13:02:10 +02001173 import That from './Xexport_ft.vim'
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001174 assert_equal('yes', That)
1175 g:did_load_mytpe = 1
1176 END
1177 writefile(import_lines, 'ftplugin/qf.vim')
1178
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001179 var save_rtp = &rtp
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001180 &rtp = getcwd() .. ',' .. &rtp
1181
1182 filetype plugin on
1183 copen
1184 assert_equal(1, g:did_load_mytpe)
1185
1186 quit!
Bram Moolenaar730b2482020-08-09 13:02:10 +02001187 delete('Xexport_ft.vim')
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02001188 delete('ftplugin', 'rf')
1189 &rtp = save_rtp
1190enddef
1191
Bram Moolenaarefa94442020-08-08 22:16:00 +02001192def Test_use_import_in_mapping()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001193 var lines =<< trim END
Bram Moolenaarefa94442020-08-08 22:16:00 +02001194 vim9script
1195 export def Funcx()
1196 g:result = 42
1197 enddef
1198 END
1199 writefile(lines, 'XsomeExport.vim')
1200 lines =<< trim END
1201 vim9script
1202 import Funcx from './XsomeExport.vim'
Bram Moolenaarb3ca9822020-08-09 14:43:58 +02001203 nnoremap <F3> :call <sid>Funcx()<cr>
Bram Moolenaarefa94442020-08-08 22:16:00 +02001204 END
1205 writefile(lines, 'Xmapscript.vim')
1206
1207 source Xmapscript.vim
Bram Moolenaarb3ca9822020-08-09 14:43:58 +02001208 feedkeys("\<F3>", "xt")
Bram Moolenaarefa94442020-08-08 22:16:00 +02001209 assert_equal(42, g:result)
1210
1211 unlet g:result
1212 delete('XsomeExport.vim')
1213 delete('Xmapscript.vim')
Bram Moolenaarb3ca9822020-08-09 14:43:58 +02001214 nunmap <F3>
Bram Moolenaarefa94442020-08-08 22:16:00 +02001215enddef
1216
Bram Moolenaar750802b2020-02-23 18:08:33 +01001217def Test_vim9script_fails()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001218 CheckScriptFailure(['scriptversion 2', 'vim9script'], 'E1039:')
1219 CheckScriptFailure(['vim9script', 'scriptversion 2'], 'E1040:')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001220 CheckScriptFailure(['export var some = 123'], 'E1042:')
Bram Moolenaar9721fb42020-06-11 23:10:46 +02001221 CheckScriptFailure(['import some from "./Xexport.vim"'], 'E1048:')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001222 CheckScriptFailure(['vim9script', 'export var g:some'], 'E1022:')
Bram Moolenaar750802b2020-02-23 18:08:33 +01001223 CheckScriptFailure(['vim9script', 'export echo 134'], 'E1043:')
1224
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001225 CheckScriptFailure(['vim9script', 'var str: string', 'str = 1234'], 'E1012:')
Bram Moolenaarc785b9a2020-06-19 18:34:15 +02001226 CheckScriptFailure(['vim9script', 'const str = "asdf"', 'str = "xxx"'], 'E46:')
1227
Bram Moolenaare2e40752020-09-04 21:18:46 +02001228 assert_fails('vim9script', 'E1038:')
1229 assert_fails('export something', 'E1043:')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001230enddef
1231
Bram Moolenaarf7d267e2020-06-17 12:04:54 +02001232func Test_import_fails_without_script()
Bram Moolenaar101f4812020-06-16 23:18:51 +02001233 CheckRunVimInTerminal
1234
Bram Moolenaar9bb3eb32020-06-17 20:03:36 +02001235 " call indirectly to avoid compilation error for missing functions
Bram Moolenaarc620c052020-07-08 15:16:19 +02001236 call Run_Test_import_fails_on_command_line()
Bram Moolenaar9bb3eb32020-06-17 20:03:36 +02001237endfunc
1238
Bram Moolenaarc620c052020-07-08 15:16:19 +02001239def Run_Test_import_fails_on_command_line()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001240 var export =<< trim END
Bram Moolenaar101f4812020-06-16 23:18:51 +02001241 vim9script
1242 export def Foo(): number
1243 return 0
1244 enddef
1245 END
Bram Moolenaar730b2482020-08-09 13:02:10 +02001246 writefile(export, 'XexportCmd.vim')
Bram Moolenaar101f4812020-06-16 23:18:51 +02001247
Bram Moolenaare0de1712020-12-02 17:36:54 +01001248 var buf = RunVimInTerminal('-c "import Foo from ''./XexportCmd.vim''"', {
Bram Moolenaar9bb3eb32020-06-17 20:03:36 +02001249 rows: 6, wait_for_ruler: 0})
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001250 WaitForAssert(() => assert_match('^E1094:', term_getline(buf, 5)))
Bram Moolenaar101f4812020-06-16 23:18:51 +02001251
Bram Moolenaar730b2482020-08-09 13:02:10 +02001252 delete('XexportCmd.vim')
Bram Moolenaar9bb3eb32020-06-17 20:03:36 +02001253 StopVimInTerminal(buf)
1254enddef
Bram Moolenaar101f4812020-06-16 23:18:51 +02001255
Bram Moolenaar2b327002020-12-26 15:39:31 +01001256def Test_vim9script_reload_noclear()
1257 var lines =<< trim END
Bram Moolenaara6294952020-12-27 13:39:50 +01001258 vim9script
1259 export var exported = 'thexport'
1260 END
1261 writefile(lines, 'XExportReload')
1262 lines =<< trim END
Bram Moolenaar2b327002020-12-26 15:39:31 +01001263 vim9script noclear
1264 g:loadCount += 1
1265 var s:reloaded = 'init'
Bram Moolenaara6294952020-12-27 13:39:50 +01001266 import exported from './XExportReload'
Bram Moolenaar2b327002020-12-26 15:39:31 +01001267
1268 def Again(): string
1269 return 'again'
1270 enddef
1271
1272 if exists('s:loaded') | finish | endif
1273 var s:loaded = true
1274
1275 var s:notReloaded = 'yes'
1276 s:reloaded = 'first'
1277 def g:Values(): list<string>
Bram Moolenaara6294952020-12-27 13:39:50 +01001278 return [s:reloaded, s:notReloaded, Again(), Once(), exported]
Bram Moolenaar2b327002020-12-26 15:39:31 +01001279 enddef
1280
1281 def Once(): string
1282 return 'once'
1283 enddef
1284 END
1285 writefile(lines, 'XReloaded')
1286 g:loadCount = 0
1287 source XReloaded
1288 assert_equal(1, g:loadCount)
Bram Moolenaara6294952020-12-27 13:39:50 +01001289 assert_equal(['first', 'yes', 'again', 'once', 'thexport'], g:Values())
Bram Moolenaar2b327002020-12-26 15:39:31 +01001290 source XReloaded
1291 assert_equal(2, g:loadCount)
Bram Moolenaara6294952020-12-27 13:39:50 +01001292 assert_equal(['init', 'yes', 'again', 'once', 'thexport'], g:Values())
Bram Moolenaar2b327002020-12-26 15:39:31 +01001293 source XReloaded
1294 assert_equal(3, g:loadCount)
Bram Moolenaara6294952020-12-27 13:39:50 +01001295 assert_equal(['init', 'yes', 'again', 'once', 'thexport'], g:Values())
Bram Moolenaar2b327002020-12-26 15:39:31 +01001296
Bram Moolenaar48e11c12021-01-11 18:47:00 +01001297 delete('XReloaded')
Bram Moolenaara6294952020-12-27 13:39:50 +01001298 delete('XExportReload')
Bram Moolenaar2b327002020-12-26 15:39:31 +01001299 delfunc g:Values
Bram Moolenaar2b327002020-12-26 15:39:31 +01001300 unlet g:loadCount
1301enddef
1302
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001303def Test_vim9script_reload_import()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001304 var lines =<< trim END
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001305 vim9script
1306 const var = ''
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001307 var valone = 1234
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001308 def MyFunc(arg: string)
1309 valone = 5678
1310 enddef
1311 END
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001312 var morelines =<< trim END
1313 var valtwo = 222
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001314 export def GetValtwo(): number
1315 return valtwo
1316 enddef
1317 END
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001318 writefile(lines + morelines, 'Xreload.vim')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001319 source Xreload.vim
1320 source Xreload.vim
1321 source Xreload.vim
1322
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001323 var testlines =<< trim END
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001324 vim9script
1325 def TheFunc()
1326 import GetValtwo from './Xreload.vim'
1327 assert_equal(222, GetValtwo())
1328 enddef
1329 TheFunc()
1330 END
1331 writefile(testlines, 'Ximport.vim')
1332 source Ximport.vim
1333
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001334 # Test that when not using "morelines" GetValtwo() and valtwo are still
1335 # defined, because import doesn't reload a script.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001336 writefile(lines, 'Xreload.vim')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001337 source Ximport.vim
1338
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001339 # cannot declare a var twice
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001340 lines =<< trim END
1341 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001342 var valone = 1234
1343 var valone = 5678
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001344 END
1345 writefile(lines, 'Xreload.vim')
Bram Moolenaar44d66522020-09-06 22:26:57 +02001346 assert_fails('source Xreload.vim', 'E1041:', '', 3, 'Xreload.vim')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001347
1348 delete('Xreload.vim')
1349 delete('Ximport.vim')
1350enddef
1351
Bram Moolenaar07a65d22020-12-26 20:09:15 +01001352" if a script is reloaded with a script-local variable that changed its type, a
1353" compiled function using that variable must fail.
1354def Test_script_reload_change_type()
1355 var lines =<< trim END
1356 vim9script noclear
1357 var str = 'string'
1358 def g:GetStr(): string
1359 return str .. 'xxx'
1360 enddef
1361 END
1362 writefile(lines, 'Xreload.vim')
1363 source Xreload.vim
1364 echo g:GetStr()
1365
1366 lines =<< trim END
1367 vim9script noclear
1368 var str = 1234
1369 END
1370 writefile(lines, 'Xreload.vim')
1371 source Xreload.vim
1372 assert_fails('echo g:GetStr()', 'E1150:')
1373
1374 delfunc g:GetStr
1375 delete('Xreload.vim')
1376enddef
1377
Bram Moolenaar95006e32020-08-29 17:47:08 +02001378def s:RetSome(): string
1379 return 'some'
1380enddef
1381
Bram Moolenaarfe465a02020-07-07 22:50:12 +02001382" Not exported function that is referenced needs to be accessed by the
1383" script-local name.
1384def Test_vim9script_funcref()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001385 var sortlines =<< trim END
Bram Moolenaarfe465a02020-07-07 22:50:12 +02001386 vim9script
1387 def Compare(i1: number, i2: number): number
Bram Moolenaarbed36b92020-07-07 23:31:36 +02001388 return i2 - i1
Bram Moolenaarfe465a02020-07-07 22:50:12 +02001389 enddef
1390
1391 export def FastSort(): list<number>
1392 return range(5)->sort(Compare)
1393 enddef
1394 END
1395 writefile(sortlines, 'Xsort.vim')
1396
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001397 var lines =<< trim END
Bram Moolenaarfe465a02020-07-07 22:50:12 +02001398 vim9script
1399 import FastSort from './Xsort.vim'
1400 def Test()
1401 g:result = FastSort()
1402 enddef
1403 Test()
1404 END
1405 writefile(lines, 'Xscript.vim')
1406
1407 source Xscript.vim
1408 assert_equal([4, 3, 2, 1, 0], g:result)
1409
1410 unlet g:result
1411 delete('Xsort.vim')
1412 delete('Xscript.vim')
Bram Moolenaar95006e32020-08-29 17:47:08 +02001413
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001414 var Funcref = function('s:RetSome')
Bram Moolenaar95006e32020-08-29 17:47:08 +02001415 assert_equal('some', Funcref())
Bram Moolenaarfe465a02020-07-07 22:50:12 +02001416enddef
1417
Bram Moolenaar601e76a2020-08-27 21:33:10 +02001418" Check that when searching for "FilterFunc" it finds the import in the
1419" script where FastFilter() is called from, both as a string and as a direct
1420" function reference.
Bram Moolenaarc620c052020-07-08 15:16:19 +02001421def Test_vim9script_funcref_other_script()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001422 var filterLines =<< trim END
Bram Moolenaarc620c052020-07-08 15:16:19 +02001423 vim9script
1424 export def FilterFunc(idx: number, val: number): bool
1425 return idx % 2 == 1
1426 enddef
1427 export def FastFilter(): list<number>
1428 return range(10)->filter('FilterFunc')
1429 enddef
Bram Moolenaar601e76a2020-08-27 21:33:10 +02001430 export def FastFilterDirect(): list<number>
1431 return range(10)->filter(FilterFunc)
1432 enddef
Bram Moolenaarc620c052020-07-08 15:16:19 +02001433 END
1434 writefile(filterLines, 'Xfilter.vim')
1435
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001436 var lines =<< trim END
Bram Moolenaarc620c052020-07-08 15:16:19 +02001437 vim9script
Bram Moolenaar601e76a2020-08-27 21:33:10 +02001438 import {FilterFunc, FastFilter, FastFilterDirect} from './Xfilter.vim'
Bram Moolenaarc620c052020-07-08 15:16:19 +02001439 def Test()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001440 var x: list<number> = FastFilter()
Bram Moolenaarc620c052020-07-08 15:16:19 +02001441 enddef
1442 Test()
Bram Moolenaar601e76a2020-08-27 21:33:10 +02001443 def TestDirect()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001444 var x: list<number> = FastFilterDirect()
Bram Moolenaar601e76a2020-08-27 21:33:10 +02001445 enddef
1446 TestDirect()
Bram Moolenaarc620c052020-07-08 15:16:19 +02001447 END
Bram Moolenaar601e76a2020-08-27 21:33:10 +02001448 CheckScriptSuccess(lines)
Bram Moolenaarc620c052020-07-08 15:16:19 +02001449 delete('Xfilter.vim')
Bram Moolenaarc620c052020-07-08 15:16:19 +02001450enddef
1451
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001452def Test_vim9script_reload_delfunc()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001453 var first_lines =<< trim END
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001454 vim9script
1455 def FuncYes(): string
1456 return 'yes'
1457 enddef
1458 END
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001459 var withno_lines =<< trim END
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001460 def FuncNo(): string
1461 return 'no'
1462 enddef
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001463 def g:DoCheck(no_exists: bool)
1464 assert_equal('yes', FuncYes())
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001465 assert_equal('no', FuncNo())
1466 enddef
1467 END
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001468 var nono_lines =<< trim END
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001469 def g:DoCheck(no_exists: bool)
1470 assert_equal('yes', FuncYes())
Bram Moolenaar44d66522020-09-06 22:26:57 +02001471 assert_fails('FuncNo()', 'E117:', '', 2, 'DoCheck')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001472 enddef
1473 END
1474
1475 # FuncNo() is defined
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001476 writefile(first_lines + withno_lines, 'Xreloaded.vim')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001477 source Xreloaded.vim
1478 g:DoCheck(true)
1479
1480 # FuncNo() is not redefined
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001481 writefile(first_lines + nono_lines, 'Xreloaded.vim')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001482 source Xreloaded.vim
Bram Moolenaar50824712020-12-20 21:10:17 +01001483 g:DoCheck(false)
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001484
1485 # FuncNo() is back
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001486 writefile(first_lines + withno_lines, 'Xreloaded.vim')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001487 source Xreloaded.vim
Bram Moolenaar50824712020-12-20 21:10:17 +01001488 g:DoCheck(false)
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001489
1490 delete('Xreloaded.vim')
1491enddef
1492
Bram Moolenaar89483d42020-05-10 15:24:44 +02001493def Test_vim9script_reload_delvar()
1494 # write the script with a script-local variable
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001495 var lines =<< trim END
Bram Moolenaar89483d42020-05-10 15:24:44 +02001496 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001497 var name = 'string'
Bram Moolenaar89483d42020-05-10 15:24:44 +02001498 END
1499 writefile(lines, 'XreloadVar.vim')
1500 source XreloadVar.vim
1501
1502 # now write the script using the same variable locally - works
1503 lines =<< trim END
1504 vim9script
1505 def Func()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001506 var name = 'string'
Bram Moolenaar89483d42020-05-10 15:24:44 +02001507 enddef
1508 END
1509 writefile(lines, 'XreloadVar.vim')
1510 source XreloadVar.vim
1511
1512 delete('XreloadVar.vim')
1513enddef
1514
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001515def Test_import_absolute()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001516 var import_lines = [
Bram Moolenaare6085c52020-04-12 20:19:16 +02001517 'vim9script',
1518 'import exported from "' .. escape(getcwd(), '\') .. '/Xexport_abs.vim"',
1519 'def UseExported()',
1520 ' g:imported_abs = exported',
1521 ' exported = 8888',
1522 ' g:imported_after = exported',
1523 'enddef',
1524 'UseExported()',
1525 'g:import_disassembled = execute("disass UseExported")',
1526 ]
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001527 writefile(import_lines, 'Ximport_abs.vim')
1528 writefile(s:export_script_lines, 'Xexport_abs.vim')
1529
1530 source Ximport_abs.vim
1531
1532 assert_equal(9876, g:imported_abs)
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +01001533 assert_equal(8888, g:imported_after)
Bram Moolenaarfbbcd002020-10-15 12:46:44 +02001534 assert_match('<SNR>\d\+_UseExported\_s*' ..
1535 'g:imported_abs = exported\_s*' ..
1536 '0 LOADSCRIPT exported-2 from .*Xexport_abs.vim\_s*' ..
1537 '1 STOREG g:imported_abs\_s*' ..
1538 'exported = 8888\_s*' ..
1539 '2 PUSHNR 8888\_s*' ..
1540 '3 STORESCRIPT exported-2 in .*Xexport_abs.vim\_s*' ..
1541 'g:imported_after = exported\_s*' ..
1542 '4 LOADSCRIPT exported-2 from .*Xexport_abs.vim\_s*' ..
1543 '5 STOREG g:imported_after',
Bram Moolenaare6085c52020-04-12 20:19:16 +02001544 g:import_disassembled)
Bram Moolenaarb3ca9822020-08-09 14:43:58 +02001545
1546 Undo_export_script_lines()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001547 unlet g:imported_abs
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +01001548 unlet g:import_disassembled
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001549
1550 delete('Ximport_abs.vim')
1551 delete('Xexport_abs.vim')
1552enddef
1553
1554def Test_import_rtp()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001555 var import_lines = [
Bram Moolenaare6085c52020-04-12 20:19:16 +02001556 'vim9script',
1557 'import exported from "Xexport_rtp.vim"',
1558 'g:imported_rtp = exported',
1559 ]
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001560 writefile(import_lines, 'Ximport_rtp.vim')
1561 mkdir('import')
1562 writefile(s:export_script_lines, 'import/Xexport_rtp.vim')
1563
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001564 var save_rtp = &rtp
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001565 &rtp = getcwd()
1566 source Ximport_rtp.vim
1567 &rtp = save_rtp
1568
1569 assert_equal(9876, g:imported_rtp)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001570
Bram Moolenaarb3ca9822020-08-09 14:43:58 +02001571 Undo_export_script_lines()
1572 unlet g:imported_rtp
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001573 delete('Ximport_rtp.vim')
Bram Moolenaar89483d42020-05-10 15:24:44 +02001574 delete('import', 'rf')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001575enddef
1576
Bram Moolenaar25e0f582020-05-25 22:36:50 +02001577def Test_import_compile_error()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001578 var export_lines = [
Bram Moolenaar25e0f582020-05-25 22:36:50 +02001579 'vim9script',
1580 'export def ExpFunc(): string',
1581 ' return notDefined',
1582 'enddef',
1583 ]
1584 writefile(export_lines, 'Xexported.vim')
1585
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001586 var import_lines = [
Bram Moolenaar25e0f582020-05-25 22:36:50 +02001587 'vim9script',
1588 'import ExpFunc from "./Xexported.vim"',
1589 'def ImpFunc()',
1590 ' echo ExpFunc()',
1591 'enddef',
1592 'defcompile',
1593 ]
1594 writefile(import_lines, 'Ximport.vim')
1595
1596 try
1597 source Ximport.vim
1598 catch /E1001/
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001599 # Error should be fore the Xexported.vim file.
Bram Moolenaar77072282020-09-16 17:55:40 +02001600 assert_match('E1001: Variable not found: notDefined', v:exception)
Bram Moolenaar25e0f582020-05-25 22:36:50 +02001601 assert_match('function <SNR>\d\+_ImpFunc\[1\]..<SNR>\d\+_ExpFunc, line 1', v:throwpoint)
1602 endtry
1603
1604 delete('Xexported.vim')
1605 delete('Ximport.vim')
1606enddef
1607
Bram Moolenaarc4ce36d2020-08-14 17:08:15 +02001608def Test_func_redefine_error()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001609 var lines = [
Bram Moolenaarc4ce36d2020-08-14 17:08:15 +02001610 'vim9script',
1611 'def Func()',
1612 ' eval [][0]',
1613 'enddef',
1614 'Func()',
1615 ]
1616 writefile(lines, 'Xtestscript.vim')
1617
1618 for count in range(3)
1619 try
1620 source Xtestscript.vim
1621 catch /E684/
1622 # function name should contain <SNR> every time
1623 assert_match('E684: list index out of range', v:exception)
1624 assert_match('function <SNR>\d\+_Func, line 1', v:throwpoint)
1625 endtry
1626 endfor
1627
1628 delete('Xtestscript.vim')
1629enddef
1630
Bram Moolenaareef21022020-08-01 22:16:43 +02001631def Test_func_overrules_import_fails()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001632 var export_lines =<< trim END
Bram Moolenaareef21022020-08-01 22:16:43 +02001633 vim9script
1634 export def Func()
1635 echo 'imported'
1636 enddef
1637 END
1638 writefile(export_lines, 'XexportedFunc.vim')
1639
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001640 var lines =<< trim END
Bram Moolenaareef21022020-08-01 22:16:43 +02001641 vim9script
1642 import Func from './XexportedFunc.vim'
1643 def Func()
1644 echo 'local to function'
1645 enddef
1646 END
1647 CheckScriptFailure(lines, 'E1073:')
1648
1649 lines =<< trim END
1650 vim9script
1651 import Func from './XexportedFunc.vim'
1652 def Outer()
1653 def Func()
1654 echo 'local to function'
1655 enddef
1656 enddef
1657 defcompile
1658 END
1659 CheckScriptFailure(lines, 'E1073:')
1660
1661 delete('XexportedFunc.vim')
1662enddef
1663
Bram Moolenaarb9a2cac2020-08-01 22:23:20 +02001664def Test_func_redefine_fails()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001665 var lines =<< trim END
Bram Moolenaarb9a2cac2020-08-01 22:23:20 +02001666 vim9script
1667 def Func()
1668 echo 'one'
1669 enddef
1670 def Func()
1671 echo 'two'
1672 enddef
1673 END
1674 CheckScriptFailure(lines, 'E1073:')
Bram Moolenaarfa211f32020-08-07 22:00:26 +02001675
1676 lines =<< trim END
1677 vim9script
1678 def Foo(): string
1679 return 'foo'
1680 enddef
1681 def Func()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001682 var Foo = {-> 'lambda'}
Bram Moolenaarfa211f32020-08-07 22:00:26 +02001683 enddef
1684 defcompile
1685 END
1686 CheckScriptFailure(lines, 'E1073:')
Bram Moolenaarb9a2cac2020-08-01 22:23:20 +02001687enddef
1688
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001689def Test_fixed_size_list()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001690 # will be allocated as one piece of memory, check that changes work
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001691 var l = [1, 2, 3, 4]
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001692 l->remove(0)
1693 l->add(5)
1694 l->insert(99, 1)
Bram Moolenaar0f18b6d2020-02-02 17:22:27 +01001695 assert_equal([2, 99, 3, 4, 5], l)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001696enddef
1697
Bram Moolenaarae616492020-07-28 20:07:27 +02001698def Test_no_insert_xit()
Bram Moolenaard2c61702020-09-06 15:58:36 +02001699 CheckDefExecFailure(['a = 1'], 'E1100:')
1700 CheckDefExecFailure(['c = 1'], 'E1100:')
1701 CheckDefExecFailure(['i = 1'], 'E1100:')
1702 CheckDefExecFailure(['t = 1'], 'E1100:')
1703 CheckDefExecFailure(['x = 1'], 'E1100:')
Bram Moolenaarae616492020-07-28 20:07:27 +02001704
Bram Moolenaarae616492020-07-28 20:07:27 +02001705 CheckScriptFailure(['vim9script', 'a = 1'], 'E488:')
1706 CheckScriptFailure(['vim9script', 'a'], 'E1100:')
Bram Moolenaarae616492020-07-28 20:07:27 +02001707 CheckScriptFailure(['vim9script', 'c = 1'], 'E488:')
1708 CheckScriptFailure(['vim9script', 'c'], 'E1100:')
Bram Moolenaarf5a48012020-08-01 17:00:03 +02001709 CheckScriptFailure(['vim9script', 'i = 1'], 'E488:')
1710 CheckScriptFailure(['vim9script', 'i'], 'E1100:')
1711 CheckScriptFailure(['vim9script', 't'], 'E1100:')
1712 CheckScriptFailure(['vim9script', 't = 1'], 'E1100:')
1713 CheckScriptFailure(['vim9script', 'x = 1'], 'E1100:')
Bram Moolenaarae616492020-07-28 20:07:27 +02001714enddef
1715
Bram Moolenaar158906c2020-02-06 20:39:45 +01001716def IfElse(what: number): string
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001717 var res = ''
Bram Moolenaar158906c2020-02-06 20:39:45 +01001718 if what == 1
1719 res = "one"
1720 elseif what == 2
1721 res = "two"
Bram Moolenaara259d8d2020-01-31 20:10:50 +01001722 else
Bram Moolenaar158906c2020-02-06 20:39:45 +01001723 res = "three"
Bram Moolenaara259d8d2020-01-31 20:10:50 +01001724 endif
Bram Moolenaar158906c2020-02-06 20:39:45 +01001725 return res
Bram Moolenaara259d8d2020-01-31 20:10:50 +01001726enddef
1727
Bram Moolenaar158906c2020-02-06 20:39:45 +01001728def Test_if_elseif_else()
1729 assert_equal('one', IfElse(1))
1730 assert_equal('two', IfElse(2))
1731 assert_equal('three', IfElse(3))
Bram Moolenaar0f18b6d2020-02-02 17:22:27 +01001732enddef
1733
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001734def Test_if_elseif_else_fails()
Bram Moolenaard2c61702020-09-06 15:58:36 +02001735 CheckDefFailure(['elseif true'], 'E582:')
1736 CheckDefFailure(['else'], 'E581:')
1737 CheckDefFailure(['endif'], 'E580:')
1738 CheckDefFailure(['if true', 'elseif xxx'], 'E1001:')
1739 CheckDefFailure(['if true', 'echo 1'], 'E171:')
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001740enddef
1741
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001742let g:bool_true = v:true
1743let g:bool_false = v:false
1744
1745def Test_if_const_expr()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001746 var res = false
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001747 if true ? true : false
1748 res = true
1749 endif
1750 assert_equal(true, res)
1751
Bram Moolenaar585fea72020-04-02 22:33:21 +02001752 g:glob = 2
1753 if false
Bram Moolenaar67979662020-06-20 22:50:47 +02001754 execute('g:glob = 3')
Bram Moolenaar585fea72020-04-02 22:33:21 +02001755 endif
1756 assert_equal(2, g:glob)
1757 if true
Bram Moolenaar67979662020-06-20 22:50:47 +02001758 execute('g:glob = 3')
Bram Moolenaar585fea72020-04-02 22:33:21 +02001759 endif
1760 assert_equal(3, g:glob)
1761
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001762 res = false
1763 if g:bool_true ? true : false
1764 res = true
1765 endif
1766 assert_equal(true, res)
1767
1768 res = false
1769 if true ? g:bool_true : false
1770 res = true
1771 endif
1772 assert_equal(true, res)
1773
1774 res = false
1775 if true ? true : g:bool_false
1776 res = true
1777 endif
1778 assert_equal(true, res)
1779
1780 res = false
1781 if true ? false : true
1782 res = true
1783 endif
1784 assert_equal(false, res)
1785
1786 res = false
1787 if false ? false : true
1788 res = true
1789 endif
1790 assert_equal(true, res)
1791
1792 res = false
1793 if false ? true : false
1794 res = true
1795 endif
1796 assert_equal(false, res)
1797
1798 res = false
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001799 if has('xyz') ? true : false
1800 res = true
1801 endif
1802 assert_equal(false, res)
1803
1804 res = false
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001805 if true && true
1806 res = true
1807 endif
1808 assert_equal(true, res)
1809
1810 res = false
1811 if true && false
1812 res = true
1813 endif
1814 assert_equal(false, res)
1815
1816 res = false
1817 if g:bool_true && false
1818 res = true
1819 endif
1820 assert_equal(false, res)
1821
1822 res = false
1823 if true && g:bool_false
1824 res = true
1825 endif
1826 assert_equal(false, res)
1827
1828 res = false
1829 if false && false
1830 res = true
1831 endif
1832 assert_equal(false, res)
1833
1834 res = false
1835 if true || false
1836 res = true
1837 endif
1838 assert_equal(true, res)
1839
1840 res = false
1841 if g:bool_true || false
1842 res = true
1843 endif
1844 assert_equal(true, res)
1845
1846 res = false
1847 if true || g:bool_false
1848 res = true
1849 endif
1850 assert_equal(true, res)
1851
1852 res = false
1853 if false || false
1854 res = true
1855 endif
1856 assert_equal(false, res)
Bram Moolenaar3988f642020-08-27 22:43:03 +02001857
1858 # with constant "false" expression may be invalid so long as the syntax is OK
1859 if false | eval 0 | endif
1860 if false | eval burp + 234 | endif
1861 if false | echo burp 234 'asd' | endif
1862 if false
1863 burp
1864 endif
Bram Moolenaar80c34ca2020-04-01 23:05:18 +02001865enddef
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001866
Bram Moolenaar80c34ca2020-04-01 23:05:18 +02001867def Test_if_const_expr_fails()
Bram Moolenaard2c61702020-09-06 15:58:36 +02001868 CheckDefFailure(['if "aaa" == "bbb'], 'E114:')
1869 CheckDefFailure(["if 'aaa' == 'bbb"], 'E115:')
1870 CheckDefFailure(["if has('aaa'"], 'E110:')
1871 CheckDefFailure(["if has('aaa') ? true false"], 'E109:')
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001872enddef
1873
Bram Moolenaar72abcf42020-06-18 18:26:24 +02001874def RunNested(i: number): number
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001875 var x: number = 0
Bram Moolenaar72abcf42020-06-18 18:26:24 +02001876 if i % 2
1877 if 1
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001878 # comment
Bram Moolenaar72abcf42020-06-18 18:26:24 +02001879 else
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001880 # comment
Bram Moolenaar72abcf42020-06-18 18:26:24 +02001881 endif
1882 x += 1
1883 else
1884 x += 1000
1885 endif
1886 return x
1887enddef
1888
1889def Test_nested_if()
1890 assert_equal(1, RunNested(1))
1891 assert_equal(1000, RunNested(2))
1892enddef
1893
Bram Moolenaarad39c092020-02-26 18:23:43 +01001894def Test_execute_cmd()
Bram Moolenaare4984292020-12-13 14:19:25 +01001895 # missing argument is ignored
1896 execute
1897 execute # comment
1898
Bram Moolenaarad39c092020-02-26 18:23:43 +01001899 new
1900 setline(1, 'default')
Bram Moolenaard2c61702020-09-06 15:58:36 +02001901 execute 'setline(1, "execute-string")'
Bram Moolenaarad39c092020-02-26 18:23:43 +01001902 assert_equal('execute-string', getline(1))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001903
Bram Moolenaard2c61702020-09-06 15:58:36 +02001904 execute "setline(1, 'execute-string')"
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001905 assert_equal('execute-string', getline(1))
1906
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001907 var cmd1 = 'setline(1,'
1908 var cmd2 = '"execute-var")'
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001909 execute cmd1 cmd2 # comment
Bram Moolenaarad39c092020-02-26 18:23:43 +01001910 assert_equal('execute-var', getline(1))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001911
Bram Moolenaard2c61702020-09-06 15:58:36 +02001912 execute cmd1 cmd2 '|setline(1, "execute-var-string")'
Bram Moolenaarad39c092020-02-26 18:23:43 +01001913 assert_equal('execute-var-string', getline(1))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001914
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001915 var cmd_first = 'call '
1916 var cmd_last = 'setline(1, "execute-var-var")'
Bram Moolenaarad39c092020-02-26 18:23:43 +01001917 execute cmd_first .. cmd_last
1918 assert_equal('execute-var-var', getline(1))
1919 bwipe!
Bram Moolenaar585fea72020-04-02 22:33:21 +02001920
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001921 var n = true
Bram Moolenaar2d6b20d2020-07-25 19:30:59 +02001922 execute 'echomsg' (n ? '"true"' : '"no"')
1923 assert_match('^true$', Screenline(&lines))
1924
Bram Moolenaare0de1712020-12-02 17:36:54 +01001925 echomsg [1, 2, 3] {a: 1, b: 2}
Bram Moolenaare5abf7a2020-08-16 18:29:35 +02001926 assert_match('^\[1, 2, 3\] {''a'': 1, ''b'': 2}$', Screenline(&lines))
1927
Bram Moolenaard2c61702020-09-06 15:58:36 +02001928 CheckDefFailure(['execute xxx'], 'E1001:', 1)
1929 CheckDefExecFailure(['execute "tabnext " .. 8'], 'E475:', 1)
1930 CheckDefFailure(['execute "cmd"# comment'], 'E488:', 1)
Bram Moolenaarad39c092020-02-26 18:23:43 +01001931enddef
1932
Bram Moolenaar47e880d2020-06-30 22:02:02 +02001933def Test_execute_cmd_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001934 # only checks line continuation
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001935 var lines =<< trim END
Bram Moolenaar47e880d2020-06-30 22:02:02 +02001936 vim9script
1937 execute 'g:someVar'
1938 .. ' = ' ..
1939 '28'
1940 assert_equal(28, g:someVar)
1941 unlet g:someVar
1942 END
1943 CheckScriptSuccess(lines)
1944enddef
1945
Bram Moolenaarad39c092020-02-26 18:23:43 +01001946def Test_echo_cmd()
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001947 echo 'some' # comment
Bram Moolenaar585fea72020-04-02 22:33:21 +02001948 echon 'thing'
Bram Moolenaarad39c092020-02-26 18:23:43 +01001949 assert_match('^something$', Screenline(&lines))
1950
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001951 echo "some" # comment
1952 echon "thing"
1953 assert_match('^something$', Screenline(&lines))
1954
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001955 var str1 = 'some'
1956 var str2 = 'more'
Bram Moolenaarad39c092020-02-26 18:23:43 +01001957 echo str1 str2
1958 assert_match('^some more$', Screenline(&lines))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001959
Bram Moolenaard2c61702020-09-06 15:58:36 +02001960 CheckDefFailure(['echo "xxx"# comment'], 'E488:')
Bram Moolenaarad39c092020-02-26 18:23:43 +01001961enddef
1962
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001963def Test_echomsg_cmd()
1964 echomsg 'some' 'more' # comment
1965 assert_match('^some more$', Screenline(&lines))
1966 echo 'clear'
Bram Moolenaardf069ee2020-06-22 23:02:51 +02001967 :1messages
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001968 assert_match('^some more$', Screenline(&lines))
1969
Bram Moolenaard2c61702020-09-06 15:58:36 +02001970 CheckDefFailure(['echomsg "xxx"# comment'], 'E488:')
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001971enddef
1972
Bram Moolenaar47e880d2020-06-30 22:02:02 +02001973def Test_echomsg_cmd_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001974 # only checks line continuation
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001975 var lines =<< trim END
Bram Moolenaar47e880d2020-06-30 22:02:02 +02001976 vim9script
1977 echomsg 'here'
1978 .. ' is ' ..
1979 'a message'
1980 assert_match('^here is a message$', Screenline(&lines))
1981 END
1982 CheckScriptSuccess(lines)
1983enddef
1984
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001985def Test_echoerr_cmd()
Bram Moolenaar40ee4662020-05-05 22:08:26 +02001986 try
1987 echoerr 'something' 'wrong' # comment
1988 catch
1989 assert_match('something wrong', v:exception)
1990 endtry
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02001991enddef
1992
Bram Moolenaar47e880d2020-06-30 22:02:02 +02001993def Test_echoerr_cmd_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001994 # only checks line continuation
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001995 var lines =<< trim END
Bram Moolenaar47e880d2020-06-30 22:02:02 +02001996 vim9script
1997 try
1998 echoerr 'this'
1999 .. ' is ' ..
2000 'wrong'
2001 catch
2002 assert_match('this is wrong', v:exception)
2003 endtry
2004 END
2005 CheckScriptSuccess(lines)
2006enddef
2007
Bram Moolenaar41fe0612020-03-01 16:22:40 +01002008def Test_for_outside_of_function()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002009 var lines =<< trim END
Bram Moolenaar41fe0612020-03-01 16:22:40 +01002010 vim9script
2011 new
2012 for var in range(0, 3)
2013 append(line('$'), var)
2014 endfor
2015 assert_equal(['', '0', '1', '2', '3'], getline(1, '$'))
2016 bwipe!
2017 END
2018 writefile(lines, 'Xvim9for.vim')
2019 source Xvim9for.vim
2020 delete('Xvim9for.vim')
2021enddef
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002022
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02002023def Test_for_loop()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002024 var result = ''
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02002025 for cnt in range(7)
2026 if cnt == 4
2027 break
2028 endif
2029 if cnt == 2
2030 continue
2031 endif
2032 result ..= cnt .. '_'
2033 endfor
2034 assert_equal('0_1_3_', result)
Bram Moolenaar0ad3e892020-07-05 21:38:11 +02002035
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002036 var concat = ''
Bram Moolenaar0ad3e892020-07-05 21:38:11 +02002037 for str in eval('["one", "two"]')
2038 concat ..= str
2039 endfor
2040 assert_equal('onetwo', concat)
Bram Moolenaar38bd8de2020-12-02 13:23:36 +01002041
2042 var total = 0
2043 for nr in
2044 [1, 2, 3]
2045 total += nr
2046 endfor
2047 assert_equal(6, total)
2048
2049 total = 0
2050 for nr
2051 in [1, 2, 3]
2052 total += nr
2053 endfor
2054 assert_equal(6, total)
2055
2056 total = 0
2057 for nr
2058 in
2059 [1, 2, 3]
2060 total += nr
2061 endfor
2062 assert_equal(6, total)
Bram Moolenaar036d0712021-01-17 20:23:38 +01002063
2064 var res = ""
2065 for [n: number, s: string] in [[1, 'a'], [2, 'b']]
2066 res ..= n .. s
2067 endfor
2068 assert_equal('1a2b', res)
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02002069enddef
2070
2071def Test_for_loop_fails()
Bram Moolenaar025cb1c2020-12-14 18:31:27 +01002072 CheckDefFailure(['for '], 'E1097:')
2073 CheckDefFailure(['for x'], 'E1097:')
2074 CheckDefFailure(['for x in'], 'E1097:')
Bram Moolenaar675f7162020-04-12 22:53:54 +02002075 CheckDefFailure(['for # in range(5)'], 'E690:')
2076 CheckDefFailure(['for i In range(5)'], 'E690:')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002077 CheckDefFailure(['var x = 5', 'for x in range(5)'], 'E1017:')
Bram Moolenaar822ba242020-05-24 23:00:18 +02002078 CheckScriptFailure(['def Func(arg: any)', 'for arg in range(5)', 'enddef', 'defcompile'], 'E1006:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002079 delfunc! g:Func
Bram Moolenaar451c2e32020-08-15 16:33:28 +02002080 CheckDefFailure(['for i in "text"'], 'E1012:')
Bram Moolenaar675f7162020-04-12 22:53:54 +02002081 CheckDefFailure(['for i in xxx'], 'E1001:')
2082 CheckDefFailure(['endfor'], 'E588:')
2083 CheckDefFailure(['for i in range(3)', 'echo 3'], 'E170:')
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02002084enddef
2085
Bram Moolenaarea870692020-12-02 14:24:30 +01002086def Test_for_loop_script_var()
2087 # cannot use s:var in a :def function
2088 CheckDefFailure(['for s:var in range(3)', 'echo 3'], 'E1101:')
2089
2090 # can use s:var in Vim9 script, with or without s:
2091 var lines =<< trim END
2092 vim9script
2093 var total = 0
2094 for s:var in [1, 2, 3]
2095 total += s:var
2096 endfor
2097 assert_equal(6, total)
2098
2099 total = 0
2100 for var in [1, 2, 3]
2101 total += var
2102 endfor
2103 assert_equal(6, total)
2104 END
2105enddef
2106
Bram Moolenaar792f7862020-11-23 08:31:18 +01002107def Test_for_loop_unpack()
Bram Moolenaar792f7862020-11-23 08:31:18 +01002108 var lines =<< trim END
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01002109 var result = []
2110 for [v1, v2] in [[1, 2], [3, 4]]
2111 result->add(v1)
2112 result->add(v2)
2113 endfor
2114 assert_equal([1, 2, 3, 4], result)
2115
2116 result = []
2117 for [v1, v2; v3] in [[1, 2], [3, 4, 5, 6]]
2118 result->add(v1)
2119 result->add(v2)
2120 result->add(v3)
2121 endfor
2122 assert_equal([1, 2, [], 3, 4, [5, 6]], result)
2123
2124 result = []
2125 for [&ts, &sw] in [[1, 2], [3, 4]]
2126 result->add(&ts)
2127 result->add(&sw)
2128 endfor
2129 assert_equal([1, 2, 3, 4], result)
2130
2131 var slist: list<string>
2132 for [$LOOPVAR, @r, v:errmsg] in [['a', 'b', 'c'], ['d', 'e', 'f']]
2133 slist->add($LOOPVAR)
2134 slist->add(@r)
2135 slist->add(v:errmsg)
2136 endfor
2137 assert_equal(['a', 'b', 'c', 'd', 'e', 'f'], slist)
2138
2139 slist = []
2140 for [g:globalvar, b:bufvar, w:winvar, t:tabvar] in [['global', 'buf', 'win', 'tab'], ['1', '2', '3', '4']]
2141 slist->add(g:globalvar)
2142 slist->add(b:bufvar)
2143 slist->add(w:winvar)
2144 slist->add(t:tabvar)
2145 endfor
2146 assert_equal(['global', 'buf', 'win', 'tab', '1', '2', '3', '4'], slist)
Bram Moolenaarf6c177a2020-12-04 17:38:00 +01002147 unlet! g:globalvar b:bufvar w:winvar t:tabvar
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01002148 END
2149 CheckDefAndScriptSuccess(lines)
2150
2151 lines =<< trim END
Bram Moolenaar792f7862020-11-23 08:31:18 +01002152 for [v1, v2] in [[1, 2, 3], [3, 4]]
2153 echo v1 v2
2154 endfor
2155 END
2156 CheckDefExecFailure(lines, 'E710:', 1)
2157
2158 lines =<< trim END
2159 for [v1, v2] in [[1], [3, 4]]
2160 echo v1 v2
2161 endfor
2162 END
2163 CheckDefExecFailure(lines, 'E711:', 1)
2164
2165 lines =<< trim END
2166 for [v1, v1] in [[1, 2], [3, 4]]
2167 echo v1
2168 endfor
2169 END
2170 CheckDefExecFailure(lines, 'E1017:', 1)
2171enddef
2172
Bram Moolenaard0df1aa2020-03-04 21:50:46 +01002173def Test_while_loop()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002174 var result = ''
2175 var cnt = 0
Bram Moolenaard0df1aa2020-03-04 21:50:46 +01002176 while cnt < 555
2177 if cnt == 3
2178 break
2179 endif
2180 cnt += 1
2181 if cnt == 2
2182 continue
2183 endif
2184 result ..= cnt .. '_'
2185 endwhile
2186 assert_equal('1_3_', result)
2187enddef
2188
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02002189def Test_while_loop_fails()
Bram Moolenaar675f7162020-04-12 22:53:54 +02002190 CheckDefFailure(['while xxx'], 'E1001:')
2191 CheckDefFailure(['endwhile'], 'E588:')
2192 CheckDefFailure(['continue'], 'E586:')
2193 CheckDefFailure(['if true', 'continue'], 'E586:')
2194 CheckDefFailure(['break'], 'E587:')
2195 CheckDefFailure(['if true', 'break'], 'E587:')
2196 CheckDefFailure(['while 1', 'echo 3'], 'E170:')
Bram Moolenaarbd5da372020-03-31 23:13:10 +02002197enddef
2198
Bram Moolenaar9645e2d2020-03-20 20:48:49 +01002199def Test_interrupt_loop()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002200 var caught = false
2201 var x = 0
Bram Moolenaar97acfc72020-03-22 13:44:28 +01002202 try
2203 while 1
2204 x += 1
2205 if x == 100
2206 feedkeys("\<C-C>", 'Lt')
2207 endif
2208 endwhile
2209 catch
2210 caught = true
2211 assert_equal(100, x)
2212 endtry
2213 assert_true(caught, 'should have caught an exception')
Bram Moolenaar25859dd2020-08-30 12:54:53 +02002214 # consume the CTRL-C
2215 getchar(0)
Bram Moolenaar9645e2d2020-03-20 20:48:49 +01002216enddef
Bram Moolenaar20431c92020-03-20 18:39:46 +01002217
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002218def Test_automatic_line_continuation()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002219 var mylist = [
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002220 'one',
2221 'two',
2222 'three',
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002223 ] # comment
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002224 assert_equal(['one', 'two', 'three'], mylist)
2225
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002226 var mydict = {
Bram Moolenaare0de1712020-12-02 17:36:54 +01002227 ['one']: 1,
2228 ['two']: 2,
2229 ['three']:
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002230 3,
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002231 } # comment
Bram Moolenaare0de1712020-12-02 17:36:54 +01002232 assert_equal({one: 1, two: 2, three: 3}, mydict)
2233 mydict = {
Bram Moolenaar2c330432020-04-13 14:41:35 +02002234 one: 1, # comment
2235 two: # comment
2236 2, # comment
2237 three: 3 # comment
2238 }
Bram Moolenaare0de1712020-12-02 17:36:54 +01002239 assert_equal({one: 1, two: 2, three: 3}, mydict)
2240 mydict = {
Bram Moolenaar2c330432020-04-13 14:41:35 +02002241 one: 1,
2242 two:
2243 2,
2244 three: 3
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002245 }
Bram Moolenaare0de1712020-12-02 17:36:54 +01002246 assert_equal({one: 1, two: 2, three: 3}, mydict)
Bram Moolenaare6085c52020-04-12 20:19:16 +02002247
2248 assert_equal(
2249 ['one', 'two', 'three'],
2250 split('one two three')
2251 )
Bram Moolenaar4fdae992020-04-12 16:38:57 +02002252enddef
2253
Bram Moolenaar7a092242020-04-16 22:10:49 +02002254def Test_vim9_comment()
2255 CheckScriptSuccess([
2256 'vim9script',
2257 '# something',
Bram Moolenaar93f82cb2020-12-12 21:25:56 +01002258 '#something',
2259 '#{something',
Bram Moolenaar7a092242020-04-16 22:10:49 +02002260 ])
Bram Moolenaar93f82cb2020-12-12 21:25:56 +01002261
2262 split Xfile
2263 CheckScriptSuccess([
2264 'vim9script',
2265 'edit #something',
2266 ])
2267 CheckScriptSuccess([
2268 'vim9script',
2269 'edit #{something',
2270 ])
2271 close
2272
Bram Moolenaar7a092242020-04-16 22:10:49 +02002273 CheckScriptFailure([
2274 'vim9script',
2275 ':# something',
2276 ], 'E488:')
2277 CheckScriptFailure([
2278 '# something',
2279 ], 'E488:')
2280 CheckScriptFailure([
2281 ':# something',
2282 ], 'E488:')
2283
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02002284 { # block start
2285 } # block end
2286 CheckDefFailure([
2287 '{# comment',
2288 ], 'E488:')
2289 CheckDefFailure([
2290 '{',
2291 '}# comment',
2292 ], 'E488:')
2293
2294 echo "yes" # comment
2295 CheckDefFailure([
2296 'echo "yes"# comment',
2297 ], 'E488:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02002298 CheckScriptSuccess([
2299 'vim9script',
2300 'echo "yes" # something',
2301 ])
2302 CheckScriptFailure([
2303 'vim9script',
2304 'echo "yes"# something',
2305 ], 'E121:')
2306 CheckScriptFailure([
2307 'vim9script',
2308 'echo# something',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002309 ], 'E1144:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02002310 CheckScriptFailure([
2311 'echo "yes" # something',
2312 ], 'E121:')
2313
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02002314 exe "echo" # comment
2315 CheckDefFailure([
2316 'exe "echo"# comment',
2317 ], 'E488:')
2318 CheckScriptSuccess([
2319 'vim9script',
2320 'exe "echo" # something',
2321 ])
2322 CheckScriptFailure([
2323 'vim9script',
2324 'exe "echo"# something',
2325 ], 'E121:')
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02002326 CheckScriptFailure([
2327 'vim9script',
2328 'exe# something',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002329 ], 'E1144:')
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02002330 CheckScriptFailure([
2331 'exe "echo" # something',
2332 ], 'E121:')
2333
Bram Moolenaar7a092242020-04-16 22:10:49 +02002334 CheckDefFailure([
2335 'try# comment',
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002336 ' echo "yes"',
Bram Moolenaar7a092242020-04-16 22:10:49 +02002337 'catch',
2338 'endtry',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002339 ], 'E1144:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002340 CheckScriptFailure([
2341 'vim9script',
2342 'try# comment',
2343 'echo "yes"',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002344 ], 'E1144:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02002345 CheckDefFailure([
2346 'try',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002347 ' throw#comment',
2348 'catch',
2349 'endtry',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002350 ], 'E1144:')
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002351 CheckDefFailure([
2352 'try',
2353 ' throw "yes"#comment',
2354 'catch',
2355 'endtry',
2356 ], 'E488:')
2357 CheckDefFailure([
2358 'try',
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002359 ' echo "yes"',
Bram Moolenaar7a092242020-04-16 22:10:49 +02002360 'catch# comment',
2361 'endtry',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002362 ], 'E1144:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002363 CheckScriptFailure([
2364 'vim9script',
2365 'try',
2366 ' echo "yes"',
2367 'catch# comment',
2368 'endtry',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002369 ], 'E1144:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002370 CheckDefFailure([
2371 'try',
2372 ' echo "yes"',
2373 'catch /pat/# comment',
2374 'endtry',
2375 ], 'E488:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02002376 CheckDefFailure([
2377 'try',
2378 'echo "yes"',
2379 'catch',
2380 'endtry# comment',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002381 ], 'E1144:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002382 CheckScriptFailure([
2383 'vim9script',
2384 'try',
2385 ' echo "yes"',
2386 'catch',
2387 'endtry# comment',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002388 ], 'E1144:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002389
2390 CheckScriptSuccess([
2391 'vim9script',
2392 'hi # comment',
2393 ])
2394 CheckScriptFailure([
2395 'vim9script',
2396 'hi# comment',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002397 ], 'E1144:')
Bram Moolenaar1966c242020-04-20 22:42:32 +02002398 CheckScriptSuccess([
2399 'vim9script',
2400 'hi Search # comment',
2401 ])
2402 CheckScriptFailure([
2403 'vim9script',
2404 'hi Search# comment',
2405 ], 'E416:')
2406 CheckScriptSuccess([
2407 'vim9script',
2408 'hi link This Search # comment',
2409 ])
2410 CheckScriptFailure([
2411 'vim9script',
2412 'hi link This That# comment',
2413 ], 'E413:')
2414 CheckScriptSuccess([
2415 'vim9script',
2416 'hi clear This # comment',
2417 'hi clear # comment',
2418 ])
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002419 # not tested, because it doesn't give an error but a warning:
2420 # hi clear This# comment',
Bram Moolenaar1966c242020-04-20 22:42:32 +02002421 CheckScriptFailure([
2422 'vim9script',
2423 'hi clear# comment',
2424 ], 'E416:')
2425
2426 CheckScriptSuccess([
2427 'vim9script',
2428 'hi Group term=bold',
2429 'match Group /todo/ # comment',
2430 ])
2431 CheckScriptFailure([
2432 'vim9script',
2433 'hi Group term=bold',
2434 'match Group /todo/# comment',
2435 ], 'E488:')
2436 CheckScriptSuccess([
2437 'vim9script',
2438 'match # comment',
2439 ])
2440 CheckScriptFailure([
2441 'vim9script',
2442 'match# comment',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002443 ], 'E1144:')
Bram Moolenaar1966c242020-04-20 22:42:32 +02002444 CheckScriptSuccess([
2445 'vim9script',
2446 'match none # comment',
2447 ])
2448 CheckScriptFailure([
2449 'vim9script',
2450 'match none# comment',
2451 ], 'E475:')
2452
2453 CheckScriptSuccess([
2454 'vim9script',
2455 'menutrans clear # comment',
2456 ])
2457 CheckScriptFailure([
2458 'vim9script',
2459 'menutrans clear# comment text',
2460 ], 'E474:')
2461
2462 CheckScriptSuccess([
2463 'vim9script',
2464 'syntax clear # comment',
2465 ])
2466 CheckScriptFailure([
2467 'vim9script',
2468 'syntax clear# comment text',
2469 ], 'E28:')
2470 CheckScriptSuccess([
2471 'vim9script',
2472 'syntax keyword Word some',
2473 'syntax clear Word # comment',
2474 ])
2475 CheckScriptFailure([
2476 'vim9script',
2477 'syntax keyword Word some',
2478 'syntax clear Word# comment text',
2479 ], 'E28:')
2480
2481 CheckScriptSuccess([
2482 'vim9script',
2483 'syntax list # comment',
2484 ])
2485 CheckScriptFailure([
2486 'vim9script',
2487 'syntax list# comment text',
2488 ], 'E28:')
2489
2490 CheckScriptSuccess([
2491 'vim9script',
2492 'syntax match Word /pat/ oneline # comment',
2493 ])
2494 CheckScriptFailure([
2495 'vim9script',
2496 'syntax match Word /pat/ oneline# comment',
2497 ], 'E475:')
2498
2499 CheckScriptSuccess([
2500 'vim9script',
2501 'syntax keyword Word word # comm[ent',
2502 ])
2503 CheckScriptFailure([
2504 'vim9script',
2505 'syntax keyword Word word# comm[ent',
2506 ], 'E789:')
2507
2508 CheckScriptSuccess([
2509 'vim9script',
2510 'syntax match Word /pat/ # comment',
2511 ])
2512 CheckScriptFailure([
2513 'vim9script',
2514 'syntax match Word /pat/# comment',
2515 ], 'E402:')
2516
2517 CheckScriptSuccess([
2518 'vim9script',
2519 'syntax match Word /pat/ contains=Something # comment',
2520 ])
2521 CheckScriptFailure([
2522 'vim9script',
2523 'syntax match Word /pat/ contains=Something# comment',
2524 ], 'E475:')
2525 CheckScriptFailure([
2526 'vim9script',
2527 'syntax match Word /pat/ contains= # comment',
2528 ], 'E406:')
2529 CheckScriptFailure([
2530 'vim9script',
2531 'syntax match Word /pat/ contains=# comment',
2532 ], 'E475:')
2533
2534 CheckScriptSuccess([
2535 'vim9script',
2536 'syntax region Word start=/pat/ end=/pat/ # comment',
2537 ])
2538 CheckScriptFailure([
2539 'vim9script',
2540 'syntax region Word start=/pat/ end=/pat/# comment',
Bram Moolenaard032f342020-07-18 18:13:02 +02002541 ], 'E402:')
Bram Moolenaar1966c242020-04-20 22:42:32 +02002542
2543 CheckScriptSuccess([
2544 'vim9script',
2545 'syntax sync # comment',
2546 ])
2547 CheckScriptFailure([
2548 'vim9script',
2549 'syntax sync# comment',
2550 ], 'E404:')
2551 CheckScriptSuccess([
2552 'vim9script',
2553 'syntax sync ccomment # comment',
2554 ])
2555 CheckScriptFailure([
2556 'vim9script',
2557 'syntax sync ccomment# comment',
2558 ], 'E404:')
2559
2560 CheckScriptSuccess([
2561 'vim9script',
2562 'syntax cluster Some contains=Word # comment',
2563 ])
2564 CheckScriptFailure([
2565 'vim9script',
2566 'syntax cluster Some contains=Word# comment',
2567 ], 'E475:')
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002568
2569 CheckScriptSuccess([
2570 'vim9script',
2571 'command Echo echo # comment',
2572 'command Echo # comment',
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002573 'delcommand Echo',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002574 ])
2575 CheckScriptFailure([
2576 'vim9script',
2577 'command Echo echo# comment',
2578 'Echo',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002579 ], 'E1144:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002580 delcommand Echo
Bram Moolenaar70249ee2020-12-10 21:01:30 +01002581
2582 var curdir = getcwd()
2583 CheckScriptSuccess([
2584 'command Echo cd " comment',
2585 'Echo',
2586 'delcommand Echo',
2587 ])
2588 CheckScriptSuccess([
Bram Moolenaar090728a2020-12-20 15:43:31 +01002589 'vim9script',
Bram Moolenaar70249ee2020-12-10 21:01:30 +01002590 'command Echo cd # comment',
2591 'Echo',
2592 'delcommand Echo',
2593 ])
2594 CheckScriptFailure([
2595 'vim9script',
2596 'command Echo cd " comment',
2597 'Echo',
2598 ], 'E344:')
2599 delcommand Echo
2600 chdir(curdir)
2601
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002602 CheckScriptFailure([
2603 'vim9script',
2604 'command Echo# comment',
2605 ], 'E182:')
2606 CheckScriptFailure([
2607 'vim9script',
2608 'command Echo echo',
2609 'command Echo# comment',
2610 ], 'E182:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002611 delcommand Echo
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002612
2613 CheckScriptSuccess([
2614 'vim9script',
2615 'function # comment',
2616 ])
2617 CheckScriptFailure([
2618 'vim9script',
Bram Moolenaar98981072020-07-29 14:40:25 +02002619 'function " comment',
2620 ], 'E129:')
2621 CheckScriptFailure([
2622 'vim9script',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002623 'function# comment',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002624 ], 'E1144:')
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002625 CheckScriptSuccess([
2626 'vim9script',
2627 'function CheckScriptSuccess # comment',
2628 ])
2629 CheckScriptFailure([
2630 'vim9script',
2631 'function CheckScriptSuccess# comment',
2632 ], 'E488:')
2633
2634 CheckScriptSuccess([
2635 'vim9script',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02002636 'func g:DeleteMeA()',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002637 'endfunc',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02002638 'delfunction g:DeleteMeA # comment',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002639 ])
2640 CheckScriptFailure([
2641 'vim9script',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02002642 'func g:DeleteMeB()',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002643 'endfunc',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02002644 'delfunction g:DeleteMeB# comment',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002645 ], 'E488:')
2646
2647 CheckScriptSuccess([
2648 'vim9script',
2649 'call execute("ls") # comment',
2650 ])
2651 CheckScriptFailure([
2652 'vim9script',
2653 'call execute("ls")# comment',
2654 ], 'E488:')
Bram Moolenaare7e48382020-07-22 18:17:08 +02002655
2656 CheckScriptFailure([
2657 'def Test() " comment',
2658 'enddef',
2659 ], 'E488:')
2660 CheckScriptFailure([
2661 'vim9script',
2662 'def Test() " comment',
2663 'enddef',
2664 ], 'E488:')
2665
2666 CheckScriptSuccess([
2667 'func Test() " comment',
2668 'endfunc',
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002669 'delfunc Test',
Bram Moolenaare7e48382020-07-22 18:17:08 +02002670 ])
Bram Moolenaar98981072020-07-29 14:40:25 +02002671 CheckScriptSuccess([
Bram Moolenaare7e48382020-07-22 18:17:08 +02002672 'vim9script',
2673 'func Test() " comment',
2674 'endfunc',
Bram Moolenaar98981072020-07-29 14:40:25 +02002675 ])
Bram Moolenaare7e48382020-07-22 18:17:08 +02002676
2677 CheckScriptSuccess([
2678 'def Test() # comment',
2679 'enddef',
2680 ])
2681 CheckScriptFailure([
2682 'func Test() # comment',
2683 'endfunc',
2684 ], 'E488:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002685enddef
2686
2687def Test_vim9_comment_gui()
2688 CheckCanRunGui
2689
2690 CheckScriptFailure([
2691 'vim9script',
2692 'gui#comment'
Bram Moolenaarf8103f22020-12-25 17:36:27 +01002693 ], 'E1144:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02002694 CheckScriptFailure([
2695 'vim9script',
2696 'gui -f#comment'
2697 ], 'E499:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02002698enddef
2699
Bram Moolenaara26b9702020-04-18 19:53:28 +02002700def Test_vim9_comment_not_compiled()
Bram Moolenaar67979662020-06-20 22:50:47 +02002701 au TabEnter *.vim g:entered = 1
2702 au TabEnter *.x g:entered = 2
Bram Moolenaara26b9702020-04-18 19:53:28 +02002703
2704 edit test.vim
2705 doautocmd TabEnter #comment
2706 assert_equal(1, g:entered)
2707
2708 doautocmd TabEnter f.x
2709 assert_equal(2, g:entered)
2710
2711 g:entered = 0
2712 doautocmd TabEnter f.x #comment
2713 assert_equal(2, g:entered)
2714
2715 assert_fails('doautocmd Syntax#comment', 'E216:')
2716
2717 au! TabEnter
2718 unlet g:entered
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02002719
2720 CheckScriptSuccess([
2721 'vim9script',
Bram Moolenaar67979662020-06-20 22:50:47 +02002722 'g:var = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02002723 'b:var = 456',
2724 'w:var = 777',
2725 't:var = 888',
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02002726 'unlet g:var w:var # something',
2727 ])
2728
2729 CheckScriptFailure([
2730 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002731 'let var = 123',
2732 ], 'E1126: Cannot use :let in Vim9 script')
2733
2734 CheckScriptFailure([
2735 'vim9script',
2736 'var g:var = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02002737 ], 'E1016: Cannot declare a global variable:')
2738
2739 CheckScriptFailure([
2740 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002741 'var b:var = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02002742 ], 'E1016: Cannot declare a buffer variable:')
2743
2744 CheckScriptFailure([
2745 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002746 'var w:var = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02002747 ], 'E1016: Cannot declare a window variable:')
2748
2749 CheckScriptFailure([
2750 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002751 'var t:var = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02002752 ], 'E1016: Cannot declare a tab variable:')
2753
2754 CheckScriptFailure([
2755 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002756 'var v:version = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02002757 ], 'E1016: Cannot declare a v: variable:')
2758
2759 CheckScriptFailure([
2760 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002761 'var $VARIABLE = "text"',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02002762 ], 'E1016: Cannot declare an environment variable:')
Bram Moolenaar67979662020-06-20 22:50:47 +02002763
2764 CheckScriptFailure([
2765 'vim9script',
2766 'g:var = 123',
Bram Moolenaar32e35112020-05-14 22:41:15 +02002767 'unlet g:var# comment1',
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02002768 ], 'E108:')
2769
2770 CheckScriptFailure([
2771 'let g:var = 123',
2772 'unlet g:var # something',
2773 ], 'E488:')
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002774
2775 CheckScriptSuccess([
2776 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02002777 'if 1 # comment2',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002778 ' echo "yes"',
2779 'elseif 2 #comment',
2780 ' echo "no"',
2781 'endif',
2782 ])
2783
2784 CheckScriptFailure([
2785 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02002786 'if 1# comment3',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002787 ' echo "yes"',
2788 'endif',
2789 ], 'E15:')
2790
2791 CheckScriptFailure([
2792 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02002793 'if 0 # comment4',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002794 ' echo "yes"',
2795 'elseif 2#comment',
2796 ' echo "no"',
2797 'endif',
2798 ], 'E15:')
2799
2800 CheckScriptSuccess([
2801 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002802 'var v = 1 # comment5',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002803 ])
2804
2805 CheckScriptFailure([
2806 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002807 'var v = 1# comment6',
Bram Moolenaar32e35112020-05-14 22:41:15 +02002808 ], 'E15:')
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002809
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002810 CheckScriptSuccess([
2811 'vim9script',
2812 'new'
Bram Moolenaard2c61702020-09-06 15:58:36 +02002813 'setline(1, ["# define pat", "last"])',
Bram Moolenaardf069ee2020-06-22 23:02:51 +02002814 ':$',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02002815 'dsearch /pat/ #comment',
2816 'bwipe!',
2817 ])
2818
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002819 CheckScriptFailure([
2820 'vim9script',
2821 'new'
Bram Moolenaard2c61702020-09-06 15:58:36 +02002822 'setline(1, ["# define pat", "last"])',
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002823 ':$',
2824 'dsearch /pat/#comment',
2825 'bwipe!',
2826 ], 'E488:')
2827
2828 CheckScriptFailure([
2829 'vim9script',
2830 'func! SomeFunc()',
2831 ], 'E477:')
Bram Moolenaara26b9702020-04-18 19:53:28 +02002832enddef
2833
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02002834def Test_finish()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002835 var lines =<< trim END
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02002836 vim9script
Bram Moolenaar67979662020-06-20 22:50:47 +02002837 g:res = 'one'
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02002838 if v:false | finish | endif
Bram Moolenaar67979662020-06-20 22:50:47 +02002839 g:res = 'two'
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02002840 finish
Bram Moolenaar67979662020-06-20 22:50:47 +02002841 g:res = 'three'
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02002842 END
2843 writefile(lines, 'Xfinished')
2844 source Xfinished
2845 assert_equal('two', g:res)
2846
2847 unlet g:res
2848 delete('Xfinished')
2849enddef
2850
Bram Moolenaara5d00772020-05-14 23:20:55 +02002851def Test_forward_declaration()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002852 var lines =<< trim END
Bram Moolenaara5d00772020-05-14 23:20:55 +02002853 vim9script
Bram Moolenaara5d00772020-05-14 23:20:55 +02002854 def GetValue(): string
2855 return theVal
2856 enddef
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002857 var theVal = 'something'
Bram Moolenaar822ba242020-05-24 23:00:18 +02002858 g:initVal = GetValue()
Bram Moolenaara5d00772020-05-14 23:20:55 +02002859 theVal = 'else'
2860 g:laterVal = GetValue()
2861 END
2862 writefile(lines, 'Xforward')
2863 source Xforward
2864 assert_equal('something', g:initVal)
2865 assert_equal('else', g:laterVal)
2866
2867 unlet g:initVal
2868 unlet g:laterVal
2869 delete('Xforward')
2870enddef
2871
Bram Moolenaar9721fb42020-06-11 23:10:46 +02002872def Test_source_vim9_from_legacy()
Bram Moolenaara6294952020-12-27 13:39:50 +01002873 var vim9_lines =<< trim END
2874 vim9script
2875 var local = 'local'
2876 g:global = 'global'
2877 export var exported = 'exported'
2878 export def GetText(): string
2879 return 'text'
2880 enddef
2881 END
2882 writefile(vim9_lines, 'Xvim9_script.vim')
2883
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002884 var legacy_lines =<< trim END
Bram Moolenaar9721fb42020-06-11 23:10:46 +02002885 source Xvim9_script.vim
2886
2887 call assert_false(exists('local'))
2888 call assert_false(exists('exported'))
2889 call assert_false(exists('s:exported'))
2890 call assert_equal('global', global)
2891 call assert_equal('global', g:global)
2892
2893 " imported variable becomes script-local
2894 import exported from './Xvim9_script.vim'
2895 call assert_equal('exported', s:exported)
2896 call assert_false(exists('exported'))
2897
2898 " imported function becomes script-local
2899 import GetText from './Xvim9_script.vim'
2900 call assert_equal('text', s:GetText())
2901 call assert_false(exists('*GetText'))
2902 END
2903 writefile(legacy_lines, 'Xlegacy_script.vim')
2904
Bram Moolenaar9721fb42020-06-11 23:10:46 +02002905 source Xlegacy_script.vim
Bram Moolenaar9721fb42020-06-11 23:10:46 +02002906 assert_equal('global', g:global)
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002907 unlet g:global
Bram Moolenaar9721fb42020-06-11 23:10:46 +02002908
2909 delete('Xlegacy_script.vim')
2910 delete('Xvim9_script.vim')
2911enddef
Bram Moolenaara5d00772020-05-14 23:20:55 +02002912
Bram Moolenaar7d699702020-08-14 20:52:28 +02002913func Test_vim9script_not_global()
2914 " check that items defined in Vim9 script are script-local, not global
2915 let vim9lines =<< trim END
2916 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002917 var name = 'local'
Bram Moolenaar7d699702020-08-14 20:52:28 +02002918 func TheFunc()
2919 echo 'local'
2920 endfunc
2921 def DefFunc()
2922 echo 'local'
2923 enddef
2924 END
2925 call writefile(vim9lines, 'Xvim9script.vim')
2926 source Xvim9script.vim
2927 try
2928 echo g:var
2929 assert_report('did not fail')
2930 catch /E121:/
2931 " caught
2932 endtry
2933 try
2934 call TheFunc()
2935 assert_report('did not fail')
2936 catch /E117:/
2937 " caught
2938 endtry
2939 try
2940 call DefFunc()
2941 assert_report('did not fail')
2942 catch /E117:/
2943 " caught
2944 endtry
2945
Bram Moolenaar25859dd2020-08-30 12:54:53 +02002946 call delete('Xvim9script.vim')
Bram Moolenaar7d699702020-08-14 20:52:28 +02002947endfunc
2948
Bram Moolenaareeb27bf2020-07-04 17:39:10 +02002949def Test_vim9_copen()
2950 # this was giving an error for setting w:quickfix_title
2951 copen
2952 quit
2953enddef
2954
Bram Moolenaar03290b82020-12-19 16:30:44 +01002955" test using an auto-loaded function and variable
Bram Moolenaar2d6b20d2020-07-25 19:30:59 +02002956def Test_vim9_autoload()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002957 var lines =<< trim END
Bram Moolenaar2d6b20d2020-07-25 19:30:59 +02002958 vim9script
Bram Moolenaar03290b82020-12-19 16:30:44 +01002959 def some#gettest(): string
2960 return 'test'
2961 enddef
2962 g:some#name = 'name'
2963 END
2964
2965 mkdir('Xdir/autoload', 'p')
2966 writefile(lines, 'Xdir/autoload/some.vim')
2967 var save_rtp = &rtp
2968 exe 'set rtp^=' .. getcwd() .. '/Xdir'
2969
2970 assert_equal('test', g:some#gettest())
2971 assert_equal('name', g:some#name)
2972 g:some#other = 'other'
2973 assert_equal('other', g:some#other)
2974
Bram Moolenaar17f700a2020-12-19 21:23:42 +01002975 # upper case script name works
2976 lines =<< trim END
2977 vim9script
2978 def Other#getOther(): string
2979 return 'other'
2980 enddef
2981 END
2982 writefile(lines, 'Xdir/autoload/Other.vim')
2983 assert_equal('other', g:Other#getOther())
2984
Bram Moolenaar03290b82020-12-19 16:30:44 +01002985 delete('Xdir', 'rf')
2986 &rtp = save_rtp
2987enddef
2988
2989" test using a vim9script that is auto-loaded from an autocmd
2990def Test_vim9_aucmd_autoload()
2991 var lines =<< trim END
2992 vim9script
Bram Moolenaar2d6b20d2020-07-25 19:30:59 +02002993 def foo#test()
2994 echomsg getreg('"')
2995 enddef
2996 END
2997
2998 mkdir('Xdir/autoload', 'p')
2999 writefile(lines, 'Xdir/autoload/foo.vim')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003000 var save_rtp = &rtp
Bram Moolenaar2d6b20d2020-07-25 19:30:59 +02003001 exe 'set rtp^=' .. getcwd() .. '/Xdir'
3002 augroup test
3003 autocmd TextYankPost * call foo#test()
3004 augroup END
3005
3006 normal Y
3007
3008 augroup test
3009 autocmd!
3010 augroup END
3011 delete('Xdir', 'rf')
3012 &rtp = save_rtp
3013enddef
3014
Bram Moolenaar77e5dcc2020-09-17 21:29:03 +02003015" This was causing a crash because suppress_errthrow wasn't reset.
3016def Test_vim9_autoload_error()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003017 var lines =<< trim END
Bram Moolenaar77e5dcc2020-09-17 21:29:03 +02003018 vim9script
3019 def crash#func()
3020 try
3021 for x in List()
3022 endfor
3023 catch
3024 endtry
3025 g:ok = true
3026 enddef
3027 fu List()
3028 invalid
3029 endfu
3030 try
Bram Moolenaar48e11c12021-01-11 18:47:00 +01003031 alsoinvalid
Bram Moolenaar77e5dcc2020-09-17 21:29:03 +02003032 catch /wontmatch/
3033 endtry
3034 END
3035 call mkdir('Xruntime/autoload', 'p')
3036 call writefile(lines, 'Xruntime/autoload/crash.vim')
3037
3038 # run in a separate Vim to avoid the side effects of assert_fails()
3039 lines =<< trim END
3040 exe 'set rtp^=' .. getcwd() .. '/Xruntime'
3041 call crash#func()
3042 call writefile(['ok'], 'Xdidit')
Bram Moolenaar9c4f5522020-09-25 21:47:28 +02003043 qall!
Bram Moolenaar77e5dcc2020-09-17 21:29:03 +02003044 END
3045 writefile(lines, 'Xscript')
3046 RunVim([], [], '-S Xscript')
3047 assert_equal(['ok'], readfile('Xdidit'))
3048
3049 delete('Xdidit')
3050 delete('Xscript')
3051 delete('Xruntime', 'rf')
Bram Moolenaar03290b82020-12-19 16:30:44 +01003052
3053 lines =<< trim END
3054 vim9script
3055 var foo#bar = 'asdf'
3056 END
3057 CheckScriptFailure(lines, 'E461: Illegal variable name: foo#bar', 2)
Bram Moolenaar77e5dcc2020-09-17 21:29:03 +02003058enddef
3059
Bram Moolenaar81e17fb2020-08-21 21:55:43 +02003060def Test_script_var_in_autocmd()
3061 # using a script variable from an autocommand, defined in a :def function in a
3062 # legacy Vim script, cannot check the variable type.
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003063 var lines =<< trim END
Bram Moolenaar81e17fb2020-08-21 21:55:43 +02003064 let s:counter = 1
3065 def s:Func()
3066 au! CursorHold
3067 au CursorHold * s:counter += 1
3068 enddef
3069 call s:Func()
3070 doau CursorHold
3071 call assert_equal(2, s:counter)
3072 au! CursorHold
3073 END
3074 CheckScriptSuccess(lines)
3075enddef
3076
Bram Moolenaar3896a102020-08-09 14:33:55 +02003077def Test_cmdline_win()
3078 # if the Vim syntax highlighting uses Vim9 constructs they can be used from
3079 # the command line window.
3080 mkdir('rtp/syntax', 'p')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003081 var export_lines =<< trim END
Bram Moolenaar3896a102020-08-09 14:33:55 +02003082 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003083 export var That = 'yes'
Bram Moolenaar3896a102020-08-09 14:33:55 +02003084 END
3085 writefile(export_lines, 'rtp/syntax/Xexport.vim')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003086 var import_lines =<< trim END
Bram Moolenaar3896a102020-08-09 14:33:55 +02003087 vim9script
3088 import That from './Xexport.vim'
3089 END
3090 writefile(import_lines, 'rtp/syntax/vim.vim')
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003091 var save_rtp = &rtp
Bram Moolenaar3896a102020-08-09 14:33:55 +02003092 &rtp = getcwd() .. '/rtp' .. ',' .. &rtp
3093 syntax on
3094 augroup CmdWin
3095 autocmd CmdwinEnter * g:got_there = 'yes'
3096 augroup END
3097 # this will open and also close the cmdline window
3098 feedkeys('q:', 'xt')
3099 assert_equal('yes', g:got_there)
3100
3101 augroup CmdWin
3102 au!
3103 augroup END
3104 &rtp = save_rtp
3105 delete('rtp', 'rf')
3106enddef
3107
Bram Moolenaare3d46852020-08-29 13:39:17 +02003108def Test_invalid_sid()
3109 assert_fails('func <SNR>1234_func', 'E123:')
Bram Moolenaar25859dd2020-08-30 12:54:53 +02003110
Bram Moolenaar9c4f5522020-09-25 21:47:28 +02003111 if RunVim([], ['wq! Xdidit'], '+"func <SNR>1_func"')
Bram Moolenaard2c61702020-09-06 15:58:36 +02003112 assert_equal([], readfile('Xdidit'))
Bram Moolenaare3d46852020-08-29 13:39:17 +02003113 endif
3114 delete('Xdidit')
3115enddef
3116
Bram Moolenaar9ec70262020-12-09 17:16:59 +01003117def Test_restoring_cpo()
3118 writefile(['vim9script', 'set nocp'], 'Xsourced')
3119 writefile(['call writefile(["done"], "Xdone")', 'quit!'], 'Xclose')
3120 if RunVim([], [], '-u NONE +"set cpo+=a" -S Xsourced -S Xclose')
3121 assert_equal(['done'], readfile('Xdone'))
3122 endif
3123 delete('Xsourced')
3124 delete('Xclose')
Bram Moolenaar090728a2020-12-20 15:43:31 +01003125 delete('Xdone')
Bram Moolenaar9ec70262020-12-09 17:16:59 +01003126enddef
3127
3128
Bram Moolenaarf0afd9e2020-09-13 18:57:47 +02003129def Test_unset_any_variable()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003130 var lines =<< trim END
3131 var name: any
3132 assert_equal(0, name)
Bram Moolenaarf0afd9e2020-09-13 18:57:47 +02003133 END
3134 CheckDefAndScriptSuccess(lines)
3135enddef
3136
Bram Moolenaar7e9210e2020-09-25 23:12:51 +02003137func Test_define_func_at_command_line()
Bram Moolenaar58dbef32020-09-25 22:13:05 +02003138 CheckRunVimInTerminal
3139
Bram Moolenaar7e9210e2020-09-25 23:12:51 +02003140 " call indirectly to avoid compilation error for missing functions
3141 call Run_Test_define_func_at_command_line()
3142endfunc
3143
3144def Run_Test_define_func_at_command_line()
Bram Moolenaar9c4f5522020-09-25 21:47:28 +02003145 # run in a separate Vim instance to avoid the script context
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003146 var lines =<< trim END
Bram Moolenaar9c4f5522020-09-25 21:47:28 +02003147 func CheckAndQuit()
3148 call assert_fails('call Afunc()', 'E117: Unknown function: Bfunc')
3149 call writefile(['errors: ' .. string(v:errors)], 'Xdidcmd')
3150 endfunc
3151 END
3152 writefile([''], 'Xdidcmd')
3153 writefile(lines, 'XcallFunc')
Bram Moolenaare0de1712020-12-02 17:36:54 +01003154 var buf = RunVimInTerminal('-S XcallFunc', {rows: 6})
Bram Moolenaar9c4f5522020-09-25 21:47:28 +02003155 # define Afunc() on the command line
3156 term_sendkeys(buf, ":def Afunc()\<CR>Bfunc()\<CR>enddef\<CR>")
3157 term_sendkeys(buf, ":call CheckAndQuit()\<CR>")
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01003158 WaitForAssert(() => assert_equal(['errors: []'], readfile('Xdidcmd')))
Bram Moolenaar9c4f5522020-09-25 21:47:28 +02003159
3160 call StopVimInTerminal(buf)
3161 delete('XcallFunc')
3162 delete('Xdidcmd')
3163enddef
3164
Bram Moolenaarfcdc5d82020-10-10 19:07:09 +02003165def Test_script_var_scope()
3166 var lines =<< trim END
3167 vim9script
3168 if true
3169 if true
3170 var one = 'one'
3171 echo one
3172 endif
3173 echo one
3174 endif
3175 END
3176 CheckScriptFailure(lines, 'E121:', 7)
3177
3178 lines =<< trim END
3179 vim9script
3180 if true
3181 if false
3182 var one = 'one'
3183 echo one
3184 else
3185 var one = 'one'
3186 echo one
3187 endif
3188 echo one
3189 endif
3190 END
3191 CheckScriptFailure(lines, 'E121:', 10)
3192
3193 lines =<< trim END
3194 vim9script
3195 while true
3196 var one = 'one'
3197 echo one
3198 break
3199 endwhile
3200 echo one
3201 END
3202 CheckScriptFailure(lines, 'E121:', 7)
3203
3204 lines =<< trim END
3205 vim9script
3206 for i in range(1)
3207 var one = 'one'
3208 echo one
3209 endfor
3210 echo one
3211 END
3212 CheckScriptFailure(lines, 'E121:', 6)
Bram Moolenaar9becdf22020-10-10 21:33:48 +02003213
3214 lines =<< trim END
3215 vim9script
3216 {
3217 var one = 'one'
3218 assert_equal('one', one)
3219 }
3220 assert_false(exists('one'))
3221 assert_false(exists('s:one'))
3222 END
3223 CheckScriptSuccess(lines)
3224
3225 lines =<< trim END
3226 vim9script
3227 {
3228 var one = 'one'
3229 echo one
3230 }
3231 echo one
3232 END
3233 CheckScriptFailure(lines, 'E121:', 6)
Bram Moolenaarfcdc5d82020-10-10 19:07:09 +02003234enddef
3235
Bram Moolenaar352134b2020-10-17 22:04:08 +02003236def Test_catch_exception_in_callback()
3237 var lines =<< trim END
3238 vim9script
3239 def Callback(...l: any)
3240 try
3241 var x: string
3242 var y: string
3243 # this error should be caught with CHECKLEN
3244 [x, y] = ['']
3245 catch
3246 g:caught = 'yes'
3247 endtry
3248 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +01003249 popup_menu('popup', {callback: Callback})
Bram Moolenaar352134b2020-10-17 22:04:08 +02003250 feedkeys("\r", 'xt')
3251 END
3252 CheckScriptSuccess(lines)
3253
3254 unlet g:caught
3255enddef
3256
Bram Moolenaar631e8f92020-11-04 15:07:16 +01003257def Test_no_unknown_error_after_error()
3258 if !has('unix') || !has('job')
3259 throw 'Skipped: not unix of missing +job feature'
3260 endif
3261 var lines =<< trim END
3262 vim9script
3263 var source: list<number>
3264 def Out_cb(...l: any)
3265 eval [][0]
3266 enddef
3267 def Exit_cb(...l: any)
3268 sleep 1m
3269 source += l
3270 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +01003271 var myjob = job_start('echo burp', {out_cb: Out_cb, exit_cb: Exit_cb, mode: 'raw'})
Bram Moolenaar6f17a3f2020-12-21 18:11:24 +01003272 while job_status(myjob) == 'run'
3273 sleep 10m
3274 endwhile
3275 sleep 10m
Bram Moolenaar631e8f92020-11-04 15:07:16 +01003276 END
3277 writefile(lines, 'Xdef')
3278 assert_fails('so Xdef', ['E684:', 'E1012:'])
3279 delete('Xdef')
3280enddef
3281
Bram Moolenaar4324d872020-12-01 20:12:24 +01003282def InvokeNormal()
3283 exe "norm! :m+1\r"
3284enddef
3285
3286def Test_invoke_normal_in_visual_mode()
3287 xnoremap <F3> <Cmd>call <SID>InvokeNormal()<CR>
3288 new
3289 setline(1, ['aaa', 'bbb'])
3290 feedkeys("V\<F3>", 'xt')
3291 assert_equal(['bbb', 'aaa'], getline(1, 2))
3292 xunmap <F3>
3293enddef
3294
Bram Moolenaarb5b94802020-12-13 17:50:20 +01003295def Test_white_space_after_command()
3296 var lines =<< trim END
3297 exit_cb: Func})
3298 END
3299 CheckDefAndScriptFailure(lines, 'E1144:', 1)
Bram Moolenaarf8103f22020-12-25 17:36:27 +01003300
3301 lines =<< trim END
3302 e#
3303 END
3304 CheckDefAndScriptFailure(lines, 'E1144:', 1)
Bram Moolenaarb5b94802020-12-13 17:50:20 +01003305enddef
3306
Bram Moolenaar4aab88d2020-12-24 21:56:41 +01003307def Test_script_var_gone_when_sourced_twice()
3308 var lines =<< trim END
3309 vim9script
3310 if exists('g:guard')
3311 finish
3312 endif
3313 g:guard = 1
3314 var name = 'thename'
3315 def g:GetName(): string
3316 return name
3317 enddef
3318 def g:SetName(arg: string)
3319 name = arg
3320 enddef
3321 END
3322 writefile(lines, 'XscriptTwice.vim')
3323 so XscriptTwice.vim
3324 assert_equal('thename', g:GetName())
3325 g:SetName('newname')
3326 assert_equal('newname', g:GetName())
3327 so XscriptTwice.vim
3328 assert_fails('call g:GetName()', 'E1149:')
3329 assert_fails('call g:SetName("x")', 'E1149:')
3330
3331 delfunc g:GetName
3332 delfunc g:SetName
3333 delete('XscriptTwice.vim')
3334 unlet g:guard
3335enddef
3336
3337def Test_import_gone_when_sourced_twice()
3338 var exportlines =<< trim END
3339 vim9script
3340 if exists('g:guard')
3341 finish
3342 endif
3343 g:guard = 1
3344 export var name = 'someName'
3345 END
3346 writefile(exportlines, 'XexportScript.vim')
3347
3348 var lines =<< trim END
3349 vim9script
3350 import name from './XexportScript.vim'
3351 def g:GetName(): string
3352 return name
3353 enddef
3354 END
3355 writefile(lines, 'XscriptImport.vim')
3356 so XscriptImport.vim
3357 assert_equal('someName', g:GetName())
3358
3359 so XexportScript.vim
3360 assert_fails('call g:GetName()', 'E1149:')
3361
3362 delfunc g:GetName
3363 delete('XexportScript.vim')
3364 delete('XscriptImport.vim')
3365 unlet g:guard
3366enddef
3367
Bram Moolenaar585fea72020-04-02 22:33:21 +02003368" Keep this last, it messes up highlighting.
3369def Test_substitute_cmd()
3370 new
3371 setline(1, 'something')
3372 :substitute(some(other(
3373 assert_equal('otherthing', getline(1))
3374 bwipe!
3375
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02003376 # also when the context is Vim9 script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003377 var lines =<< trim END
Bram Moolenaar585fea72020-04-02 22:33:21 +02003378 vim9script
3379 new
3380 setline(1, 'something')
3381 :substitute(some(other(
3382 assert_equal('otherthing', getline(1))
3383 bwipe!
3384 END
3385 writefile(lines, 'Xvim9lines')
3386 source Xvim9lines
3387
3388 delete('Xvim9lines')
3389enddef
3390
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003391" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker