Mercurial > vim

comparison src/testdir/test_vim9_disassemble.vim @ 22425:eabc059a6ac4 v8.2.1761

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
patch 8.2.1761: Vim9: Some tests are still using :let Commit: https://github.com/vim/vim/commit/ac564082f118ccdca828980c5f10b65a40bffb4d Author: Bram Moolenaar <Bram@vim.org> Date: Sun Sep 27 19:05:33 2020 +0200 patch 8.2.1761: Vim9: Some tests are still using :let Problem: Vim9: Some tests are still using :let. Solution: Change more declarations to use :var.
author Bram Moolenaar <Bram@vim.org>
date Sun, 27 Sep 2020 19:15:03 +0200
parents 15003353a464
children 166a0f17b05e
comparison
equal deleted inserted replaced
22424:2cf3f399bedb 22425:eabc059a6ac4
1 " Test the :disassemble command, and compilation as a side effect 1 " Test the :disassemble command, and compilation as a side effect
2 2
3 source check.vim 3 source check.vim
4
5 " TODO: remove later
6 let v:disallow_let = 1
4 7
5 func NotCompiled() 8 func NotCompiled()
6 echo "not" 9 echo "not"
7 endfunc 10 endfunc
8 11
11 let b:buffervar = 'b' 14 let b:buffervar = 'b'
12 let w:windowvar = 'w' 15 let w:windowvar = 'w'
13 let t:tabpagevar = 't' 16 let t:tabpagevar = 't'
14 17
15 def s:ScriptFuncLoad(arg: string) 18 def s:ScriptFuncLoad(arg: string)
16 let local = 1 19 var local = 1
17 buffers 20 buffers
18 echo arg 21 echo arg
19 echo local 22 echo local
20 echo &lines 23 echo &lines
21 echo v:version 24 echo v:version
39 assert_fails('disass', 'E471:') 42 assert_fails('disass', 'E471:')
40 assert_fails('disass [', 'E475:') 43 assert_fails('disass [', 'E475:')
41 assert_fails('disass 234', 'E129:') 44 assert_fails('disass 234', 'E129:')
42 assert_fails('disass <XX>foo', 'E129:') 45 assert_fails('disass <XX>foo', 'E129:')
43 46
44 let res = execute('disass s:ScriptFuncLoad') 47 var res = execute('disass s:ScriptFuncLoad')
45 assert_match('<SNR>\d*_ScriptFuncLoad.*' .. 48 assert_match('<SNR>\d*_ScriptFuncLoad.*' ..
46 'buffers.*' .. 49 'buffers.*' ..
47 ' EXEC \+buffers.*' .. 50 ' EXEC \+buffers.*' ..
48 ' LOAD arg\[-1\].*' .. 51 ' LOAD arg\[-1\].*' ..
49 ' LOAD $0.*' .. 52 ' LOAD $0.*' ..
74 ' LOADREG @z.*', 77 ' LOADREG @z.*',
75 res) 78 res)
76 enddef 79 enddef
77 80
78 def s:EditExpand() 81 def s:EditExpand()
79 let filename = "file" 82 var filename = "file"
80 let filenr = 123 83 var filenr = 123
81 edit the`=filename``=filenr`.txt 84 edit the`=filename``=filenr`.txt
82 enddef 85 enddef
83 86
84 def Test_disassemble_exec_expr() 87 def Test_disassemble_exec_expr()
85 let res = execute('disass s:EditExpand') 88 var res = execute('disass s:EditExpand')
86 assert_match('<SNR>\d*_EditExpand\_s*' .. 89 assert_match('<SNR>\d*_EditExpand\_s*' ..
87 ' let filename = "file"\_s*' .. 90 ' var filename = "file"\_s*' ..
88 '\d PUSHS "file"\_s*' .. 91 '\d PUSHS "file"\_s*' ..
89 '\d STORE $0\_s*' .. 92 '\d STORE $0\_s*' ..
90 ' let filenr = 123\_s*' .. 93 ' var filenr = 123\_s*' ..
91 '\d STORE 123 in $1\_s*' .. 94 '\d STORE 123 in $1\_s*' ..
92 ' edit the`=filename``=filenr`.txt\_s*' .. 95 ' edit the`=filename``=filenr`.txt\_s*' ..
93 '\d PUSHS "edit the"\_s*' .. 96 '\d PUSHS "edit the"\_s*' ..
94 '\d LOAD $0\_s*' .. 97 '\d LOAD $0\_s*' ..
95 '\d LOAD $1\_s*' .. 98 '\d LOAD $1\_s*' ..
105 norm! m[jjm] 108 norm! m[jjm]
106 :'[,']yank 109 :'[,']yank
107 enddef 110 enddef
108 111
109 def Test_disassemble_yank_range() 112 def Test_disassemble_yank_range()
110 let res = execute('disass s:YankRange') 113 var res = execute('disass s:YankRange')
111 assert_match('<SNR>\d*_YankRange.*' .. 114 assert_match('<SNR>\d*_YankRange.*' ..
112 ' norm! m\[jjm\]\_s*' .. 115 ' norm! m\[jjm\]\_s*' ..
113 '\d EXEC norm! m\[jjm\]\_s*' .. 116 '\d EXEC norm! m\[jjm\]\_s*' ..
114 ' :''\[,''\]yank\_s*' .. 117 ' :''\[,''\]yank\_s*' ..
115 '\d EXEC :''\[,''\]yank\_s*' .. 118 '\d EXEC :''\[,''\]yank\_s*' ..
121 def s:PutExpr() 124 def s:PutExpr()
122 :3put ="text" 125 :3put ="text"
123 enddef 126 enddef
124 127
125 def Test_disassemble_put_expr() 128 def Test_disassemble_put_expr()
126 let res = execute('disass s:PutExpr') 129 var res = execute('disass s:PutExpr')
127 assert_match('<SNR>\d*_PutExpr.*' .. 130 assert_match('<SNR>\d*_PutExpr.*' ..
128 ' :3put ="text"\_s*' .. 131 ' :3put ="text"\_s*' ..
129 '\d PUSHS "text"\_s*' .. 132 '\d PUSHS "text"\_s*' ..
130 '\d PUT = 3\_s*' .. 133 '\d PUT = 3\_s*' ..
131 '\d PUSHNR 0\_s*' .. 134 '\d PUSHNR 0\_s*' ..
132 '\d RETURN', 135 '\d RETURN',
133 res) 136 res)
134 enddef 137 enddef
135 138
136 def s:ScriptFuncPush() 139 def s:ScriptFuncPush()
137 let localbool = true 140 var localbool = true
138 let localspec = v:none 141 var localspec = v:none
139 let localblob = 0z1234 142 var localblob = 0z1234
140 if has('float') 143 if has('float')
141 let localfloat = 1.234 144 var localfloat = 1.234
142 endif 145 endif
143 enddef 146 enddef
144 147
145 def Test_disassemble_push() 148 def Test_disassemble_push()
146 let res = execute('disass s:ScriptFuncPush') 149 var res = execute('disass s:ScriptFuncPush')
147 assert_match('<SNR>\d*_ScriptFuncPush.*' .. 150 assert_match('<SNR>\d*_ScriptFuncPush.*' ..
148 'localbool = true.*' .. 151 'localbool = true.*' ..
149 ' PUSH v:true.*' .. 152 ' PUSH v:true.*' ..
150 'localspec = v:none.*' .. 153 'localspec = v:none.*' ..
151 ' PUSH v:none.*' .. 154 ' PUSH v:none.*' ..
159 res) 162 res)
160 endif 163 endif
161 enddef 164 enddef
162 165
163 def s:ScriptFuncStore() 166 def s:ScriptFuncStore()
164 let localnr = 1 167 var localnr = 1
165 localnr = 2 168 localnr = 2
166 let localstr = 'abc' 169 var localstr = 'abc'
167 localstr = 'xyz' 170 localstr = 'xyz'
168 v:char = 'abc' 171 v:char = 'abc'
169 s:scriptvar = 'sv' 172 s:scriptvar = 'sv'
170 g:globalvar = 'gv' 173 g:globalvar = 'gv'
171 b:buffervar = 'bv' 174 b:buffervar = 'bv'
175 $ENVVAR = 'ev' 178 $ENVVAR = 'ev'
176 @z = 'rv' 179 @z = 'rv'
177 enddef 180 enddef
178 181
179 def Test_disassemble_store() 182 def Test_disassemble_store()
180 let res = execute('disass s:ScriptFuncStore') 183 var res = execute('disass s:ScriptFuncStore')
181 assert_match('<SNR>\d*_ScriptFuncStore.*' .. 184 assert_match('<SNR>\d*_ScriptFuncStore.*' ..
182 'let localnr = 1.*' .. 185 'var localnr = 1.*' ..
183 'localnr = 2.*' .. 186 'localnr = 2.*' ..
184 ' STORE 2 in $0.*' .. 187 ' STORE 2 in $0.*' ..
185 'let localstr = ''abc''.*' .. 188 'var localstr = ''abc''.*' ..
186 'localstr = ''xyz''.*' .. 189 'localstr = ''xyz''.*' ..
187 ' STORE $1.*' .. 190 ' STORE $1.*' ..
188 'v:char = ''abc''.*' .. 191 'v:char = ''abc''.*' ..
189 'STOREV v:char.*' .. 192 'STOREV v:char.*' ..
190 's:scriptvar = ''sv''.*' .. 193 's:scriptvar = ''sv''.*' ..
205 ' STOREREG @z.*', 208 ' STOREREG @z.*',
206 res) 209 res)
207 enddef 210 enddef
208 211
209 def s:ScriptFuncStoreMember() 212 def s:ScriptFuncStoreMember()
210 let locallist: list<number> = [] 213 var locallist: list<number> = []
211 locallist[0] = 123 214 locallist[0] = 123
212 let localdict: dict<number> = {} 215 var localdict: dict<number> = {}
213 localdict["a"] = 456 216 localdict["a"] = 456
214 enddef 217 enddef
215 218
216 def Test_disassemble_store_member() 219 def Test_disassemble_store_member()
217 let res = execute('disass s:ScriptFuncStoreMember') 220 var res = execute('disass s:ScriptFuncStoreMember')
218 assert_match('<SNR>\d*_ScriptFuncStoreMember\_s*' .. 221 assert_match('<SNR>\d*_ScriptFuncStoreMember\_s*' ..
219 'let locallist: list<number> = []\_s*' .. 222 'var locallist: list<number> = []\_s*' ..
220 '\d NEWLIST size 0\_s*' .. 223 '\d NEWLIST size 0\_s*' ..
221 '\d STORE $0\_s*' .. 224 '\d STORE $0\_s*' ..
222 'locallist\[0\] = 123\_s*' .. 225 'locallist\[0\] = 123\_s*' ..
223 '\d PUSHNR 123\_s*' .. 226 '\d PUSHNR 123\_s*' ..
224 '\d PUSHNR 0\_s*' .. 227 '\d PUSHNR 0\_s*' ..
225 '\d LOAD $0\_s*' .. 228 '\d LOAD $0\_s*' ..
226 '\d STORELIST\_s*' .. 229 '\d STORELIST\_s*' ..
227 'let localdict: dict<number> = {}\_s*' .. 230 'var localdict: dict<number> = {}\_s*' ..
228 '\d NEWDICT size 0\_s*' .. 231 '\d NEWDICT size 0\_s*' ..
229 '\d STORE $1\_s*' .. 232 '\d STORE $1\_s*' ..
230 'localdict\["a"\] = 456\_s*' .. 233 'localdict\["a"\] = 456\_s*' ..
231 '\d\+ PUSHNR 456\_s*' .. 234 '\d\+ PUSHNR 456\_s*' ..
232 '\d\+ PUSHS "a"\_s*' .. 235 '\d\+ PUSHS "a"\_s*' ..
236 '\d\+ RETURN', 239 '\d\+ RETURN',
237 res) 240 res)
238 enddef 241 enddef
239 242
240 def s:ListAssign() 243 def s:ListAssign()
241 let x: string 244 var x: string
242 let y: string 245 var y: string
243 let l: list<any> 246 var l: list<any>
244 [x, y; l] = g:stringlist 247 [x, y; l] = g:stringlist
245 enddef 248 enddef
246 249
247 def Test_disassemble_list_assign() 250 def Test_disassemble_list_assign()
248 let res = execute('disass s:ListAssign') 251 var res = execute('disass s:ListAssign')
249 assert_match('<SNR>\d*_ListAssign\_s*' .. 252 assert_match('<SNR>\d*_ListAssign\_s*' ..
250 'let x: string\_s*' .. 253 'var x: string\_s*' ..
251 '\d PUSHS "\[NULL\]"\_s*' .. 254 '\d PUSHS "\[NULL\]"\_s*' ..
252 '\d STORE $0\_s*' .. 255 '\d STORE $0\_s*' ..
253 'let y: string\_s*' .. 256 'var y: string\_s*' ..
254 '\d PUSHS "\[NULL\]"\_s*' .. 257 '\d PUSHS "\[NULL\]"\_s*' ..
255 '\d STORE $1\_s*' .. 258 '\d STORE $1\_s*' ..
256 'let l: list<any>\_s*' .. 259 'var l: list<any>\_s*' ..
257 '\d NEWLIST size 0\_s*' .. 260 '\d NEWLIST size 0\_s*' ..
258 '\d STORE $2\_s*' .. 261 '\d STORE $2\_s*' ..
259 '\[x, y; l\] = g:stringlist\_s*' .. 262 '\[x, y; l\] = g:stringlist\_s*' ..
260 '\d LOADG g:stringlist\_s*' .. 263 '\d LOADG g:stringlist\_s*' ..
261 '\d CHECKTYPE list<any> stack\[-1\]\_s*' .. 264 '\d CHECKTYPE list<any> stack\[-1\]\_s*' ..
279 unlet! g:somevar 282 unlet! g:somevar
280 unlet $SOMEVAR 283 unlet $SOMEVAR
281 enddef 284 enddef
282 285
283 def Test_disassemble_unlet() 286 def Test_disassemble_unlet()
284 let res = execute('disass s:ScriptFuncUnlet') 287 var res = execute('disass s:ScriptFuncUnlet')
285 assert_match('<SNR>\d*_ScriptFuncUnlet\_s*' .. 288 assert_match('<SNR>\d*_ScriptFuncUnlet\_s*' ..
286 'g:somevar = "value"\_s*' .. 289 'g:somevar = "value"\_s*' ..
287 '\d PUSHS "value"\_s*' .. 290 '\d PUSHS "value"\_s*' ..
288 '\d STOREG g:somevar\_s*' .. 291 '\d STOREG g:somevar\_s*' ..
289 'unlet g:somevar\_s*' .. 292 'unlet g:somevar\_s*' ..
304 throw "end" 307 throw "end"
305 endtry 308 endtry
306 enddef 309 enddef
307 310
308 def Test_disassemble_try() 311 def Test_disassemble_try()
309 let res = execute('disass s:ScriptFuncTry') 312 var res = execute('disass s:ScriptFuncTry')
310 assert_match('<SNR>\d*_ScriptFuncTry\_s*' .. 313 assert_match('<SNR>\d*_ScriptFuncTry\_s*' ..
311 'try\_s*' .. 314 'try\_s*' ..
312 '\d TRY catch -> \d\+, finally -> \d\+\_s*' .. 315 '\d TRY catch -> \d\+, finally -> \d\+\_s*' ..
313 'echo "yes"\_s*' .. 316 'echo "yes"\_s*' ..
314 '\d PUSHS "yes"\_s*' .. 317 '\d PUSHS "yes"\_s*' ..
331 '\d\+ ENDTRY', 334 '\d\+ ENDTRY',
332 res) 335 res)
333 enddef 336 enddef
334 337
335 def s:ScriptFuncNew() 338 def s:ScriptFuncNew()
336 let ll = [1, "two", 333] 339 var ll = [1, "two", 333]
337 let dd = #{one: 1, two: "val"} 340 var dd = #{one: 1, two: "val"}
338 enddef 341 enddef
339 342
340 def Test_disassemble_new() 343 def Test_disassemble_new()
341 let res = execute('disass s:ScriptFuncNew') 344 var res = execute('disass s:ScriptFuncNew')
342 assert_match('<SNR>\d*_ScriptFuncNew\_s*' .. 345 assert_match('<SNR>\d*_ScriptFuncNew\_s*' ..
343 'let ll = \[1, "two", 333\]\_s*' .. 346 'var ll = \[1, "two", 333\]\_s*' ..
344 '\d PUSHNR 1\_s*' .. 347 '\d PUSHNR 1\_s*' ..
345 '\d PUSHS "two"\_s*' .. 348 '\d PUSHS "two"\_s*' ..
346 '\d PUSHNR 333\_s*' .. 349 '\d PUSHNR 333\_s*' ..
347 '\d NEWLIST size 3\_s*' .. 350 '\d NEWLIST size 3\_s*' ..
348 '\d STORE $0\_s*' .. 351 '\d STORE $0\_s*' ..
349 'let dd = #{one: 1, two: "val"}\_s*' .. 352 'var dd = #{one: 1, two: "val"}\_s*' ..
350 '\d PUSHS "one"\_s*' .. 353 '\d PUSHS "one"\_s*' ..
351 '\d PUSHNR 1\_s*' .. 354 '\d PUSHNR 1\_s*' ..
352 '\d PUSHS "two"\_s*' .. 355 '\d PUSHS "two"\_s*' ..
353 '\d PUSHS "val"\_s*' .. 356 '\d PUSHS "val"\_s*' ..
354 '\d NEWDICT size 2\_s*', 357 '\d NEWDICT size 2\_s*',
374 FuncWithArg(343) 377 FuncWithArg(343)
375 ScriptFuncNew() 378 ScriptFuncNew()
376 s:ScriptFuncNew() 379 s:ScriptFuncNew()
377 UserFunc() 380 UserFunc()
378 UserFuncWithArg("foo") 381 UserFuncWithArg("foo")
379 let FuncRef = function("UserFunc") 382 var FuncRef = function("UserFunc")
380 FuncRef() 383 FuncRef()
381 let FuncRefWithArg = function("UserFuncWithArg") 384 var FuncRefWithArg = function("UserFuncWithArg")
382 FuncRefWithArg("bar") 385 FuncRefWithArg("bar")
383 return "yes" 386 return "yes"
384 enddef 387 enddef
385 388
386 def Test_disassemble_call() 389 def Test_disassemble_call()
387 let res = execute('disass s:ScriptFuncCall') 390 var res = execute('disass s:ScriptFuncCall')
388 assert_match('<SNR>\d\+_ScriptFuncCall\_s*' .. 391 assert_match('<SNR>\d\+_ScriptFuncCall\_s*' ..
389 'changenr()\_s*' .. 392 'changenr()\_s*' ..
390 '\d BCALL changenr(argc 0)\_s*' .. 393 '\d BCALL changenr(argc 0)\_s*' ..
391 '\d DROP\_s*' .. 394 '\d DROP\_s*' ..
392 'char2nr("abc")\_s*' .. 395 'char2nr("abc")\_s*' ..
411 '\d\+ DROP\_s*' .. 414 '\d\+ DROP\_s*' ..
412 'UserFuncWithArg("foo")\_s*' .. 415 'UserFuncWithArg("foo")\_s*' ..
413 '\d\+ PUSHS "foo"\_s*' .. 416 '\d\+ PUSHS "foo"\_s*' ..
414 '\d\+ UCALL UserFuncWithArg(argc 1)\_s*' .. 417 '\d\+ UCALL UserFuncWithArg(argc 1)\_s*' ..
415 '\d\+ DROP\_s*' .. 418 '\d\+ DROP\_s*' ..
416 'let FuncRef = function("UserFunc")\_s*' .. 419 'var FuncRef = function("UserFunc")\_s*' ..
417 '\d\+ PUSHS "UserFunc"\_s*' .. 420 '\d\+ PUSHS "UserFunc"\_s*' ..
418 '\d\+ BCALL function(argc 1)\_s*' .. 421 '\d\+ BCALL function(argc 1)\_s*' ..
419 '\d\+ STORE $0\_s*' .. 422 '\d\+ STORE $0\_s*' ..
420 'FuncRef()\_s*' .. 423 'FuncRef()\_s*' ..
421 '\d\+ LOAD $\d\_s*' .. 424 '\d\+ LOAD $\d\_s*' ..
422 '\d\+ PCALL (argc 0)\_s*' .. 425 '\d\+ PCALL (argc 0)\_s*' ..
423 '\d\+ DROP\_s*' .. 426 '\d\+ DROP\_s*' ..
424 'let FuncRefWithArg = function("UserFuncWithArg")\_s*' .. 427 'var FuncRefWithArg = function("UserFuncWithArg")\_s*' ..
425 '\d\+ PUSHS "UserFuncWithArg"\_s*' .. 428 '\d\+ PUSHS "UserFuncWithArg"\_s*' ..
426 '\d\+ BCALL function(argc 1)\_s*' .. 429 '\d\+ BCALL function(argc 1)\_s*' ..
427 '\d\+ STORE $1\_s*' .. 430 '\d\+ STORE $1\_s*' ..
428 'FuncRefWithArg("bar")\_s*' .. 431 'FuncRefWithArg("bar")\_s*' ..
429 '\d\+ PUSHS "bar"\_s*' .. 432 '\d\+ PUSHS "bar"\_s*' ..
435 '\d\+ RETURN', 438 '\d\+ RETURN',
436 res) 439 res)
437 enddef 440 enddef
438 441
439 def s:CreateRefs() 442 def s:CreateRefs()
440 let local = 'a' 443 var local = 'a'
441 def Append(arg: string) 444 def Append(arg: string)
442 local ..= arg 445 local ..= arg
443 enddef 446 enddef
444 g:Append = Append 447 g:Append = Append
445 def Get(): string 448 def Get(): string
448 g:Get = Get 451 g:Get = Get
449 enddef 452 enddef
450 453
451 def Test_disassemble_closure() 454 def Test_disassemble_closure()
452 CreateRefs() 455 CreateRefs()
453 let res = execute('disass g:Append') 456 var res = execute('disass g:Append')
454 assert_match('<lambda>\d\_s*' .. 457 assert_match('<lambda>\d\_s*' ..
455 'local ..= arg\_s*' .. 458 'local ..= arg\_s*' ..
456 '\d LOADOUTER $0\_s*' .. 459 '\d LOADOUTER $0\_s*' ..
457 '\d LOAD arg\[-1\]\_s*' .. 460 '\d LOAD arg\[-1\]\_s*' ..
458 '\d CONCAT\_s*' .. 461 '\d CONCAT\_s*' ..
482 def s:ScriptPCall() 485 def s:ScriptPCall()
483 RefThis()("text") 486 RefThis()("text")
484 enddef 487 enddef
485 488
486 def Test_disassemble_pcall() 489 def Test_disassemble_pcall()
487 let res = execute('disass s:ScriptPCall') 490 var res = execute('disass s:ScriptPCall')
488 assert_match('<SNR>\d\+_ScriptPCall\_s*' .. 491 assert_match('<SNR>\d\+_ScriptPCall\_s*' ..
489 'RefThis()("text")\_s*' .. 492 'RefThis()("text")\_s*' ..
490 '\d DCALL RefThis(argc 0)\_s*' .. 493 '\d DCALL RefThis(argc 0)\_s*' ..
491 '\d PUSHS "text"\_s*' .. 494 '\d PUSHS "text"\_s*' ..
492 '\d PCALL top (argc 1)\_s*' .. 495 '\d PCALL top (argc 1)\_s*' ..
505 def DefinedLater(arg: string): string 508 def DefinedLater(arg: string): string
506 return arg 509 return arg
507 enddef 510 enddef
508 511
509 def Test_disassemble_update_instr() 512 def Test_disassemble_update_instr()
510 let res = execute('disass s:FuncWithForwardCall') 513 var res = execute('disass s:FuncWithForwardCall')
511 assert_match('FuncWithForwardCall\_s*' .. 514 assert_match('FuncWithForwardCall\_s*' ..
512 'return g:DefinedLater("yes")\_s*' .. 515 'return g:DefinedLater("yes")\_s*' ..
513 '\d PUSHS "yes"\_s*' .. 516 '\d PUSHS "yes"\_s*' ..
514 '\d DCALL DefinedLater(argc 1)\_s*' .. 517 '\d DCALL DefinedLater(argc 1)\_s*' ..
515 '\d RETURN', 518 '\d RETURN',
531 def FuncWithDefault(arg: string = 'default'): string 534 def FuncWithDefault(arg: string = 'default'): string
532 return arg 535 return arg
533 enddef 536 enddef
534 537
535 def Test_disassemble_call_default() 538 def Test_disassemble_call_default()
536 let res = execute('disass FuncWithDefault') 539 var res = execute('disass FuncWithDefault')
537 assert_match('FuncWithDefault\_s*' .. 540 assert_match('FuncWithDefault\_s*' ..
538 '\d PUSHS "default"\_s*' .. 541 '\d PUSHS "default"\_s*' ..
539 '\d STORE arg\[-1]\_s*' .. 542 '\d STORE arg\[-1]\_s*' ..
540 'return arg\_s*' .. 543 'return arg\_s*' ..
541 '\d LOAD arg\[-1]\_s*' .. 544 '\d LOAD arg\[-1]\_s*' ..
572 endif 575 endif
573 enddef 576 enddef
574 577
575 def Test_disassemble_const_expr() 578 def Test_disassemble_const_expr()
576 assert_equal("\nyes", execute('HasEval()')) 579 assert_equal("\nyes", execute('HasEval()'))
577 let instr = execute('disassemble HasEval') 580 var instr = execute('disassemble HasEval')
578 assert_match('HasEval\_s*' .. 581 assert_match('HasEval\_s*' ..
579 'if has("eval")\_s*' .. 582 'if has("eval")\_s*' ..
580 'echo "yes"\_s*' .. 583 'echo "yes"\_s*' ..
581 '\d PUSHS "yes"\_s*' .. 584 '\d PUSHS "yes"\_s*' ..
582 '\d ECHO 1\_s*' .. 585 '\d ECHO 1\_s*' ..
628 return "no" 631 return "no"
629 endif 632 endif
630 enddef 633 enddef
631 634
632 def Test_disassemble_return_in_if() 635 def Test_disassemble_return_in_if()
633 let instr = execute('disassemble ReturnInIf') 636 var instr = execute('disassemble ReturnInIf')
634 assert_match('ReturnInIf\_s*' .. 637 assert_match('ReturnInIf\_s*' ..
635 'if g:cond\_s*' .. 638 'if g:cond\_s*' ..
636 '0 LOADG g:cond\_s*' .. 639 '0 LOADG g:cond\_s*' ..
637 '1 JUMP_IF_FALSE -> 4\_s*' .. 640 '1 JUMP_IF_FALSE -> 4\_s*' ..
638 'return "yes"\_s*' .. 641 'return "yes"\_s*' ..
644 '5 RETURN$', 647 '5 RETURN$',
645 instr) 648 instr)
646 enddef 649 enddef
647 650
648 def WithFunc() 651 def WithFunc()
649 let Funky1: func 652 var Funky1: func
650 let Funky2: func = function("len") 653 var Funky2: func = function("len")
651 let Party2: func = funcref("UserFunc") 654 var Party2: func = funcref("UserFunc")
652 enddef 655 enddef
653 656
654 def Test_disassemble_function() 657 def Test_disassemble_function()
655 let instr = execute('disassemble WithFunc') 658 var instr = execute('disassemble WithFunc')
656 assert_match('WithFunc\_s*' .. 659 assert_match('WithFunc\_s*' ..
657 'let Funky1: func\_s*' .. 660 'var Funky1: func\_s*' ..
658 '0 PUSHFUNC "\[none]"\_s*' .. 661 '0 PUSHFUNC "\[none]"\_s*' ..
659 '1 STORE $0\_s*' .. 662 '1 STORE $0\_s*' ..
660 'let Funky2: func = function("len")\_s*' .. 663 'var Funky2: func = function("len")\_s*' ..
661 '2 PUSHS "len"\_s*' .. 664 '2 PUSHS "len"\_s*' ..
662 '3 BCALL function(argc 1)\_s*' .. 665 '3 BCALL function(argc 1)\_s*' ..
663 '4 STORE $1\_s*' .. 666 '4 STORE $1\_s*' ..
664 'let Party2: func = funcref("UserFunc")\_s*' .. 667 'var Party2: func = funcref("UserFunc")\_s*' ..
665 '\d PUSHS "UserFunc"\_s*' .. 668 '\d PUSHS "UserFunc"\_s*' ..
666 '\d BCALL funcref(argc 1)\_s*' .. 669 '\d BCALL funcref(argc 1)\_s*' ..
667 '\d STORE $2\_s*' .. 670 '\d STORE $2\_s*' ..
668 '\d PUSHNR 0\_s*' .. 671 '\d PUSHNR 0\_s*' ..
669 '\d RETURN', 672 '\d RETURN',
670 instr) 673 instr)
671 enddef 674 enddef
672 675
673 if has('channel') 676 if has('channel')
674 def WithChannel() 677 def WithChannel()
675 let job1: job 678 var job1: job
676 let job2: job = job_start("donothing") 679 var job2: job = job_start("donothing")
677 let chan1: channel 680 var chan1: channel
678 enddef 681 enddef
679 endif 682 endif
680 683
681 def Test_disassemble_channel() 684 def Test_disassemble_channel()
682 CheckFeature channel 685 CheckFeature channel
683 686
684 let instr = execute('disassemble WithChannel') 687 var instr = execute('disassemble WithChannel')
685 assert_match('WithChannel\_s*' .. 688 assert_match('WithChannel\_s*' ..
686 'let job1: job\_s*' .. 689 'var job1: job\_s*' ..
687 '\d PUSHJOB "no process"\_s*' .. 690 '\d PUSHJOB "no process"\_s*' ..
688 '\d STORE $0\_s*' .. 691 '\d STORE $0\_s*' ..
689 'let job2: job = job_start("donothing")\_s*' .. 692 'var job2: job = job_start("donothing")\_s*' ..
690 '\d PUSHS "donothing"\_s*' .. 693 '\d PUSHS "donothing"\_s*' ..
691 '\d BCALL job_start(argc 1)\_s*' .. 694 '\d BCALL job_start(argc 1)\_s*' ..
692 '\d STORE $1\_s*' .. 695 '\d STORE $1\_s*' ..
693 'let chan1: channel\_s*' .. 696 'var chan1: channel\_s*' ..
694 '\d PUSHCHANNEL 0\_s*' .. 697 '\d PUSHCHANNEL 0\_s*' ..
695 '\d STORE $2\_s*' .. 698 '\d STORE $2\_s*' ..
696 '\d PUSHNR 0\_s*' .. 699 '\d PUSHNR 0\_s*' ..
697 '\d RETURN', 700 '\d RETURN',
698 instr) 701 instr)
699 enddef 702 enddef
700 703
701 def WithLambda(): string 704 def WithLambda(): string
702 let F = {a -> "X" .. a .. "X"} 705 var F = {a -> "X" .. a .. "X"}
703 return F("x") 706 return F("x")
704 enddef 707 enddef
705 708
706 def Test_disassemble_lambda() 709 def Test_disassemble_lambda()
707 assert_equal("XxX", WithLambda()) 710 assert_equal("XxX", WithLambda())
708 let instr = execute('disassemble WithLambda') 711 var instr = execute('disassemble WithLambda')
709 assert_match('WithLambda\_s*' .. 712 assert_match('WithLambda\_s*' ..
710 'let F = {a -> "X" .. a .. "X"}\_s*' .. 713 'var F = {a -> "X" .. a .. "X"}\_s*' ..
711 '\d FUNCREF <lambda>\d\+\_s*' .. 714 '\d FUNCREF <lambda>\d\+\_s*' ..
712 '\d STORE $0\_s*' .. 715 '\d STORE $0\_s*' ..
713 'return F("x")\_s*' .. 716 'return F("x")\_s*' ..
714 '\d PUSHS "x"\_s*' .. 717 '\d PUSHS "x"\_s*' ..
715 '\d LOAD $0\_s*' .. 718 '\d LOAD $0\_s*' ..
716 '\d PCALL (argc 1)\_s*' .. 719 '\d PCALL (argc 1)\_s*' ..
717 '\d RETURN', 720 '\d RETURN',
718 instr) 721 instr)
719 722
720 let name = substitute(instr, '.*\(<lambda>\d\+\).*', '\1', '') 723 var name = substitute(instr, '.*\(<lambda>\d\+\).*', '\1', '')
721 instr = execute('disassemble ' .. name) 724 instr = execute('disassemble ' .. name)
722 assert_match('<lambda>\d\+\_s*' .. 725 assert_match('<lambda>\d\+\_s*' ..
723 'return "X" .. a .. "X"\_s*' .. 726 'return "X" .. a .. "X"\_s*' ..
724 '\d PUSHS "X"\_s*' .. 727 '\d PUSHS "X"\_s*' ..
725 '\d LOAD arg\[-1\]\_s*' .. 728 '\d LOAD arg\[-1\]\_s*' ..
736 echomsg "inner" 739 echomsg "inner"
737 enddef 740 enddef
738 enddef 741 enddef
739 742
740 def Test_nested_func() 743 def Test_nested_func()
741 let instr = execute('disassemble NestedOuter') 744 var instr = execute('disassemble NestedOuter')
742 assert_match('NestedOuter\_s*' .. 745 assert_match('NestedOuter\_s*' ..
743 'def g:Inner()\_s*' .. 746 'def g:Inner()\_s*' ..
744 'echomsg "inner"\_s*' .. 747 'echomsg "inner"\_s*' ..
745 'enddef\_s*' .. 748 'enddef\_s*' ..
746 '\d NEWFUNC <lambda>\d\+ Inner\_s*' .. 749 '\d NEWFUNC <lambda>\d\+ Inner\_s*' ..
758 761
759 def Test_disassemble_and_or() 762 def Test_disassemble_and_or()
760 assert_equal("yes", AndOr(1)) 763 assert_equal("yes", AndOr(1))
761 assert_equal("no", AndOr(2)) 764 assert_equal("no", AndOr(2))
762 assert_equal("yes", AndOr(4)) 765 assert_equal("yes", AndOr(4))
763 let instr = execute('disassemble AndOr') 766 var instr = execute('disassemble AndOr')
764 assert_match('AndOr\_s*' .. 767 assert_match('AndOr\_s*' ..
765 'if arg == 1 && arg != 2 || arg == 4\_s*' .. 768 'if arg == 1 && arg != 2 || arg == 4\_s*' ..
766 '\d LOAD arg\[-1]\_s*' .. 769 '\d LOAD arg\[-1]\_s*' ..
767 '\d PUSHNR 1\_s*' .. 770 '\d PUSHNR 1\_s*' ..
768 '\d COMPAREANY ==\_s*' .. 771 '\d COMPAREANY ==\_s*' ..
777 '\d\+ JUMP_IF_FALSE -> \d\+', 780 '\d\+ JUMP_IF_FALSE -> \d\+',
778 instr) 781 instr)
779 enddef 782 enddef
780 783
781 def ForLoop(): list<number> 784 def ForLoop(): list<number>
782 let res: list<number> 785 var res: list<number>
783 for i in range(3) 786 for i in range(3)
784 res->add(i) 787 res->add(i)
785 endfor 788 endfor
786 return res 789 return res
787 enddef 790 enddef
788 791
789 def Test_disassemble_for_loop() 792 def Test_disassemble_for_loop()
790 assert_equal([0, 1, 2], ForLoop()) 793 assert_equal([0, 1, 2], ForLoop())
791 let instr = execute('disassemble ForLoop') 794 var instr = execute('disassemble ForLoop')
792 assert_match('ForLoop\_s*' .. 795 assert_match('ForLoop\_s*' ..
793 'let res: list<number>\_s*' .. 796 'var res: list<number>\_s*' ..
794 '\d NEWLIST size 0\_s*' .. 797 '\d NEWLIST size 0\_s*' ..
795 '\d STORE $0\_s*' .. 798 '\d STORE $0\_s*' ..
796 'for i in range(3)\_s*' .. 799 'for i in range(3)\_s*' ..
797 '\d STORE -1 in $1\_s*' .. 800 '\d STORE -1 in $1\_s*' ..
798 '\d PUSHNR 3\_s*' .. 801 '\d PUSHNR 3\_s*' ..
809 '\d\+ DROP', 812 '\d\+ DROP',
810 instr) 813 instr)
811 enddef 814 enddef
812 815
813 def ForLoopEval(): string 816 def ForLoopEval(): string
814 let res = "" 817 var res = ""
815 for str in eval('["one", "two"]') 818 for str in eval('["one", "two"]')
816 res ..= str 819 res ..= str
817 endfor 820 endfor
818 return res 821 return res
819 enddef 822 enddef
820 823
821 def Test_disassemble_for_loop_eval() 824 def Test_disassemble_for_loop_eval()
822 assert_equal('onetwo', ForLoopEval()) 825 assert_equal('onetwo', ForLoopEval())
823 let instr = execute('disassemble ForLoopEval') 826 var instr = execute('disassemble ForLoopEval')
824 assert_match('ForLoopEval\_s*' .. 827 assert_match('ForLoopEval\_s*' ..
825 'let res = ""\_s*' .. 828 'var res = ""\_s*' ..
826 '\d PUSHS ""\_s*' .. 829 '\d PUSHS ""\_s*' ..
827 '\d STORE $0\_s*' .. 830 '\d STORE $0\_s*' ..
828 'for str in eval(''\["one", "two"\]'')\_s*' .. 831 'for str in eval(''\["one", "two"\]'')\_s*' ..
829 '\d STORE -1 in $1\_s*' .. 832 '\d STORE -1 in $1\_s*' ..
830 '\d PUSHS "\["one", "two"\]"\_s*' .. 833 '\d PUSHS "\["one", "two"\]"\_s*' ..
848 enddef 851 enddef
849 852
850 let g:number = 42 853 let g:number = 42
851 854
852 def TypeCast() 855 def TypeCast()
853 let l: list<number> = [23, <number>g:number] 856 var l: list<number> = [23, <number>g:number]
854 enddef 857 enddef
855 858
856 def Test_disassemble_typecast() 859 def Test_disassemble_typecast()
857 let instr = execute('disassemble TypeCast') 860 var instr = execute('disassemble TypeCast')
858 assert_match('TypeCast.*' .. 861 assert_match('TypeCast.*' ..
859 'let l: list<number> = \[23, <number>g:number\].*' .. 862 'var l: list<number> = \[23, <number>g:number\].*' ..
860 '\d PUSHNR 23\_s*' .. 863 '\d PUSHNR 23\_s*' ..
861 '\d LOADG g:number\_s*' .. 864 '\d LOADG g:number\_s*' ..
862 '\d CHECKTYPE number stack\[-1\]\_s*' .. 865 '\d CHECKTYPE number stack\[-1\]\_s*' ..
863 '\d NEWLIST size 2\_s*' .. 866 '\d NEWLIST size 2\_s*' ..
864 '\d STORE $0\_s*' .. 867 '\d STORE $0\_s*' ..
866 '\d RETURN\_s*', 869 '\d RETURN\_s*',
867 instr) 870 instr)
868 enddef 871 enddef
869 872
870 def Computing() 873 def Computing()
871 let nr = 3 874 var nr = 3
872 let nrres = nr + 7 875 var nrres = nr + 7
873 nrres = nr - 7 876 nrres = nr - 7
874 nrres = nr * 7 877 nrres = nr * 7
875 nrres = nr / 7 878 nrres = nr / 7
876 nrres = nr % 7 879 nrres = nr % 7
877 880
878 let anyres = g:number + 7 881 var anyres = g:number + 7
879 anyres = g:number - 7 882 anyres = g:number - 7
880 anyres = g:number * 7 883 anyres = g:number * 7
881 anyres = g:number / 7 884 anyres = g:number / 7
882 anyres = g:number % 7 885 anyres = g:number % 7
883 886
884 if has('float') 887 if has('float')
885 let fl = 3.0 888 var fl = 3.0
886 let flres = fl + 7.0 889 var flres = fl + 7.0
887 flres = fl - 7.0 890 flres = fl - 7.0
888 flres = fl * 7.0 891 flres = fl * 7.0
889 flres = fl / 7.0 892 flres = fl / 7.0
890 endif 893 endif
891 enddef 894 enddef
892 895
893 def Test_disassemble_computing() 896 def Test_disassemble_computing()
894 let instr = execute('disassemble Computing') 897 var instr = execute('disassemble Computing')
895 assert_match('Computing.*' .. 898 assert_match('Computing.*' ..
896 'let nr = 3.*' .. 899 'var nr = 3.*' ..
897 '\d STORE 3 in $0.*' .. 900 '\d STORE 3 in $0.*' ..
898 'let nrres = nr + 7.*' .. 901 'var nrres = nr + 7.*' ..
899 '\d LOAD $0.*' .. 902 '\d LOAD $0.*' ..
900 '\d PUSHNR 7.*' .. 903 '\d PUSHNR 7.*' ..
901 '\d OPNR +.*' .. 904 '\d OPNR +.*' ..
902 '\d STORE $1.*' .. 905 '\d STORE $1.*' ..
903 'nrres = nr - 7.*' .. 906 'nrres = nr - 7.*' ..
906 '\d OPNR \*.*' .. 909 '\d OPNR \*.*' ..
907 'nrres = nr / 7.*' .. 910 'nrres = nr / 7.*' ..
908 '\d OPNR /.*' .. 911 '\d OPNR /.*' ..
909 'nrres = nr % 7.*' .. 912 'nrres = nr % 7.*' ..
910 '\d OPNR %.*' .. 913 '\d OPNR %.*' ..
911 'let anyres = g:number + 7.*' .. 914 'var anyres = g:number + 7.*' ..
912 '\d LOADG g:number.*' .. 915 '\d LOADG g:number.*' ..
913 '\d PUSHNR 7.*' .. 916 '\d PUSHNR 7.*' ..
914 '\d OPANY +.*' .. 917 '\d OPANY +.*' ..
915 '\d STORE $2.*' .. 918 '\d STORE $2.*' ..
916 'anyres = g:number - 7.*' .. 919 'anyres = g:number - 7.*' ..
922 'anyres = g:number % 7.*' .. 925 'anyres = g:number % 7.*' ..
923 '\d OPANY %.*', 926 '\d OPANY %.*',
924 instr) 927 instr)
925 if has('float') 928 if has('float')
926 assert_match('Computing.*' .. 929 assert_match('Computing.*' ..
927 'let fl = 3.0.*' .. 930 'var fl = 3.0.*' ..
928 '\d PUSHF 3.0.*' .. 931 '\d PUSHF 3.0.*' ..
929 '\d STORE $3.*' .. 932 '\d STORE $3.*' ..
930 'let flres = fl + 7.0.*' .. 933 'var flres = fl + 7.0.*' ..
931 '\d LOAD $3.*' .. 934 '\d LOAD $3.*' ..
932 '\d PUSHF 7.0.*' .. 935 '\d PUSHF 7.0.*' ..
933 '\d OPFLOAT +.*' .. 936 '\d OPFLOAT +.*' ..
934 '\d STORE $4.*' .. 937 '\d STORE $4.*' ..
935 'flres = fl - 7.0.*' .. 938 'flres = fl - 7.0.*' ..
941 instr) 944 instr)
942 endif 945 endif
943 enddef 946 enddef
944 947
945 def AddListBlob() 948 def AddListBlob()
946 let reslist = [1, 2] + [3, 4] 949 var reslist = [1, 2] + [3, 4]
947 let resblob = 0z1122 + 0z3344 950 var resblob = 0z1122 + 0z3344
948 enddef 951 enddef
949 952
950 def Test_disassemble_add_list_blob() 953 def Test_disassemble_add_list_blob()
951 let instr = execute('disassemble AddListBlob') 954 var instr = execute('disassemble AddListBlob')
952 assert_match('AddListBlob.*' .. 955 assert_match('AddListBlob.*' ..
953 'let reslist = \[1, 2] + \[3, 4].*' .. 956 'var reslist = \[1, 2] + \[3, 4].*' ..
954 '\d PUSHNR 1.*' .. 957 '\d PUSHNR 1.*' ..
955 '\d PUSHNR 2.*' .. 958 '\d PUSHNR 2.*' ..
956 '\d NEWLIST size 2.*' .. 959 '\d NEWLIST size 2.*' ..
957 '\d PUSHNR 3.*' .. 960 '\d PUSHNR 3.*' ..
958 '\d PUSHNR 4.*' .. 961 '\d PUSHNR 4.*' ..
959 '\d NEWLIST size 2.*' .. 962 '\d NEWLIST size 2.*' ..
960 '\d ADDLIST.*' .. 963 '\d ADDLIST.*' ..
961 '\d STORE $.*.*' .. 964 '\d STORE $.*.*' ..
962 'let resblob = 0z1122 + 0z3344.*' .. 965 'var resblob = 0z1122 + 0z3344.*' ..
963 '\d PUSHBLOB 0z1122.*' .. 966 '\d PUSHBLOB 0z1122.*' ..
964 '\d PUSHBLOB 0z3344.*' .. 967 '\d PUSHBLOB 0z3344.*' ..
965 '\d ADDBLOB.*' .. 968 '\d ADDBLOB.*' ..
966 '\d STORE $.*', 969 '\d STORE $.*',
967 instr) 970 instr)
968 enddef 971 enddef
969 972
970 let g:aa = 'aa' 973 let g:aa = 'aa'
971 def ConcatString(): string 974 def ConcatString(): string
972 let res = g:aa .. "bb" 975 var res = g:aa .. "bb"
973 return res 976 return res
974 enddef 977 enddef
975 978
976 def Test_disassemble_concat() 979 def Test_disassemble_concat()
977 let instr = execute('disassemble ConcatString') 980 var instr = execute('disassemble ConcatString')
978 assert_match('ConcatString.*' .. 981 assert_match('ConcatString.*' ..
979 'let res = g:aa .. "bb".*' .. 982 'var res = g:aa .. "bb".*' ..
980 '\d LOADG g:aa.*' .. 983 '\d LOADG g:aa.*' ..
981 '\d PUSHS "bb".*' .. 984 '\d PUSHS "bb".*' ..
982 '\d 2STRING_ANY stack\[-2].*' .. 985 '\d 2STRING_ANY stack\[-2].*' ..
983 '\d CONCAT.*' .. 986 '\d CONCAT.*' ..
984 '\d STORE $.*', 987 '\d STORE $.*',
985 instr) 988 instr)
986 assert_equal('aabb', ConcatString()) 989 assert_equal('aabb', ConcatString())
987 enddef 990 enddef
988 991
989 def StringIndex(): string 992 def StringIndex(): string
990 let s = "abcd" 993 var s = "abcd"
991 let res = s[1] 994 var res = s[1]
992 return res 995 return res
993 enddef 996 enddef
994 997
995 def Test_disassemble_string_index() 998 def Test_disassemble_string_index()
996 let instr = execute('disassemble StringIndex') 999 var instr = execute('disassemble StringIndex')
997 assert_match('StringIndex\_s*' .. 1000 assert_match('StringIndex\_s*' ..
998 'let s = "abcd"\_s*' .. 1001 'var s = "abcd"\_s*' ..
999 '\d PUSHS "abcd"\_s*' .. 1002 '\d PUSHS "abcd"\_s*' ..
1000 '\d STORE $0\_s*' .. 1003 '\d STORE $0\_s*' ..
1001 'let res = s\[1]\_s*' .. 1004 'var res = s\[1]\_s*' ..
1002 '\d LOAD $0\_s*' .. 1005 '\d LOAD $0\_s*' ..
1003 '\d PUSHNR 1\_s*' .. 1006 '\d PUSHNR 1\_s*' ..
1004 '\d STRINDEX\_s*' .. 1007 '\d STRINDEX\_s*' ..
1005 '\d STORE $1\_s*', 1008 '\d STORE $1\_s*',
1006 instr) 1009 instr)
1007 assert_equal('b', StringIndex()) 1010 assert_equal('b', StringIndex())
1008 enddef 1011 enddef
1009 1012
1010 def StringSlice(): string 1013 def StringSlice(): string
1011 let s = "abcd" 1014 var s = "abcd"
1012 let res = s[1:8] 1015 var res = s[1:8]
1013 return res 1016 return res
1014 enddef 1017 enddef
1015 1018
1016 def Test_disassemble_string_slice() 1019 def Test_disassemble_string_slice()
1017 let instr = execute('disassemble StringSlice') 1020 var instr = execute('disassemble StringSlice')
1018 assert_match('StringSlice\_s*' .. 1021 assert_match('StringSlice\_s*' ..
1019 'let s = "abcd"\_s*' .. 1022 'var s = "abcd"\_s*' ..
1020 '\d PUSHS "abcd"\_s*' .. 1023 '\d PUSHS "abcd"\_s*' ..
1021 '\d STORE $0\_s*' .. 1024 '\d STORE $0\_s*' ..
1022 'let res = s\[1:8]\_s*' .. 1025 'var res = s\[1:8]\_s*' ..
1023 '\d LOAD $0\_s*' .. 1026 '\d LOAD $0\_s*' ..
1024 '\d PUSHNR 1\_s*' .. 1027 '\d PUSHNR 1\_s*' ..
1025 '\d PUSHNR 8\_s*' .. 1028 '\d PUSHNR 8\_s*' ..
1026 '\d STRSLICE\_s*' .. 1029 '\d STRSLICE\_s*' ..
1027 '\d STORE $1\_s*', 1030 '\d STORE $1\_s*',
1028 instr) 1031 instr)
1029 assert_equal('bcd', StringSlice()) 1032 assert_equal('bcd', StringSlice())
1030 enddef 1033 enddef
1031 1034
1032 def ListIndex(): number 1035 def ListIndex(): number
1033 let l = [1, 2, 3] 1036 var l = [1, 2, 3]
1034 let res = l[1] 1037 var res = l[1]
1035 return res 1038 return res
1036 enddef 1039 enddef
1037 1040
1038 def Test_disassemble_list_index() 1041 def Test_disassemble_list_index()
1039 let instr = execute('disassemble ListIndex') 1042 var instr = execute('disassemble ListIndex')
1040 assert_match('ListIndex\_s*' .. 1043 assert_match('ListIndex\_s*' ..
1041 'let l = \[1, 2, 3]\_s*' .. 1044 'var l = \[1, 2, 3]\_s*' ..
1042 '\d PUSHNR 1\_s*' .. 1045 '\d PUSHNR 1\_s*' ..
1043 '\d PUSHNR 2\_s*' .. 1046 '\d PUSHNR 2\_s*' ..
1044 '\d PUSHNR 3\_s*' .. 1047 '\d PUSHNR 3\_s*' ..
1045 '\d NEWLIST size 3\_s*' .. 1048 '\d NEWLIST size 3\_s*' ..
1046 '\d STORE $0\_s*' .. 1049 '\d STORE $0\_s*' ..
1047 'let res = l\[1]\_s*' .. 1050 'var res = l\[1]\_s*' ..
1048 '\d LOAD $0\_s*' .. 1051 '\d LOAD $0\_s*' ..
1049 '\d PUSHNR 1\_s*' .. 1052 '\d PUSHNR 1\_s*' ..
1050 '\d LISTINDEX\_s*' .. 1053 '\d LISTINDEX\_s*' ..
1051 '\d STORE $1\_s*', 1054 '\d STORE $1\_s*',
1052 instr) 1055 instr)
1053 assert_equal(2, ListIndex()) 1056 assert_equal(2, ListIndex())
1054 enddef 1057 enddef
1055 1058
1056 def ListSlice(): list<number> 1059 def ListSlice(): list<number>
1057 let l = [1, 2, 3] 1060 var l = [1, 2, 3]
1058 let res = l[1:8] 1061 var res = l[1:8]
1059 return res 1062 return res
1060 enddef 1063 enddef
1061 1064
1062 def Test_disassemble_list_slice() 1065 def Test_disassemble_list_slice()
1063 let instr = execute('disassemble ListSlice') 1066 var instr = execute('disassemble ListSlice')
1064 assert_match('ListSlice\_s*' .. 1067 assert_match('ListSlice\_s*' ..
1065 'let l = \[1, 2, 3]\_s*' .. 1068 'var l = \[1, 2, 3]\_s*' ..
1066 '\d PUSHNR 1\_s*' .. 1069 '\d PUSHNR 1\_s*' ..
1067 '\d PUSHNR 2\_s*' .. 1070 '\d PUSHNR 2\_s*' ..
1068 '\d PUSHNR 3\_s*' .. 1071 '\d PUSHNR 3\_s*' ..
1069 '\d NEWLIST size 3\_s*' .. 1072 '\d NEWLIST size 3\_s*' ..
1070 '\d STORE $0\_s*' .. 1073 '\d STORE $0\_s*' ..
1071 'let res = l\[1:8]\_s*' .. 1074 'var res = l\[1:8]\_s*' ..
1072 '\d LOAD $0\_s*' .. 1075 '\d LOAD $0\_s*' ..
1073 '\d PUSHNR 1\_s*' .. 1076 '\d PUSHNR 1\_s*' ..
1074 '\d PUSHNR 8\_s*' .. 1077 '\d PUSHNR 8\_s*' ..
1075 '\d LISTSLICE\_s*' .. 1078 '\d LISTSLICE\_s*' ..
1076 '\d STORE $1\_s*', 1079 '\d STORE $1\_s*',
1077 instr) 1080 instr)
1078 assert_equal([2, 3], ListSlice()) 1081 assert_equal([2, 3], ListSlice())
1079 enddef 1082 enddef
1080 1083
1081 def DictMember(): number 1084 def DictMember(): number
1082 let d = #{item: 1} 1085 var d = #{item: 1}
1083 let res = d.item 1086 var res = d.item
1084 res = d["item"] 1087 res = d["item"]
1085 return res 1088 return res
1086 enddef 1089 enddef
1087 1090
1088 def Test_disassemble_dict_member() 1091 def Test_disassemble_dict_member()
1089 let instr = execute('disassemble DictMember') 1092 var instr = execute('disassemble DictMember')
1090 assert_match('DictMember\_s*' .. 1093 assert_match('DictMember\_s*' ..
1091 'let d = #{item: 1}\_s*' .. 1094 'var d = #{item: 1}\_s*' ..
1092 '\d PUSHS "item"\_s*' .. 1095 '\d PUSHS "item"\_s*' ..
1093 '\d PUSHNR 1\_s*' .. 1096 '\d PUSHNR 1\_s*' ..
1094 '\d NEWDICT size 1\_s*' .. 1097 '\d NEWDICT size 1\_s*' ..
1095 '\d STORE $0\_s*' .. 1098 '\d STORE $0\_s*' ..
1096 'let res = d.item\_s*' .. 1099 'var res = d.item\_s*' ..
1097 '\d\+ LOAD $0\_s*' .. 1100 '\d\+ LOAD $0\_s*' ..
1098 '\d\+ MEMBER item\_s*' .. 1101 '\d\+ MEMBER item\_s*' ..
1099 '\d\+ STORE $1\_s*' .. 1102 '\d\+ STORE $1\_s*' ..
1100 'res = d\["item"\]\_s*' .. 1103 'res = d\["item"\]\_s*' ..
1101 '\d\+ LOAD $0\_s*' .. 1104 '\d\+ LOAD $0\_s*' ..
1106 assert_equal(1, DictMember()) 1109 assert_equal(1, DictMember())
1107 enddef 1110 enddef
1108 1111
1109 let somelist = [1, 2, 3, 4, 5] 1112 let somelist = [1, 2, 3, 4, 5]
1110 def AnyIndex(): number 1113 def AnyIndex(): number
1111 let res = g:somelist[2] 1114 var res = g:somelist[2]
1112 return res 1115 return res
1113 enddef 1116 enddef
1114 1117
1115 def Test_disassemble_any_index() 1118 def Test_disassemble_any_index()
1116 let instr = execute('disassemble AnyIndex') 1119 var instr = execute('disassemble AnyIndex')
1117 assert_match('AnyIndex\_s*' .. 1120 assert_match('AnyIndex\_s*' ..
1118 'let res = g:somelist\[2\]\_s*' .. 1121 'var res = g:somelist\[2\]\_s*' ..
1119 '\d LOADG g:somelist\_s*' .. 1122 '\d LOADG g:somelist\_s*' ..
1120 '\d PUSHNR 2\_s*' .. 1123 '\d PUSHNR 2\_s*' ..
1121 '\d ANYINDEX\_s*' .. 1124 '\d ANYINDEX\_s*' ..
1122 '\d STORE $0\_s*' .. 1125 '\d STORE $0\_s*' ..
1123 'return res\_s*' .. 1126 'return res\_s*' ..
1127 instr) 1130 instr)
1128 assert_equal(3, AnyIndex()) 1131 assert_equal(3, AnyIndex())
1129 enddef 1132 enddef
1130 1133
1131 def AnySlice(): list<number> 1134 def AnySlice(): list<number>
1132 let res = g:somelist[1:3] 1135 var res = g:somelist[1:3]
1133 return res 1136 return res
1134 enddef 1137 enddef
1135 1138
1136 def Test_disassemble_any_slice() 1139 def Test_disassemble_any_slice()
1137 let instr = execute('disassemble AnySlice') 1140 var instr = execute('disassemble AnySlice')
1138 assert_match('AnySlice\_s*' .. 1141 assert_match('AnySlice\_s*' ..
1139 'let res = g:somelist\[1:3\]\_s*' .. 1142 'var res = g:somelist\[1:3\]\_s*' ..
1140 '\d LOADG g:somelist\_s*' .. 1143 '\d LOADG g:somelist\_s*' ..
1141 '\d PUSHNR 1\_s*' .. 1144 '\d PUSHNR 1\_s*' ..
1142 '\d PUSHNR 3\_s*' .. 1145 '\d PUSHNR 3\_s*' ..
1143 '\d ANYSLICE\_s*' .. 1146 '\d ANYSLICE\_s*' ..
1144 '\d STORE $0\_s*' .. 1147 '\d STORE $0\_s*' ..
1149 instr) 1152 instr)
1150 assert_equal([2, 3, 4], AnySlice()) 1153 assert_equal([2, 3, 4], AnySlice())
1151 enddef 1154 enddef
1152 1155
1153 def NegateNumber(): number 1156 def NegateNumber(): number
1154 let nr = 9 1157 var nr = 9
1155 let plus = +nr 1158 var plus = +nr
1156 let res = -nr 1159 var res = -nr
1157 return res 1160 return res
1158 enddef 1161 enddef
1159 1162
1160 def Test_disassemble_negate_number() 1163 def Test_disassemble_negate_number()
1161 let instr = execute('disassemble NegateNumber') 1164 var instr = execute('disassemble NegateNumber')
1162 assert_match('NegateNumber\_s*' .. 1165 assert_match('NegateNumber\_s*' ..
1163 'let nr = 9\_s*' .. 1166 'var nr = 9\_s*' ..
1164 '\d STORE 9 in $0\_s*' .. 1167 '\d STORE 9 in $0\_s*' ..
1165 'let plus = +nr\_s*' .. 1168 'var plus = +nr\_s*' ..
1166 '\d LOAD $0\_s*' .. 1169 '\d LOAD $0\_s*' ..
1167 '\d CHECKNR\_s*' .. 1170 '\d CHECKNR\_s*' ..
1168 '\d STORE $1\_s*' .. 1171 '\d STORE $1\_s*' ..
1169 'let res = -nr\_s*' .. 1172 'var res = -nr\_s*' ..
1170 '\d LOAD $0\_s*' .. 1173 '\d LOAD $0\_s*' ..
1171 '\d NEGATENR\_s*' .. 1174 '\d NEGATENR\_s*' ..
1172 '\d STORE $2\_s*', 1175 '\d STORE $2\_s*',
1173 instr) 1176 instr)
1174 assert_equal(-9, NegateNumber()) 1177 assert_equal(-9, NegateNumber())
1175 enddef 1178 enddef
1176 1179
1177 def InvertBool(): bool 1180 def InvertBool(): bool
1178 let flag = true 1181 var flag = true
1179 let invert = !flag 1182 var invert = !flag
1180 let res = !!flag 1183 var res = !!flag
1181 return res 1184 return res
1182 enddef 1185 enddef
1183 1186
1184 def Test_disassemble_invert_bool() 1187 def Test_disassemble_invert_bool()
1185 let instr = execute('disassemble InvertBool') 1188 var instr = execute('disassemble InvertBool')
1186 assert_match('InvertBool\_s*' .. 1189 assert_match('InvertBool\_s*' ..
1187 'let flag = true\_s*' .. 1190 'var flag = true\_s*' ..
1188 '\d PUSH v:true\_s*' .. 1191 '\d PUSH v:true\_s*' ..
1189 '\d STORE $0\_s*' .. 1192 '\d STORE $0\_s*' ..
1190 'let invert = !flag\_s*' .. 1193 'var invert = !flag\_s*' ..
1191 '\d LOAD $0\_s*' .. 1194 '\d LOAD $0\_s*' ..
1192 '\d INVERT (!val)\_s*' .. 1195 '\d INVERT (!val)\_s*' ..
1193 '\d STORE $1\_s*' .. 1196 '\d STORE $1\_s*' ..
1194 'let res = !!flag\_s*' .. 1197 'var res = !!flag\_s*' ..
1195 '\d LOAD $0\_s*' .. 1198 '\d LOAD $0\_s*' ..
1196 '\d 2BOOL (!!val)\_s*' .. 1199 '\d 2BOOL (!!val)\_s*' ..
1197 '\d STORE $2\_s*', 1200 '\d STORE $2\_s*',
1198 instr) 1201 instr)
1199 assert_equal(true, InvertBool()) 1202 assert_equal(true, InvertBool())
1200 enddef 1203 enddef
1201 1204
1202 def ReturnBool(): bool 1205 def ReturnBool(): bool
1203 let var: bool = "no" && [] || 123 1206 var var: bool = "no" && [] || 123
1204 return var 1207 return var
1205 enddef 1208 enddef
1206 1209
1207 def Test_disassemble_return_bool() 1210 def Test_disassemble_return_bool()
1208 let instr = execute('disassemble ReturnBool') 1211 var instr = execute('disassemble ReturnBool')
1209 assert_match('ReturnBool\_s*' .. 1212 assert_match('ReturnBool\_s*' ..
1210 'let var: bool = "no" && \[\] || 123\_s*' .. 1213 'var var: bool = "no" && \[\] || 123\_s*' ..
1211 '0 PUSHS "no"\_s*' .. 1214 '0 PUSHS "no"\_s*' ..
1212 '1 JUMP_AND_KEEP_IF_FALSE -> 3\_s*' .. 1215 '1 JUMP_AND_KEEP_IF_FALSE -> 3\_s*' ..
1213 '2 NEWLIST size 0\_s*' .. 1216 '2 NEWLIST size 0\_s*' ..
1214 '3 JUMP_AND_KEEP_IF_TRUE -> 5\_s*' .. 1217 '3 JUMP_AND_KEEP_IF_TRUE -> 5\_s*' ..
1215 '4 PUSHNR 123\_s*' .. 1218 '4 PUSHNR 123\_s*' ..
1221 instr) 1224 instr)
1222 assert_equal(true, InvertBool()) 1225 assert_equal(true, InvertBool())
1223 enddef 1226 enddef
1224 1227
1225 def Test_disassemble_compare() 1228 def Test_disassemble_compare()
1226 let cases = [ 1229 var cases = [
1227 ['true == isFalse', 'COMPAREBOOL =='], 1230 ['true == isFalse', 'COMPAREBOOL =='],
1228 ['true != isFalse', 'COMPAREBOOL !='], 1231 ['true != isFalse', 'COMPAREBOOL !='],
1229 ['v:none == isNull', 'COMPARESPECIAL =='], 1232 ['v:none == isNull', 'COMPARESPECIAL =='],
1230 ['v:none != isNull', 'COMPARESPECIAL !='], 1233 ['v:none != isNull', 'COMPARESPECIAL !='],
1231 1234
1277 ['77 =~ g:xx', 'COMPAREANY =\~'], 1280 ['77 =~ g:xx', 'COMPAREANY =\~'],
1278 ['77 !~ g:xx', 'COMPAREANY !\~'], 1281 ['77 !~ g:xx', 'COMPAREANY !\~'],
1279 ['77 is g:xx', 'COMPAREANY is'], 1282 ['77 is g:xx', 'COMPAREANY is'],
1280 ['77 isnot g:xx', 'COMPAREANY isnot'], 1283 ['77 isnot g:xx', 'COMPAREANY isnot'],
1281 ] 1284 ]
1282 let floatDecl = '' 1285 var floatDecl = ''
1283 if has('float') 1286 if has('float')
1284 cases->extend([ 1287 cases->extend([
1285 ['1.1 == aFloat', 'COMPAREFLOAT =='], 1288 ['1.1 == aFloat', 'COMPAREFLOAT =='],
1286 ['1.1 != aFloat', 'COMPAREFLOAT !='], 1289 ['1.1 != aFloat', 'COMPAREFLOAT !='],
1287 ['1.1 > aFloat', 'COMPAREFLOAT >'], 1290 ['1.1 > aFloat', 'COMPAREFLOAT >'],
1289 ['1.1 >= aFloat', 'COMPAREFLOAT >='], 1292 ['1.1 >= aFloat', 'COMPAREFLOAT >='],
1290 ['1.1 <= aFloat', 'COMPAREFLOAT <='], 1293 ['1.1 <= aFloat', 'COMPAREFLOAT <='],
1291 ['1.1 =~ aFloat', 'COMPAREFLOAT =\~'], 1294 ['1.1 =~ aFloat', 'COMPAREFLOAT =\~'],
1292 ['1.1 !~ aFloat', 'COMPAREFLOAT !\~'], 1295 ['1.1 !~ aFloat', 'COMPAREFLOAT !\~'],
1293 ]) 1296 ])
1294 floatDecl = 'let aFloat = 2.2' 1297 floatDecl = 'var aFloat = 2.2'
1295 endif 1298 endif
1296 1299
1297 let nr = 1 1300 var nr = 1
1298 for case in cases 1301 for case in cases
1299 # declare local variables to get a non-constant with the right type 1302 # declare local variables to get a non-constant with the right type
1300 writefile(['def TestCase' .. nr .. '()', 1303 writefile(['def TestCase' .. nr .. '()',
1301 ' let isFalse = false', 1304 ' var isFalse = false',
1302 ' let isNull = v:null', 1305 ' var isNull = v:null',
1303 ' let aNumber = 222', 1306 ' var aNumber = 222',
1304 ' let aString = "yy"', 1307 ' var aString = "yy"',
1305 ' let aBlob = 0z22', 1308 ' var aBlob = 0z22',
1306 ' let aList = [3, 4]', 1309 ' var aList = [3, 4]',
1307 ' let aDict = #{x: 2}', 1310 ' var aDict = #{x: 2}',
1308 floatDecl, 1311 floatDecl,
1309 ' if ' .. case[0], 1312 ' if ' .. case[0],
1310 ' echo 42' 1313 ' echo 42'
1311 ' endif', 1314 ' endif',
1312 'enddef'], 'Xdisassemble') 1315 'enddef'], 'Xdisassemble')
1313 source Xdisassemble 1316 source Xdisassemble
1314 let instr = execute('disassemble TestCase' .. nr) 1317 var instr = execute('disassemble TestCase' .. nr)
1315 assert_match('TestCase' .. nr .. '.*' .. 1318 assert_match('TestCase' .. nr .. '.*' ..
1316 'if ' .. substitute(case[0], '[[~]', '\\\0', 'g') .. '.*' .. 1319 'if ' .. substitute(case[0], '[[~]', '\\\0', 'g') .. '.*' ..
1317 '\d \(PUSH\|FUNCREF\).*' .. 1320 '\d \(PUSH\|FUNCREF\).*' ..
1318 '\d \(PUSH\|FUNCREF\|LOAD\).*' .. 1321 '\d \(PUSH\|FUNCREF\|LOAD\).*' ..
1319 '\d ' .. case[1] .. '.*' .. 1322 '\d ' .. case[1] .. '.*' ..
1325 1328
1326 delete('Xdisassemble') 1329 delete('Xdisassemble')
1327 enddef 1330 enddef
1328 1331
1329 def Test_disassemble_compare_const() 1332 def Test_disassemble_compare_const()
1330 let cases = [ 1333 var cases = [
1331 ['"xx" == "yy"', false], 1334 ['"xx" == "yy"', false],
1332 ['"aa" == "aa"', true], 1335 ['"aa" == "aa"', true],
1333 ['has("eval") ? true : false', true], 1336 ['has("eval") ? true : false', true],
1334 ['has("asdf") ? true : false', false], 1337 ['has("asdf") ? true : false', false],
1335 ] 1338 ]
1336 1339
1337 let nr = 1 1340 var nr = 1
1338 for case in cases 1341 for case in cases
1339 writefile(['def TestCase' .. nr .. '()', 1342 writefile(['def TestCase' .. nr .. '()',
1340 ' if ' .. case[0], 1343 ' if ' .. case[0],
1341 ' echo 42' 1344 ' echo 42'
1342 ' endif', 1345 ' endif',
1343 'enddef'], 'Xdisassemble') 1346 'enddef'], 'Xdisassemble')
1344 source Xdisassemble 1347 source Xdisassemble
1345 let instr = execute('disassemble TestCase' .. nr) 1348 var instr = execute('disassemble TestCase' .. nr)
1346 if case[1] 1349 if case[1]
1347 # condition true, "echo 42" executed 1350 # condition true, "echo 42" executed
1348 assert_match('TestCase' .. nr .. '.*' .. 1351 assert_match('TestCase' .. nr .. '.*' ..
1349 'if ' .. substitute(case[0], '[[~]', '\\\0', 'g') .. '.*' .. 1352 'if ' .. substitute(case[0], '[[~]', '\\\0', 'g') .. '.*' ..
1350 '\d PUSHNR 42.*' .. 1353 '\d PUSHNR 42.*' ..
1369 delete('Xdisassemble') 1372 delete('Xdisassemble')
1370 enddef 1373 enddef
1371 1374
1372 def s:Execute() 1375 def s:Execute()
1373 execute 'help vim9.txt' 1376 execute 'help vim9.txt'
1374 let cmd = 'help vim9.txt' 1377 var cmd = 'help vim9.txt'
1375 execute cmd 1378 execute cmd
1376 let tag = 'vim9.txt' 1379 var tag = 'vim9.txt'
1377 execute 'help ' .. tag 1380 execute 'help ' .. tag
1378 enddef 1381 enddef
1379 1382
1380 def Test_disassemble_execute() 1383 def Test_disassemble_execute()
1381 let res = execute('disass s:Execute') 1384 var res = execute('disass s:Execute')
1382 assert_match('\<SNR>\d*_Execute\_s*' .. 1385 assert_match('\<SNR>\d*_Execute\_s*' ..
1383 "execute 'help vim9.txt'\\_s*" .. 1386 "execute 'help vim9.txt'\\_s*" ..
1384 '\d PUSHS "help vim9.txt"\_s*' .. 1387 '\d PUSHS "help vim9.txt"\_s*' ..
1385 '\d EXECUTE 1\_s*' .. 1388 '\d EXECUTE 1\_s*' ..
1386 "let cmd = 'help vim9.txt'\\_s*" .. 1389 "var cmd = 'help vim9.txt'\\_s*" ..
1387 '\d PUSHS "help vim9.txt"\_s*' .. 1390 '\d PUSHS "help vim9.txt"\_s*' ..
1388 '\d STORE $0\_s*' .. 1391 '\d STORE $0\_s*' ..
1389 'execute cmd\_s*' .. 1392 'execute cmd\_s*' ..
1390 '\d LOAD $0\_s*' .. 1393 '\d LOAD $0\_s*' ..
1391 '\d EXECUTE 1\_s*' .. 1394 '\d EXECUTE 1\_s*' ..
1392 "let tag = 'vim9.txt'\\_s*" .. 1395 "var tag = 'vim9.txt'\\_s*" ..
1393 '\d PUSHS "vim9.txt"\_s*' .. 1396 '\d PUSHS "vim9.txt"\_s*' ..
1394 '\d STORE $1\_s*' .. 1397 '\d STORE $1\_s*' ..
1395 "execute 'help ' .. tag\\_s*" .. 1398 "execute 'help ' .. tag\\_s*" ..
1396 '\d\+ PUSHS "help "\_s*' .. 1399 '\d\+ PUSHS "help "\_s*' ..
1397 '\d\+ LOAD $1\_s*' .. 1400 '\d\+ LOAD $1\_s*' ..
1406 echomsg 'some' 'message' 1409 echomsg 'some' 'message'
1407 echoerr 'went' .. 'wrong' 1410 echoerr 'went' .. 'wrong'
1408 enddef 1411 enddef
1409 1412
1410 def Test_disassemble_echomsg() 1413 def Test_disassemble_echomsg()
1411 let res = execute('disass s:Echomsg') 1414 var res = execute('disass s:Echomsg')
1412 assert_match('\<SNR>\d*_Echomsg\_s*' .. 1415 assert_match('\<SNR>\d*_Echomsg\_s*' ..
1413 "echomsg 'some' 'message'\\_s*" .. 1416 "echomsg 'some' 'message'\\_s*" ..
1414 '\d PUSHS "some"\_s*' .. 1417 '\d PUSHS "some"\_s*' ..
1415 '\d PUSHS "message"\_s*' .. 1418 '\d PUSHS "message"\_s*' ..
1416 '\d ECHOMSG 2\_s*' .. 1419 '\d ECHOMSG 2\_s*' ..
1433 def SomeStringArgAndReturn(arg: string): string 1436 def SomeStringArgAndReturn(arg: string): string
1434 return arg 1437 return arg
1435 enddef 1438 enddef
1436 1439
1437 def Test_display_func() 1440 def Test_display_func()
1438 let res1 = execute('function SomeStringArg') 1441 var res1 = execute('function SomeStringArg')
1439 assert_match('.* def SomeStringArg(arg: string)\_s*' .. 1442 assert_match('.* def SomeStringArg(arg: string)\_s*' ..
1440 '\d *echo arg.*' .. 1443 '\d *echo arg.*' ..
1441 ' *enddef', 1444 ' *enddef',
1442 res1) 1445 res1)
1443 1446
1444 let res2 = execute('function SomeAnyArg') 1447 var res2 = execute('function SomeAnyArg')
1445 assert_match('.* def SomeAnyArg(arg: any)\_s*' .. 1448 assert_match('.* def SomeAnyArg(arg: any)\_s*' ..
1446 '\d *echo arg\_s*' .. 1449 '\d *echo arg\_s*' ..
1447 ' *enddef', 1450 ' *enddef',
1448 res2) 1451 res2)
1449 1452
1450 let res3 = execute('function SomeStringArgAndReturn') 1453 var res3 = execute('function SomeStringArgAndReturn')
1451 assert_match('.* def SomeStringArgAndReturn(arg: string): string\_s*' .. 1454 assert_match('.* def SomeStringArgAndReturn(arg: string): string\_s*' ..
1452 '\d *return arg\_s*' .. 1455 '\d *return arg\_s*' ..
1453 ' *enddef', 1456 ' *enddef',
1454 res3) 1457 res3)
1455 enddef 1458 enddef
1456 1459
1457 def Test_vim9script_forward_func() 1460 def Test_vim9script_forward_func()
1458 let lines =<< trim END 1461 var lines =<< trim END
1459 vim9script 1462 vim9script
1460 def FuncOne(): string 1463 def FuncOne(): string
1461 return FuncTwo() 1464 return FuncTwo()
1462 enddef 1465 enddef
1463 def FuncTwo(): string 1466 def FuncTwo(): string
1490 def s:ComputeConstParen(): number 1493 def s:ComputeConstParen(): number
1491 return ((2 + 4) * (8 / 2)) / (3 + 4) 1494 return ((2 + 4) * (8 / 2)) / (3 + 4)
1492 enddef 1495 enddef
1493 1496
1494 def Test_simplify_const_expr() 1497 def Test_simplify_const_expr()
1495 let res = execute('disass s:ConcatStrings') 1498 var res = execute('disass s:ConcatStrings')
1496 assert_match('<SNR>\d*_ConcatStrings\_s*' .. 1499 assert_match('<SNR>\d*_ConcatStrings\_s*' ..
1497 "return 'one' .. 'two' .. 'three'\\_s*" .. 1500 "return 'one' .. 'two' .. 'three'\\_s*" ..
1498 '\d PUSHS "onetwothree"\_s*' .. 1501 '\d PUSHS "onetwothree"\_s*' ..
1499 '\d RETURN', 1502 '\d RETURN',
1500 res) 1503 res)
1517 def s:CallAppend() 1520 def s:CallAppend()
1518 eval "some text"->append(2) 1521 eval "some text"->append(2)
1519 enddef 1522 enddef
1520 1523
1521 def Test_shuffle() 1524 def Test_shuffle()
1522 let res = execute('disass s:CallAppend') 1525 var res = execute('disass s:CallAppend')
1523 assert_match('<SNR>\d*_CallAppend\_s*' .. 1526 assert_match('<SNR>\d*_CallAppend\_s*' ..
1524 'eval "some text"->append(2)\_s*' .. 1527 'eval "some text"->append(2)\_s*' ..
1525 '\d PUSHS "some text"\_s*' .. 1528 '\d PUSHS "some text"\_s*' ..
1526 '\d PUSHNR 2\_s*' .. 1529 '\d PUSHNR 2\_s*' ..
1527 '\d SHUFFLE 2 up 1\_s*' .. 1530 '\d SHUFFLE 2 up 1\_s*' ..