blob: 9ec92b398d5420901f50a437634c819803a61dab [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 Moolenaar62aec932022-01-29 21:45:34 +00005import './vim9.vim' as v9
Bram Moolenaar37294bd2021-03-10 13:40:08 +01006source screendump.vim
Bram Moolenaard8448622022-01-07 21:39:52 +00007source shared.vim
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01008
Bram Moolenaarb79ee0c2022-01-01 12:17:00 +00009def Test_vim9script_feature()
10 # example from the help, here the feature is always present
11 var lines =<< trim END
12 " old style comment
13 if !has('vim9script')
14 " legacy commands would go here
15 finish
16 endif
17 vim9script
18 # Vim9 script commands go here
19 g:didit = true
20 END
Bram Moolenaar62aec932022-01-29 21:45:34 +000021 v9.CheckScriptSuccess(lines)
Bram Moolenaarb79ee0c2022-01-01 12:17:00 +000022 assert_equal(true, g:didit)
23 unlet g:didit
24enddef
25
Bram Moolenaar5d72ce62020-08-20 23:04:06 +020026def Test_range_only()
27 new
28 setline(1, ['blah', 'Blah'])
29 :/Blah/
30 assert_equal(2, getcurpos()[1])
Bram Moolenaarc2af0af2020-08-23 21:06:02 +020031 bwipe!
32
33 # without range commands use current line
34 new
35 setline(1, ['one', 'two', 'three'])
36 :2
37 print
Bram Moolenaar62aec932022-01-29 21:45:34 +000038 assert_equal('two', g:Screenline(&lines))
Bram Moolenaarc2af0af2020-08-23 21:06:02 +020039 :3
40 list
Bram Moolenaar62aec932022-01-29 21:45:34 +000041 assert_equal('three$', g:Screenline(&lines))
Bram Moolenaarb8554302021-02-15 21:30:30 +010042
43 # missing command does not print the line
44 var lines =<< trim END
45 vim9script
46 :1|
Bram Moolenaar62aec932022-01-29 21:45:34 +000047 assert_equal('three$', g:Screenline(&lines))
Bram Moolenaarb8554302021-02-15 21:30:30 +010048 :|
Bram Moolenaar62aec932022-01-29 21:45:34 +000049 assert_equal('three$', g:Screenline(&lines))
Bram Moolenaarb8554302021-02-15 21:30:30 +010050 END
Bram Moolenaar62aec932022-01-29 21:45:34 +000051 v9.CheckScriptSuccess(lines)
Bram Moolenaarb8554302021-02-15 21:30:30 +010052
Bram Moolenaarc2af0af2020-08-23 21:06:02 +020053 bwipe!
Bram Moolenaar025cb1c2020-12-14 18:31:27 +010054
Bram Moolenaar0c7f2612022-02-17 19:44:07 +000055 lines =<< trim END
56 set cpo+=-
57 :1,999
58 END
59 v9.CheckDefExecAndScriptFailure(lines, 'E16:', 2)
60 set cpo&vim
61
62 v9.CheckDefExecAndScriptFailure([":'x"], 'E20:', 1)
63
Bram Moolenaar025cb1c2020-12-14 18:31:27 +010064 # won't generate anything
65 if false
66 :123
67 endif
Bram Moolenaar5d72ce62020-08-20 23:04:06 +020068enddef
69
Bram Moolenaar09d94212022-05-05 15:20:03 +010070def Test_invalid_range()
71 var lines =<< trim END
72 :123 eval 1 + 2
73 END
74 v9.CheckDefAndScriptFailure(lines, 'E481:', 1)
75
76 lines =<< trim END
77 :123 if true
78 endif
79 END
80 v9.CheckDefAndScriptFailure(lines, 'E481:', 1)
81
82 lines =<< trim END
83 :123 echo 'yes'
84 END
85 v9.CheckDefAndScriptFailure(lines, 'E481:', 1)
86
87 lines =<< trim END
88 :123 cd there
89 END
90 v9.CheckDefAndScriptFailure(lines, 'E481:', 1)
91enddef
92
Bram Moolenaara6e67e42020-05-15 23:36:40 +020093let g:alist = [7]
94let g:astring = 'text'
Bram Moolenaarf0b9f432020-07-17 23:03:17 +020095let g:anumber = 123
Bram Moolenaar6e587dc2020-02-06 13:15:52 +010096
Bram Moolenaar4c17ad92020-04-27 22:47:51 +020097def Test_delfunction()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +020098 # Check function is defined in script namespace
Bram Moolenaar62aec932022-01-29 21:45:34 +000099 v9.CheckScriptSuccess([
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200100 'vim9script',
101 'func CheckMe()',
102 ' return 123',
103 'endfunc',
Bram Moolenaara749a422022-02-12 19:52:25 +0000104 'func DoTest()',
105 ' call assert_equal(123, s:CheckMe())',
106 'endfunc',
107 'DoTest()',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200108 ])
109
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200110 # Check function in script namespace cannot be deleted
Bram Moolenaar62aec932022-01-29 21:45:34 +0000111 v9.CheckScriptFailure([
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200112 'vim9script',
113 'func DeleteMe1()',
114 'endfunc',
115 'delfunction DeleteMe1',
116 ], 'E1084:')
Bram Moolenaar62aec932022-01-29 21:45:34 +0000117 v9.CheckScriptFailure([
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200118 'vim9script',
119 'func DeleteMe2()',
120 'endfunc',
121 'def DoThat()',
122 ' delfunction DeleteMe2',
123 'enddef',
124 'DoThat()',
125 ], 'E1084:')
Bram Moolenaar62aec932022-01-29 21:45:34 +0000126 v9.CheckScriptFailure([
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200127 'vim9script',
128 'def DeleteMe3()',
129 'enddef',
130 'delfunction DeleteMe3',
131 ], 'E1084:')
Bram Moolenaar62aec932022-01-29 21:45:34 +0000132 v9.CheckScriptFailure([
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200133 'vim9script',
134 'def DeleteMe4()',
135 'enddef',
136 'def DoThat()',
137 ' delfunction DeleteMe4',
138 'enddef',
139 'DoThat()',
140 ], 'E1084:')
Bram Moolenaar925e9fd2020-07-25 15:41:11 +0200141
142 # Check that global :def function can be replaced and deleted
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200143 var lines =<< trim END
Bram Moolenaar925e9fd2020-07-25 15:41:11 +0200144 vim9script
145 def g:Global(): string
146 return "yes"
147 enddef
148 assert_equal("yes", g:Global())
149 def! g:Global(): string
150 return "no"
151 enddef
152 assert_equal("no", g:Global())
153 delfunc g:Global
154 assert_false(exists('*g:Global'))
155 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000156 v9.CheckScriptSuccess(lines)
Bram Moolenaar925e9fd2020-07-25 15:41:11 +0200157
158 # Check that global function can be replaced by a :def function and deleted
159 lines =<< trim END
160 vim9script
161 func g:Global()
162 return "yes"
163 endfunc
164 assert_equal("yes", g:Global())
165 def! g:Global(): string
166 return "no"
167 enddef
168 assert_equal("no", g:Global())
169 delfunc g:Global
170 assert_false(exists('*g:Global'))
171 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000172 v9.CheckScriptSuccess(lines)
Bram Moolenaar925e9fd2020-07-25 15:41:11 +0200173
174 # Check that global :def function can be replaced by a function and deleted
175 lines =<< trim END
176 vim9script
177 def g:Global(): string
178 return "yes"
179 enddef
180 assert_equal("yes", g:Global())
181 func! g:Global()
182 return "no"
183 endfunc
184 assert_equal("no", g:Global())
185 delfunc g:Global
186 assert_false(exists('*g:Global'))
187 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000188 v9.CheckScriptSuccess(lines)
Bram Moolenaar4c17ad92020-04-27 22:47:51 +0200189enddef
190
Bram Moolenaar08052222020-09-14 17:04:31 +0200191def Test_wrong_type()
Bram Moolenaar62aec932022-01-29 21:45:34 +0000192 v9.CheckDefFailure(['var name: list<nothing>'], 'E1010:')
193 v9.CheckDefFailure(['var name: list<list<nothing>>'], 'E1010:')
194 v9.CheckDefFailure(['var name: dict<nothing>'], 'E1010:')
195 v9.CheckDefFailure(['var name: dict<dict<nothing>>'], 'E1010:')
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100196
Bram Moolenaar62aec932022-01-29 21:45:34 +0000197 v9.CheckDefFailure(['var name: dict<number'], 'E1009:')
198 v9.CheckDefFailure(['var name: dict<list<number>'], 'E1009:')
Bram Moolenaar42a480b2020-02-29 23:23:47 +0100199
Bram Moolenaar62aec932022-01-29 21:45:34 +0000200 v9.CheckDefFailure(['var name: ally'], 'E1010:')
201 v9.CheckDefFailure(['var name: bram'], 'E1010:')
202 v9.CheckDefFailure(['var name: cathy'], 'E1010:')
203 v9.CheckDefFailure(['var name: dom'], 'E1010:')
204 v9.CheckDefFailure(['var name: freddy'], 'E1010:')
205 v9.CheckDefFailure(['var name: john'], 'E1010:')
206 v9.CheckDefFailure(['var name: larry'], 'E1010:')
207 v9.CheckDefFailure(['var name: ned'], 'E1010:')
208 v9.CheckDefFailure(['var name: pam'], 'E1010:')
209 v9.CheckDefFailure(['var name: sam'], 'E1010:')
210 v9.CheckDefFailure(['var name: vim'], 'E1010:')
Bram Moolenaara0a9f432020-04-28 21:29:34 +0200211
Bram Moolenaar62aec932022-01-29 21:45:34 +0000212 v9.CheckDefFailure(['var Ref: number', 'Ref()'], 'E1085:')
213 v9.CheckDefFailure(['var Ref: string', 'var res = Ref()'], 'E1085:')
Bram Moolenaar08052222020-09-14 17:04:31 +0200214enddef
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100215
Bram Moolenaara749a422022-02-12 19:52:25 +0000216def Test_script_namespace()
217 # defining a function or variable with s: is not allowed
218 var lines =<< trim END
219 vim9script
220 def s:Function()
221 enddef
222 END
223 v9.CheckScriptFailure(lines, 'E1268:')
224
225 for decl in ['var', 'const', 'final']
226 lines =<< trim END
227 vim9script
228 var s:var = 'var'
229 END
230 v9.CheckScriptFailure([
231 'vim9script',
232 decl .. ' s:var = "var"',
233 ], 'E1268:')
234 endfor
235
236 # Calling a function or using a variable with s: is not allowed at script
237 # level
238 lines =<< trim END
239 vim9script
240 def Function()
241 enddef
242 s:Function()
243 END
244 v9.CheckScriptFailure(lines, 'E1268:')
245 lines =<< trim END
246 vim9script
247 def Function()
248 enddef
249 call s:Function()
250 END
251 v9.CheckScriptFailure(lines, 'E1268:')
252 lines =<< trim END
253 vim9script
254 var var = 'var'
255 echo s:var
256 END
257 v9.CheckScriptFailure(lines, 'E1268:')
258enddef
259
Bram Moolenaar10c65862020-10-08 21:16:42 +0200260def Test_script_wrong_type()
261 var lines =<< trim END
262 vim9script
Bram Moolenaara749a422022-02-12 19:52:25 +0000263 var dict: dict<string>
264 dict['a'] = ['x']
Bram Moolenaar10c65862020-10-08 21:16:42 +0200265 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000266 v9.CheckScriptFailure(lines, 'E1012: Type mismatch; expected string but got list<string>', 3)
Bram Moolenaar10c65862020-10-08 21:16:42 +0200267enddef
268
Bram Moolenaar08052222020-09-14 17:04:31 +0200269def Test_const()
Bram Moolenaar62aec932022-01-29 21:45:34 +0000270 v9.CheckDefFailure(['final name = 234', 'name = 99'], 'E1018:')
271 v9.CheckDefFailure(['final one = 234', 'var one = 99'], 'E1017:')
272 v9.CheckDefFailure(['final list = [1, 2]', 'var list = [3, 4]'], 'E1017:')
273 v9.CheckDefFailure(['final two'], 'E1125:')
274 v9.CheckDefFailure(['final &option'], 'E996:')
Bram Moolenaardbeecb22020-09-14 18:15:09 +0200275
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200276 var lines =<< trim END
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200277 final list = [1, 2, 3]
Bram Moolenaardbeecb22020-09-14 18:15:09 +0200278 list[0] = 4
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200279 list->assert_equal([4, 2, 3])
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200280 const other = [5, 6, 7]
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200281 other->assert_equal([5, 6, 7])
Bram Moolenaar71abe482020-09-14 22:28:30 +0200282
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200283 var varlist = [7, 8]
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200284 const constlist = [1, varlist, 3]
Bram Moolenaar71abe482020-09-14 22:28:30 +0200285 varlist[0] = 77
Bram Moolenaar23e2e112021-08-03 21:16:18 +0200286 constlist[1][1] = 88
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200287 var cl = constlist[1]
Bram Moolenaar71abe482020-09-14 22:28:30 +0200288 cl[1] = 88
289 constlist->assert_equal([1, [77, 88], 3])
290
Bram Moolenaare0de1712020-12-02 17:36:54 +0100291 var vardict = {five: 5, six: 6}
292 const constdict = {one: 1, two: vardict, three: 3}
Bram Moolenaar71abe482020-09-14 22:28:30 +0200293 vardict['five'] = 55
Bram Moolenaar23e2e112021-08-03 21:16:18 +0200294 constdict['two']['six'] = 66
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200295 var cd = constdict['two']
Bram Moolenaar71abe482020-09-14 22:28:30 +0200296 cd['six'] = 66
Bram Moolenaare0de1712020-12-02 17:36:54 +0100297 constdict->assert_equal({one: 1, two: {five: 55, six: 66}, three: 3})
Bram Moolenaardbeecb22020-09-14 18:15:09 +0200298 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000299 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar0089ce22022-10-08 14:39:36 +0100300
301 # "any" type with const flag is recognized as "any"
302 lines =<< trim END
303 const dict: dict<any> = {foo: {bar: 42}}
304 const foo = dict.foo
305 assert_equal(v:t_number, type(foo.bar))
306 END
307 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar330d64d2022-10-09 12:55:33 +0100308
309 # also when used as a builtin function argument
310 lines =<< trim END
311 vim9script
312
313 def SorterFunc(lhs: dict<string>, rhs: dict<string>): number
314 return lhs.name <# rhs.name ? -1 : 1
315 enddef
316
317 def Run(): void
318 var list = [{name: "3"}, {name: "2"}]
319 const Sorter = get({}, "unknown", SorterFunc)
320 sort(list, Sorter)
321 assert_equal([{name: "2"}, {name: "3"}], list)
322 enddef
323
324 Run()
325 END
326 v9.CheckScriptSuccess(lines)
Bram Moolenaar08052222020-09-14 17:04:31 +0200327enddef
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100328
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200329def Test_const_bang()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200330 var lines =<< trim END
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200331 const var = 234
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200332 var = 99
333 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000334 v9.CheckDefExecFailure(lines, 'E1018:', 2)
335 v9.CheckScriptFailure(['vim9script'] + lines, 'E46:', 3)
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200336
337 lines =<< trim END
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200338 const ll = [2, 3, 4]
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200339 ll[0] = 99
340 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000341 v9.CheckDefExecFailure(lines, 'E1119:', 2)
342 v9.CheckScriptFailure(['vim9script'] + lines, 'E741:', 3)
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200343
344 lines =<< trim END
Bram Moolenaar30fd8202020-09-26 15:09:30 +0200345 const ll = [2, 3, 4]
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200346 ll[3] = 99
347 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000348 v9.CheckDefExecFailure(lines, 'E1118:', 2)
349 v9.CheckScriptFailure(['vim9script'] + lines, 'E684:', 3)
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200350
351 lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +0100352 const dd = {one: 1, two: 2}
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200353 dd["one"] = 99
354 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000355 v9.CheckDefExecFailure(lines, 'E1121:', 2)
356 v9.CheckScriptFailure(['vim9script'] + lines, 'E741:', 3)
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200357
358 lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +0100359 const dd = {one: 1, two: 2}
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200360 dd["three"] = 99
361 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000362 v9.CheckDefExecFailure(lines, 'E1120:')
363 v9.CheckScriptFailure(['vim9script'] + lines, 'E741:', 3)
Bram Moolenaar0b4c66c2020-09-14 21:39:44 +0200364enddef
365
Bram Moolenaardf069ee2020-06-22 23:02:51 +0200366def Test_range_no_colon()
Bram Moolenaar62aec932022-01-29 21:45:34 +0000367 v9.CheckDefFailure(['%s/a/b/'], 'E1050:')
368 v9.CheckDefFailure(['+ s/a/b/'], 'E1050:')
369 v9.CheckDefFailure(['- s/a/b/'], 'E1050:')
370 v9.CheckDefFailure(['. s/a/b/'], 'E1050:')
Bram Moolenaardf069ee2020-06-22 23:02:51 +0200371enddef
372
373
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100374def Test_block()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200375 var outer = 1
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100376 {
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200377 var inner = 2
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100378 assert_equal(1, outer)
379 assert_equal(2, inner)
380 }
381 assert_equal(1, outer)
Bram Moolenaar3f1e9f02021-02-27 22:36:43 +0100382
383 {|echo 'yes'|}
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100384enddef
385
Bram Moolenaar08052222020-09-14 17:04:31 +0200386def Test_block_failure()
Bram Moolenaar62aec932022-01-29 21:45:34 +0000387 v9.CheckDefFailure(['{', 'var inner = 1', '}', 'echo inner'], 'E1001:')
388 v9.CheckDefFailure(['}'], 'E1025:')
389 v9.CheckDefFailure(['{', 'echo 1'], 'E1026:')
Bram Moolenaar08052222020-09-14 17:04:31 +0200390enddef
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100391
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200392def Test_block_local_vars()
393 var lines =<< trim END
394 vim9script
Bram Moolenaared234f22020-10-15 20:42:20 +0200395 v:testing = 1
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200396 if true
Bram Moolenaared234f22020-10-15 20:42:20 +0200397 var text = ['hello']
398 def SayHello(): list<string>
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200399 return text
400 enddef
401 def SetText(v: string)
Bram Moolenaared234f22020-10-15 20:42:20 +0200402 text = [v]
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200403 enddef
404 endif
405
406 if true
Bram Moolenaared234f22020-10-15 20:42:20 +0200407 var text = ['again']
408 def SayAgain(): list<string>
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200409 return text
410 enddef
411 endif
Bram Moolenaared234f22020-10-15 20:42:20 +0200412
413 # test that the "text" variables are not cleaned up
414 test_garbagecollect_now()
415
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200416 defcompile
417
Bram Moolenaared234f22020-10-15 20:42:20 +0200418 assert_equal(['hello'], SayHello())
419 assert_equal(['again'], SayAgain())
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200420
421 SetText('foobar')
Bram Moolenaared234f22020-10-15 20:42:20 +0200422 assert_equal(['foobar'], SayHello())
423
424 call writefile(['ok'], 'Xdidit')
425 qall!
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200426 END
Bram Moolenaared234f22020-10-15 20:42:20 +0200427
428 # need to execute this with a separate Vim instance to avoid the current
429 # context gets garbage collected.
Bram Moolenaardd674772022-09-15 22:26:18 +0100430 writefile(lines, 'Xscript', 'D')
Bram Moolenaar62aec932022-01-29 21:45:34 +0000431 g:RunVim([], [], '-S Xscript')
Bram Moolenaared234f22020-10-15 20:42:20 +0200432 assert_equal(['ok'], readfile('Xdidit'))
433
Bram Moolenaared234f22020-10-15 20:42:20 +0200434 delete('Xdidit')
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200435enddef
436
Bram Moolenaar39ca4122020-10-20 14:25:07 +0200437def Test_block_local_vars_with_func()
438 var lines =<< trim END
439 vim9script
440 if true
441 var foo = 'foo'
442 if true
443 var bar = 'bar'
444 def Func(): list<string>
445 return [foo, bar]
446 enddef
447 endif
448 endif
449 # function is compiled here, after blocks have finished, can still access
450 # "foo" and "bar"
451 assert_equal(['foo', 'bar'], Func())
452 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000453 v9.CheckScriptSuccess(lines)
Bram Moolenaar39ca4122020-10-20 14:25:07 +0200454enddef
455
Bram Moolenaare4db17f2021-08-01 21:19:43 +0200456" legacy func for command that's defined later
Bram Moolenaar62aec932022-01-29 21:45:34 +0000457func s:InvokeSomeCommand()
Bram Moolenaare4db17f2021-08-01 21:19:43 +0200458 SomeCommand
459endfunc
460
Yegappan Lakshmanane74cad32024-04-12 18:48:35 +0200461def Test_command_block()
Bram Moolenaare4db17f2021-08-01 21:19:43 +0200462 com SomeCommand {
463 g:someVar = 'some'
464 }
465 InvokeSomeCommand()
466 assert_equal('some', g:someVar)
467
468 delcommand SomeCommand
469 unlet g:someVar
470enddef
471
Yegappan Lakshmanane74cad32024-04-12 18:48:35 +0200472" Test for using heredoc in a :command command block
473def Test_command_block_heredoc()
474 var lines =<< trim CODE
475 vim9script
476 com SomeCommand {
477 g:someVar =<< trim END
478 aaa
479 bbb
480 END
481 }
482 SomeCommand
483 assert_equal(['aaa', 'bbb'], g:someVar)
484 def Foo()
485 g:someVar = []
486 SomeCommand
487 assert_equal(['aaa', 'bbb'], g:someVar)
488 enddef
489 Foo()
490 delcommand SomeCommand
491 unlet g:someVar
492 CODE
493 v9.CheckSourceSuccess( lines)
494
495 # Execute a command with heredoc in a block
496 lines =<< trim CODE
497 vim9script
498 com SomeCommand {
499 g:someVar =<< trim END
500 aaa
501 bbb
502 END
503 }
504 execute('SomeCommand')
505 assert_equal(['aaa', 'bbb'], g:someVar)
506 delcommand SomeCommand
507 unlet g:someVar
508 CODE
509 v9.CheckSourceSuccess(lines)
510
zeertzjq1f5175d2024-04-13 17:52:26 +0200511 # Heredoc with comment
512 lines =<< trim CODE
513 vim9script
514 com SomeCommand {
515 g:someVar =<< trim END # comment
516 aaa
517 bbb
518 END
519 }
520 execute('SomeCommand')
521 assert_equal(['aaa', 'bbb'], g:someVar)
522 delcommand SomeCommand
523 unlet g:someVar
524 CODE
525 v9.CheckSourceSuccess(lines)
526
Yegappan Lakshmanane74cad32024-04-12 18:48:35 +0200527 # heredoc evaluation
528 lines =<< trim CODE
529 vim9script
530 com SomeCommand {
531 var suffix = '---'
532 g:someVar =<< trim eval END
533 ccc{suffix}
534 ddd
535 END
536 }
537 SomeCommand
538 assert_equal(['ccc---', 'ddd'], g:someVar)
539 def Foo()
540 g:someVar = []
541 SomeCommand
542 assert_equal(['ccc---', 'ddd'], g:someVar)
543 enddef
544 Foo()
545 delcommand SomeCommand
546 unlet g:someVar
547 CODE
548 v9.CheckSourceSuccess(lines)
549
550 # command following heredoc
551 lines =<< trim CODE
552 vim9script
553 com SomeCommand {
554 var l =<< trim END
555 eee
556 fff
557 END
558 g:someVar = l
559 }
560 SomeCommand
561 assert_equal(['eee', 'fff'], g:someVar)
562 delcommand SomeCommand
563 unlet g:someVar
564 CODE
565 v9.CheckSourceSuccess(lines)
566
567 # Error in heredoc
568 lines =<< trim CODE
569 vim9script
570 com SomeCommand {
571 g:someVar =<< trim END
572 eee
573 fff
574 }
575 try
576 SomeCommand
577 catch
578 assert_match("E990: Missing end marker 'END'", v:exception)
579 endtry
580 delcommand SomeCommand
581 unlet g:someVar
582 CODE
583 v9.CheckSourceSuccess(lines)
584enddef
585
586def Test_autocommand_block()
Bram Moolenaare4db17f2021-08-01 21:19:43 +0200587 au BufNew *.xml {
588 g:otherVar = 'other'
589 }
590 split other.xml
591 assert_equal('other', g:otherVar)
592
593 bwipe!
594 au! BufNew *.xml
595 unlet g:otherVar
596enddef
597
Bram Moolenaard032f342020-07-18 18:13:02 +0200598func g:NoSuchFunc()
599 echo 'none'
600endfunc
601
Bram Moolenaar9e1d9e32021-01-11 20:17:34 +0100602def Test_try_catch_throw()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200603 var l = []
Bram Moolenaar7a092242020-04-16 22:10:49 +0200604 try # comment
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100605 add(l, '1')
606 throw 'wrong'
Bram Moolenaar9d383f32023-05-14 21:38:12 +0100607 add(l, '2') # "unreachable code"
Bram Moolenaar7a092242020-04-16 22:10:49 +0200608 catch # comment
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100609 add(l, v:exception)
Bram Moolenaar7a092242020-04-16 22:10:49 +0200610 finally # comment
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100611 add(l, '3')
Bram Moolenaar7a092242020-04-16 22:10:49 +0200612 endtry # comment
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100613 assert_equal(['1', 'wrong', '3'], l)
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200614
Bram Moolenaare8593122020-07-18 15:17:02 +0200615 l = []
616 try
617 try
618 add(l, '1')
619 throw 'wrong'
Bram Moolenaar9d383f32023-05-14 21:38:12 +0100620 add(l, '2') # "unreachable code"
Bram Moolenaare8593122020-07-18 15:17:02 +0200621 catch /right/
622 add(l, v:exception)
623 endtry
624 catch /wrong/
625 add(l, 'caught')
Bram Moolenaar204852a2022-03-05 12:56:44 +0000626 finally
Bram Moolenaare8593122020-07-18 15:17:02 +0200627 add(l, 'finally')
628 endtry
629 assert_equal(['1', 'caught', 'finally'], l)
630
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200631 var n: number
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200632 try
633 n = l[3]
634 catch /E684:/
635 n = 99
636 endtry
637 assert_equal(99, n)
638
Bram Moolenaar69f70502021-01-01 16:10:46 +0100639 var done = 'no'
640 if 0
641 try | catch | endtry
642 else
643 done = 'yes'
644 endif
645 assert_equal('yes', done)
646
647 done = 'no'
648 if 1
649 done = 'yes'
650 else
651 try | catch | endtry
652 done = 'never'
653 endif
654 assert_equal('yes', done)
655
656 if 1
657 else
658 try | catch /pat/ | endtry
Bram Moolenaar755bf2b2023-01-28 19:38:49 +0000659 try | catch /pat/
Bram Moolenaar69f70502021-01-01 16:10:46 +0100660 endtry
Bram Moolenaar755bf2b2023-01-28 19:38:49 +0000661 try
Bram Moolenaar69f70502021-01-01 16:10:46 +0100662 catch /pat/ | endtry
Bram Moolenaar755bf2b2023-01-28 19:38:49 +0000663 try
664 catch /pat/
Bram Moolenaar69f70502021-01-01 16:10:46 +0100665 endtry
666 endif
667
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200668 try
Bram Moolenaarcc673e72020-08-16 17:33:35 +0200669 # string slice returns a string, not a number
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200670 n = g:astring[3]
Bram Moolenaar5e654232020-09-16 15:22:00 +0200671 catch /E1012:/
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200672 n = 77
673 endtry
674 assert_equal(77, n)
675
676 try
677 n = l[g:astring]
Bram Moolenaar5e654232020-09-16 15:22:00 +0200678 catch /E1012:/
Bram Moolenaar56acb092020-08-16 14:48:19 +0200679 n = 88
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200680 endtry
Bram Moolenaar56acb092020-08-16 14:48:19 +0200681 assert_equal(88, n)
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200682
683 try
684 n = s:does_not_exist
685 catch /E121:/
Bram Moolenaarf0b9f432020-07-17 23:03:17 +0200686 n = 111
687 endtry
688 assert_equal(111, n)
689
690 try
691 n = g:does_not_exist
692 catch /E121:/
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200693 n = 121
694 endtry
695 assert_equal(121, n)
696
Bram Moolenaare0de1712020-12-02 17:36:54 +0100697 var d = {one: 1}
Bram Moolenaar68d130c2020-07-17 22:06:44 +0200698 try
699 n = d[g:astring]
700 catch /E716:/
701 n = 222
702 endtry
703 assert_equal(222, n)
Bram Moolenaarf0b9f432020-07-17 23:03:17 +0200704
705 try
706 n = -g:astring
Bram Moolenaarcd6b4f32021-08-15 20:36:28 +0200707 catch /E1012:/
Bram Moolenaarf0b9f432020-07-17 23:03:17 +0200708 n = 233
709 endtry
710 assert_equal(233, n)
711
712 try
713 n = +g:astring
Bram Moolenaarcd6b4f32021-08-15 20:36:28 +0200714 catch /E1012:/
Bram Moolenaarf0b9f432020-07-17 23:03:17 +0200715 n = 244
716 endtry
717 assert_equal(244, n)
718
719 try
720 n = +g:alist
Bram Moolenaarcd6b4f32021-08-15 20:36:28 +0200721 catch /E1012:/
Bram Moolenaarf0b9f432020-07-17 23:03:17 +0200722 n = 255
723 endtry
724 assert_equal(255, n)
725
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200726 var nd: dict<any>
Bram Moolenaarf0b9f432020-07-17 23:03:17 +0200727 try
Bram Moolenaar2e5910b2021-02-03 17:41:24 +0100728 nd = {[g:alist]: 1}
729 catch /E1105:/
Bram Moolenaarf0b9f432020-07-17 23:03:17 +0200730 n = 266
731 endtry
732 assert_equal(266, n)
733
Bram Moolenaar755bf2b2023-01-28 19:38:49 +0000734 l = [1, 2, 3]
Bram Moolenaarf0b9f432020-07-17 23:03:17 +0200735 try
Bram Moolenaardb9ff9a2021-12-01 17:38:01 +0000736 [n] = l
Bram Moolenaarf0b9f432020-07-17 23:03:17 +0200737 catch /E1093:/
738 n = 277
739 endtry
740 assert_equal(277, n)
741
Bram Moolenaare8593122020-07-18 15:17:02 +0200742 try
743 &ts = g:astring
Bram Moolenaar5e654232020-09-16 15:22:00 +0200744 catch /E1012:/
Bram Moolenaare8593122020-07-18 15:17:02 +0200745 n = 288
746 endtry
747 assert_equal(288, n)
748
749 try
750 &backspace = 'asdf'
751 catch /E474:/
752 n = 299
753 endtry
754 assert_equal(299, n)
755
756 l = [1]
757 try
758 l[3] = 3
759 catch /E684:/
760 n = 300
761 endtry
762 assert_equal(300, n)
763
764 try
Bram Moolenaare8593122020-07-18 15:17:02 +0200765 unlet g:does_not_exist
766 catch /E108:/
767 n = 322
768 endtry
769 assert_equal(322, n)
770
771 try
Bram Moolenaar2bede172020-11-19 18:53:18 +0100772 d = {text: 1, [g:astring]: 2}
Bram Moolenaare8593122020-07-18 15:17:02 +0200773 catch /E721:/
774 n = 333
775 endtry
776 assert_equal(333, n)
777
778 try
Bram Moolenaar62aec932022-01-29 21:45:34 +0000779 l = g:DeletedFunc()
Bram Moolenaare8593122020-07-18 15:17:02 +0200780 catch /E933:/
781 n = 344
782 endtry
783 assert_equal(344, n)
Bram Moolenaard032f342020-07-18 18:13:02 +0200784
785 try
Yegappan Lakshmanana764e732021-07-25 15:57:32 +0200786 echo range(1, 2, 0)
787 catch /E726:/
Bram Moolenaard032f342020-07-18 18:13:02 +0200788 n = 355
789 endtry
790 assert_equal(355, n)
791
Bram Moolenaarcfcd0112020-09-27 15:19:27 +0200792 var P = function('g:NoSuchFunc')
Bram Moolenaard032f342020-07-18 18:13:02 +0200793 delfunc g:NoSuchFunc
794 try
795 echo P()
796 catch /E117:/
797 n = 366
798 endtry
799 assert_equal(366, n)
800
801 try
802 echo g:NoSuchFunc()
803 catch /E117:/
804 n = 377
805 endtry
806 assert_equal(377, n)
807
808 try
809 echo g:alist + 4
810 catch /E745:/
811 n = 388
812 endtry
813 assert_equal(388, n)
814
815 try
816 echo 4 + g:alist
817 catch /E745:/
818 n = 399
819 endtry
820 assert_equal(399, n)
821
822 try
823 echo g:alist.member
824 catch /E715:/
825 n = 400
826 endtry
827 assert_equal(400, n)
828
829 try
830 echo d.member
831 catch /E716:/
832 n = 411
833 endtry
834 assert_equal(411, n)
Bram Moolenaard9d77892021-02-12 21:32:47 +0100835
836 var counter = 0
837 for i in range(4)
838 try
839 eval [][0]
840 catch
841 endtry
842 counter += 1
843 endfor
844 assert_equal(4, counter)
Bram Moolenaar7e82c5f2021-02-21 21:32:45 +0100845
Bram Moolenaar9fa5dab2021-07-20 19:18:44 +0200846 # no requirement for spaces before |
847 try|echo 0|catch|endtry
848
Bram Moolenaar003312b2021-12-20 10:55:35 +0000849 # return in try with finally
850 def ReturnInTry(): number
851 var ret = 4
852 try
853 return ret
854 catch /this/
855 return -1
856 catch /that/
857 return -1
858 finally
859 # changing ret has no effect
860 ret = 7
861 endtry
862 return -2
863 enddef
864 assert_equal(4, ReturnInTry())
865
866 # return in catch with finally
867 def ReturnInCatch(): number
868 var ret = 5
869 try
870 throw 'getout'
Bram Moolenaar9d383f32023-05-14 21:38:12 +0100871 return -1 # "unreachable code"
Bram Moolenaar003312b2021-12-20 10:55:35 +0000872 catch /getout/
873 # ret is evaluated here
874 return ret
875 finally
876 # changing ret later has no effect
877 ret = -3
878 endtry
879 return -2
880 enddef
881 assert_equal(5, ReturnInCatch())
882
Bram Moolenaar7e82c5f2021-02-21 21:32:45 +0100883 # return in finally after empty catch
884 def ReturnInFinally(): number
885 try
886 finally
Bram Moolenaar003312b2021-12-20 10:55:35 +0000887 return 6
Bram Moolenaar7e82c5f2021-02-21 21:32:45 +0100888 endtry
Bram Moolenaar7e82c5f2021-02-21 21:32:45 +0100889 enddef
Bram Moolenaar003312b2021-12-20 10:55:35 +0000890 assert_equal(6, ReturnInFinally())
Bram Moolenaar8ac681a2021-06-15 20:06:34 +0200891
892 var lines =<< trim END
893 vim9script
894 try
895 acos('0.5')
896 ->setline(1)
897 catch
898 g:caught = v:exception
899 endtry
900 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000901 v9.CheckScriptSuccess(lines)
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +0200902 assert_match('E1219: Float or Number required for argument 1', g:caught)
Bram Moolenaar8ac681a2021-06-15 20:06:34 +0200903 unlet g:caught
Bram Moolenaar41978282021-07-04 14:47:30 +0200904
905 # missing catch and/or finally
906 lines =<< trim END
907 vim9script
908 try
909 echo 'something'
910 endtry
911 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000912 v9.CheckScriptFailure(lines, 'E1032:')
rbtnn84934992021-08-07 13:26:53 +0200913
914 # skipping try-finally-endtry when try-finally-endtry is used in another block
915 lines =<< trim END
916 if v:true
917 try
918 finally
919 endtry
920 else
921 try
922 finally
923 endtry
924 endif
925 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000926 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100927enddef
928
Bram Moolenaara2c00282023-05-14 22:05:15 +0100929def Test_unreachable_after()
930 var lines =<< trim END
931 try
932 throw 'Error'
933 echo 'not reached'
934 catch /Error/
935 endtry
936 END
937 v9.CheckDefFailure(lines, 'E1095: Unreachable code after :throw')
938
939 lines =<< trim END
940 def SomeFunc(): number
941 try
942 return 3
943 echo 'not reached'
944 catch /Error/
945 endtry
946 return 4
947 enddef
948 defcompile
949 END
950 v9.CheckScriptFailure(lines, 'E1095: Unreachable code after :return')
951enddef
952
Bram Moolenaar3ef2e412023-04-30 18:50:48 +0100953def Test_throw_in_nested_try()
954 var lines =<< trim END
955 vim9script
956
957 def Try(F: func(): void)
958 try
959 F()
960 catch
961 endtry
962 enddef
963
964 class X
965 def F()
966 try
967 throw 'Foobar'
968 catch
969 throw v:exception
970 endtry
971 enddef
972 endclass
973
974 def Test_TryMethod()
975 var x = X.new()
976 Try(() => x.F())
977 enddef
978
979
980 try
981 Test_TryMethod()
982 catch
983 endtry
984 END
985 v9.CheckScriptSuccess(lines)
986enddef
987
Bram Moolenaar28bf6492022-03-03 15:11:20 +0000988def Test_try_var_decl()
989 var lines =<< trim END
990 vim9script
991 try
992 var in_try = 1
993 assert_equal(1, get(s:, 'in_try', -1))
994 throw "getout"
995 catch
996 var in_catch = 2
997 assert_equal(-1, get(s:, 'in_try', -1))
998 assert_equal(2, get(s:, 'in_catch', -1))
999 finally
1000 var in_finally = 3
1001 assert_equal(-1, get(s:, 'in_try', -1))
1002 assert_equal(-1, get(s:, 'in_catch', -1))
1003 assert_equal(3, get(s:, 'in_finally', -1))
1004 endtry
1005 assert_equal(-1, get(s:, 'in_try', -1))
1006 assert_equal(-1, get(s:, 'in_catch', -1))
1007 assert_equal(-1, get(s:, 'in_finally', -1))
1008 END
1009 v9.CheckScriptSuccess(lines)
1010enddef
1011
Bram Moolenaar53c29612022-01-12 16:18:18 +00001012def Test_try_ends_in_return()
1013 var lines =<< trim END
1014 vim9script
1015 def Foo(): string
1016 try
1017 return 'foo'
1018 catch
1019 return 'caught'
1020 endtry
1021 enddef
1022 assert_equal('foo', Foo())
1023 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001024 v9.CheckScriptSuccess(lines)
Bram Moolenaar53c29612022-01-12 16:18:18 +00001025
1026 lines =<< trim END
1027 vim9script
1028 def Foo(): string
1029 try
1030 return 'foo'
1031 catch
1032 return 'caught'
1033 endtry
1034 echo 'notreached'
1035 enddef
1036 assert_equal('foo', Foo())
1037 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001038 v9.CheckScriptFailure(lines, 'E1095:')
Bram Moolenaar53c29612022-01-12 16:18:18 +00001039
1040 lines =<< trim END
1041 vim9script
1042 def Foo(): string
1043 try
1044 return 'foo'
1045 catch /x/
1046 return 'caught'
1047 endtry
1048 enddef
1049 assert_equal('foo', Foo())
1050 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001051 v9.CheckScriptFailure(lines, 'E1027:')
Bram Moolenaar53c29612022-01-12 16:18:18 +00001052
1053 lines =<< trim END
1054 vim9script
1055 def Foo(): string
1056 try
1057 echo 'foo'
1058 catch
1059 echo 'caught'
1060 finally
1061 return 'done'
1062 endtry
1063 enddef
1064 assert_equal('done', Foo())
1065 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001066 v9.CheckScriptSuccess(lines)
Bram Moolenaar53c29612022-01-12 16:18:18 +00001067
1068enddef
1069
Bram Moolenaar3f987b52021-06-30 12:02:24 +02001070def Test_try_in_catch()
1071 var lines =<< trim END
1072 vim9script
1073 var seq = []
1074 def DoIt()
1075 try
1076 seq->add('throw 1')
1077 eval [][0]
1078 seq->add('notreached')
1079 catch
1080 seq->add('catch')
1081 try
1082 seq->add('throw 2')
1083 eval [][0]
1084 seq->add('notreached')
1085 catch /nothing/
1086 seq->add('notreached')
1087 endtry
1088 seq->add('done')
1089 endtry
1090 enddef
1091 DoIt()
1092 assert_equal(['throw 1', 'catch', 'throw 2', 'done'], seq)
1093 END
1094enddef
1095
Bram Moolenaard3d8fee2021-06-30 19:54:43 +02001096def Test_error_in_catch()
1097 var lines =<< trim END
1098 try
1099 eval [][0]
1100 catch /E684:/
1101 eval [][0]
1102 endtry
1103 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001104 v9.CheckDefExecFailure(lines, 'E684:', 4)
Bram Moolenaard3d8fee2021-06-30 19:54:43 +02001105enddef
1106
Bram Moolenaar2e34c342021-03-14 12:13:33 +01001107" :while at the very start of a function that :continue jumps to
Bram Moolenaar62aec932022-01-29 21:45:34 +00001108def s:TryContinueFunc()
Bram Moolenaar2e34c342021-03-14 12:13:33 +01001109 while g:Count < 2
1110 g:sequence ..= 't'
1111 try
1112 echoerr 'Test'
1113 catch
1114 g:Count += 1
1115 g:sequence ..= 'c'
1116 continue
1117 endtry
1118 g:sequence ..= 'e'
1119 g:Count += 1
1120 endwhile
1121enddef
1122
1123def Test_continue_in_try_in_while()
1124 g:Count = 0
1125 g:sequence = ''
1126 TryContinueFunc()
1127 assert_equal('tctc', g:sequence)
1128 unlet g:Count
1129 unlet g:sequence
1130enddef
1131
Bram Moolenaar873f8242022-03-10 21:53:44 +00001132def Test_break_in_try_in_for()
1133 var lines =<< trim END
1134 vim9script
1135 def Ls(): list<string>
1136 var ls: list<string>
1137 for s in ['abc', 'def']
1138 for _ in [123, 456]
1139 try
1140 eval [][0]
1141 catch
1142 break
1143 endtry
1144 endfor
1145 ls += [s]
1146 endfor
1147 return ls
1148 enddef
1149 assert_equal(['abc', 'def'], Ls())
1150 END
1151 v9.CheckScriptSuccess(lines)
1152enddef
1153
Bram Moolenaar9cb577a2021-02-22 22:45:10 +01001154def Test_nocatch_return_in_try()
1155 # return in try block returns normally
1156 def ReturnInTry(): string
1157 try
1158 return '"some message"'
1159 catch
1160 endtry
1161 return 'not reached'
1162 enddef
1163 exe 'echoerr ' .. ReturnInTry()
1164enddef
1165
Bram Moolenaar1430cee2021-01-17 19:20:32 +01001166def Test_cnext_works_in_catch()
1167 var lines =<< trim END
1168 vim9script
Bram Moolenaarc3235272021-07-10 19:42:03 +02001169 au BufEnter * eval 1 + 2
Bram Moolenaarb18b4962022-09-02 21:55:50 +01001170 writefile(['text'], 'Xcncfile1')
1171 writefile(['text'], 'Xcncfile2')
Bram Moolenaar1430cee2021-01-17 19:20:32 +01001172 var items = [
Bram Moolenaarb18b4962022-09-02 21:55:50 +01001173 {lnum: 1, filename: 'Xcncfile1', valid: true},
1174 {lnum: 1, filename: 'Xcncfile2', valid: true}
Bram Moolenaar1430cee2021-01-17 19:20:32 +01001175 ]
1176 setqflist([], ' ', {items: items})
1177 cwindow
1178
1179 def CnextOrCfirst()
1180 # if cnext fails, cfirst is used
1181 try
1182 cnext
1183 catch
1184 cfirst
1185 endtry
1186 enddef
1187
1188 CnextOrCfirst()
1189 CnextOrCfirst()
Bram Moolenaarb18b4962022-09-02 21:55:50 +01001190 writefile([getqflist({idx: 0}).idx], 'Xcncresult')
Bram Moolenaar1430cee2021-01-17 19:20:32 +01001191 qall
1192 END
Bram Moolenaardd674772022-09-15 22:26:18 +01001193 writefile(lines, 'XCatchCnext', 'D')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001194 g:RunVim([], [], '--clean -S XCatchCnext')
Bram Moolenaarb18b4962022-09-02 21:55:50 +01001195 assert_equal(['1'], readfile('Xcncresult'))
Bram Moolenaar1430cee2021-01-17 19:20:32 +01001196
Bram Moolenaarb18b4962022-09-02 21:55:50 +01001197 delete('Xcncfile1')
1198 delete('Xcncfile2')
Bram Moolenaarb18b4962022-09-02 21:55:50 +01001199 delete('Xcncresult')
Bram Moolenaar1430cee2021-01-17 19:20:32 +01001200enddef
1201
Bram Moolenaar9e1d9e32021-01-11 20:17:34 +01001202def Test_throw_skipped()
1203 if 0
1204 throw dontgethere
1205 endif
1206enddef
1207
Bram Moolenaar8f81b222021-01-14 21:47:06 +01001208def Test_nocatch_throw_silenced()
1209 var lines =<< trim END
1210 vim9script
1211 def Func()
1212 throw 'error'
1213 enddef
1214 silent! Func()
1215 END
Bram Moolenaardd674772022-09-15 22:26:18 +01001216 writefile(lines, 'XthrowSilenced', 'D')
Bram Moolenaar8f81b222021-01-14 21:47:06 +01001217 source XthrowSilenced
Bram Moolenaar8f81b222021-01-14 21:47:06 +01001218enddef
1219
Bram Moolenaara2c00282023-05-14 22:05:15 +01001220" g:DeletedFunc() is found when compiling Test_try_catch_throw() and then
1221" deleted, this should give a runtime error.
Bram Moolenaare8593122020-07-18 15:17:02 +02001222def DeletedFunc(): list<any>
1223 return ['delete me']
1224enddef
Bram Moolenaar9d383f32023-05-14 21:38:12 +01001225defcompile DeletedFunc
1226
1227call test_override('unreachable', 1)
1228defcompile Test_try_catch_throw
1229call test_override('unreachable', 0)
1230
Bram Moolenaare8593122020-07-18 15:17:02 +02001231delfunc DeletedFunc
1232
Bram Moolenaar62aec932022-01-29 21:45:34 +00001233def s:ThrowFromDef()
Bram Moolenaara72cfb82020-04-23 17:07:30 +02001234 throw "getout" # comment
Bram Moolenaar257cc5e2020-02-19 17:06:11 +01001235enddef
1236
Bram Moolenaar62aec932022-01-29 21:45:34 +00001237func s:CatchInFunc()
Bram Moolenaar257cc5e2020-02-19 17:06:11 +01001238 try
Bram Moolenaar62aec932022-01-29 21:45:34 +00001239 call s:ThrowFromDef()
Bram Moolenaar257cc5e2020-02-19 17:06:11 +01001240 catch
1241 let g:thrown_func = v:exception
1242 endtry
1243endfunc
1244
Bram Moolenaar62aec932022-01-29 21:45:34 +00001245def s:CatchInDef()
Bram Moolenaar257cc5e2020-02-19 17:06:11 +01001246 try
1247 ThrowFromDef()
1248 catch
1249 g:thrown_def = v:exception
1250 endtry
1251enddef
1252
Bram Moolenaar62aec932022-01-29 21:45:34 +00001253def s:ReturnFinally(): string
Bram Moolenaarf575adf2020-02-20 20:41:06 +01001254 try
1255 return 'intry'
Bram Moolenaar204852a2022-03-05 12:56:44 +00001256 finally
Bram Moolenaarf575adf2020-02-20 20:41:06 +01001257 g:in_finally = 'finally'
1258 endtry
1259 return 'end'
1260enddef
1261
Bram Moolenaar257cc5e2020-02-19 17:06:11 +01001262def Test_try_catch_nested()
1263 CatchInFunc()
1264 assert_equal('getout', g:thrown_func)
1265
1266 CatchInDef()
1267 assert_equal('getout', g:thrown_def)
Bram Moolenaarf575adf2020-02-20 20:41:06 +01001268
1269 assert_equal('intry', ReturnFinally())
1270 assert_equal('finally', g:in_finally)
Bram Moolenaard3d8fee2021-06-30 19:54:43 +02001271
1272 var l = []
1273 try
1274 l->add('1')
1275 throw 'bad'
Bram Moolenaar9d383f32023-05-14 21:38:12 +01001276 l->add('x') # "unreachable code"
Bram Moolenaard3d8fee2021-06-30 19:54:43 +02001277 catch /bad/
1278 l->add('2')
1279 try
1280 l->add('3')
1281 throw 'one'
1282 l->add('x')
1283 catch /one/
1284 l->add('4')
1285 try
1286 l->add('5')
1287 throw 'more'
1288 l->add('x')
1289 catch /more/
1290 l->add('6')
1291 endtry
1292 endtry
1293 endtry
1294 assert_equal(['1', '2', '3', '4', '5', '6'], l)
Bram Moolenaar834193a2021-06-30 20:39:15 +02001295
1296 l = []
1297 try
1298 try
1299 l->add('1')
1300 throw 'foo'
1301 l->add('x')
1302 catch
1303 l->add('2')
1304 throw 'bar'
1305 l->add('x')
1306 finally
1307 l->add('3')
1308 endtry
1309 l->add('x')
1310 catch /bar/
1311 l->add('4')
1312 endtry
1313 assert_equal(['1', '2', '3', '4'], l)
Bram Moolenaarf575adf2020-02-20 20:41:06 +01001314enddef
1315
Bram Moolenaar9d383f32023-05-14 21:38:12 +01001316call test_override('unreachable', 1)
1317defcompile Test_try_catch_nested
1318call test_override('unreachable', 0)
1319
Bram Moolenaar62aec932022-01-29 21:45:34 +00001320def s:TryOne(): number
Bram Moolenaar9939f572020-09-16 22:29:52 +02001321 try
1322 return 0
1323 catch
1324 endtry
1325 return 0
1326enddef
1327
Bram Moolenaar62aec932022-01-29 21:45:34 +00001328def s:TryTwo(n: number): string
Bram Moolenaar9939f572020-09-16 22:29:52 +02001329 try
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001330 var x = {}
Bram Moolenaar9939f572020-09-16 22:29:52 +02001331 catch
1332 endtry
1333 return 'text'
1334enddef
1335
1336def Test_try_catch_twice()
1337 assert_equal('text', TryOne()->TryTwo())
1338enddef
1339
Bram Moolenaarf575adf2020-02-20 20:41:06 +01001340def Test_try_catch_match()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001341 var seq = 'a'
Bram Moolenaarf575adf2020-02-20 20:41:06 +01001342 try
1343 throw 'something'
1344 catch /nothing/
1345 seq ..= 'x'
1346 catch /some/
1347 seq ..= 'b'
1348 catch /asdf/
1349 seq ..= 'x'
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001350 catch ?a\?sdf?
1351 seq ..= 'y'
Bram Moolenaarf575adf2020-02-20 20:41:06 +01001352 finally
1353 seq ..= 'c'
1354 endtry
1355 assert_equal('abc', seq)
Bram Moolenaar257cc5e2020-02-19 17:06:11 +01001356enddef
1357
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001358def Test_try_catch_fails()
Bram Moolenaar62aec932022-01-29 21:45:34 +00001359 v9.CheckDefFailure(['catch'], 'E603:')
1360 v9.CheckDefFailure(['try', 'echo 0', 'catch', 'catch'], 'E1033:')
1361 v9.CheckDefFailure(['try', 'echo 0', 'catch /pat'], 'E1067:')
1362 v9.CheckDefFailure(['finally'], 'E606:')
1363 v9.CheckDefFailure(['try', 'echo 0', 'finally', 'echo 1', 'finally'], 'E607:')
1364 v9.CheckDefFailure(['endtry'], 'E602:')
1365 v9.CheckDefFailure(['while 1', 'endtry'], 'E170:')
1366 v9.CheckDefFailure(['for i in range(5)', 'endtry'], 'E170:')
1367 v9.CheckDefFailure(['if 1', 'endtry'], 'E171:')
1368 v9.CheckDefFailure(['try', 'echo 1', 'endtry'], 'E1032:')
Bram Moolenaar585fea72020-04-02 22:33:21 +02001369
Bram Moolenaar62aec932022-01-29 21:45:34 +00001370 v9.CheckDefFailure(['throw'], 'E1143:')
1371 v9.CheckDefFailure(['throw xxx'], 'E1001:')
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001372enddef
1373
Bram Moolenaar7c5b3c0362021-02-14 22:40:57 +01001374def Try_catch_skipped()
1375 var l = []
1376 try
1377 finally
1378 endtry
1379
1380 if 1
1381 else
1382 try
1383 endtry
1384 endif
1385enddef
1386
1387" The skipped try/endtry was updating the wrong instruction.
1388def Test_try_catch_skipped()
1389 var instr = execute('disassemble Try_catch_skipped')
1390 assert_match("NEWLIST size 0\n", instr)
1391enddef
1392
Bram Moolenaar90a57162022-02-12 14:23:17 +00001393def Test_throw_line_number()
1394 def Func()
1395 eval 1 + 1
1396 eval 2 + 2
1397 throw 'exception'
1398 enddef
1399 try
1400 Func()
1401 catch /exception/
1402 assert_match('line 3', v:throwpoint)
1403 endtry
1404enddef
Bram Moolenaar7c5b3c0362021-02-14 22:40:57 +01001405
1406
Bram Moolenaar006ad482020-06-30 20:55:15 +02001407def Test_throw_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001408 # only checks line continuation
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001409 var lines =<< trim END
Bram Moolenaar006ad482020-06-30 20:55:15 +02001410 vim9script
1411 try
1412 throw 'one'
1413 .. 'two'
1414 catch
1415 assert_equal('onetwo', v:exception)
1416 endtry
1417 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001418 v9.CheckScriptSuccess(lines)
Bram Moolenaar1e021e62020-10-16 20:25:23 +02001419
1420 lines =<< trim END
1421 vim9script
Bram Moolenaar352134b2020-10-17 22:04:08 +02001422 @r = ''
Bram Moolenaar1e021e62020-10-16 20:25:23 +02001423 def Func()
1424 throw @r
1425 enddef
1426 var result = ''
1427 try
1428 Func()
1429 catch /E1129:/
1430 result = 'caught'
1431 endtry
1432 assert_equal('caught', result)
1433 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001434 v9.CheckScriptSuccess(lines)
Bram Moolenaar006ad482020-06-30 20:55:15 +02001435enddef
1436
Bram Moolenaared677f52020-08-12 16:38:10 +02001437def Test_error_in_nested_function()
Bram Moolenaar03dfde22021-02-14 13:17:22 +01001438 # an error in a nested :function aborts executing in the calling :def function
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001439 var lines =<< trim END
Bram Moolenaared677f52020-08-12 16:38:10 +02001440 vim9script
1441 def Func()
1442 Error()
1443 g:test_var = 1
1444 enddef
1445 func Error() abort
1446 eval [][0]
1447 endfunc
1448 Func()
1449 END
1450 g:test_var = 0
Bram Moolenaar62aec932022-01-29 21:45:34 +00001451 v9.CheckScriptFailure(lines, 'E684:')
Bram Moolenaared677f52020-08-12 16:38:10 +02001452 assert_equal(0, g:test_var)
1453enddef
1454
Bram Moolenaar227c58a2021-04-28 20:40:44 +02001455def Test_abort_after_error()
1456 var lines =<< trim END
1457 vim9script
1458 while true
1459 echo notfound
1460 endwhile
1461 g:gotthere = true
1462 END
1463 g:gotthere = false
Bram Moolenaar62aec932022-01-29 21:45:34 +00001464 v9.CheckScriptFailure(lines, 'E121:')
Bram Moolenaar227c58a2021-04-28 20:40:44 +02001465 assert_false(g:gotthere)
1466 unlet g:gotthere
1467enddef
1468
Bram Moolenaar37c83712020-06-30 21:18:36 +02001469def Test_cexpr_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001470 # only checks line continuation
Bram Moolenaar37c83712020-06-30 21:18:36 +02001471 set errorformat=File\ %f\ line\ %l
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001472 var lines =<< trim END
Bram Moolenaar37c83712020-06-30 21:18:36 +02001473 vim9script
1474 cexpr 'File'
1475 .. ' someFile' ..
1476 ' line 19'
1477 assert_equal(19, getqflist()[0].lnum)
1478 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001479 v9.CheckScriptSuccess(lines)
Bram Moolenaar397a87a2022-03-20 21:14:15 +00001480
1481 lines =<< trim END
1482 vim9script
1483 def CexprFail()
1484 au QuickfixCmdPre * echo g:doesnotexist
1485 cexpr 'File otherFile line 99'
1486 g:didContinue = 'yes'
1487 enddef
1488 CexprFail()
1489 g:didContinue = 'also'
1490 END
1491 g:didContinue = 'no'
1492 v9.CheckScriptFailure(lines, 'E121: Undefined variable: g:doesnotexist')
1493 assert_equal('no', g:didContinue)
1494 au! QuickfixCmdPre
1495
1496 lines =<< trim END
1497 vim9script
1498 def CexprFail()
1499 cexpr g:aNumber
1500 g:didContinue = 'yes'
1501 enddef
1502 CexprFail()
1503 g:didContinue = 'also'
1504 END
1505 g:aNumber = 123
1506 g:didContinue = 'no'
1507 v9.CheckScriptFailure(lines, 'E777: String or List expected')
1508 assert_equal('no', g:didContinue)
1509 unlet g:didContinue
1510
Bram Moolenaar37c83712020-06-30 21:18:36 +02001511 set errorformat&
1512enddef
1513
Bram Moolenaarc9edd6b2020-08-12 22:18:23 +02001514def Test_statusline_syntax()
1515 # legacy syntax is used for 'statusline'
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001516 var lines =<< trim END
Bram Moolenaarc9edd6b2020-08-12 22:18:23 +02001517 vim9script
1518 func g:Status()
1519 return '%{"x" is# "x"}'
1520 endfunc
1521 set laststatus=2 statusline=%!Status()
1522 redrawstatus
Bram Moolenaar755bf2b2023-01-28 19:38:49 +00001523 set laststatus statusline=
Bram Moolenaarc9edd6b2020-08-12 22:18:23 +02001524 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001525 v9.CheckScriptSuccess(lines)
Bram Moolenaarc9edd6b2020-08-12 22:18:23 +02001526enddef
1527
Bram Moolenaarb2097502020-07-19 17:17:02 +02001528def Test_list_vimscript()
1529 # checks line continuation and comments
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001530 var lines =<< trim END
Bram Moolenaarb2097502020-07-19 17:17:02 +02001531 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001532 var mylist = [
Bram Moolenaarb2097502020-07-19 17:17:02 +02001533 'one',
1534 # comment
1535 'two', # empty line follows
1536
1537 'three',
1538 ]
1539 assert_equal(['one', 'two', 'three'], mylist)
1540 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001541 v9.CheckScriptSuccess(lines)
Bram Moolenaar66250c92020-08-20 15:02:42 +02001542
1543 # check all lines from heredoc are kept
1544 lines =<< trim END
1545 # comment 1
1546 two
1547 # comment 3
1548
1549 five
1550 # comment 6
1551 END
1552 assert_equal(['# comment 1', 'two', '# comment 3', '', 'five', '# comment 6'], lines)
Bram Moolenaar4bce26b2021-01-22 22:06:56 +01001553
1554 lines =<< trim END
1555 [{
1556 a: 0}]->string()->assert_equal("[{'a': 0}]")
1557 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001558 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarb2097502020-07-19 17:17:02 +02001559enddef
1560
Bram Moolenaar2a1381c2020-05-05 23:32:58 +02001561if has('channel')
1562 let someJob = test_null_job()
Bram Moolenaar40ee4662020-05-05 22:08:26 +02001563
Bram Moolenaar2a1381c2020-05-05 23:32:58 +02001564 def FuncWithError()
1565 echomsg g:someJob
1566 enddef
Bram Moolenaar40ee4662020-05-05 22:08:26 +02001567
Bram Moolenaar2a1381c2020-05-05 23:32:58 +02001568 func Test_convert_emsg_to_exception()
1569 try
1570 call FuncWithError()
1571 catch
1572 call assert_match('Vim:E908:', v:exception)
1573 endtry
1574 endfunc
1575endif
Bram Moolenaar40ee4662020-05-05 22:08:26 +02001576
Bram Moolenaard3f8a9e2021-02-17 21:57:03 +01001577def Test_vim9script_mix()
1578 var lines =<< trim END
1579 if has(g:feature)
1580 " legacy script
1581 let g:legacy = 1
1582 finish
1583 endif
1584 vim9script
1585 g:legacy = 0
1586 END
1587 g:feature = 'eval'
1588 g:legacy = -1
Bram Moolenaar62aec932022-01-29 21:45:34 +00001589 v9.CheckScriptSuccess(lines)
Bram Moolenaard3f8a9e2021-02-17 21:57:03 +01001590 assert_equal(1, g:legacy)
1591
1592 g:feature = 'noteval'
1593 g:legacy = -1
Bram Moolenaar62aec932022-01-29 21:45:34 +00001594 v9.CheckScriptSuccess(lines)
Bram Moolenaard3f8a9e2021-02-17 21:57:03 +01001595 assert_equal(0, g:legacy)
1596enddef
1597
Bram Moolenaar750802b2020-02-23 18:08:33 +01001598def Test_vim9script_fails()
Bram Moolenaar62aec932022-01-29 21:45:34 +00001599 v9.CheckScriptFailure(['scriptversion 2', 'vim9script'], 'E1039:')
1600 v9.CheckScriptFailure(['vim9script', 'scriptversion 2'], 'E1040:')
Bram Moolenaar750802b2020-02-23 18:08:33 +01001601
Bram Moolenaar62aec932022-01-29 21:45:34 +00001602 v9.CheckScriptFailure(['vim9script', 'var str: string', 'str = 1234'], 'E1012:')
1603 v9.CheckScriptFailure(['vim9script', 'const str = "asdf"', 'str = "xxx"'], 'E46:')
Bram Moolenaarc785b9a2020-06-19 18:34:15 +02001604
Bram Moolenaare2e40752020-09-04 21:18:46 +02001605 assert_fails('vim9script', 'E1038:')
Bram Moolenaar107f7322022-02-06 17:30:41 +00001606 v9.CheckDefFailure(['vim9script'], 'E1038:')
Bram Moolenaar8cbf2492022-02-06 20:28:13 +00001607
1608 # no error when skipping
1609 if has('nothing')
1610 vim9script
1611 endif
Bram Moolenaarc970e422021-03-17 15:03:04 +01001612enddef
1613
Bram Moolenaar6c3843c2021-03-04 12:38:21 +01001614def Test_script_var_shadows_function()
1615 var lines =<< trim END
1616 vim9script
1617 def Func(): number
1618 return 123
1619 enddef
1620 var Func = 1
1621 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001622 v9.CheckScriptFailure(lines, 'E1041:', 5)
Bram Moolenaar6c3843c2021-03-04 12:38:21 +01001623enddef
1624
Bram Moolenaar052ff292021-12-11 13:54:46 +00001625def Test_function_shadows_script_var()
1626 var lines =<< trim END
1627 vim9script
1628 var Func = 1
1629 def Func(): number
1630 return 123
1631 enddef
1632 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001633 v9.CheckScriptFailure(lines, 'E1041:', 3)
Bram Moolenaar052ff292021-12-11 13:54:46 +00001634enddef
1635
Bram Moolenaarc3235272021-07-10 19:42:03 +02001636def Test_script_var_shadows_command()
1637 var lines =<< trim END
1638 var undo = 1
1639 undo = 2
1640 assert_equal(2, undo)
1641 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001642 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarc3235272021-07-10 19:42:03 +02001643
1644 lines =<< trim END
1645 var undo = 1
1646 undo
1647 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001648 v9.CheckDefAndScriptFailure(lines, 'E1207:', 2)
Bram Moolenaarc3235272021-07-10 19:42:03 +02001649enddef
1650
Bram Moolenaar2ef91562021-12-11 16:14:07 +00001651def Test_vim9script_call_wrong_type()
1652 var lines =<< trim END
1653 vim9script
1654 var Time = 'localtime'
1655 Time()
1656 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001657 v9.CheckScriptFailure(lines, 'E1085:')
Bram Moolenaar2ef91562021-12-11 16:14:07 +00001658enddef
1659
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001660def Test_vim9script_reload_delfunc()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001661 var first_lines =<< trim END
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001662 vim9script
1663 def FuncYes(): string
1664 return 'yes'
1665 enddef
1666 END
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001667 var withno_lines =<< trim END
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001668 def FuncNo(): string
1669 return 'no'
1670 enddef
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001671 def g:DoCheck(no_exists: bool)
1672 assert_equal('yes', FuncYes())
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001673 assert_equal('no', FuncNo())
1674 enddef
1675 END
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001676 var nono_lines =<< trim END
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001677 def g:DoCheck(no_exists: bool)
1678 assert_equal('yes', FuncYes())
Bram Moolenaar44d66522020-09-06 22:26:57 +02001679 assert_fails('FuncNo()', 'E117:', '', 2, 'DoCheck')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001680 enddef
1681 END
1682
1683 # FuncNo() is defined
Bram Moolenaardd674772022-09-15 22:26:18 +01001684 writefile(first_lines + withno_lines, 'Xreloaded.vim', 'D')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001685 source Xreloaded.vim
1686 g:DoCheck(true)
1687
1688 # FuncNo() is not redefined
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001689 writefile(first_lines + nono_lines, 'Xreloaded.vim')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001690 source Xreloaded.vim
Bram Moolenaar50824712020-12-20 21:10:17 +01001691 g:DoCheck(false)
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001692
1693 # FuncNo() is back
Bram Moolenaar03afdcf2020-04-27 23:39:30 +02001694 writefile(first_lines + withno_lines, 'Xreloaded.vim')
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001695 source Xreloaded.vim
Bram Moolenaar50824712020-12-20 21:10:17 +01001696 g:DoCheck(false)
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02001697enddef
1698
Bram Moolenaar89483d42020-05-10 15:24:44 +02001699def Test_vim9script_reload_delvar()
1700 # write the script with a script-local variable
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001701 var lines =<< trim END
Bram Moolenaar89483d42020-05-10 15:24:44 +02001702 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001703 var name = 'string'
Bram Moolenaar89483d42020-05-10 15:24:44 +02001704 END
Bram Moolenaardd674772022-09-15 22:26:18 +01001705 writefile(lines, 'XreloadVar.vim', 'D')
Bram Moolenaar89483d42020-05-10 15:24:44 +02001706 source XreloadVar.vim
1707
1708 # now write the script using the same variable locally - works
1709 lines =<< trim END
1710 vim9script
1711 def Func()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001712 var name = 'string'
Bram Moolenaar89483d42020-05-10 15:24:44 +02001713 enddef
1714 END
1715 writefile(lines, 'XreloadVar.vim')
1716 source XreloadVar.vim
Bram Moolenaar89483d42020-05-10 15:24:44 +02001717enddef
1718
Bram Moolenaarc4ce36d2020-08-14 17:08:15 +02001719def Test_func_redefine_error()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001720 var lines = [
Bram Moolenaarc4ce36d2020-08-14 17:08:15 +02001721 'vim9script',
1722 'def Func()',
1723 ' eval [][0]',
1724 'enddef',
1725 'Func()',
1726 ]
Bram Moolenaardd674772022-09-15 22:26:18 +01001727 writefile(lines, 'Xtestscript.vim', 'D')
Bram Moolenaarc4ce36d2020-08-14 17:08:15 +02001728
1729 for count in range(3)
1730 try
1731 source Xtestscript.vim
1732 catch /E684/
1733 # function name should contain <SNR> every time
Bram Moolenaarec892232022-05-06 17:53:06 +01001734 assert_match('E684: List index out of range', v:exception)
Bram Moolenaarc4ce36d2020-08-14 17:08:15 +02001735 assert_match('function <SNR>\d\+_Func, line 1', v:throwpoint)
1736 endtry
1737 endfor
Bram Moolenaarc4ce36d2020-08-14 17:08:15 +02001738enddef
1739
Bram Moolenaarb9a2cac2020-08-01 22:23:20 +02001740def Test_func_redefine_fails()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001741 var lines =<< trim END
Bram Moolenaarb9a2cac2020-08-01 22:23:20 +02001742 vim9script
1743 def Func()
1744 echo 'one'
1745 enddef
1746 def Func()
1747 echo 'two'
1748 enddef
1749 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001750 v9.CheckScriptFailure(lines, 'E1073:')
Bram Moolenaarfa211f32020-08-07 22:00:26 +02001751
1752 lines =<< trim END
1753 vim9script
1754 def Foo(): string
1755 return 'foo'
Bram Moolenaar052ff292021-12-11 13:54:46 +00001756 enddef
Bram Moolenaarfa211f32020-08-07 22:00:26 +02001757 def Func()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001758 var Foo = {-> 'lambda'}
Bram Moolenaarfa211f32020-08-07 22:00:26 +02001759 enddef
1760 defcompile
1761 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001762 v9.CheckScriptFailure(lines, 'E1073:')
Bram Moolenaarb9a2cac2020-08-01 22:23:20 +02001763enddef
1764
Bram Moolenaar91c7cbf2022-08-18 13:28:31 +01001765def Test_lambda_split()
1766 # this was using freed memory, because of the split expression
1767 var lines =<< trim END
1768 vim9script
1769 try
1770 0
1771 0->(0
1772 ->a.0(
1773 ->u
1774 END
1775 v9.CheckScriptFailure(lines, 'E1050:')
1776enddef
1777
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001778def Test_fixed_size_list()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001779 # will be allocated as one piece of memory, check that changes work
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001780 var l = [1, 2, 3, 4]
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001781 l->remove(0)
1782 l->add(5)
1783 l->insert(99, 1)
Bram Moolenaar0f18b6d2020-02-02 17:22:27 +01001784 assert_equal([2, 99, 3, 4, 5], l)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001785enddef
1786
Bram Moolenaarae616492020-07-28 20:07:27 +02001787def Test_no_insert_xit()
Bram Moolenaar62aec932022-01-29 21:45:34 +00001788 v9.CheckDefExecFailure(['a = 1'], 'E1100:')
1789 v9.CheckDefExecFailure(['c = 1'], 'E1100:')
1790 v9.CheckDefExecFailure(['i = 1'], 'E1100:')
1791 v9.CheckDefExecFailure(['t = 1'], 'E1100:')
1792 v9.CheckDefExecFailure(['x = 1'], 'E1100:')
Bram Moolenaarae616492020-07-28 20:07:27 +02001793
Bram Moolenaar62aec932022-01-29 21:45:34 +00001794 v9.CheckScriptFailure(['vim9script', 'a = 1'], 'E488:')
1795 v9.CheckScriptFailure(['vim9script', 'a'], 'E1100:')
1796 v9.CheckScriptFailure(['vim9script', 'c = 1'], 'E488:')
1797 v9.CheckScriptFailure(['vim9script', 'c'], 'E1100:')
1798 v9.CheckScriptFailure(['vim9script', 'i = 1'], 'E488:')
1799 v9.CheckScriptFailure(['vim9script', 'i'], 'E1100:')
1800 v9.CheckScriptFailure(['vim9script', 'o = 1'], 'E1100:')
1801 v9.CheckScriptFailure(['vim9script', 'o'], 'E1100:')
1802 v9.CheckScriptFailure(['vim9script', 't'], 'E1100:')
1803 v9.CheckScriptFailure(['vim9script', 't = 1'], 'E1100:')
1804 v9.CheckScriptFailure(['vim9script', 'x = 1'], 'E1100:')
Bram Moolenaarae616492020-07-28 20:07:27 +02001805enddef
1806
Bram Moolenaar62aec932022-01-29 21:45:34 +00001807def s:IfElse(what: number): string
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001808 var res = ''
Bram Moolenaar158906c2020-02-06 20:39:45 +01001809 if what == 1
1810 res = "one"
1811 elseif what == 2
1812 res = "two"
Bram Moolenaara259d8d2020-01-31 20:10:50 +01001813 else
Bram Moolenaar158906c2020-02-06 20:39:45 +01001814 res = "three"
Bram Moolenaara259d8d2020-01-31 20:10:50 +01001815 endif
Bram Moolenaar158906c2020-02-06 20:39:45 +01001816 return res
Bram Moolenaara259d8d2020-01-31 20:10:50 +01001817enddef
1818
Bram Moolenaar158906c2020-02-06 20:39:45 +01001819def Test_if_elseif_else()
1820 assert_equal('one', IfElse(1))
1821 assert_equal('two', IfElse(2))
1822 assert_equal('three', IfElse(3))
Bram Moolenaar0f18b6d2020-02-02 17:22:27 +01001823enddef
1824
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001825def Test_if_elseif_else_fails()
Bram Moolenaar62aec932022-01-29 21:45:34 +00001826 v9.CheckDefFailure(['elseif true'], 'E582:')
1827 v9.CheckDefFailure(['else'], 'E581:')
1828 v9.CheckDefFailure(['endif'], 'E580:')
1829 v9.CheckDefFailure(['if g:abool', 'elseif xxx'], 'E1001:')
1830 v9.CheckDefFailure(['if true', 'echo 1'], 'E171:')
Bram Moolenaar6628b7e2021-02-07 16:33:35 +01001831
1832 var lines =<< trim END
1833 var s = ''
1834 if s = ''
1835 endif
1836 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001837 v9.CheckDefFailure(lines, 'E488:')
Bram Moolenaar6628b7e2021-02-07 16:33:35 +01001838
1839 lines =<< trim END
1840 var s = ''
1841 if s == ''
1842 elseif s = ''
1843 endif
1844 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001845 v9.CheckDefFailure(lines, 'E488:')
Bram Moolenaarfa010cd2022-04-03 16:13:07 +01001846
1847 lines =<< trim END
1848 var cond = true
1849 if cond
1850 echo 'true'
1851 elseif
1852 echo 'false'
1853 endif
1854 END
1855 v9.CheckDefAndScriptFailure(lines, ['E1143:', 'E15:'], 4)
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001856enddef
1857
Bram Moolenaar505ed0c2022-05-05 17:02:46 +01001858def Test_if_else_func_using_var()
1859 var lines =<< trim END
1860 vim9script
1861
1862 const debug = true
1863 if debug
1864 var mode_chars = 'something'
1865 def Bits2Ascii()
1866 var x = mode_chars
1867 g:where = 'in true'
1868 enddef
1869 else
1870 def Bits2Ascii()
1871 g:where = 'in false'
1872 enddef
1873 endif
1874
1875 Bits2Ascii()
1876 END
1877 v9.CheckScriptSuccess(lines)
1878 assert_equal('in true', g:where)
1879 unlet g:where
1880
1881 lines =<< trim END
1882 vim9script
1883
1884 const debug = false
1885 if debug
1886 var mode_chars = 'something'
1887 def Bits2Ascii()
1888 g:where = 'in true'
1889 enddef
1890 else
1891 def Bits2Ascii()
1892 var x = mode_chars
1893 g:where = 'in false'
1894 enddef
1895 endif
1896
1897 Bits2Ascii()
1898 END
1899 v9.CheckScriptFailure(lines, 'E1001: Variable not found: mode_chars')
1900enddef
1901
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001902let g:bool_true = v:true
1903let g:bool_false = v:false
1904
1905def Test_if_const_expr()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02001906 var res = false
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001907 if true ? true : false
1908 res = true
1909 endif
1910 assert_equal(true, res)
1911
Bram Moolenaar585fea72020-04-02 22:33:21 +02001912 g:glob = 2
1913 if false
Bram Moolenaar67979662020-06-20 22:50:47 +02001914 execute('g:glob = 3')
Bram Moolenaar585fea72020-04-02 22:33:21 +02001915 endif
1916 assert_equal(2, g:glob)
1917 if true
Bram Moolenaar67979662020-06-20 22:50:47 +02001918 execute('g:glob = 3')
Bram Moolenaar585fea72020-04-02 22:33:21 +02001919 endif
1920 assert_equal(3, g:glob)
1921
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001922 res = false
1923 if g:bool_true ? true : false
1924 res = true
1925 endif
1926 assert_equal(true, res)
1927
1928 res = false
1929 if true ? g:bool_true : false
1930 res = true
1931 endif
1932 assert_equal(true, res)
1933
1934 res = false
1935 if true ? true : g:bool_false
1936 res = true
1937 endif
1938 assert_equal(true, res)
1939
1940 res = false
1941 if true ? false : true
1942 res = true
1943 endif
1944 assert_equal(false, res)
1945
1946 res = false
1947 if false ? false : true
1948 res = true
1949 endif
1950 assert_equal(true, res)
1951
1952 res = false
1953 if false ? true : false
1954 res = true
1955 endif
1956 assert_equal(false, res)
1957
1958 res = false
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001959 if has('xyz') ? true : false
1960 res = true
1961 endif
1962 assert_equal(false, res)
1963
1964 res = false
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001965 if true && true
1966 res = true
1967 endif
1968 assert_equal(true, res)
1969
1970 res = false
1971 if true && false
1972 res = true
1973 endif
1974 assert_equal(false, res)
1975
1976 res = false
1977 if g:bool_true && false
1978 res = true
1979 endif
1980 assert_equal(false, res)
1981
1982 res = false
1983 if true && g:bool_false
1984 res = true
1985 endif
1986 assert_equal(false, res)
1987
1988 res = false
1989 if false && false
1990 res = true
1991 endif
1992 assert_equal(false, res)
1993
1994 res = false
1995 if true || false
1996 res = true
1997 endif
1998 assert_equal(true, res)
1999
2000 res = false
2001 if g:bool_true || false
2002 res = true
2003 endif
2004 assert_equal(true, res)
2005
2006 res = false
2007 if true || g:bool_false
2008 res = true
2009 endif
2010 assert_equal(true, res)
2011
2012 res = false
2013 if false || false
2014 res = true
2015 endif
2016 assert_equal(false, res)
Bram Moolenaar3988f642020-08-27 22:43:03 +02002017
2018 # with constant "false" expression may be invalid so long as the syntax is OK
Bram Moolenaarc3235272021-07-10 19:42:03 +02002019 if false | eval 1 + 2 | endif
Bram Moolenaar3988f642020-08-27 22:43:03 +02002020 if false | eval burp + 234 | endif
2021 if false | echo burp 234 'asd' | endif
2022 if false
2023 burp
2024 endif
Bram Moolenaare525bdd2021-08-07 18:12:40 +02002025
Bram Moolenaar21ebb082022-02-04 21:58:58 +00002026 if 0
2027 if 1
2028 echo nothing
2029 elseif 1
2030 echo still nothing
2031 endif
2032 endif
2033
Bram Moolenaare525bdd2021-08-07 18:12:40 +02002034 # expression with line breaks skipped
2035 if false
2036 ('aaa'
2037 .. 'bbb'
2038 .. 'ccc'
2039 )->setline(1)
2040 endif
Bram Moolenaar80c34ca2020-04-01 23:05:18 +02002041enddef
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01002042
Bram Moolenaar80c34ca2020-04-01 23:05:18 +02002043def Test_if_const_expr_fails()
Bram Moolenaar62aec932022-01-29 21:45:34 +00002044 v9.CheckDefFailure(['if "aaa" == "bbb'], 'E114:')
2045 v9.CheckDefFailure(["if 'aaa' == 'bbb"], 'E115:')
2046 v9.CheckDefFailure(["if has('aaa'"], 'E110:')
2047 v9.CheckDefFailure(["if has('aaa') ? true false"], 'E109:')
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01002048enddef
2049
Bram Moolenaar62aec932022-01-29 21:45:34 +00002050def s:RunNested(i: number): number
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002051 var x: number = 0
Bram Moolenaar72abcf42020-06-18 18:26:24 +02002052 if i % 2
2053 if 1
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002054 # comment
Bram Moolenaar72abcf42020-06-18 18:26:24 +02002055 else
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002056 # comment
Bram Moolenaar72abcf42020-06-18 18:26:24 +02002057 endif
2058 x += 1
2059 else
2060 x += 1000
2061 endif
2062 return x
2063enddef
2064
2065def Test_nested_if()
2066 assert_equal(1, RunNested(1))
2067 assert_equal(1000, RunNested(2))
2068enddef
2069
Bram Moolenaarad39c092020-02-26 18:23:43 +01002070def Test_execute_cmd()
Bram Moolenaare4984292020-12-13 14:19:25 +01002071 # missing argument is ignored
2072 execute
2073 execute # comment
2074
Bram Moolenaarad39c092020-02-26 18:23:43 +01002075 new
2076 setline(1, 'default')
Bram Moolenaard2c61702020-09-06 15:58:36 +02002077 execute 'setline(1, "execute-string")'
Bram Moolenaarad39c092020-02-26 18:23:43 +01002078 assert_equal('execute-string', getline(1))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002079
Bram Moolenaard2c61702020-09-06 15:58:36 +02002080 execute "setline(1, 'execute-string')"
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002081 assert_equal('execute-string', getline(1))
2082
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002083 var cmd1 = 'setline(1,'
2084 var cmd2 = '"execute-var")'
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002085 execute cmd1 cmd2 # comment
Bram Moolenaarad39c092020-02-26 18:23:43 +01002086 assert_equal('execute-var', getline(1))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002087
Bram Moolenaard2c61702020-09-06 15:58:36 +02002088 execute cmd1 cmd2 '|setline(1, "execute-var-string")'
Bram Moolenaarad39c092020-02-26 18:23:43 +01002089 assert_equal('execute-var-string', getline(1))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002090
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002091 var cmd_first = 'call '
2092 var cmd_last = 'setline(1, "execute-var-var")'
Bram Moolenaarad39c092020-02-26 18:23:43 +01002093 execute cmd_first .. cmd_last
2094 assert_equal('execute-var-var', getline(1))
2095 bwipe!
Bram Moolenaar585fea72020-04-02 22:33:21 +02002096
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002097 var n = true
Bram Moolenaar2d6b20d2020-07-25 19:30:59 +02002098 execute 'echomsg' (n ? '"true"' : '"no"')
Bram Moolenaar62aec932022-01-29 21:45:34 +00002099 assert_match('^true$', g:Screenline(&lines))
Bram Moolenaar2d6b20d2020-07-25 19:30:59 +02002100
Bram Moolenaare0de1712020-12-02 17:36:54 +01002101 echomsg [1, 2, 3] {a: 1, b: 2}
Bram Moolenaar62aec932022-01-29 21:45:34 +00002102 assert_match('^\[1, 2, 3\] {''a'': 1, ''b'': 2}$', g:Screenline(&lines))
Bram Moolenaare5abf7a2020-08-16 18:29:35 +02002103
Bram Moolenaar62aec932022-01-29 21:45:34 +00002104 v9.CheckDefFailure(['execute xxx'], 'E1001:', 1)
2105 v9.CheckDefExecFailure(['execute "tabnext " .. 8'], 'E475:', 1)
2106 v9.CheckDefFailure(['execute "cmd"# comment'], 'E488:', 1)
Bram Moolenaar0c7f2612022-02-17 19:44:07 +00002107 if has('channel')
2108 v9.CheckDefExecFailure(['execute test_null_channel()'], 'E908:', 1)
2109 endif
Bram Moolenaarad39c092020-02-26 18:23:43 +01002110enddef
2111
Bram Moolenaar47e880d2020-06-30 22:02:02 +02002112def Test_execute_cmd_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002113 # only checks line continuation
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002114 var lines =<< trim END
Bram Moolenaar47e880d2020-06-30 22:02:02 +02002115 vim9script
2116 execute 'g:someVar'
2117 .. ' = ' ..
2118 '28'
2119 assert_equal(28, g:someVar)
2120 unlet g:someVar
2121 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002122 v9.CheckScriptSuccess(lines)
Bram Moolenaar47e880d2020-06-30 22:02:02 +02002123enddef
2124
Bram Moolenaar43216612022-03-25 11:16:28 +00002125def Test_execute_finish()
2126 # the empty lines are relevant here
2127 var lines =<< trim END
2128 vim9script
2129
2130 var vname = "g:hello"
2131
2132 if exists(vname) | finish | endif | execute vname '= "world"'
2133
2134 assert_equal('world', g:hello)
2135
2136 if exists(vname) | finish | endif | execute vname '= "world"'
2137
2138 assert_report('should not be reached')
2139 END
2140 v9.CheckScriptSuccess(lines)
2141enddef
2142
Bram Moolenaarad39c092020-02-26 18:23:43 +01002143def Test_echo_cmd()
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002144 echo 'some' # comment
Bram Moolenaar585fea72020-04-02 22:33:21 +02002145 echon 'thing'
Bram Moolenaar62aec932022-01-29 21:45:34 +00002146 assert_match('^something$', g:Screenline(&lines))
Bram Moolenaarad39c092020-02-26 18:23:43 +01002147
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002148 echo "some" # comment
2149 echon "thing"
Bram Moolenaar62aec932022-01-29 21:45:34 +00002150 assert_match('^something$', g:Screenline(&lines))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002151
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002152 var str1 = 'some'
2153 var str2 = 'more'
Bram Moolenaarad39c092020-02-26 18:23:43 +01002154 echo str1 str2
Bram Moolenaar62aec932022-01-29 21:45:34 +00002155 assert_match('^some more$', g:Screenline(&lines))
Bram Moolenaara72cfb82020-04-23 17:07:30 +02002156
Bram Moolenaar397a87a2022-03-20 21:14:15 +00002157 echo "one\ntwo"
2158 assert_match('^one$', g:Screenline(&lines - 1))
2159 assert_match('^two$', g:Screenline(&lines))
2160
Bram Moolenaar62aec932022-01-29 21:45:34 +00002161 v9.CheckDefFailure(['echo "xxx"# comment'], 'E488:')
Bram Moolenaarad39c092020-02-26 18:23:43 +01002162enddef
2163
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02002164def Test_echomsg_cmd()
2165 echomsg 'some' 'more' # comment
Bram Moolenaar62aec932022-01-29 21:45:34 +00002166 assert_match('^some more$', g:Screenline(&lines))
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02002167 echo 'clear'
Bram Moolenaardf069ee2020-06-22 23:02:51 +02002168 :1messages
Bram Moolenaar62aec932022-01-29 21:45:34 +00002169 assert_match('^some more$', g:Screenline(&lines))
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02002170
Bram Moolenaar62aec932022-01-29 21:45:34 +00002171 v9.CheckDefFailure(['echomsg "xxx"# comment'], 'E488:')
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02002172enddef
2173
Bram Moolenaar47e880d2020-06-30 22:02:02 +02002174def Test_echomsg_cmd_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002175 # only checks line continuation
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002176 var lines =<< trim END
Bram Moolenaar47e880d2020-06-30 22:02:02 +02002177 vim9script
2178 echomsg 'here'
2179 .. ' is ' ..
2180 'a message'
Bram Moolenaar62aec932022-01-29 21:45:34 +00002181 assert_match('^here is a message$', g:Screenline(&lines))
Bram Moolenaar47e880d2020-06-30 22:02:02 +02002182 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002183 v9.CheckScriptSuccess(lines)
Bram Moolenaar47e880d2020-06-30 22:02:02 +02002184enddef
2185
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02002186def Test_echoerr_cmd()
Bram Moolenaar7de62622021-08-07 15:05:47 +02002187 var local = 'local'
Bram Moolenaar40ee4662020-05-05 22:08:26 +02002188 try
Bram Moolenaar7de62622021-08-07 15:05:47 +02002189 echoerr 'something' local 'wrong' # comment
Bram Moolenaar40ee4662020-05-05 22:08:26 +02002190 catch
Bram Moolenaar7de62622021-08-07 15:05:47 +02002191 assert_match('something local wrong', v:exception)
Bram Moolenaar40ee4662020-05-05 22:08:26 +02002192 endtry
Bram Moolenaarf93c7fe2020-04-23 22:16:53 +02002193enddef
2194
Bram Moolenaar47e880d2020-06-30 22:02:02 +02002195def Test_echoerr_cmd_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002196 # only checks line continuation
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002197 var lines =<< trim END
Bram Moolenaar47e880d2020-06-30 22:02:02 +02002198 vim9script
2199 try
2200 echoerr 'this'
2201 .. ' is ' ..
2202 'wrong'
2203 catch
2204 assert_match('this is wrong', v:exception)
2205 endtry
2206 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002207 v9.CheckScriptSuccess(lines)
Bram Moolenaar47e880d2020-06-30 22:02:02 +02002208enddef
2209
Bram Moolenaar7de62622021-08-07 15:05:47 +02002210def Test_echoconsole_cmd()
2211 var local = 'local'
2212 echoconsole 'something' local # comment
2213 # output goes anywhere
2214enddef
2215
Bram Moolenaar7d7ad7b2022-09-01 16:00:53 +01002216def Test_echowindow_cmd()
2217 var local = 'local'
2218 echowindow 'something' local # comment
Bram Moolenaar2435adf2022-10-21 12:05:46 +01002219
2220 # with modifier
2221 unsilent echowin 'loud'
2222
Bram Moolenaar7d7ad7b2022-09-01 16:00:53 +01002223 # output goes in message window
2224 popup_clear()
2225enddef
2226
Bram Moolenaar41fe0612020-03-01 16:22:40 +01002227def Test_for_outside_of_function()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02002228 var lines =<< trim END
Bram Moolenaar41fe0612020-03-01 16:22:40 +01002229 vim9script
2230 new
2231 for var in range(0, 3)
2232 append(line('$'), var)
2233 endfor
2234 assert_equal(['', '0', '1', '2', '3'], getline(1, '$'))
2235 bwipe!
Bram Moolenaar522eefd2021-03-26 18:49:22 +01002236
2237 var result = ''
2238 for i in [1, 2, 3]
2239 var loop = ' loop ' .. i
2240 result ..= loop
2241 endfor
2242 assert_equal(' loop 1 loop 2 loop 3', result)
Bram Moolenaar41fe0612020-03-01 16:22:40 +01002243 END
Bram Moolenaardd674772022-09-15 22:26:18 +01002244 writefile(lines, 'Xvim9for.vim', 'D')
Bram Moolenaar41fe0612020-03-01 16:22:40 +01002245 source Xvim9for.vim
Bram Moolenaar41fe0612020-03-01 16:22:40 +01002246enddef
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002247
rbtnnbebf0692021-08-21 17:26:50 +02002248def Test_for_skipped_block()
2249 # test skipped blocks at outside of function
2250 var lines =<< trim END
2251 var result = []
2252 if true
2253 for n in [1, 2]
2254 result += [n]
2255 endfor
2256 else
2257 for n in [3, 4]
2258 result += [n]
2259 endfor
2260 endif
2261 assert_equal([1, 2], result)
2262
2263 result = []
2264 if false
2265 for n in [1, 2]
2266 result += [n]
2267 endfor
2268 else
2269 for n in [3, 4]
2270 result += [n]
2271 endfor
2272 endif
2273 assert_equal([3, 4], result)
2274 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002275 v9.CheckDefAndScriptSuccess(lines)
rbtnnbebf0692021-08-21 17:26:50 +02002276
2277 # test skipped blocks at inside of function
2278 lines =<< trim END
2279 def DefTrue()
2280 var result = []
2281 if true
2282 for n in [1, 2]
2283 result += [n]
2284 endfor
2285 else
2286 for n in [3, 4]
2287 result += [n]
2288 endfor
2289 endif
2290 assert_equal([1, 2], result)
2291 enddef
2292 DefTrue()
2293
2294 def DefFalse()
2295 var result = []
2296 if false
2297 for n in [1, 2]
2298 result += [n]
2299 endfor
2300 else
2301 for n in [3, 4]
2302 result += [n]
2303 endfor
2304 endif
2305 assert_equal([3, 4], result)
2306 enddef
2307 DefFalse()
Bram Moolenaar97f8c102022-04-02 19:43:57 +01002308
2309 def BuildDiagrams()
2310 var diagrams: list<any>
2311 if false
2312 var max = 0
2313 for v in diagrams
2314 var l = 3
2315 if max < l | max = l | endif
2316 v->add(l)
2317 endfor
2318 endif
2319 enddef
2320 BuildDiagrams()
rbtnnbebf0692021-08-21 17:26:50 +02002321 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002322 v9.CheckDefAndScriptSuccess(lines)
rbtnnbebf0692021-08-21 17:26:50 +02002323enddef
2324
Bram Moolenaar4875d6a2022-08-17 15:55:51 +01002325def Test_skipped_redir()
2326 var lines =<< trim END
Bram Moolenaar3558afe2022-10-13 16:12:57 +01002327 def Tredir()
Bram Moolenaar4875d6a2022-08-17 15:55:51 +01002328 if 0
Bram Moolenaar3558afe2022-10-13 16:12:57 +01002329 redir => l[0]
Bram Moolenaar4875d6a2022-08-17 15:55:51 +01002330 redir END
2331 endif
2332 enddef
2333 defcompile
2334 END
2335 v9.CheckScriptSuccess(lines)
Bram Moolenaar3558afe2022-10-13 16:12:57 +01002336 delfunc g:Tredir
2337
2338 lines =<< trim END
2339 def Tredir()
2340 if 0
2341 redir => l[0]
2342 endif
2343 echo 'executed'
2344 if 0
2345 redir END
2346 endif
2347 enddef
2348 defcompile
2349 END
2350 v9.CheckScriptSuccess(lines)
2351 delfunc g:Tredir
2352
2353 lines =<< trim END
2354 def Tredir()
2355 var l = ['']
2356 if 1
2357 redir => l[0]
2358 endif
2359 echo 'executed'
2360 if 0
2361 redir END
2362 else
2363 redir END
2364 endif
2365 enddef
2366 defcompile
2367 END
2368 v9.CheckScriptSuccess(lines)
2369 delfunc g:Tredir
2370
2371 lines =<< trim END
2372 let doit = 1
2373 def Tredir()
2374 var l = ['']
2375 if g:doit
2376 redir => l[0]
2377 endif
2378 echo 'executed'
2379 if g:doit
2380 redir END
2381 endif
2382 enddef
2383 defcompile
2384 END
2385 v9.CheckScriptSuccess(lines)
2386 delfunc g:Tredir
Bram Moolenaar4875d6a2022-08-17 15:55:51 +01002387enddef
2388
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02002389def Test_for_loop()
Bram Moolenaarf2253962021-04-13 20:53:13 +02002390 var lines =<< trim END
2391 var result = ''
2392 for cnt in range(7)
2393 if cnt == 4
2394 break
2395 endif
2396 if cnt == 2
2397 continue
2398 endif
2399 result ..= cnt .. '_'
2400 endfor
2401 assert_equal('0_1_3_', result)
Bram Moolenaar0ad3e892020-07-05 21:38:11 +02002402
Bram Moolenaarf2253962021-04-13 20:53:13 +02002403 var concat = ''
2404 for str in eval('["one", "two"]')
2405 concat ..= str
2406 endfor
2407 assert_equal('onetwo', concat)
Bram Moolenaar38bd8de2020-12-02 13:23:36 +01002408
Bram Moolenaarf2253962021-04-13 20:53:13 +02002409 var total = 0
2410 for nr in
2411 [1, 2, 3]
2412 total += nr
2413 endfor
2414 assert_equal(6, total)
Bram Moolenaar38bd8de2020-12-02 13:23:36 +01002415
Bram Moolenaarf2253962021-04-13 20:53:13 +02002416 total = 0
2417 for nr
2418 in [1, 2, 3]
2419 total += nr
2420 endfor
2421 assert_equal(6, total)
Bram Moolenaar38bd8de2020-12-02 13:23:36 +01002422
Bram Moolenaarf2253962021-04-13 20:53:13 +02002423 total = 0
2424 for nr
2425 in
2426 [1, 2, 3]
2427 total += nr
2428 endfor
2429 assert_equal(6, total)
Bram Moolenaar036d0712021-01-17 20:23:38 +01002430
Bram Moolenaara3589a02021-04-14 13:30:46 +02002431 # with type
2432 total = 0
2433 for n: number in [1, 2, 3]
2434 total += n
2435 endfor
2436 assert_equal(6, total)
2437
Bram Moolenaarefd73ae2022-03-20 18:51:00 +00002438 total = 0
2439 for b in 0z010203
2440 total += b
2441 endfor
2442 assert_equal(6, total)
2443
Bram Moolenaarfe090eb2021-04-15 21:48:32 +02002444 var chars = ''
2445 for s: string in 'foobar'
2446 chars ..= s
2447 endfor
2448 assert_equal('foobar', chars)
2449
Bram Moolenaar5ede5b22021-07-07 21:55:25 +02002450 chars = ''
2451 for x: string in {a: 'a', b: 'b'}->values()
2452 chars ..= x
2453 endfor
2454 assert_equal('ab', chars)
2455
Bram Moolenaara3589a02021-04-14 13:30:46 +02002456 # unpack with type
Bram Moolenaarf2253962021-04-13 20:53:13 +02002457 var res = ''
Bram Moolenaara3589a02021-04-14 13:30:46 +02002458 for [n: number, s: string] in [[1, 'a'], [2, 'b']]
2459 res ..= n .. s
2460 endfor
2461 assert_equal('1a2b', res)
2462
Bram Moolenaar444d8782021-06-26 12:40:56 +02002463 # unpack with one var
2464 var reslist = []
2465 for [x] in [['aaa'], ['bbb']]
2466 reslist->add(x)
2467 endfor
2468 assert_equal(['aaa', 'bbb'], reslist)
2469
Bram Moolenaara3589a02021-04-14 13:30:46 +02002470 # loop over string
2471 res = ''
Bram Moolenaarf2253962021-04-13 20:53:13 +02002472 for c in 'aéc̀d'
2473 res ..= c .. '-'
2474 endfor
2475 assert_equal('a-é-c̀-d-', res)
2476
2477 res = ''
2478 for c in ''
2479 res ..= c .. '-'
2480 endfor
2481 assert_equal('', res)
2482
2483 res = ''
2484 for c in test_null_string()
2485 res ..= c .. '-'
2486 endfor
2487 assert_equal('', res)
2488
Bram Moolenaar10611952022-04-03 21:11:34 +01002489 total = 0
2490 for c in null_list
2491 total += 1
2492 endfor
2493 assert_equal(0, total)
2494
2495 for c in null_blob
2496 total += 1
2497 endfor
2498 assert_equal(0, total)
2499
Bram Moolenaarf2253962021-04-13 20:53:13 +02002500 var foo: list<dict<any>> = [
2501 {a: 'Cat'}
2502 ]
2503 for dd in foo
2504 dd.counter = 12
2505 endfor
2506 assert_equal([{a: 'Cat', counter: 12}], foo)
Bram Moolenaarad2d4962021-07-18 17:08:50 +02002507
2508 reslist = []
2509 for _ in range(3)
2510 reslist->add('x')
2511 endfor
2512 assert_equal(['x', 'x', 'x'], reslist)
Bram Moolenaarf2253962021-04-13 20:53:13 +02002513 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002514 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02002515enddef
2516
Bram Moolenaar159b2d52022-10-11 21:41:25 +01002517def Test_for_loop_list_of_lists()
2518 # loop variable is final, not const
2519 var lines =<< trim END
2520 # Filter out all odd numbers in each sublist
2521 var list: list<list<number>> = [[1], [1, 2], [1, 2, 3], [1, 2, 3, 4]]
2522 for i in list
2523 filter(i, (_, n: number): bool => n % 2 == 0)
2524 endfor
2525
2526 assert_equal([[], [2], [2], [2, 4]], list)
2527 END
2528 v9.CheckDefAndScriptSuccess(lines)
2529enddef
2530
Bram Moolenaar2eb6fc32021-07-25 14:13:53 +02002531def Test_for_loop_with_closure()
Bram Moolenaar766ae5b2022-09-14 00:30:51 +01002532 # using the loop variable in a closure results in the last used value
Bram Moolenaar2eb6fc32021-07-25 14:13:53 +02002533 var lines =<< trim END
2534 var flist: list<func>
2535 for i in range(5)
Bram Moolenaar766ae5b2022-09-14 00:30:51 +01002536 flist[i] = () => i
2537 endfor
2538 for i in range(5)
2539 assert_equal(4, flist[i]())
2540 endfor
2541 END
2542 v9.CheckDefAndScriptSuccess(lines)
2543
Bram Moolenaardd674772022-09-15 22:26:18 +01002544 # also works when the loop variable is used only once halfway the loops
2545 lines =<< trim END
2546 var Clo: func
2547 for i in range(5)
2548 if i == 3
2549 Clo = () => i
2550 endif
2551 endfor
2552 assert_equal(4, Clo())
2553 END
2554 v9.CheckDefAndScriptSuccess(lines)
2555
Bram Moolenaar766ae5b2022-09-14 00:30:51 +01002556 # using a local variable set to the loop variable in a closure results in the
2557 # value at that moment
2558 lines =<< trim END
2559 var flist: list<func>
2560 for i in range(5)
Bram Moolenaar2eb6fc32021-07-25 14:13:53 +02002561 var inloop = i
2562 flist[i] = () => inloop
2563 endfor
2564 for i in range(5)
Bram Moolenaar353b68a2022-09-13 21:10:45 +01002565 assert_equal(i, flist[i]())
Bram Moolenaar2eb6fc32021-07-25 14:13:53 +02002566 endfor
2567 END
Bram Moolenaar0cdfb7c2022-09-17 15:44:52 +01002568 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar2eb6fc32021-07-25 14:13:53 +02002569
Bram Moolenaara275f2c2022-10-11 20:04:09 +01002570 # also with an extra block level
2571 lines =<< trim END
2572 var flist: list<func>
2573 for i in range(5)
2574 {
2575 var inloop = i
2576 flist[i] = () => inloop
2577 }
2578 endfor
2579 for i in range(5)
2580 assert_equal(i, flist[i]())
2581 endfor
2582 END
2583 v9.CheckDefAndScriptSuccess(lines)
2584
2585 # and declaration in higher block
2586 lines =<< trim END
2587 var flist: list<func>
2588 for i in range(5)
2589 var inloop = i
2590 {
2591 flist[i] = () => inloop
2592 }
2593 endfor
2594 for i in range(5)
2595 assert_equal(i, flist[i]())
2596 endfor
2597 END
2598 v9.CheckDefAndScriptSuccess(lines)
2599
Bram Moolenaar2eb6fc32021-07-25 14:13:53 +02002600 lines =<< trim END
2601 var flist: list<func>
2602 for i in range(5)
2603 var inloop = i
2604 flist[i] = () => {
2605 return inloop
2606 }
2607 endfor
2608 for i in range(5)
Bram Moolenaar353b68a2022-09-13 21:10:45 +01002609 assert_equal(i, flist[i]())
Bram Moolenaar2eb6fc32021-07-25 14:13:53 +02002610 endfor
2611 END
Bram Moolenaar0cdfb7c2022-09-17 15:44:52 +01002612 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaardbbb02b2022-09-18 12:00:21 +01002613
2614 # Also works for a nested loop
2615 lines =<< trim END
2616 var flist: list<func>
2617 var n = 0
2618 for i in range(3)
2619 var ii = i
2620 for a in ['a', 'b', 'c']
2621 var aa = a
2622 flist[n] = () => ii .. aa
2623 ++n
2624 endfor
2625 endfor
2626
2627 n = 0
2628 for i in range(3)
2629 for a in ['a', 'b', 'c']
2630 assert_equal(i .. a, flist[n]())
2631 ++n
2632 endfor
2633 endfor
2634 END
Bram Moolenaarcc341812022-09-19 15:54:34 +01002635 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaare8e369a2022-09-21 18:59:14 +01002636
2637 # using two loop variables
2638 lines =<< trim END
2639 var lv_list: list<func>
2640 var copy_list: list<func>
2641 for [idx, c] in items('word')
2642 var lidx = idx
2643 var lc = c
2644 lv_list[idx] = () => {
2645 return idx .. c
2646 }
2647 copy_list[idx] = () => {
2648 return lidx .. lc
2649 }
2650 endfor
2651 for [i, c] in items('word')
2652 assert_equal(3 .. 'd', lv_list[i]())
2653 assert_equal(i .. c, copy_list[i]())
2654 endfor
2655 END
2656 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarcc341812022-09-19 15:54:34 +01002657enddef
2658
2659def Test_define_global_closure_in_loops()
2660 var lines =<< trim END
2661 vim9script
2662
2663 def Func()
2664 for i in range(3)
2665 var ii = i
2666 for a in ['a', 'b', 'c']
2667 var aa = a
2668 if ii == 0 && aa == 'a'
2669 def g:Global_0a(): string
2670 return ii .. aa
2671 enddef
2672 endif
2673 if ii == 1 && aa == 'b'
2674 def g:Global_1b(): string
2675 return ii .. aa
2676 enddef
2677 endif
2678 if ii == 2 && aa == 'c'
2679 def g:Global_2c(): string
2680 return ii .. aa
2681 enddef
2682 endif
2683 endfor
2684 endfor
2685 enddef
2686 Func()
2687 END
2688 v9.CheckScriptSuccess(lines)
2689 assert_equal("0a", g:Global_0a())
2690 assert_equal("1b", g:Global_1b())
2691 assert_equal("2c", g:Global_2c())
2692
2693 delfunc g:Global_0a
2694 delfunc g:Global_1b
2695 delfunc g:Global_2c
Bram Moolenaar2eb6fc32021-07-25 14:13:53 +02002696enddef
2697
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02002698def Test_for_loop_fails()
Bram Moolenaar62aec932022-01-29 21:45:34 +00002699 v9.CheckDefAndScriptFailure(['for '], ['E1097:', 'E690:'])
2700 v9.CheckDefAndScriptFailure(['for x'], ['E1097:', 'E690:'])
2701 v9.CheckDefAndScriptFailure(['for x in'], ['E1097:', 'E15:'])
2702 v9.CheckDefAndScriptFailure(['for # in range(5)'], 'E690:')
2703 v9.CheckDefAndScriptFailure(['for i In range(5)'], 'E690:')
2704 v9.CheckDefAndScriptFailure(['var x = 5', 'for x in range(5)', 'endfor'], ['E1017:', 'E1041:'])
2705 v9.CheckScriptFailure(['vim9script', 'var x = 5', 'for x in range(5)', '# comment', 'endfor'], 'E1041:', 3)
2706 v9.CheckScriptFailure(['def Func(arg: any)', 'for arg in range(5)', 'enddef', 'defcompile'], 'E1006:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01002707 delfunc! g:Func
Bram Moolenaar62aec932022-01-29 21:45:34 +00002708 v9.CheckDefFailure(['for i in xxx'], 'E1001:')
2709 v9.CheckDefFailure(['endfor'], 'E588:')
2710 v9.CheckDefFailure(['for i in range(3)', 'echo 3'], 'E170:')
Bram Moolenaar74e54fc2021-03-26 20:41:29 +01002711
2712 # wrong type detected at compile time
Bram Moolenaar62aec932022-01-29 21:45:34 +00002713 v9.CheckDefFailure(['for i in {a: 1}', 'echo 3', 'endfor'], 'E1177: For loop on dict not supported')
Bram Moolenaar74e54fc2021-03-26 20:41:29 +01002714
2715 # wrong type detected at runtime
2716 g:adict = {a: 1}
Bram Moolenaar62aec932022-01-29 21:45:34 +00002717 v9.CheckDefExecFailure(['for i in g:adict', 'echo 3', 'endfor'], 'E1177: For loop on dict not supported')
Bram Moolenaar74e54fc2021-03-26 20:41:29 +01002718 unlet g:adict
Bram Moolenaarf6a8d422021-04-13 21:48:03 +02002719
2720 var lines =<< trim END
2721 var d: list<dict<any>> = [{a: 0}]
2722 for e in d
2723 e = {a: 0, b: ''}
2724 endfor
2725 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002726 v9.CheckDefAndScriptFailure(lines, ['E1018:', 'E46:'], 3)
Bram Moolenaarfe090eb2021-04-15 21:48:32 +02002727
2728 lines =<< trim END
2729 for nr: number in ['foo']
2730 endfor
2731 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002732 v9.CheckDefAndScriptFailure(lines, 'E1012: Type mismatch; expected number but got string', 1)
Bram Moolenaar404557e2021-07-05 21:41:48 +02002733
2734 lines =<< trim END
2735 for n : number in [1, 2]
2736 echo n
2737 endfor
2738 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002739 v9.CheckDefAndScriptFailure(lines, 'E1059:', 1)
Bram Moolenaarefc5db52021-07-07 21:21:30 +02002740
2741 lines =<< trim END
2742 var d: dict<number> = {a: 1, b: 2}
2743 for [k: job, v: job] in d->items()
2744 echo k v
2745 endfor
2746 END
Bram Moolenaarbd3a9d22022-05-17 16:12:39 +01002747 v9.CheckDefExecAndScriptFailure(lines, ['E1163: Variable 1: type mismatch, expected job but got string', 'E1012: Type mismatch; expected job but got string'], 2)
Bram Moolenaar3b3755f2021-11-22 20:10:18 +00002748
2749 lines =<< trim END
2750 var i = 0
2751 for i in [1, 2, 3]
2752 echo i
2753 endfor
2754 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002755 v9.CheckDefExecAndScriptFailure(lines, ['E1017:', 'E1041:'])
Bram Moolenaar3b3755f2021-11-22 20:10:18 +00002756
2757 lines =<< trim END
2758 var l = [0]
2759 for l[0] in [1, 2, 3]
2760 echo l[0]
2761 endfor
2762 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002763 v9.CheckDefExecAndScriptFailure(lines, ['E461:', 'E1017:'])
Bram Moolenaar3b3755f2021-11-22 20:10:18 +00002764
2765 lines =<< trim END
2766 var d = {x: 0}
2767 for d.x in [1, 2, 3]
2768 echo d.x
2769 endfor
2770 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002771 v9.CheckDefExecAndScriptFailure(lines, ['E461:', 'E1017:'])
Bram Moolenaara1c51952022-02-02 16:20:26 +00002772
2773 lines =<< trim END
2774 var l: list<dict<any>> = [{a: 1, b: 'x'}]
2775 for item: dict<number> in l
2776 echo item
2777 endfor
2778 END
2779 v9.CheckDefExecAndScriptFailure(lines, 'E1012: Type mismatch; expected dict<number> but got dict<any>')
2780
2781 lines =<< trim END
2782 var l: list<dict<any>> = [{n: 1}]
2783 for item: dict<number> in l
Bram Moolenaarfa103972022-09-29 19:14:42 +01002784 var d = {s: ''}
2785 d->extend(item)
Bram Moolenaara1c51952022-02-02 16:20:26 +00002786 endfor
2787 END
Bram Moolenaarfa103972022-09-29 19:14:42 +01002788 v9.CheckDefExecAndScriptFailure(lines, 'E1013: Argument 2: type mismatch, expected dict<string> but got dict<number>')
Bram Moolenaarcc341812022-09-19 15:54:34 +01002789
2790 lines =<< trim END
2791 for a in range(3)
2792 while a > 3
2793 for b in range(2)
2794 while b < 0
2795 for c in range(5)
2796 while c > 6
2797 while c < 0
2798 for d in range(1)
2799 for e in range(3)
2800 while e > 3
2801 endwhile
2802 endfor
2803 endfor
2804 endwhile
2805 endwhile
2806 endfor
2807 endwhile
2808 endfor
2809 endwhile
2810 endfor
2811 END
2812 v9.CheckDefSuccess(lines)
2813
2814 v9.CheckDefFailure(['for x in range(3)'] + lines + ['endfor'], 'E1306:')
Yegappan Lakshmanan062bb6b2023-12-16 14:46:40 +01002815
2816 # Test for too many for loops
2817 lines =<< trim END
2818 vim9script
2819 def Foo()
2820 for a in range(1)
2821 for b in range(1)
2822 for c in range(1)
2823 for d in range(1)
2824 for e in range(1)
2825 for f in range(1)
2826 for g in range(1)
2827 for h in range(1)
2828 for i in range(1)
2829 for j in range(1)
2830 for k in range(1)
2831 endfor
2832 endfor
2833 endfor
2834 endfor
2835 endfor
2836 endfor
2837 endfor
2838 endfor
2839 endfor
2840 endfor
2841 endfor
2842 enddef
2843 defcompile
2844 END
2845 v9.CheckSourceFailure(lines, 'E1306: Loop nesting too deep', 11)
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02002846enddef
2847
Bram Moolenaarea870692020-12-02 14:24:30 +01002848def Test_for_loop_script_var()
2849 # cannot use s:var in a :def function
Bram Moolenaar62aec932022-01-29 21:45:34 +00002850 v9.CheckDefFailure(['for s:var in range(3)', 'echo 3'], 'E1254:')
Bram Moolenaarea870692020-12-02 14:24:30 +01002851
2852 # can use s:var in Vim9 script, with or without s:
2853 var lines =<< trim END
2854 vim9script
2855 var total = 0
2856 for s:var in [1, 2, 3]
2857 total += s:var
2858 endfor
2859 assert_equal(6, total)
2860
2861 total = 0
2862 for var in [1, 2, 3]
2863 total += var
2864 endfor
2865 assert_equal(6, total)
2866 END
2867enddef
2868
Bram Moolenaar792f7862020-11-23 08:31:18 +01002869def Test_for_loop_unpack()
Bram Moolenaar792f7862020-11-23 08:31:18 +01002870 var lines =<< trim END
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01002871 var result = []
2872 for [v1, v2] in [[1, 2], [3, 4]]
2873 result->add(v1)
2874 result->add(v2)
2875 endfor
2876 assert_equal([1, 2, 3, 4], result)
2877
2878 result = []
2879 for [v1, v2; v3] in [[1, 2], [3, 4, 5, 6]]
2880 result->add(v1)
2881 result->add(v2)
2882 result->add(v3)
2883 endfor
2884 assert_equal([1, 2, [], 3, 4, [5, 6]], result)
2885
2886 result = []
2887 for [&ts, &sw] in [[1, 2], [3, 4]]
2888 result->add(&ts)
2889 result->add(&sw)
2890 endfor
2891 assert_equal([1, 2, 3, 4], result)
2892
2893 var slist: list<string>
2894 for [$LOOPVAR, @r, v:errmsg] in [['a', 'b', 'c'], ['d', 'e', 'f']]
2895 slist->add($LOOPVAR)
2896 slist->add(@r)
2897 slist->add(v:errmsg)
2898 endfor
2899 assert_equal(['a', 'b', 'c', 'd', 'e', 'f'], slist)
2900
2901 slist = []
2902 for [g:globalvar, b:bufvar, w:winvar, t:tabvar] in [['global', 'buf', 'win', 'tab'], ['1', '2', '3', '4']]
2903 slist->add(g:globalvar)
2904 slist->add(b:bufvar)
2905 slist->add(w:winvar)
2906 slist->add(t:tabvar)
2907 endfor
2908 assert_equal(['global', 'buf', 'win', 'tab', '1', '2', '3', '4'], slist)
Bram Moolenaarf6c177a2020-12-04 17:38:00 +01002909 unlet! g:globalvar b:bufvar w:winvar t:tabvar
Bram Moolenaarb777da92021-05-22 21:40:39 +02002910
2911 var res = []
2912 for [_, n, _] in [[1, 2, 3], [4, 5, 6]]
2913 res->add(n)
2914 endfor
2915 assert_equal([2, 5], res)
Bram Moolenaar61efa162022-03-18 13:10:48 +00002916
2917 var text: list<string> = ["hello there", "goodbye now"]
2918 var splitted = ''
2919 for [first; next] in mapnew(text, (i, v) => split(v))
2920 splitted ..= string(first) .. string(next) .. '/'
2921 endfor
2922 assert_equal("'hello'['there']/'goodbye'['now']/", splitted)
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01002923 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002924 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar4b8a0652020-12-01 16:30:44 +01002925
2926 lines =<< trim END
Bram Moolenaar792f7862020-11-23 08:31:18 +01002927 for [v1, v2] in [[1, 2, 3], [3, 4]]
2928 echo v1 v2
2929 endfor
2930 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002931 v9.CheckDefExecFailure(lines, 'E710:', 1)
Bram Moolenaar792f7862020-11-23 08:31:18 +01002932
2933 lines =<< trim END
2934 for [v1, v2] in [[1], [3, 4]]
2935 echo v1 v2
2936 endfor
2937 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002938 v9.CheckDefExecFailure(lines, 'E711:', 1)
Bram Moolenaar792f7862020-11-23 08:31:18 +01002939
2940 lines =<< trim END
2941 for [v1, v1] in [[1, 2], [3, 4]]
2942 echo v1
2943 endfor
2944 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002945 v9.CheckDefExecFailure(lines, 'E1017:', 1)
Bram Moolenaar95e4dd82022-04-27 22:15:40 +01002946
2947 lines =<< trim END
2948 for [a, b] in g:listlist
2949 echo a
2950 endfor
2951 END
2952 g:listlist = [1, 2, 3]
2953 v9.CheckDefExecFailure(lines, 'E1140:', 1)
Bram Moolenaar792f7862020-11-23 08:31:18 +01002954enddef
2955
Bram Moolenaarc150c092021-02-13 15:02:46 +01002956def Test_for_loop_with_try_continue()
Bram Moolenaarf2253962021-04-13 20:53:13 +02002957 var lines =<< trim END
2958 var looped = 0
2959 var cleanup = 0
2960 for i in range(3)
2961 looped += 1
2962 try
2963 eval [][0]
2964 catch
2965 continue
2966 finally
2967 cleanup += 1
2968 endtry
2969 endfor
2970 assert_equal(3, looped)
2971 assert_equal(3, cleanup)
2972 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002973 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarc150c092021-02-13 15:02:46 +01002974enddef
2975
rbtnnd895b1d2021-08-20 20:54:25 +02002976def Test_while_skipped_block()
2977 # test skipped blocks at outside of function
2978 var lines =<< trim END
2979 var result = []
2980 var n = 0
2981 if true
2982 n = 1
2983 while n < 3
2984 result += [n]
2985 n += 1
2986 endwhile
2987 else
2988 n = 3
2989 while n < 5
2990 result += [n]
2991 n += 1
2992 endwhile
2993 endif
2994 assert_equal([1, 2], result)
2995
2996 result = []
2997 if false
2998 n = 1
2999 while n < 3
3000 result += [n]
3001 n += 1
3002 endwhile
3003 else
3004 n = 3
3005 while n < 5
3006 result += [n]
3007 n += 1
3008 endwhile
3009 endif
3010 assert_equal([3, 4], result)
3011 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003012 v9.CheckDefAndScriptSuccess(lines)
rbtnnd895b1d2021-08-20 20:54:25 +02003013
3014 # test skipped blocks at inside of function
3015 lines =<< trim END
3016 def DefTrue()
3017 var result = []
3018 var n = 0
3019 if true
3020 n = 1
3021 while n < 3
3022 result += [n]
3023 n += 1
3024 endwhile
3025 else
3026 n = 3
3027 while n < 5
3028 result += [n]
3029 n += 1
3030 endwhile
3031 endif
3032 assert_equal([1, 2], result)
3033 enddef
3034 DefTrue()
3035
3036 def DefFalse()
3037 var result = []
3038 var n = 0
3039 if false
3040 n = 1
3041 while n < 3
3042 result += [n]
3043 n += 1
3044 endwhile
3045 else
3046 n = 3
3047 while n < 5
3048 result += [n]
3049 n += 1
3050 endwhile
3051 endif
3052 assert_equal([3, 4], result)
3053 enddef
3054 DefFalse()
3055 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003056 v9.CheckDefAndScriptSuccess(lines)
rbtnnd895b1d2021-08-20 20:54:25 +02003057enddef
3058
Bram Moolenaard0df1aa2020-03-04 21:50:46 +01003059def Test_while_loop()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003060 var result = ''
3061 var cnt = 0
Bram Moolenaard0df1aa2020-03-04 21:50:46 +01003062 while cnt < 555
3063 if cnt == 3
3064 break
3065 endif
3066 cnt += 1
3067 if cnt == 2
3068 continue
3069 endif
3070 result ..= cnt .. '_'
3071 endwhile
3072 assert_equal('1_3_', result)
Bram Moolenaardee37dc2021-02-07 16:40:05 +01003073
3074 var s = ''
Bram Moolenaar4b3e1962021-03-18 21:37:55 +01003075 while s == 'x' # {comment}
Bram Moolenaardee37dc2021-02-07 16:40:05 +01003076 endwhile
Bram Moolenaard0df1aa2020-03-04 21:50:46 +01003077enddef
3078
Bram Moolenaar7a53f292021-11-22 18:31:02 +00003079def Test_while_loop_in_script()
3080 var lines =<< trim END
3081 vim9script
3082 var result = ''
3083 var cnt = 0
3084 while cnt < 3
3085 var s = 'v' .. cnt
3086 result ..= s
3087 cnt += 1
3088 endwhile
3089 assert_equal('v0v1v2', result)
3090 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003091 v9.CheckScriptSuccess(lines)
Bram Moolenaar7a53f292021-11-22 18:31:02 +00003092enddef
3093
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02003094def Test_while_loop_fails()
Bram Moolenaar62aec932022-01-29 21:45:34 +00003095 v9.CheckDefFailure(['while xxx'], 'E1001:')
3096 v9.CheckDefFailure(['endwhile'], 'E588:')
3097 v9.CheckDefFailure(['continue'], 'E586:')
3098 v9.CheckDefFailure(['if true', 'continue'], 'E586:')
3099 v9.CheckDefFailure(['break'], 'E587:')
3100 v9.CheckDefFailure(['if true', 'break'], 'E587:')
3101 v9.CheckDefFailure(['while 1', 'echo 3'], 'E170:')
Bram Moolenaar6628b7e2021-02-07 16:33:35 +01003102
3103 var lines =<< trim END
3104 var s = ''
3105 while s = ''
3106 endwhile
3107 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003108 v9.CheckDefFailure(lines, 'E488:')
Bram Moolenaarbd5da372020-03-31 23:13:10 +02003109enddef
3110
Bram Moolenaar9645e2d2020-03-20 20:48:49 +01003111def Test_interrupt_loop()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003112 var caught = false
3113 var x = 0
Bram Moolenaar97acfc72020-03-22 13:44:28 +01003114 try
3115 while 1
3116 x += 1
3117 if x == 100
3118 feedkeys("\<C-C>", 'Lt')
3119 endif
3120 endwhile
3121 catch
3122 caught = true
3123 assert_equal(100, x)
3124 endtry
3125 assert_true(caught, 'should have caught an exception')
Bram Moolenaar25859dd2020-08-30 12:54:53 +02003126 # consume the CTRL-C
3127 getchar(0)
Bram Moolenaar9645e2d2020-03-20 20:48:49 +01003128enddef
Bram Moolenaar20431c92020-03-20 18:39:46 +01003129
Bram Moolenaar4fdae992020-04-12 16:38:57 +02003130def Test_automatic_line_continuation()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003131 var mylist = [
Bram Moolenaar4fdae992020-04-12 16:38:57 +02003132 'one',
3133 'two',
3134 'three',
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02003135 ] # comment
Bram Moolenaar4fdae992020-04-12 16:38:57 +02003136 assert_equal(['one', 'two', 'three'], mylist)
3137
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003138 var mydict = {
Bram Moolenaare0de1712020-12-02 17:36:54 +01003139 ['one']: 1,
3140 ['two']: 2,
3141 ['three']:
Bram Moolenaar4fdae992020-04-12 16:38:57 +02003142 3,
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02003143 } # comment
Bram Moolenaare0de1712020-12-02 17:36:54 +01003144 assert_equal({one: 1, two: 2, three: 3}, mydict)
3145 mydict = {
Bram Moolenaar2c330432020-04-13 14:41:35 +02003146 one: 1, # comment
3147 two: # comment
3148 2, # comment
3149 three: 3 # comment
3150 }
Bram Moolenaare0de1712020-12-02 17:36:54 +01003151 assert_equal({one: 1, two: 2, three: 3}, mydict)
3152 mydict = {
Bram Moolenaar2c330432020-04-13 14:41:35 +02003153 one: 1,
3154 two:
3155 2,
3156 three: 3
Bram Moolenaar4fdae992020-04-12 16:38:57 +02003157 }
Bram Moolenaare0de1712020-12-02 17:36:54 +01003158 assert_equal({one: 1, two: 2, three: 3}, mydict)
Bram Moolenaare6085c52020-04-12 20:19:16 +02003159
3160 assert_equal(
3161 ['one', 'two', 'three'],
3162 split('one two three')
3163 )
Bram Moolenaar4fdae992020-04-12 16:38:57 +02003164enddef
3165
Bram Moolenaar7a092242020-04-16 22:10:49 +02003166def Test_vim9_comment()
Bram Moolenaar62aec932022-01-29 21:45:34 +00003167 v9.CheckScriptSuccess([
Bram Moolenaar7a092242020-04-16 22:10:49 +02003168 'vim9script',
3169 '# something',
Bram Moolenaar93f82cb2020-12-12 21:25:56 +01003170 '#something',
Bram Moolenaar3f74c0a2022-08-06 18:12:06 +01003171 '#{{something',
Bram Moolenaar7a092242020-04-16 22:10:49 +02003172 ])
Bram Moolenaar3f74c0a2022-08-06 18:12:06 +01003173 v9.CheckScriptFailure([
3174 'vim9script',
3175 '#{something',
3176 ], 'E1170:')
Bram Moolenaar93f82cb2020-12-12 21:25:56 +01003177
Bram Moolenaarb18b4962022-09-02 21:55:50 +01003178 split Xv9cfile
Bram Moolenaar62aec932022-01-29 21:45:34 +00003179 v9.CheckScriptSuccess([
Bram Moolenaar93f82cb2020-12-12 21:25:56 +01003180 'vim9script',
3181 'edit #something',
3182 ])
Bram Moolenaar62aec932022-01-29 21:45:34 +00003183 v9.CheckScriptSuccess([
Bram Moolenaar93f82cb2020-12-12 21:25:56 +01003184 'vim9script',
3185 'edit #{something',
3186 ])
3187 close
3188
Bram Moolenaar62aec932022-01-29 21:45:34 +00003189 v9.CheckScriptFailure([
Bram Moolenaar7a092242020-04-16 22:10:49 +02003190 'vim9script',
3191 ':# something',
3192 ], 'E488:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00003193 v9.CheckScriptFailure([
Bram Moolenaar7a092242020-04-16 22:10:49 +02003194 '# something',
3195 ], 'E488:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00003196 v9.CheckScriptFailure([
Bram Moolenaar7a092242020-04-16 22:10:49 +02003197 ':# something',
3198 ], 'E488:')
3199
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02003200 { # block start
3201 } # block end
Bram Moolenaar62aec932022-01-29 21:45:34 +00003202 v9.CheckDefFailure([
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02003203 '{# comment',
3204 ], 'E488:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00003205 v9.CheckDefFailure([
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02003206 '{',
3207 '}# comment',
3208 ], 'E488:')
3209
3210 echo "yes" # comment
Bram Moolenaar62aec932022-01-29 21:45:34 +00003211 v9.CheckDefFailure([
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02003212 'echo "yes"# comment',
3213 ], 'E488:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00003214 v9.CheckScriptSuccess([
Bram Moolenaar7a092242020-04-16 22:10:49 +02003215 'vim9script',
3216 'echo "yes" # something',
3217 ])
Bram Moolenaar62aec932022-01-29 21:45:34 +00003218 v9.CheckScriptFailure([
Bram Moolenaar7a092242020-04-16 22:10:49 +02003219 'vim9script',
3220 'echo "yes"# something',
3221 ], 'E121:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00003222 v9.CheckScriptFailure([
Bram Moolenaar7a092242020-04-16 22:10:49 +02003223 'vim9script',
3224 'echo# something',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01003225 ], 'E1144:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00003226 v9.CheckScriptFailure([
Bram Moolenaar7a092242020-04-16 22:10:49 +02003227 'echo "yes" # something',
3228 ], 'E121:')
3229
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02003230 exe "echo" # comment
Bram Moolenaar62aec932022-01-29 21:45:34 +00003231 v9.CheckDefFailure([
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02003232 'exe "echo"# comment',
3233 ], 'E488:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00003234 v9.CheckScriptSuccess([
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02003235 'vim9script',
3236 'exe "echo" # something',
3237 ])
Bram Moolenaar62aec932022-01-29 21:45:34 +00003238 v9.CheckScriptFailure([
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02003239 'vim9script',
3240 'exe "echo"# something',
3241 ], 'E121:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00003242 v9.CheckScriptFailure([
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02003243 'vim9script',
3244 'exe# something',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01003245 ], 'E1144:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00003246 v9.CheckScriptFailure([
Bram Moolenaar4a8d9f22020-04-16 22:54:32 +02003247 'exe "echo" # something',
3248 ], 'E121:')
3249
Bram Moolenaar62aec932022-01-29 21:45:34 +00003250 v9.CheckDefFailure([
Bram Moolenaar7a092242020-04-16 22:10:49 +02003251 'try# comment',
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02003252 ' echo "yes"',
Bram Moolenaar7a092242020-04-16 22:10:49 +02003253 'catch',
3254 'endtry',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01003255 ], 'E1144:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00003256 v9.CheckScriptFailure([
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02003257 'vim9script',
3258 'try# comment',
3259 'echo "yes"',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01003260 ], 'E1144:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00003261 v9.CheckDefFailure([
Bram Moolenaar7a092242020-04-16 22:10:49 +02003262 'try',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02003263 ' throw#comment',
3264 'catch',
3265 'endtry',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01003266 ], 'E1144:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00003267 v9.CheckDefFailure([
Bram Moolenaara72cfb82020-04-23 17:07:30 +02003268 'try',
3269 ' throw "yes"#comment',
3270 'catch',
3271 'endtry',
3272 ], 'E488:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00003273 v9.CheckDefFailure([
Bram Moolenaara72cfb82020-04-23 17:07:30 +02003274 'try',
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02003275 ' echo "yes"',
Bram Moolenaar7a092242020-04-16 22:10:49 +02003276 'catch# comment',
3277 'endtry',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01003278 ], 'E1144:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00003279 v9.CheckScriptFailure([
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02003280 'vim9script',
3281 'try',
3282 ' echo "yes"',
3283 'catch# comment',
3284 'endtry',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01003285 ], 'E1144:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00003286 v9.CheckDefFailure([
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02003287 'try',
3288 ' echo "yes"',
3289 'catch /pat/# comment',
3290 'endtry',
3291 ], 'E488:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00003292 v9.CheckDefFailure([
Bram Moolenaar7a092242020-04-16 22:10:49 +02003293 'try',
3294 'echo "yes"',
3295 'catch',
3296 'endtry# comment',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01003297 ], 'E1144:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00003298 v9.CheckScriptFailure([
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02003299 'vim9script',
3300 'try',
3301 ' echo "yes"',
3302 'catch',
3303 'endtry# comment',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01003304 ], 'E1144:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02003305
Bram Moolenaar62aec932022-01-29 21:45:34 +00003306 v9.CheckScriptSuccess([
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02003307 'vim9script',
3308 'hi # comment',
3309 ])
Bram Moolenaar62aec932022-01-29 21:45:34 +00003310 v9.CheckScriptFailure([
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02003311 'vim9script',
3312 'hi# comment',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01003313 ], 'E1144:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00003314 v9.CheckScriptSuccess([
Bram Moolenaar1966c242020-04-20 22:42:32 +02003315 'vim9script',
3316 'hi Search # comment',
3317 ])
Bram Moolenaar62aec932022-01-29 21:45:34 +00003318 v9.CheckScriptFailure([
Bram Moolenaar1966c242020-04-20 22:42:32 +02003319 'vim9script',
3320 'hi Search# comment',
3321 ], 'E416:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00003322 v9.CheckScriptSuccess([
Bram Moolenaar1966c242020-04-20 22:42:32 +02003323 'vim9script',
3324 'hi link This Search # comment',
3325 ])
Bram Moolenaar62aec932022-01-29 21:45:34 +00003326 v9.CheckScriptFailure([
Bram Moolenaar1966c242020-04-20 22:42:32 +02003327 'vim9script',
3328 'hi link This That# comment',
3329 ], 'E413:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00003330 v9.CheckScriptSuccess([
Bram Moolenaar1966c242020-04-20 22:42:32 +02003331 'vim9script',
3332 'hi clear This # comment',
3333 'hi clear # comment',
3334 ])
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02003335 # not tested, because it doesn't give an error but a warning:
3336 # hi clear This# comment',
Bram Moolenaar62aec932022-01-29 21:45:34 +00003337 v9.CheckScriptFailure([
Bram Moolenaar1966c242020-04-20 22:42:32 +02003338 'vim9script',
3339 'hi clear# comment',
3340 ], 'E416:')
3341
Bram Moolenaar62aec932022-01-29 21:45:34 +00003342 v9.CheckScriptSuccess([
Bram Moolenaar1966c242020-04-20 22:42:32 +02003343 'vim9script',
3344 'hi Group term=bold',
3345 'match Group /todo/ # comment',
3346 ])
Bram Moolenaar62aec932022-01-29 21:45:34 +00003347 v9.CheckScriptFailure([
Bram Moolenaar1966c242020-04-20 22:42:32 +02003348 'vim9script',
3349 'hi Group term=bold',
3350 'match Group /todo/# comment',
3351 ], 'E488:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00003352 v9.CheckScriptSuccess([
Bram Moolenaar1966c242020-04-20 22:42:32 +02003353 'vim9script',
3354 'match # comment',
3355 ])
Bram Moolenaar62aec932022-01-29 21:45:34 +00003356 v9.CheckScriptFailure([
Bram Moolenaar1966c242020-04-20 22:42:32 +02003357 'vim9script',
3358 'match# comment',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01003359 ], 'E1144:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00003360 v9.CheckScriptSuccess([
Bram Moolenaar1966c242020-04-20 22:42:32 +02003361 'vim9script',
3362 'match none # comment',
3363 ])
Bram Moolenaar62aec932022-01-29 21:45:34 +00003364 v9.CheckScriptFailure([
Bram Moolenaar1966c242020-04-20 22:42:32 +02003365 'vim9script',
3366 'match none# comment',
3367 ], 'E475:')
3368
Bram Moolenaar62aec932022-01-29 21:45:34 +00003369 v9.CheckScriptSuccess([
Bram Moolenaar1966c242020-04-20 22:42:32 +02003370 'vim9script',
3371 'menutrans clear # comment',
3372 ])
Bram Moolenaar62aec932022-01-29 21:45:34 +00003373 v9.CheckScriptFailure([
Bram Moolenaar1966c242020-04-20 22:42:32 +02003374 'vim9script',
3375 'menutrans clear# comment text',
3376 ], 'E474:')
3377
Bram Moolenaar62aec932022-01-29 21:45:34 +00003378 v9.CheckScriptSuccess([
Bram Moolenaar1966c242020-04-20 22:42:32 +02003379 'vim9script',
3380 'syntax clear # comment',
3381 ])
Bram Moolenaar62aec932022-01-29 21:45:34 +00003382 v9.CheckScriptFailure([
Bram Moolenaar1966c242020-04-20 22:42:32 +02003383 'vim9script',
3384 'syntax clear# comment text',
3385 ], 'E28:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00003386 v9.CheckScriptSuccess([
Bram Moolenaar1966c242020-04-20 22:42:32 +02003387 'vim9script',
3388 'syntax keyword Word some',
3389 'syntax clear Word # comment',
3390 ])
Bram Moolenaar62aec932022-01-29 21:45:34 +00003391 v9.CheckScriptFailure([
Bram Moolenaar1966c242020-04-20 22:42:32 +02003392 'vim9script',
3393 'syntax keyword Word some',
3394 'syntax clear Word# comment text',
3395 ], 'E28:')
3396
Bram Moolenaar62aec932022-01-29 21:45:34 +00003397 v9.CheckScriptSuccess([
Bram Moolenaar1966c242020-04-20 22:42:32 +02003398 'vim9script',
3399 'syntax list # comment',
3400 ])
Bram Moolenaar62aec932022-01-29 21:45:34 +00003401 v9.CheckScriptFailure([
Bram Moolenaar1966c242020-04-20 22:42:32 +02003402 'vim9script',
3403 'syntax list# comment text',
3404 ], 'E28:')
3405
Bram Moolenaar62aec932022-01-29 21:45:34 +00003406 v9.CheckScriptSuccess([
Bram Moolenaar1966c242020-04-20 22:42:32 +02003407 'vim9script',
3408 'syntax match Word /pat/ oneline # comment',
3409 ])
Bram Moolenaar62aec932022-01-29 21:45:34 +00003410 v9.CheckScriptFailure([
Bram Moolenaar1966c242020-04-20 22:42:32 +02003411 'vim9script',
3412 'syntax match Word /pat/ oneline# comment',
3413 ], 'E475:')
3414
Bram Moolenaar62aec932022-01-29 21:45:34 +00003415 v9.CheckScriptSuccess([
Bram Moolenaar1966c242020-04-20 22:42:32 +02003416 'vim9script',
3417 'syntax keyword Word word # comm[ent',
3418 ])
Bram Moolenaar62aec932022-01-29 21:45:34 +00003419 v9.CheckScriptFailure([
Bram Moolenaar1966c242020-04-20 22:42:32 +02003420 'vim9script',
3421 'syntax keyword Word word# comm[ent',
3422 ], 'E789:')
3423
Bram Moolenaar62aec932022-01-29 21:45:34 +00003424 v9.CheckScriptSuccess([
Bram Moolenaar1966c242020-04-20 22:42:32 +02003425 'vim9script',
3426 'syntax match Word /pat/ # comment',
3427 ])
Bram Moolenaar62aec932022-01-29 21:45:34 +00003428 v9.CheckScriptFailure([
Bram Moolenaar1966c242020-04-20 22:42:32 +02003429 'vim9script',
3430 'syntax match Word /pat/# comment',
3431 ], 'E402:')
3432
Bram Moolenaar62aec932022-01-29 21:45:34 +00003433 v9.CheckScriptSuccess([
Bram Moolenaar1966c242020-04-20 22:42:32 +02003434 'vim9script',
3435 'syntax match Word /pat/ contains=Something # comment',
3436 ])
Bram Moolenaar62aec932022-01-29 21:45:34 +00003437 v9.CheckScriptFailure([
Bram Moolenaar1966c242020-04-20 22:42:32 +02003438 'vim9script',
3439 'syntax match Word /pat/ contains=Something# comment',
3440 ], 'E475:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00003441 v9.CheckScriptFailure([
Bram Moolenaar1966c242020-04-20 22:42:32 +02003442 'vim9script',
3443 'syntax match Word /pat/ contains= # comment',
3444 ], 'E406:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00003445 v9.CheckScriptFailure([
Bram Moolenaar1966c242020-04-20 22:42:32 +02003446 'vim9script',
3447 'syntax match Word /pat/ contains=# comment',
3448 ], 'E475:')
3449
Bram Moolenaar62aec932022-01-29 21:45:34 +00003450 v9.CheckScriptSuccess([
Bram Moolenaar1966c242020-04-20 22:42:32 +02003451 'vim9script',
3452 'syntax region Word start=/pat/ end=/pat/ # comment',
3453 ])
Bram Moolenaar62aec932022-01-29 21:45:34 +00003454 v9.CheckScriptFailure([
Bram Moolenaar1966c242020-04-20 22:42:32 +02003455 'vim9script',
3456 'syntax region Word start=/pat/ end=/pat/# comment',
Bram Moolenaard032f342020-07-18 18:13:02 +02003457 ], 'E402:')
Bram Moolenaar1966c242020-04-20 22:42:32 +02003458
Bram Moolenaar62aec932022-01-29 21:45:34 +00003459 v9.CheckScriptSuccess([
Bram Moolenaar1966c242020-04-20 22:42:32 +02003460 'vim9script',
3461 'syntax sync # comment',
3462 ])
Bram Moolenaar62aec932022-01-29 21:45:34 +00003463 v9.CheckScriptFailure([
Bram Moolenaar1966c242020-04-20 22:42:32 +02003464 'vim9script',
3465 'syntax sync# comment',
3466 ], 'E404:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00003467 v9.CheckScriptSuccess([
Bram Moolenaar1966c242020-04-20 22:42:32 +02003468 'vim9script',
3469 'syntax sync ccomment # comment',
3470 ])
Bram Moolenaar62aec932022-01-29 21:45:34 +00003471 v9.CheckScriptFailure([
Bram Moolenaar1966c242020-04-20 22:42:32 +02003472 'vim9script',
3473 'syntax sync ccomment# comment',
3474 ], 'E404:')
3475
Bram Moolenaar62aec932022-01-29 21:45:34 +00003476 v9.CheckScriptSuccess([
Bram Moolenaar1966c242020-04-20 22:42:32 +02003477 'vim9script',
3478 'syntax cluster Some contains=Word # comment',
3479 ])
Bram Moolenaar62aec932022-01-29 21:45:34 +00003480 v9.CheckScriptFailure([
Bram Moolenaar1966c242020-04-20 22:42:32 +02003481 'vim9script',
3482 'syntax cluster Some contains=Word# comment',
3483 ], 'E475:')
Bram Moolenaara72cfb82020-04-23 17:07:30 +02003484
Bram Moolenaar62aec932022-01-29 21:45:34 +00003485 v9.CheckScriptSuccess([
Bram Moolenaara72cfb82020-04-23 17:07:30 +02003486 'vim9script',
3487 'command Echo echo # comment',
3488 'command Echo # comment',
Bram Moolenaar2d870f82020-12-05 13:41:01 +01003489 'delcommand Echo',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02003490 ])
Bram Moolenaar62aec932022-01-29 21:45:34 +00003491 v9.CheckScriptFailure([
Bram Moolenaara72cfb82020-04-23 17:07:30 +02003492 'vim9script',
3493 'command Echo echo# comment',
3494 'Echo',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01003495 ], 'E1144:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01003496 delcommand Echo
Bram Moolenaar70249ee2020-12-10 21:01:30 +01003497
3498 var curdir = getcwd()
Bram Moolenaar62aec932022-01-29 21:45:34 +00003499 v9.CheckScriptSuccess([
Bram Moolenaar70249ee2020-12-10 21:01:30 +01003500 'command Echo cd " comment',
3501 'Echo',
3502 'delcommand Echo',
3503 ])
Bram Moolenaar62aec932022-01-29 21:45:34 +00003504 v9.CheckScriptSuccess([
Bram Moolenaar090728a2020-12-20 15:43:31 +01003505 'vim9script',
Bram Moolenaar70249ee2020-12-10 21:01:30 +01003506 'command Echo cd # comment',
3507 'Echo',
3508 'delcommand Echo',
3509 ])
Bram Moolenaar62aec932022-01-29 21:45:34 +00003510 v9.CheckScriptFailure([
Bram Moolenaar70249ee2020-12-10 21:01:30 +01003511 'vim9script',
3512 'command Echo cd " comment',
3513 'Echo',
3514 ], 'E344:')
3515 delcommand Echo
3516 chdir(curdir)
3517
Bram Moolenaar62aec932022-01-29 21:45:34 +00003518 v9.CheckScriptFailure([
Bram Moolenaara72cfb82020-04-23 17:07:30 +02003519 'vim9script',
3520 'command Echo# comment',
3521 ], 'E182:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00003522 v9.CheckScriptFailure([
Bram Moolenaara72cfb82020-04-23 17:07:30 +02003523 'vim9script',
3524 'command Echo echo',
3525 'command Echo# comment',
3526 ], 'E182:')
Bram Moolenaar2d870f82020-12-05 13:41:01 +01003527 delcommand Echo
Bram Moolenaara72cfb82020-04-23 17:07:30 +02003528
Bram Moolenaar62aec932022-01-29 21:45:34 +00003529 v9.CheckScriptSuccess([
Bram Moolenaara72cfb82020-04-23 17:07:30 +02003530 'vim9script',
3531 'function # comment',
3532 ])
Bram Moolenaar62aec932022-01-29 21:45:34 +00003533 v9.CheckScriptFailure([
Bram Moolenaara72cfb82020-04-23 17:07:30 +02003534 'vim9script',
Bram Moolenaar98981072020-07-29 14:40:25 +02003535 'function " comment',
3536 ], 'E129:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00003537 v9.CheckScriptFailure([
Bram Moolenaar98981072020-07-29 14:40:25 +02003538 'vim9script',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02003539 'function# comment',
Bram Moolenaarf8103f22020-12-25 17:36:27 +01003540 ], 'E1144:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00003541 v9.CheckScriptSuccess([
Bram Moolenaara72cfb82020-04-23 17:07:30 +02003542 'vim9script',
Bram Moolenaar62aec932022-01-29 21:45:34 +00003543 'import "./vim9.vim" as v9',
3544 'function v9.CheckScriptSuccess # comment',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02003545 ])
Bram Moolenaar62aec932022-01-29 21:45:34 +00003546 v9.CheckScriptFailure([
Bram Moolenaara72cfb82020-04-23 17:07:30 +02003547 'vim9script',
Bram Moolenaar62aec932022-01-29 21:45:34 +00003548 'import "./vim9.vim" as v9',
3549 'function v9.CheckScriptSuccess# comment',
3550 ], 'E1048: Item not found in script: CheckScriptSuccess#')
Bram Moolenaara72cfb82020-04-23 17:07:30 +02003551
Bram Moolenaar62aec932022-01-29 21:45:34 +00003552 v9.CheckScriptSuccess([
Bram Moolenaara72cfb82020-04-23 17:07:30 +02003553 'vim9script',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02003554 'func g:DeleteMeA()',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02003555 'endfunc',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02003556 'delfunction g:DeleteMeA # comment',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02003557 ])
Bram Moolenaar62aec932022-01-29 21:45:34 +00003558 v9.CheckScriptFailure([
Bram Moolenaara72cfb82020-04-23 17:07:30 +02003559 'vim9script',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02003560 'func g:DeleteMeB()',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02003561 'endfunc',
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02003562 'delfunction g:DeleteMeB# comment',
Bram Moolenaara72cfb82020-04-23 17:07:30 +02003563 ], 'E488:')
3564
Bram Moolenaar62aec932022-01-29 21:45:34 +00003565 v9.CheckScriptSuccess([
Bram Moolenaara72cfb82020-04-23 17:07:30 +02003566 'vim9script',
3567 'call execute("ls") # comment',
3568 ])
Bram Moolenaar62aec932022-01-29 21:45:34 +00003569 v9.CheckScriptFailure([
Bram Moolenaara72cfb82020-04-23 17:07:30 +02003570 'vim9script',
3571 'call execute("ls")# comment',
3572 ], 'E488:')
Bram Moolenaare7e48382020-07-22 18:17:08 +02003573
Bram Moolenaar62aec932022-01-29 21:45:34 +00003574 v9.CheckScriptFailure([
Bram Moolenaare7e48382020-07-22 18:17:08 +02003575 'def Test() " comment',
3576 'enddef',
3577 ], 'E488:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00003578 v9.CheckScriptFailure([
Bram Moolenaare7e48382020-07-22 18:17:08 +02003579 'vim9script',
3580 'def Test() " comment',
3581 'enddef',
3582 ], 'E488:')
3583
Bram Moolenaar62aec932022-01-29 21:45:34 +00003584 v9.CheckScriptSuccess([
Bram Moolenaare7e48382020-07-22 18:17:08 +02003585 'func Test() " comment',
3586 'endfunc',
Bram Moolenaar2d870f82020-12-05 13:41:01 +01003587 'delfunc Test',
Bram Moolenaare7e48382020-07-22 18:17:08 +02003588 ])
Bram Moolenaar62aec932022-01-29 21:45:34 +00003589 v9.CheckScriptSuccess([
Bram Moolenaare7e48382020-07-22 18:17:08 +02003590 'vim9script',
3591 'func Test() " comment',
3592 'endfunc',
Bram Moolenaar98981072020-07-29 14:40:25 +02003593 ])
Bram Moolenaare7e48382020-07-22 18:17:08 +02003594
Bram Moolenaar62aec932022-01-29 21:45:34 +00003595 v9.CheckScriptSuccess([
Bram Moolenaare7e48382020-07-22 18:17:08 +02003596 'def Test() # comment',
3597 'enddef',
3598 ])
Bram Moolenaar62aec932022-01-29 21:45:34 +00003599 v9.CheckScriptFailure([
Bram Moolenaare7e48382020-07-22 18:17:08 +02003600 'func Test() # comment',
3601 'endfunc',
3602 ], 'E488:')
Bram Moolenaar0f37e352021-06-02 15:28:15 +02003603
3604 var lines =<< trim END
3605 vim9script
3606 syn region Text
3607 \ start='foo'
3608 #\ comment
3609 \ end='bar'
Bram Moolenaar5072b472021-06-03 21:56:10 +02003610 syn region Text start='foo'
3611 #\ comment
3612 \ end='bar'
Bram Moolenaar0f37e352021-06-02 15:28:15 +02003613 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003614 v9.CheckScriptSuccess(lines)
Bram Moolenaar0f37e352021-06-02 15:28:15 +02003615
3616 lines =<< trim END
3617 vim9script
3618 syn region Text
3619 \ start='foo'
3620 "\ comment
3621 \ end='bar'
3622 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003623 v9.CheckScriptFailure(lines, 'E399:')
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02003624enddef
3625
3626def Test_vim9_comment_gui()
3627 CheckCanRunGui
3628
Bram Moolenaar62aec932022-01-29 21:45:34 +00003629 v9.CheckScriptFailure([
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02003630 'vim9script',
3631 'gui#comment'
Bram Moolenaarf8103f22020-12-25 17:36:27 +01003632 ], 'E1144:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00003633 v9.CheckScriptFailure([
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02003634 'vim9script',
3635 'gui -f#comment'
Bram Moolenaarb8bd2e62021-08-21 17:13:14 +02003636 ], 'E194:')
Bram Moolenaar7a092242020-04-16 22:10:49 +02003637enddef
3638
Bram Moolenaara26b9702020-04-18 19:53:28 +02003639def Test_vim9_comment_not_compiled()
Bram Moolenaar67979662020-06-20 22:50:47 +02003640 au TabEnter *.vim g:entered = 1
3641 au TabEnter *.x g:entered = 2
Bram Moolenaara26b9702020-04-18 19:53:28 +02003642
3643 edit test.vim
3644 doautocmd TabEnter #comment
3645 assert_equal(1, g:entered)
3646
3647 doautocmd TabEnter f.x
3648 assert_equal(2, g:entered)
3649
3650 g:entered = 0
3651 doautocmd TabEnter f.x #comment
3652 assert_equal(2, g:entered)
3653
3654 assert_fails('doautocmd Syntax#comment', 'E216:')
3655
3656 au! TabEnter
3657 unlet g:entered
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02003658
Bram Moolenaar62aec932022-01-29 21:45:34 +00003659 v9.CheckScriptSuccess([
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02003660 'vim9script',
Bram Moolenaar67979662020-06-20 22:50:47 +02003661 'g:var = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02003662 'b:var = 456',
3663 'w:var = 777',
3664 't:var = 888',
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02003665 'unlet g:var w:var # something',
3666 ])
3667
Bram Moolenaar62aec932022-01-29 21:45:34 +00003668 v9.CheckScriptFailure([
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02003669 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003670 'let var = 123',
3671 ], 'E1126: Cannot use :let in Vim9 script')
3672
Bram Moolenaar62aec932022-01-29 21:45:34 +00003673 v9.CheckScriptFailure([
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003674 'vim9script',
3675 'var g:var = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02003676 ], 'E1016: Cannot declare a global variable:')
3677
Bram Moolenaar62aec932022-01-29 21:45:34 +00003678 v9.CheckScriptFailure([
Bram Moolenaare55b1c02020-06-21 15:52:59 +02003679 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003680 'var b:var = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02003681 ], 'E1016: Cannot declare a buffer variable:')
3682
Bram Moolenaar62aec932022-01-29 21:45:34 +00003683 v9.CheckScriptFailure([
Bram Moolenaare55b1c02020-06-21 15:52:59 +02003684 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003685 'var w:var = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02003686 ], 'E1016: Cannot declare a window variable:')
3687
Bram Moolenaar62aec932022-01-29 21:45:34 +00003688 v9.CheckScriptFailure([
Bram Moolenaare55b1c02020-06-21 15:52:59 +02003689 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003690 'var t:var = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02003691 ], 'E1016: Cannot declare a tab variable:')
3692
Bram Moolenaar62aec932022-01-29 21:45:34 +00003693 v9.CheckScriptFailure([
Bram Moolenaare55b1c02020-06-21 15:52:59 +02003694 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003695 'var v:version = 123',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02003696 ], 'E1016: Cannot declare a v: variable:')
3697
Bram Moolenaar62aec932022-01-29 21:45:34 +00003698 v9.CheckScriptFailure([
Bram Moolenaare55b1c02020-06-21 15:52:59 +02003699 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003700 'var $VARIABLE = "text"',
Bram Moolenaare55b1c02020-06-21 15:52:59 +02003701 ], 'E1016: Cannot declare an environment variable:')
Bram Moolenaar67979662020-06-20 22:50:47 +02003702
Bram Moolenaar62aec932022-01-29 21:45:34 +00003703 v9.CheckScriptFailure([
Bram Moolenaar67979662020-06-20 22:50:47 +02003704 'vim9script',
3705 'g:var = 123',
Bram Moolenaar32e35112020-05-14 22:41:15 +02003706 'unlet g:var# comment1',
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02003707 ], 'E108:')
3708
Bram Moolenaar62aec932022-01-29 21:45:34 +00003709 v9.CheckScriptFailure([
Bram Moolenaard72c1bf2020-04-19 16:28:59 +02003710 'let g:var = 123',
3711 'unlet g:var # something',
3712 ], 'E488:')
Bram Moolenaarfaac4102020-04-20 17:46:14 +02003713
Bram Moolenaar62aec932022-01-29 21:45:34 +00003714 v9.CheckScriptSuccess([
Bram Moolenaarfaac4102020-04-20 17:46:14 +02003715 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02003716 'if 1 # comment2',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02003717 ' echo "yes"',
3718 'elseif 2 #comment',
3719 ' echo "no"',
3720 'endif',
3721 ])
3722
Bram Moolenaar62aec932022-01-29 21:45:34 +00003723 v9.CheckScriptFailure([
Bram Moolenaarfaac4102020-04-20 17:46:14 +02003724 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02003725 'if 1# comment3',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02003726 ' echo "yes"',
3727 'endif',
Bram Moolenaarfae55a92021-06-17 22:08:30 +02003728 ], 'E488:')
Bram Moolenaarfaac4102020-04-20 17:46:14 +02003729
Bram Moolenaar62aec932022-01-29 21:45:34 +00003730 v9.CheckScriptFailure([
Bram Moolenaarfaac4102020-04-20 17:46:14 +02003731 'vim9script',
Bram Moolenaar32e35112020-05-14 22:41:15 +02003732 'if 0 # comment4',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02003733 ' echo "yes"',
3734 'elseif 2#comment',
3735 ' echo "no"',
3736 'endif',
Bram Moolenaarfae55a92021-06-17 22:08:30 +02003737 ], 'E488:')
Bram Moolenaarfaac4102020-04-20 17:46:14 +02003738
Bram Moolenaar62aec932022-01-29 21:45:34 +00003739 v9.CheckScriptSuccess([
Bram Moolenaarfaac4102020-04-20 17:46:14 +02003740 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003741 'var v = 1 # comment5',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02003742 ])
3743
Bram Moolenaar62aec932022-01-29 21:45:34 +00003744 v9.CheckScriptFailure([
Bram Moolenaarfaac4102020-04-20 17:46:14 +02003745 'vim9script',
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003746 'var v = 1# comment6',
Bram Moolenaarfae55a92021-06-17 22:08:30 +02003747 ], 'E488:')
Bram Moolenaarfaac4102020-04-20 17:46:14 +02003748
Bram Moolenaar62aec932022-01-29 21:45:34 +00003749 v9.CheckScriptSuccess([
Bram Moolenaarfaac4102020-04-20 17:46:14 +02003750 'vim9script',
Bram Moolenaar2984ed32022-08-20 14:51:17 +01003751 'new',
Bram Moolenaard2c61702020-09-06 15:58:36 +02003752 'setline(1, ["# define pat", "last"])',
Bram Moolenaardf069ee2020-06-22 23:02:51 +02003753 ':$',
Bram Moolenaarfaac4102020-04-20 17:46:14 +02003754 'dsearch /pat/ #comment',
3755 'bwipe!',
3756 ])
3757
Bram Moolenaar62aec932022-01-29 21:45:34 +00003758 v9.CheckScriptFailure([
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02003759 'vim9script',
Bram Moolenaar2984ed32022-08-20 14:51:17 +01003760 'new',
Bram Moolenaard2c61702020-09-06 15:58:36 +02003761 'setline(1, ["# define pat", "last"])',
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02003762 ':$',
3763 'dsearch /pat/#comment',
3764 'bwipe!',
3765 ], 'E488:')
3766
Bram Moolenaar62aec932022-01-29 21:45:34 +00003767 v9.CheckScriptFailure([
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02003768 'vim9script',
3769 'func! SomeFunc()',
3770 ], 'E477:')
Bram Moolenaara26b9702020-04-18 19:53:28 +02003771enddef
3772
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02003773def Test_finish()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003774 var lines =<< trim END
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02003775 vim9script
Bram Moolenaar67979662020-06-20 22:50:47 +02003776 g:res = 'one'
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02003777 if v:false | finish | endif
Bram Moolenaar67979662020-06-20 22:50:47 +02003778 g:res = 'two'
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02003779 finish
Bram Moolenaar67979662020-06-20 22:50:47 +02003780 g:res = 'three'
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02003781 END
Bram Moolenaardd674772022-09-15 22:26:18 +01003782 writefile(lines, 'Xfinished', 'D')
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02003783 source Xfinished
3784 assert_equal('two', g:res)
3785
3786 unlet g:res
Bram Moolenaar7e5bd912020-05-10 21:20:29 +02003787enddef
3788
Bram Moolenaara5d00772020-05-14 23:20:55 +02003789def Test_forward_declaration()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003790 var lines =<< trim END
Bram Moolenaara5d00772020-05-14 23:20:55 +02003791 vim9script
Bram Moolenaara5d00772020-05-14 23:20:55 +02003792 def GetValue(): string
3793 return theVal
3794 enddef
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003795 var theVal = 'something'
Bram Moolenaar822ba242020-05-24 23:00:18 +02003796 g:initVal = GetValue()
Bram Moolenaara5d00772020-05-14 23:20:55 +02003797 theVal = 'else'
3798 g:laterVal = GetValue()
3799 END
Bram Moolenaardd674772022-09-15 22:26:18 +01003800 writefile(lines, 'Xforward', 'D')
Bram Moolenaara5d00772020-05-14 23:20:55 +02003801 source Xforward
3802 assert_equal('something', g:initVal)
3803 assert_equal('else', g:laterVal)
3804
3805 unlet g:initVal
3806 unlet g:laterVal
Bram Moolenaara5d00772020-05-14 23:20:55 +02003807enddef
3808
Bram Moolenaar75e27d72022-02-13 13:56:29 +00003809def Test_declare_script_var_in_func()
Bram Moolenaare535db82021-03-31 21:07:24 +02003810 var lines =<< trim END
3811 vim9script
3812 func Declare()
3813 let s:local = 123
3814 endfunc
3815 Declare()
Bram Moolenaar75e27d72022-02-13 13:56:29 +00003816 END
3817 v9.CheckScriptFailure(lines, 'E1269:')
3818enddef
Bram Moolenaar755bf2b2023-01-28 19:38:49 +00003819
Bram Moolenaar75e27d72022-02-13 13:56:29 +00003820def Test_lock_script_var()
3821 var lines =<< trim END
3822 vim9script
3823 var local = 123
Bram Moolenaare535db82021-03-31 21:07:24 +02003824 assert_equal(123, local)
3825
3826 var error: string
3827 try
3828 local = 'asdf'
3829 catch
3830 error = v:exception
3831 endtry
3832 assert_match('E1012: Type mismatch; expected number but got string', error)
3833
3834 lockvar local
3835 try
3836 local = 999
3837 catch
3838 error = v:exception
3839 endtry
3840 assert_match('E741: Value is locked: local', error)
3841 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003842 v9.CheckScriptSuccess(lines)
Bram Moolenaare535db82021-03-31 21:07:24 +02003843enddef
Bram Moolenaar755bf2b2023-01-28 19:38:49 +00003844
Bram Moolenaare535db82021-03-31 21:07:24 +02003845
Bram Moolenaar7d699702020-08-14 20:52:28 +02003846func Test_vim9script_not_global()
3847 " check that items defined in Vim9 script are script-local, not global
3848 let vim9lines =<< trim END
3849 vim9script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003850 var name = 'local'
Bram Moolenaar7d699702020-08-14 20:52:28 +02003851 func TheFunc()
3852 echo 'local'
3853 endfunc
3854 def DefFunc()
3855 echo 'local'
3856 enddef
3857 END
Bram Moolenaardd674772022-09-15 22:26:18 +01003858 call writefile(vim9lines, 'Xvim9script.vim', 'D')
Bram Moolenaar7d699702020-08-14 20:52:28 +02003859 source Xvim9script.vim
3860 try
3861 echo g:var
3862 assert_report('did not fail')
3863 catch /E121:/
3864 " caught
3865 endtry
3866 try
3867 call TheFunc()
3868 assert_report('did not fail')
3869 catch /E117:/
3870 " caught
3871 endtry
3872 try
3873 call DefFunc()
3874 assert_report('did not fail')
3875 catch /E117:/
3876 " caught
3877 endtry
Bram Moolenaar7d699702020-08-14 20:52:28 +02003878endfunc
3879
Bram Moolenaareeb27bf2020-07-04 17:39:10 +02003880def Test_vim9_copen()
3881 # this was giving an error for setting w:quickfix_title
3882 copen
3883 quit
3884enddef
3885
Bram Moolenaar81e17fb2020-08-21 21:55:43 +02003886def Test_script_var_in_autocmd()
3887 # using a script variable from an autocommand, defined in a :def function in a
3888 # legacy Vim script, cannot check the variable type.
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02003889 var lines =<< trim END
Bram Moolenaar81e17fb2020-08-21 21:55:43 +02003890 let s:counter = 1
3891 def s:Func()
3892 au! CursorHold
3893 au CursorHold * s:counter += 1
3894 enddef
3895 call s:Func()
3896 doau CursorHold
3897 call assert_equal(2, s:counter)
3898 au! CursorHold
3899 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003900 v9.CheckScriptSuccess(lines)
Bram Moolenaar81e17fb2020-08-21 21:55:43 +02003901enddef
3902
Bram Moolenaarb5841b92021-07-15 18:09:53 +02003903def Test_error_in_autoload_script()
3904 var save_rtp = &rtp
3905 var dir = getcwd() .. '/Xruntime'
3906 &rtp = dir
Bram Moolenaardd674772022-09-15 22:26:18 +01003907 mkdir(dir .. '/autoload', 'pR')
Bram Moolenaarb5841b92021-07-15 18:09:53 +02003908
3909 var lines =<< trim END
3910 vim9script noclear
Bram Moolenaard8fe6d32022-01-30 18:40:44 +00003911 export def Autoloaded()
Bram Moolenaarb5841b92021-07-15 18:09:53 +02003912 enddef
3913 def Broken()
3914 var x: any = ''
3915 eval x != 0
3916 enddef
3917 Broken()
3918 END
3919 writefile(lines, dir .. '/autoload/script.vim')
3920
3921 lines =<< trim END
3922 vim9script
3923 def CallAutoloaded()
Bram Moolenaard8fe6d32022-01-30 18:40:44 +00003924 script#Autoloaded()
Bram Moolenaarb5841b92021-07-15 18:09:53 +02003925 enddef
3926
3927 function Legacy()
3928 try
3929 call s:CallAutoloaded()
3930 catch
3931 call assert_match('E1030: Using a String as a Number', v:exception)
3932 endtry
3933 endfunction
3934
3935 Legacy()
3936 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003937 v9.CheckScriptSuccess(lines)
Bram Moolenaarb5841b92021-07-15 18:09:53 +02003938
3939 &rtp = save_rtp
Bram Moolenaarb5841b92021-07-15 18:09:53 +02003940enddef
3941
Bram Moolenaar6809ff92022-07-26 15:10:56 +01003942def Test_error_in_autoload_script_foldexpr()
3943 var save_rtp = &rtp
Bram Moolenaardd674772022-09-15 22:26:18 +01003944 mkdir('Xvim/autoload', 'pR')
Bram Moolenaar6809ff92022-07-26 15:10:56 +01003945 &runtimepath = 'Xvim'
3946
3947 var lines =<< trim END
3948 vim9script
3949 eval [][0]
3950 echomsg 'no error'
3951 END
3952 lines->writefile('Xvim/autoload/script.vim')
3953
3954 lines =<< trim END
3955 vim9script
3956 import autoload 'script.vim'
3957 &foldmethod = 'expr'
3958 &foldexpr = 'script.Func()'
3959 redraw
3960 END
3961 v9.CheckScriptFailure(lines, 'E684: List index out of range: 0')
Bram Moolenaar6809ff92022-07-26 15:10:56 +01003962enddef
3963
Bram Moolenaare3d46852020-08-29 13:39:17 +02003964def Test_invalid_sid()
3965 assert_fails('func <SNR>1234_func', 'E123:')
Bram Moolenaar25859dd2020-08-30 12:54:53 +02003966
Bram Moolenaar62aec932022-01-29 21:45:34 +00003967 if g:RunVim([], ['wq! Xdidit'], '+"func <SNR>1_func"')
Bram Moolenaard2c61702020-09-06 15:58:36 +02003968 assert_equal([], readfile('Xdidit'))
Bram Moolenaare3d46852020-08-29 13:39:17 +02003969 endif
3970 delete('Xdidit')
3971enddef
3972
Bram Moolenaar9ec70262020-12-09 17:16:59 +01003973def Test_restoring_cpo()
Bram Moolenaardd674772022-09-15 22:26:18 +01003974 writefile(['vim9script', 'set nocp'], 'Xsourced', 'D')
3975 writefile(['call writefile(["done"], "Xdone")', 'quit!'], 'Xclose', 'D')
Bram Moolenaar62aec932022-01-29 21:45:34 +00003976 if g:RunVim([], [], '-u NONE +"set cpo+=a" -S Xsourced -S Xclose')
Bram Moolenaar9ec70262020-12-09 17:16:59 +01003977 assert_equal(['done'], readfile('Xdone'))
3978 endif
Bram Moolenaar090728a2020-12-20 15:43:31 +01003979 delete('Xdone')
Bram Moolenaar0123cc12021-02-07 17:17:58 +01003980
Bram Moolenaardd674772022-09-15 22:26:18 +01003981 writefile(['vim9script', 'g:cpoval = &cpo'], 'XanotherScript', 'D')
Bram Moolenaar0123cc12021-02-07 17:17:58 +01003982 set cpo=aABceFsMny>
3983 edit XanotherScript
3984 so %
3985 assert_equal('aABceFsMny>', &cpo)
Bram Moolenaar71eb3ad2021-12-26 12:07:30 +00003986 assert_equal('aABceFs', g:cpoval)
Bram Moolenaar0123cc12021-02-07 17:17:58 +01003987 :1del
Bram Moolenaar71eb3ad2021-12-26 12:07:30 +00003988 setline(1, 'let g:cpoval = &cpo')
Bram Moolenaar0123cc12021-02-07 17:17:58 +01003989 w
3990 so %
3991 assert_equal('aABceFsMny>', &cpo)
Bram Moolenaar71eb3ad2021-12-26 12:07:30 +00003992 assert_equal('aABceFsMny>', g:cpoval)
Bram Moolenaar0123cc12021-02-07 17:17:58 +01003993
Bram Moolenaar0123cc12021-02-07 17:17:58 +01003994 set cpo&vim
Bram Moolenaar71eb3ad2021-12-26 12:07:30 +00003995 unlet g:cpoval
3996
3997 if has('unix')
3998 # 'cpo' is not restored in main vimrc
3999 var save_HOME = $HOME
4000 $HOME = getcwd() .. '/Xhome'
Bram Moolenaardd674772022-09-15 22:26:18 +01004001 mkdir('Xhome', 'R')
Bram Moolenaar71eb3ad2021-12-26 12:07:30 +00004002 var lines =<< trim END
4003 vim9script
Bram Moolenaarb18b4962022-09-02 21:55:50 +01004004 writefile(['before: ' .. &cpo], 'Xrporesult')
Bram Moolenaar71eb3ad2021-12-26 12:07:30 +00004005 set cpo+=M
Bram Moolenaarb18b4962022-09-02 21:55:50 +01004006 writefile(['after: ' .. &cpo], 'Xrporesult', 'a')
Bram Moolenaar71eb3ad2021-12-26 12:07:30 +00004007 END
4008 writefile(lines, 'Xhome/.vimrc')
4009
4010 lines =<< trim END
Bram Moolenaarb18b4962022-09-02 21:55:50 +01004011 call writefile(['later: ' .. &cpo], 'Xrporesult', 'a')
Bram Moolenaar71eb3ad2021-12-26 12:07:30 +00004012 END
Bram Moolenaardd674772022-09-15 22:26:18 +01004013 writefile(lines, 'Xlegacy', 'D')
Bram Moolenaar71eb3ad2021-12-26 12:07:30 +00004014
4015 lines =<< trim END
4016 vim9script
Bram Moolenaarb18b4962022-09-02 21:55:50 +01004017 call writefile(['vim9: ' .. &cpo], 'Xrporesult', 'a')
Bram Moolenaar71eb3ad2021-12-26 12:07:30 +00004018 qa
4019 END
Bram Moolenaardd674772022-09-15 22:26:18 +01004020 writefile(lines, 'Xvim9', 'D')
Bram Moolenaar71eb3ad2021-12-26 12:07:30 +00004021
Bram Moolenaar62aec932022-01-29 21:45:34 +00004022 var cmd = g:GetVimCommand() .. " -S Xlegacy -S Xvim9"
Bram Moolenaar71eb3ad2021-12-26 12:07:30 +00004023 cmd = substitute(cmd, '-u NONE', '', '')
4024 exe "silent !" .. cmd
4025
4026 assert_equal([
4027 'before: aABceFs',
4028 'after: aABceFsM',
4029 'later: aABceFsM',
Bram Moolenaarb18b4962022-09-02 21:55:50 +01004030 'vim9: aABceFs'], readfile('Xrporesult'))
Bram Moolenaar71eb3ad2021-12-26 12:07:30 +00004031
4032 $HOME = save_HOME
Bram Moolenaarb18b4962022-09-02 21:55:50 +01004033 delete('Xrporesult')
Bram Moolenaar71eb3ad2021-12-26 12:07:30 +00004034 endif
Bram Moolenaar9ec70262020-12-09 17:16:59 +01004035enddef
4036
Bram Moolenaarffb7dcd2021-03-10 14:00:18 +01004037" Use :function so we can use Check commands
4038func Test_no_redraw_when_restoring_cpo()
Bram Moolenaar37294bd2021-03-10 13:40:08 +01004039 CheckScreendump
Bram Moolenaarffb7dcd2021-03-10 14:00:18 +01004040 CheckFeature timers
Bram Moolenaar0e1574c2022-03-03 17:05:35 +00004041 call Run_test_no_redraw_when_restoring_cpo()
4042endfunc
Bram Moolenaar37294bd2021-03-10 13:40:08 +01004043
Bram Moolenaar0e1574c2022-03-03 17:05:35 +00004044def Run_test_no_redraw_when_restoring_cpo()
4045 var lines =<< trim END
Bram Moolenaar37294bd2021-03-10 13:40:08 +01004046 vim9script
Bram Moolenaard8fe6d32022-01-30 18:40:44 +00004047 export def Func()
Bram Moolenaar37294bd2021-03-10 13:40:08 +01004048 enddef
4049 END
Bram Moolenaardd674772022-09-15 22:26:18 +01004050 mkdir('Xnordir/autoload', 'pR')
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01004051 writefile(lines, 'Xnordir/autoload/script.vim')
Bram Moolenaar37294bd2021-03-10 13:40:08 +01004052
Bram Moolenaar0e1574c2022-03-03 17:05:35 +00004053 lines =<< trim END
Bram Moolenaar37294bd2021-03-10 13:40:08 +01004054 vim9script
4055 set cpo+=M
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01004056 exe 'set rtp^=' .. getcwd() .. '/Xnordir'
Bram Moolenaard8fe6d32022-01-30 18:40:44 +00004057 au CmdlineEnter : ++once timer_start(0, (_) => script#Func())
Bram Moolenaar37294bd2021-03-10 13:40:08 +01004058 setline(1, 'some text')
4059 END
Bram Moolenaardd674772022-09-15 22:26:18 +01004060 writefile(lines, 'XTest_redraw_cpo', 'D')
Bram Moolenaar0e1574c2022-03-03 17:05:35 +00004061 var buf = g:RunVimInTerminal('-S XTest_redraw_cpo', {'rows': 6})
4062 term_sendkeys(buf, "V:")
4063 g:VerifyScreenDump(buf, 'Test_vim9_no_redraw', {})
Bram Moolenaar37294bd2021-03-10 13:40:08 +01004064
Bram Moolenaar0e1574c2022-03-03 17:05:35 +00004065 # clean up
4066 term_sendkeys(buf, "\<Esc>u")
4067 g:StopVimInTerminal(buf)
Bram Moolenaar0e1574c2022-03-03 17:05:35 +00004068enddef
4069
4070func Test_reject_declaration()
4071 CheckScreendump
4072 call Run_test_reject_declaration()
Bram Moolenaarffb7dcd2021-03-10 14:00:18 +01004073endfunc
Bram Moolenaar37294bd2021-03-10 13:40:08 +01004074
Bram Moolenaar0e1574c2022-03-03 17:05:35 +00004075def Run_test_reject_declaration()
4076 var buf = g:RunVimInTerminal('', {'rows': 6})
4077 term_sendkeys(buf, ":vim9cmd var x: number\<CR>")
Bram Moolenaar330a3882022-03-05 11:05:57 +00004078 g:VerifyScreenDump(buf, 'Test_vim9_reject_declaration_1', {})
4079 term_sendkeys(buf, ":\<CR>")
4080 term_sendkeys(buf, ":vim9cmd g:foo = 123 | echo g:foo\<CR>")
4081 g:VerifyScreenDump(buf, 'Test_vim9_reject_declaration_2', {})
Bram Moolenaar0e1574c2022-03-03 17:05:35 +00004082
4083 # clean up
4084 g:StopVimInTerminal(buf)
4085enddef
Bram Moolenaar9ec70262020-12-09 17:16:59 +01004086
Bram Moolenaar204852a2022-03-05 12:56:44 +00004087def Test_minimal_command_name_length()
4088 var names = [
4089 'cons',
4090 'brea',
4091 'cat',
4092 'catc',
4093 'con',
Bram Moolenaarb2175222022-03-05 20:24:41 +00004094 'cont',
4095 'conti',
4096 'contin',
4097 'continu',
Bram Moolenaar204852a2022-03-05 12:56:44 +00004098 'el',
4099 'els',
4100 'elsei',
4101 'endfo',
4102 'en',
4103 'end',
4104 'endi',
4105 'endw',
4106 'endt',
4107 'endtr',
Bram Moolenaarb2175222022-03-05 20:24:41 +00004108 'exp',
4109 'expo',
4110 'expor',
Bram Moolenaar204852a2022-03-05 12:56:44 +00004111 'fina',
4112 'finall',
Bram Moolenaard523c7b2022-03-06 14:51:22 +00004113 'fini',
4114 'finis',
Bram Moolenaarb2175222022-03-05 20:24:41 +00004115 'imp',
4116 'impo',
4117 'impor',
4118 'retu',
4119 'retur',
Bram Moolenaar204852a2022-03-05 12:56:44 +00004120 'th',
4121 'thr',
4122 'thro',
4123 'wh',
4124 'whi',
4125 'whil',
4126 ]
4127 for name in names
4128 v9.CheckDefAndScriptFailure([name .. ' '], 'E1065:')
4129 endfor
Bram Moolenaarb2175222022-03-05 20:24:41 +00004130
4131 var lines =<< trim END
4132 vim9script
4133 def SomeFunc()
4134 endd
4135 END
4136 v9.CheckScriptFailure(lines, 'E1065:')
4137 lines =<< trim END
4138 vim9script
4139 def SomeFunc()
4140 endde
4141 END
4142 v9.CheckScriptFailure(lines, 'E1065:')
Bram Moolenaar204852a2022-03-05 12:56:44 +00004143enddef
4144
Bram Moolenaarf0afd9e2020-09-13 18:57:47 +02004145def Test_unset_any_variable()
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02004146 var lines =<< trim END
4147 var name: any
4148 assert_equal(0, name)
Bram Moolenaarf0afd9e2020-09-13 18:57:47 +02004149 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004150 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarf0afd9e2020-09-13 18:57:47 +02004151enddef
4152
Bram Moolenaar7e9210e2020-09-25 23:12:51 +02004153func Test_define_func_at_command_line()
Bram Moolenaar58dbef32020-09-25 22:13:05 +02004154 CheckRunVimInTerminal
4155
Bram Moolenaar7e9210e2020-09-25 23:12:51 +02004156 " call indirectly to avoid compilation error for missing functions
4157 call Run_Test_define_func_at_command_line()
4158endfunc
4159
4160def Run_Test_define_func_at_command_line()
Bram Moolenaar9c4f5522020-09-25 21:47:28 +02004161 # run in a separate Vim instance to avoid the script context
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02004162 var lines =<< trim END
Bram Moolenaar9c4f5522020-09-25 21:47:28 +02004163 func CheckAndQuit()
4164 call assert_fails('call Afunc()', 'E117: Unknown function: Bfunc')
4165 call writefile(['errors: ' .. string(v:errors)], 'Xdidcmd')
4166 endfunc
4167 END
Bram Moolenaardd674772022-09-15 22:26:18 +01004168 writefile([''], 'Xdidcmd', 'D')
4169 writefile(lines, 'XcallFunc', 'D')
Bram Moolenaar62aec932022-01-29 21:45:34 +00004170 var buf = g:RunVimInTerminal('-S XcallFunc', {rows: 6})
Bram Moolenaar9c4f5522020-09-25 21:47:28 +02004171 # define Afunc() on the command line
4172 term_sendkeys(buf, ":def Afunc()\<CR>Bfunc()\<CR>enddef\<CR>")
4173 term_sendkeys(buf, ":call CheckAndQuit()\<CR>")
Bram Moolenaar62aec932022-01-29 21:45:34 +00004174 g:WaitForAssert(() => assert_equal(['errors: []'], readfile('Xdidcmd')))
Bram Moolenaar9c4f5522020-09-25 21:47:28 +02004175
Bram Moolenaar62aec932022-01-29 21:45:34 +00004176 call g:StopVimInTerminal(buf)
Bram Moolenaar9c4f5522020-09-25 21:47:28 +02004177enddef
4178
Bram Moolenaarfcdc5d82020-10-10 19:07:09 +02004179def Test_script_var_scope()
4180 var lines =<< trim END
4181 vim9script
4182 if true
4183 if true
4184 var one = 'one'
4185 echo one
4186 endif
4187 echo one
4188 endif
4189 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004190 v9.CheckScriptFailure(lines, 'E121:', 7)
Bram Moolenaarfcdc5d82020-10-10 19:07:09 +02004191
4192 lines =<< trim END
4193 vim9script
4194 if true
4195 if false
4196 var one = 'one'
4197 echo one
4198 else
4199 var one = 'one'
4200 echo one
4201 endif
4202 echo one
4203 endif
4204 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004205 v9.CheckScriptFailure(lines, 'E121:', 10)
Bram Moolenaarfcdc5d82020-10-10 19:07:09 +02004206
4207 lines =<< trim END
4208 vim9script
4209 while true
4210 var one = 'one'
4211 echo one
4212 break
4213 endwhile
4214 echo one
4215 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004216 v9.CheckScriptFailure(lines, 'E121:', 7)
Bram Moolenaarfcdc5d82020-10-10 19:07:09 +02004217
4218 lines =<< trim END
4219 vim9script
4220 for i in range(1)
4221 var one = 'one'
4222 echo one
4223 endfor
4224 echo one
4225 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004226 v9.CheckScriptFailure(lines, 'E121:', 6)
Bram Moolenaar9becdf22020-10-10 21:33:48 +02004227
4228 lines =<< trim END
4229 vim9script
4230 {
4231 var one = 'one'
4232 assert_equal('one', one)
4233 }
4234 assert_false(exists('one'))
4235 assert_false(exists('s:one'))
4236 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004237 v9.CheckScriptSuccess(lines)
Bram Moolenaar9becdf22020-10-10 21:33:48 +02004238
4239 lines =<< trim END
4240 vim9script
4241 {
4242 var one = 'one'
4243 echo one
4244 }
4245 echo one
4246 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004247 v9.CheckScriptFailure(lines, 'E121:', 6)
Bram Moolenaarfcdc5d82020-10-10 19:07:09 +02004248enddef
4249
Bram Moolenaar352134b2020-10-17 22:04:08 +02004250def Test_catch_exception_in_callback()
4251 var lines =<< trim END
4252 vim9script
Bram Moolenaar2a389082021-04-09 20:24:31 +02004253 def Callback(...l: list<any>)
Bram Moolenaar352134b2020-10-17 22:04:08 +02004254 try
4255 var x: string
4256 var y: string
4257 # this error should be caught with CHECKLEN
Bram Moolenaardb9ff9a2021-12-01 17:38:01 +00004258 var sl = ['']
4259 [x, y] = sl
Bram Moolenaar352134b2020-10-17 22:04:08 +02004260 catch
4261 g:caught = 'yes'
4262 endtry
4263 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +01004264 popup_menu('popup', {callback: Callback})
Bram Moolenaar352134b2020-10-17 22:04:08 +02004265 feedkeys("\r", 'xt')
4266 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004267 v9.CheckScriptSuccess(lines)
Bram Moolenaar352134b2020-10-17 22:04:08 +02004268
4269 unlet g:caught
4270enddef
4271
Bram Moolenaar631e8f92020-11-04 15:07:16 +01004272def Test_no_unknown_error_after_error()
4273 if !has('unix') || !has('job')
4274 throw 'Skipped: not unix of missing +job feature'
4275 endif
Bram Moolenaarb16ff292021-09-26 20:14:39 +01004276 # FIXME: this check should not be needed
4277 if has('win32')
4278 throw 'Skipped: does not work on MS-Windows'
4279 endif
Bram Moolenaar631e8f92020-11-04 15:07:16 +01004280 var lines =<< trim END
4281 vim9script
4282 var source: list<number>
Bram Moolenaar2a389082021-04-09 20:24:31 +02004283 def Out_cb(...l: list<any>)
Bram Moolenaar631e8f92020-11-04 15:07:16 +01004284 eval [][0]
4285 enddef
Bram Moolenaar2a389082021-04-09 20:24:31 +02004286 def Exit_cb(...l: list<any>)
Bram Moolenaar631e8f92020-11-04 15:07:16 +01004287 sleep 1m
Bram Moolenaar23d44492022-05-04 16:24:57 +01004288 g:did_call_exit_cb = true
Bram Moolenaar631e8f92020-11-04 15:07:16 +01004289 source += l
4290 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +01004291 var myjob = job_start('echo burp', {out_cb: Out_cb, exit_cb: Exit_cb, mode: 'raw'})
Bram Moolenaar6f17a3f2020-12-21 18:11:24 +01004292 while job_status(myjob) == 'run'
4293 sleep 10m
4294 endwhile
Bram Moolenaar206c2a62021-01-31 14:04:44 +01004295 # wait for Exit_cb() to be called
Bram Moolenaar23d44492022-05-04 16:24:57 +01004296 for x in range(100)
4297 if exists('g:did_call_exit_cb')
4298 unlet g:did_call_exit_cb
4299 break
4300 endif
4301 sleep 10m
4302 endfor
Bram Moolenaar631e8f92020-11-04 15:07:16 +01004303 END
Bram Moolenaardd674772022-09-15 22:26:18 +01004304 writefile(lines, 'Xdef', 'D')
Yee Cheng Chin69a8bb82022-11-06 12:25:47 +00004305 # Either the exit or out callback is called first, accept them in any order
4306 assert_fails('so Xdef', ['E684:\|E1012:', 'E1012:\|E684:'])
Bram Moolenaar631e8f92020-11-04 15:07:16 +01004307enddef
4308
Bram Moolenaar4324d872020-12-01 20:12:24 +01004309def InvokeNormal()
4310 exe "norm! :m+1\r"
4311enddef
4312
4313def Test_invoke_normal_in_visual_mode()
4314 xnoremap <F3> <Cmd>call <SID>InvokeNormal()<CR>
4315 new
4316 setline(1, ['aaa', 'bbb'])
4317 feedkeys("V\<F3>", 'xt')
4318 assert_equal(['bbb', 'aaa'], getline(1, 2))
4319 xunmap <F3>
4320enddef
4321
Bram Moolenaarb5b94802020-12-13 17:50:20 +01004322def Test_white_space_after_command()
4323 var lines =<< trim END
4324 exit_cb: Func})
4325 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004326 v9.CheckDefAndScriptFailure(lines, 'E1144:', 1)
Bram Moolenaarf8103f22020-12-25 17:36:27 +01004327
4328 lines =<< trim END
4329 e#
4330 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004331 v9.CheckDefAndScriptFailure(lines, 'E1144:', 1)
Bram Moolenaarb5b94802020-12-13 17:50:20 +01004332enddef
4333
Bram Moolenaar4aab88d2020-12-24 21:56:41 +01004334def Test_script_var_gone_when_sourced_twice()
4335 var lines =<< trim END
4336 vim9script
4337 if exists('g:guard')
4338 finish
4339 endif
4340 g:guard = 1
4341 var name = 'thename'
4342 def g:GetName(): string
4343 return name
4344 enddef
4345 def g:SetName(arg: string)
4346 name = arg
4347 enddef
4348 END
Bram Moolenaardd674772022-09-15 22:26:18 +01004349 writefile(lines, 'XscriptTwice.vim', 'D')
Bram Moolenaar4aab88d2020-12-24 21:56:41 +01004350 so XscriptTwice.vim
4351 assert_equal('thename', g:GetName())
4352 g:SetName('newname')
4353 assert_equal('newname', g:GetName())
4354 so XscriptTwice.vim
4355 assert_fails('call g:GetName()', 'E1149:')
4356 assert_fails('call g:SetName("x")', 'E1149:')
4357
4358 delfunc g:GetName
4359 delfunc g:SetName
Bram Moolenaar4aab88d2020-12-24 21:56:41 +01004360 unlet g:guard
4361enddef
4362
Bram Moolenaar10b94212021-02-19 21:42:57 +01004363def Test_unsupported_commands()
4364 var lines =<< trim END
4365 ka
4366 END
Bram Moolenaar6aca4d32022-03-04 17:10:19 +00004367 v9.CheckDefAndScriptFailure(lines, ['E476:', 'E492:'])
Bram Moolenaar10b94212021-02-19 21:42:57 +01004368
4369 lines =<< trim END
Bram Moolenaarada1d872021-02-20 08:16:51 +01004370 :1ka
4371 END
Bram Moolenaar6aca4d32022-03-04 17:10:19 +00004372 v9.CheckDefAndScriptFailure(lines, ['E476:', 'E492:'])
Bram Moolenaarada1d872021-02-20 08:16:51 +01004373
4374 lines =<< trim END
Yegappan Lakshmanan885de442022-04-23 10:51:14 +01004375 :k a
4376 END
4377 v9.CheckDefAndScriptFailure(lines, 'E1100:')
4378
4379 lines =<< trim END
4380 :1k a
4381 END
4382 v9.CheckDefAndScriptFailure(lines, 'E481:')
4383
4384 lines =<< trim END
Bram Moolenaar10b94212021-02-19 21:42:57 +01004385 t
4386 END
Bram Moolenaar6aca4d32022-03-04 17:10:19 +00004387 v9.CheckDefAndScriptFailure(lines, 'E1100:')
Bram Moolenaar10b94212021-02-19 21:42:57 +01004388
4389 lines =<< trim END
4390 x
4391 END
Bram Moolenaar6aca4d32022-03-04 17:10:19 +00004392 v9.CheckDefAndScriptFailure(lines, 'E1100:')
Bram Moolenaar10b94212021-02-19 21:42:57 +01004393
4394 lines =<< trim END
4395 xit
4396 END
Bram Moolenaar6aca4d32022-03-04 17:10:19 +00004397 v9.CheckDefAndScriptFailure(lines, 'E1100:')
4398
4399 lines =<< trim END
4400 Print
4401 END
4402 v9.CheckDefAndScriptFailure(lines, ['E476: Invalid command: Print', 'E492: Not an editor command: Print'])
4403
4404 lines =<< trim END
4405 mode 4
4406 END
4407 v9.CheckDefAndScriptFailure(lines, ['E476: Invalid command: mode 4', 'E492: Not an editor command: mode 4'])
Bram Moolenaar10b94212021-02-19 21:42:57 +01004408enddef
4409
Bram Moolenaarc70fe462021-04-17 17:59:19 +02004410def Test_mapping_line_number()
4411 var lines =<< trim END
4412 vim9script
4413 def g:FuncA()
4414 # Some comment
4415 FuncB(0)
4416 enddef
4417 # Some comment
4418 def FuncB(
4419 # Some comment
4420 n: number
4421 )
4422 exe 'nno '
4423 # Some comment
4424 .. '<F3> a'
4425 .. 'b'
4426 .. 'c'
4427 enddef
4428 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004429 v9.CheckScriptSuccess(lines)
Bram Moolenaarc70fe462021-04-17 17:59:19 +02004430 var res = execute('verbose nmap <F3>')
4431 assert_match('No mapping found', res)
4432
4433 g:FuncA()
4434 res = execute('verbose nmap <F3>')
4435 assert_match(' <F3> .* abc.*Last set from .*XScriptSuccess\d\+ line 11', res)
4436
4437 nunmap <F3>
4438 delfunc g:FuncA
4439enddef
4440
Bram Moolenaardeb108b2021-07-08 17:35:36 +02004441def Test_option_set()
4442 # legacy script allows for white space
4443 var lines =<< trim END
4444 set foldlevel =11
4445 call assert_equal(11, &foldlevel)
4446 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004447 v9.CheckScriptSuccess(lines)
Bram Moolenaardeb108b2021-07-08 17:35:36 +02004448
4449 set foldlevel
4450 set foldlevel=12
4451 assert_equal(12, &foldlevel)
4452 set foldlevel+=2
4453 assert_equal(14, &foldlevel)
4454 set foldlevel-=3
4455 assert_equal(11, &foldlevel)
4456
4457 lines =<< trim END
4458 set foldlevel =1
4459 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004460 v9.CheckDefExecAndScriptFailure(lines, 'E1205: No white space allowed between option and: =1')
Bram Moolenaardeb108b2021-07-08 17:35:36 +02004461
4462 lines =<< trim END
4463 set foldlevel +=1
4464 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004465 v9.CheckDefExecAndScriptFailure(lines, 'E1205: No white space allowed between option and: +=1')
Bram Moolenaardeb108b2021-07-08 17:35:36 +02004466
4467 lines =<< trim END
4468 set foldlevel ^=1
4469 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004470 v9.CheckDefExecAndScriptFailure(lines, 'E1205: No white space allowed between option and: ^=1')
Bram Moolenaardeb108b2021-07-08 17:35:36 +02004471
4472 lines =<< trim END
4473 set foldlevel -=1
4474 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004475 v9.CheckDefExecAndScriptFailure(lines, 'E1205: No white space allowed between option and: -=1')
Bram Moolenaardeb108b2021-07-08 17:35:36 +02004476
4477 set foldlevel&
4478enddef
4479
LemonBoy32f34612023-09-02 21:52:05 +02004480def Test_option_set_line_number()
4481 var lines =<< trim END
4482 vim9script
4483 # line2
4484 # line3
4485 def F()
4486 # line5
4487 &foldlevel = -128
4488 enddef
4489 F()
4490 END
4491 v9.CheckScriptSuccess(lines)
4492
4493 var res = execute('verbose set foldlevel')
4494 assert_match(' foldlevel.*Last set from .*XScriptSuccess\d\+ line 6', res)
4495enddef
4496
Bram Moolenaar208f0b42021-06-20 12:40:08 +02004497def Test_option_modifier()
Bram Moolenaar1594f312021-07-08 16:40:13 +02004498 # legacy script allows for white space
Bram Moolenaar208f0b42021-06-20 12:40:08 +02004499 var lines =<< trim END
4500 set hlsearch & hlsearch !
4501 call assert_equal(1, &hlsearch)
4502 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004503 v9.CheckScriptSuccess(lines)
Bram Moolenaar208f0b42021-06-20 12:40:08 +02004504
Bram Moolenaar1594f312021-07-08 16:40:13 +02004505 set hlsearch
4506 set hlsearch!
4507 assert_equal(false, &hlsearch)
4508
4509 set hlsearch
4510 set hlsearch&
4511 assert_equal(false, &hlsearch)
Bram Moolenaar208f0b42021-06-20 12:40:08 +02004512
4513 lines =<< trim END
Bram Moolenaar1594f312021-07-08 16:40:13 +02004514 set hlsearch &
Bram Moolenaar208f0b42021-06-20 12:40:08 +02004515 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004516 v9.CheckDefExecAndScriptFailure(lines, 'E1205: No white space allowed between option and: &')
Bram Moolenaar1594f312021-07-08 16:40:13 +02004517
4518 lines =<< trim END
4519 set hlsearch !
4520 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004521 v9.CheckDefExecAndScriptFailure(lines, 'E1205: No white space allowed between option and: !')
Bram Moolenaar1594f312021-07-08 16:40:13 +02004522
4523 set hlsearch&
Bram Moolenaar208f0b42021-06-20 12:40:08 +02004524enddef
4525
Bram Moolenaarc03fe662021-07-11 16:52:45 +02004526" This must be called last, it may cause following :def functions to fail
4527def Test_xxx_echoerr_line_number()
4528 var lines =<< trim END
4529 echoerr 'some'
4530 .. ' error'
4531 .. ' continued'
4532 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004533 v9.CheckDefExecAndScriptFailure(lines, 'some error continued', 1)
Bram Moolenaarc03fe662021-07-11 16:52:45 +02004534enddef
4535
Bram Moolenaar9537e372021-12-10 21:05:53 +00004536func Test_debug_with_lambda()
Bram Moolenaar9fffef92021-12-10 16:55:58 +00004537 CheckRunVimInTerminal
4538
Bram Moolenaar9537e372021-12-10 21:05:53 +00004539 " call indirectly to avoid compilation error for missing functions
4540 call Run_Test_debug_with_lambda()
4541endfunc
4542
4543def Run_Test_debug_with_lambda()
Bram Moolenaar9fffef92021-12-10 16:55:58 +00004544 var lines =<< trim END
4545 vim9script
4546 def Func()
4547 var n = 0
4548 echo [0]->filter((_, v) => v == n)
4549 enddef
4550 breakadd func Func
4551 Func()
4552 END
Bram Moolenaardd674772022-09-15 22:26:18 +01004553 writefile(lines, 'XdebugFunc', 'D')
Bram Moolenaar62aec932022-01-29 21:45:34 +00004554 var buf = g:RunVimInTerminal('-S XdebugFunc', {rows: 6, wait_for_ruler: 0})
4555 g:WaitForAssert(() => assert_match('^>', term_getline(buf, 6)))
Bram Moolenaar9fffef92021-12-10 16:55:58 +00004556
4557 term_sendkeys(buf, "cont\<CR>")
Bram Moolenaar62aec932022-01-29 21:45:34 +00004558 g:WaitForAssert(() => assert_match('\[0\]', term_getline(buf, 5)))
Bram Moolenaar9fffef92021-12-10 16:55:58 +00004559
Bram Moolenaar62aec932022-01-29 21:45:34 +00004560 g:StopVimInTerminal(buf)
Bram Moolenaar9fffef92021-12-10 16:55:58 +00004561enddef
4562
Bram Moolenaar310091d2021-12-23 21:14:37 +00004563func Test_debug_running_out_of_lines()
4564 CheckRunVimInTerminal
4565
4566 " call indirectly to avoid compilation error for missing functions
4567 call Run_Test_debug_running_out_of_lines()
4568endfunc
4569
4570def Run_Test_debug_running_out_of_lines()
4571 var lines =<< trim END
4572 vim9script
4573 def Crash()
4574 #
4575 #
4576 #
4577 #
4578 #
4579 #
4580 #
4581 if true
4582 #
4583 endif
4584 enddef
4585 breakadd func Crash
4586 Crash()
4587 END
Bram Moolenaardd674772022-09-15 22:26:18 +01004588 writefile(lines, 'XdebugFunc', 'D')
Bram Moolenaar62aec932022-01-29 21:45:34 +00004589 var buf = g:RunVimInTerminal('-S XdebugFunc', {rows: 6, wait_for_ruler: 0})
4590 g:WaitForAssert(() => assert_match('^>', term_getline(buf, 6)))
Bram Moolenaar310091d2021-12-23 21:14:37 +00004591
4592 term_sendkeys(buf, "next\<CR>")
Bram Moolenaar62aec932022-01-29 21:45:34 +00004593 g:TermWait(buf)
4594 g:WaitForAssert(() => assert_match('^>', term_getline(buf, 6)))
Bram Moolenaar310091d2021-12-23 21:14:37 +00004595
4596 term_sendkeys(buf, "cont\<CR>")
Bram Moolenaar62aec932022-01-29 21:45:34 +00004597 g:TermWait(buf)
Bram Moolenaar310091d2021-12-23 21:14:37 +00004598
Bram Moolenaar62aec932022-01-29 21:45:34 +00004599 g:StopVimInTerminal(buf)
Bram Moolenaar310091d2021-12-23 21:14:37 +00004600enddef
4601
dundargocc57b5bc2022-11-02 13:30:51 +00004602def Test_ambiguous_command_error()
Bram Moolenaarbed34f02022-01-19 20:48:37 +00004603 var lines =<< trim END
4604 vim9script
4605 command CmdA echomsg 'CmdA'
4606 command CmdB echomsg 'CmdB'
4607 Cmd
4608 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004609 v9.CheckScriptFailure(lines, 'E464: Ambiguous use of user-defined command: Cmd', 4)
Bram Moolenaarbed34f02022-01-19 20:48:37 +00004610
4611 lines =<< trim END
4612 vim9script
4613 def Func()
4614 Cmd
4615 enddef
4616 Func()
4617 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004618 v9.CheckScriptFailure(lines, 'E464: Ambiguous use of user-defined command: Cmd', 1)
Bram Moolenaarbed34f02022-01-19 20:48:37 +00004619
4620 lines =<< trim END
4621 vim9script
4622 nnoremap <F3> <ScriptCmd>Cmd<CR>
4623 feedkeys("\<F3>", 'xt')
4624 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00004625 v9.CheckScriptFailure(lines, 'E464: Ambiguous use of user-defined command: Cmd', 3)
Bram Moolenaarbed34f02022-01-19 20:48:37 +00004626
4627 delcommand CmdA
4628 delcommand CmdB
4629 nunmap <F3>
4630enddef
4631
Dominique Pelle923dce22021-11-21 11:36:04 +00004632" Execute this near the end, profiling doesn't stop until Vim exits.
Bram Moolenaard9162552021-07-11 15:26:13 +02004633" This only tests that it works, not the profiling output.
Bram Moolenaar129e33e2022-03-14 10:50:23 +00004634def Test_profile_with_lambda()
Bram Moolenaar4ece1522021-07-11 16:31:51 +02004635 CheckFeature profile
4636
Bram Moolenaar129e33e2022-03-14 10:50:23 +00004637 var lines =<< trim END
4638 vim9script
Bram Moolenaarffcfddc2021-07-11 20:22:30 +02004639
Bram Moolenaar129e33e2022-03-14 10:50:23 +00004640 def ProfiledWithLambda()
4641 var n = 3
4642 echo [[1, 2], [3, 4]]->filter((_, l) => l[0] == n)
4643 enddef
Bram Moolenaarffcfddc2021-07-11 20:22:30 +02004644
Bram Moolenaar129e33e2022-03-14 10:50:23 +00004645 def ProfiledNested()
4646 var x = 0
4647 def Nested(): any
4648 return x
4649 enddef
4650 Nested()
4651 enddef
Bram Moolenaarffcfddc2021-07-11 20:22:30 +02004652
Bram Moolenaar129e33e2022-03-14 10:50:23 +00004653 def g:ProfiledNestedProfiled()
4654 var x = 0
4655 def Nested(): any
4656 return x
4657 enddef
4658 Nested()
4659 enddef
4660
4661 def Profile()
Bram Moolenaar48f69cd2022-03-15 16:16:47 +00004662 ProfiledWithLambda()
Bram Moolenaar129e33e2022-03-14 10:50:23 +00004663 ProfiledNested()
4664
Bram Moolenaar48f69cd2022-03-15 16:16:47 +00004665 # Also profile the nested function. Use a different function, although
4666 # the contents is the same, to make sure it was not already compiled.
Bram Moolenaar129e33e2022-03-14 10:50:23 +00004667 profile func *
4668 g:ProfiledNestedProfiled()
4669
4670 profdel func *
4671 profile pause
4672 enddef
Bram Moolenaar4c8b5462022-03-16 20:01:39 +00004673
4674 var result = 'done'
4675 try
4676 # mark functions for profiling now to avoid E1271
4677 profile start Xprofile.log
4678 profile func ProfiledWithLambda
4679 profile func ProfiledNested
4680
4681 Profile()
4682 catch
4683 result = 'failed: ' .. v:exception
4684 finally
4685 writefile([result], 'Xdidprofile')
4686 endtry
Bram Moolenaar129e33e2022-03-14 10:50:23 +00004687 END
Bram Moolenaardd674772022-09-15 22:26:18 +01004688 writefile(lines, 'Xprofile.vim', 'D')
Bram Moolenaar129e33e2022-03-14 10:50:23 +00004689 call system(g:GetVimCommand()
4690 .. ' --clean'
4691 .. ' -c "so Xprofile.vim"'
4692 .. ' -c "qall!"')
4693 call assert_equal(0, v:shell_error)
4694
4695 assert_equal(['done'], readfile('Xdidprofile'))
4696 assert_true(filereadable('Xprofile.log'))
4697 delete('Xdidprofile')
4698 delete('Xprofile.log')
Bram Moolenaard9162552021-07-11 15:26:13 +02004699enddef
4700
Bram Moolenaar4f6e7722022-03-16 20:26:02 +00004701func Test_misplaced_type()
4702 CheckRunVimInTerminal
4703 call Run_Test_misplaced_type()
4704endfunc
4705
4706def Run_Test_misplaced_type()
Bram Moolenaar9510d222022-09-11 15:14:05 +01004707 writefile(['let g:somevar = "asdf"'], 'XTest_misplaced_type', 'D')
Bram Moolenaar4c8b5462022-03-16 20:01:39 +00004708 var buf = g:RunVimInTerminal('-S XTest_misplaced_type', {'rows': 6})
Bram Moolenaar9510d222022-09-11 15:14:05 +01004709 term_sendkeys(buf, ":vim9cmd echo islocked('somevar: string')\<CR>")
Bram Moolenaar4c8b5462022-03-16 20:01:39 +00004710 g:VerifyScreenDump(buf, 'Test_misplaced_type', {})
4711
4712 g:StopVimInTerminal(buf)
Bram Moolenaar4c8b5462022-03-16 20:01:39 +00004713enddef
4714
LemonBoya5d35902022-04-29 21:15:02 +01004715" Ensure echo doesn't crash when stringifying empty variables.
4716def Test_echo_uninit_variables()
4717 var res: string
4718
4719 var var_bool: bool
4720 var var_num: number
4721 var var_float: float
4722 var Var_func: func
4723 var var_string: string
4724 var var_blob: blob
LemonBoya5d35902022-04-29 21:15:02 +01004725 var var_list: list<any>
4726 var var_dict: dict<any>
4727
4728 redir => res
4729 echo var_bool
4730 echo var_num
4731 echo var_float
4732 echo Var_func
4733 echo var_string
4734 echo var_blob
LemonBoya5d35902022-04-29 21:15:02 +01004735 echo var_list
4736 echo var_dict
4737 redir END
4738
Bram Moolenaarf1d63b92022-05-06 13:37:42 +01004739 assert_equal(['false', '0', '0.0', 'function()', '', '0z', '[]', '{}'], res->split('\n'))
4740
4741 if has('job')
4742 var var_job: job
4743 var var_channel: channel
4744
4745 redir => res
4746 echo var_job
4747 echo var_channel
4748 redir END
4749
4750 assert_equal(['no process', 'channel fail'], res->split('\n'))
4751 endif
LemonBoya5d35902022-04-29 21:15:02 +01004752enddef
4753
Bram Moolenaar6342e2c2022-12-12 18:56:32 +00004754def Test_free_type_before_use()
4755 # this rather complicated script was freeing a type before using it
4756 var lines =<< trim END
4757 vim9script
4758
4759 def Scan(rel: list<dict<any>>): func(func(dict<any>))
4760 return (Emit: func(dict<any>)) => {
4761 for t in rel
4762 Emit(t)
4763 endfor
4764 }
4765 enddef
4766
4767 def Build(Cont: func(func(dict<any>))): list<dict<any>>
4768 var rel: list<dict<any>> = []
4769 Cont((t) => {
4770 add(rel, t)
4771 })
4772 return rel
4773 enddef
4774
4775 var R = [{A: 0}]
4776 var result = Scan(R)->Build()
4777 result = Scan(R)->Build()
4778
4779 assert_equal(R, result)
4780 END
4781 v9.CheckScriptSuccess(lines)
4782enddef
4783
Yegappan Lakshmanana76fbe62023-09-27 18:51:43 +02004784" The following complicated script used to cause an internal error (E340)
4785" because the funcref instruction memory was referenced after the instruction
4786" memory was reallocated (Github issue #13178)
4787def Test_refer_funcref_instr_after_realloc()
4788 var lines =<< trim END
4789 vim9script
4790 def A(d: bool)
4791 var e = abs(0)
4792 var f = &emoji
4793 &emoji = true
4794 if ['', '', '']->index('xxx') == 0
4795 eval 0 + 0
4796 endif
4797 if &filetype == 'xxx'
4798 var g = abs(0)
4799 while g > 0
4800 if getline(g) == ''
4801 break
4802 endif
4803 --g
4804 endwhile
4805 if g == 0
4806 return
4807 endif
4808 if d
4809 feedkeys($'{g}G')
4810 g = abs(0)
4811 endif
4812 var h = abs(0)
4813 var i = abs(0)
4814 var j = abs(0)
4815 while j < 0
4816 if abs(0) < h && getline(j) != ''
4817 break
4818 endif
4819 ++j
4820 endwhile
4821 feedkeys($'{g}G{j}G')
4822 return
4823 endif
4824 def B()
4825 enddef
4826 def C()
4827 enddef
4828 enddef
4829 A(false)
4830 END
4831 v9.CheckScriptSuccess(lines)
4832enddef
4833
Yegappan Lakshmanan06725952023-10-18 11:47:37 +02004834" Test for calling a deferred function after an exception
4835def Test_defer_after_exception()
4836 var lines =<< trim END
4837 vim9script
4838
Yegappan Lakshmananc59c1e02023-10-19 10:52:34 +02004839 var callTrace: list<number> = []
4840 def Bar()
4841 callTrace += [1]
4842 throw 'InnerException'
4843 enddef
4844
Yegappan Lakshmanan06725952023-10-18 11:47:37 +02004845 def Defer()
Yegappan Lakshmananc59c1e02023-10-19 10:52:34 +02004846 callTrace += [2]
4847 callTrace += [3]
4848 try
4849 Bar()
4850 catch /InnerException/
4851 callTrace += [4]
4852 endtry
4853 callTrace += [5]
4854 callTrace += [6]
Yegappan Lakshmanan06725952023-10-18 11:47:37 +02004855 enddef
4856
4857 def Foo()
4858 defer Defer()
4859 throw "TestException"
4860 enddef
4861
4862 try
4863 Foo()
4864 catch /TestException/
Yegappan Lakshmananc59c1e02023-10-19 10:52:34 +02004865 callTrace += [7]
Yegappan Lakshmanan06725952023-10-18 11:47:37 +02004866 endtry
4867
Yegappan Lakshmananc59c1e02023-10-19 10:52:34 +02004868 assert_equal([2, 3, 1, 4, 5, 6, 7], callTrace)
Yegappan Lakshmanan06725952023-10-18 11:47:37 +02004869 END
Yegappan Lakshmananec3cebb2023-10-27 19:35:26 +02004870 v9.CheckSourceSuccess(lines)
Yegappan Lakshmanan06725952023-10-18 11:47:37 +02004871enddef
4872
Yegappan Lakshmanan0ab500d2023-10-21 11:59:42 +02004873" Test for multiple deferred function which throw exceptions.
4874" Exceptions thrown by deferred functions should result in error messages but
4875" not propagated into the calling functions.
4876def Test_multidefer_with_exception()
4877 var lines =<< trim END
4878 vim9script
4879
4880 var callTrace: list<number> = []
4881 def Except()
4882 callTrace += [1]
4883 throw 'InnerException'
4884 callTrace += [2]
4885 enddef
4886
4887 def FirstDefer()
4888 callTrace += [3]
4889 callTrace += [4]
4890 enddef
4891
4892 def SecondDeferWithExcept()
4893 callTrace += [5]
4894 Except()
4895 callTrace += [6]
4896 enddef
4897
4898 def ThirdDefer()
4899 callTrace += [7]
4900 callTrace += [8]
4901 enddef
4902
4903 def Foo()
4904 callTrace += [9]
4905 defer FirstDefer()
4906 defer SecondDeferWithExcept()
4907 defer ThirdDefer()
4908 callTrace += [10]
4909 enddef
4910
4911 v:errmsg = ''
4912 try
4913 callTrace += [11]
4914 Foo()
4915 callTrace += [12]
4916 catch /TestException/
4917 callTrace += [13]
4918 catch
4919 callTrace += [14]
4920 finally
4921 callTrace += [15]
4922 endtry
4923 callTrace += [16]
4924
4925 assert_equal('E605: Exception not caught: InnerException', v:errmsg)
4926 assert_equal([11, 9, 10, 7, 8, 5, 1, 3, 4, 12, 15, 16], callTrace)
4927 END
Yegappan Lakshmananec3cebb2023-10-27 19:35:26 +02004928 v9.CheckSourceSuccess(lines)
4929enddef
4930
Yegappan Lakshmanana185a312023-12-16 14:36:08 +01004931" Test for using ":defer" inside an if statement with a false condition
4932def Test_defer_skipped()
4933 var lines =<< trim END
4934 def Foo()
4935 if false
4936 defer execute('echow "hello"', "")
4937 endif
4938 enddef
4939 defcompile
4940 END
4941 v9.CheckSourceSuccess(lines)
4942enddef
4943
Yegappan Lakshmanan062bb6b2023-12-16 14:46:40 +01004944" Test for using defer without parenthesis for the function name
4945def Test_defer_func_without_paren()
4946 var lines =<< trim END
4947 vim9script
4948 def Foo()
4949 defer Bar
4950 enddef
4951 defcompile
4952 END
4953 v9.CheckScriptFailure(lines, 'E107: Missing parentheses: Bar', 1)
4954enddef
4955
4956" Test for using defer without parenthesis for the function name
4957def Test_defer_non_existing_func()
4958 var lines =<< trim END
4959 vim9script
4960 def Foo()
4961 defer Bar()
4962 enddef
4963 defcompile
4964 END
4965 v9.CheckScriptFailure(lines, 'E1001: Variable not found: Bar', 1)
4966enddef
4967
4968" Test for using defer with an invalid function name
4969def Test_defer_invalid_func()
4970 var lines =<< trim END
4971 vim9script
4972 def Foo()
4973 var Abc = 10
4974 defer Abc()
4975 enddef
4976 defcompile
4977 END
4978 v9.CheckScriptFailure(lines, 'E129: Function name required', 2)
4979enddef
4980
4981" Test for using defer with an invalid argument to a function
4982def Test_defer_invalid_func_arg()
4983 var lines =<< trim END
4984 vim9script
4985 def Bar(x: number)
4986 enddef
4987 def Foo()
4988 defer Bar(a)
4989 enddef
4990 defcompile
4991 END
4992 v9.CheckScriptFailure(lines, 'E1001: Variable not found: a', 1)
4993enddef
4994
4995" Test for using an non-existing type in a "for" statement.
4996def Test_invalid_type_in_for()
4997 var lines =<< trim END
4998 vim9script
4999 def Foo()
5000 for b: x in range(10)
5001 endfor
5002 enddef
5003 defcompile
5004 END
5005 v9.CheckSourceFailure(lines, 'E1010: Type not recognized: x in range(10)', 1)
5006enddef
5007
5008" Test for using a line break between the variable name and the type in a for
5009" statement.
5010def Test_for_stmt_space_before_type()
5011 var lines =<< trim END
5012 vim9script
5013 def Foo()
5014 for a
5015 :number in range(10)
5016 endfor
5017 enddef
5018 defcompile
5019 END
5020 v9.CheckSourceFailure(lines, 'E1059: No white space allowed before colon: :number in range(10)', 2)
5021enddef
5022
zeertzjqc029c132024-03-28 11:37:26 +01005023" This test used to cause a use-after-free memory access
Yegappan Lakshmanan28d71b52024-01-12 17:21:55 +01005024def Test_for_empty_line_after_lambda()
5025 var lines =<< trim END
5026 vim9script
5027 echomsg range(0, 2)->map((_, v) => {
5028 return 1
5029 })
5030
5031 assert_equal('[1, 1, 1]', v:statusmsg)
5032 END
5033 v9.CheckSourceSuccess(lines)
5034
5035 lines =<< trim END
5036 vim9script
5037 echomsg range(0, 1)->map((_, v) => {
5038 return 1
5039 }) range(0, 1)->map((_, v) => {
5040 return 2
5041 }) # comment
5042
5043 assert_equal('[1, 1] [2, 2]', v:statusmsg)
5044 END
5045 v9.CheckSourceSuccess(lines)
5046enddef
5047
Yegappan Lakshmanan3fa8f772024-04-04 21:42:07 +02005048" Test for evaluating a lambda block from a string
5049def Test_eval_lambda_block()
5050 var lines =<< trim END
5051 vim9script
5052 var Fn = eval("(x: number): number => {\nreturn x * 2\n}")
5053 assert_equal(6, Fn(3))
5054 END
5055 v9.CheckSourceSuccess(lines)
5056enddef
5057
Yegappan Lakshmananda9d3452024-05-02 13:02:36 +02005058" Test for using various null values
5059def Test_null_values()
5060 var lines =<< trim END
5061 var nullValues = [
5062 [null, 1, 'null', 7, 'special'],
5063 [null_blob, 1, '0z', 10, 'blob'],
5064 [null_channel, 1, 'channel fail', 9, 'channel'],
5065 [null_dict, 1, '{}', 4, 'dict<any>'],
5066 [null_function, 1, "function('')", 2, 'func(...): unknown'],
5067 [null_job, 1, 'no process', 8, 'job'],
5068 [null_list, 1, '[]', 3, 'list<any>'],
5069 [null_object, 1, 'object of [unknown]', 13, 'object<Unknown>'],
5070 [null_partial, 1, "function('')", 2, 'func(...): unknown'],
5071 [null_string, 1, "''", 1, 'string']
5072 ]
5073
5074 for [Val, emptyExp, stringExp, typeExp, typenameExp] in nullValues
5075 assert_equal(emptyExp, empty(Val))
5076 assert_equal(stringExp, string(Val))
5077 assert_equal(typeExp, type(Val))
5078 assert_equal(typenameExp, typename(Val))
5079 assert_equal(Val, copy(Val))
5080 assert_equal(-1, test_refcount(Val))
5081 endfor
5082 END
5083 v9.CheckSourceDefAndScriptSuccess(lines)
5084enddef
5085
Bram Moolenaar585fea72020-04-02 22:33:21 +02005086" Keep this last, it messes up highlighting.
5087def Test_substitute_cmd()
5088 new
5089 setline(1, 'something')
5090 :substitute(some(other(
5091 assert_equal('otherthing', getline(1))
5092 bwipe!
5093
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02005094 # also when the context is Vim9 script
Bram Moolenaarcfcd0112020-09-27 15:19:27 +02005095 var lines =<< trim END
Bram Moolenaar585fea72020-04-02 22:33:21 +02005096 vim9script
5097 new
5098 setline(1, 'something')
5099 :substitute(some(other(
5100 assert_equal('otherthing', getline(1))
5101 bwipe!
5102 END
Bram Moolenaardd674772022-09-15 22:26:18 +01005103 writefile(lines, 'Xvim9lines', 'D')
Bram Moolenaar585fea72020-04-02 22:33:21 +02005104 source Xvim9lines
Bram Moolenaar585fea72020-04-02 22:33:21 +02005105enddef
5106
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005107" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker