aniani/vim
0
0
Fork 1
mirror of https://github.com/vim/vim.git synced 2025-07-26 11:04:33 -04:00
Code

patch 8.2.1761: Vim9: Some tests are still using :let

Browse Source 
Problem:    Vim9: Some tests are still using :let.
Solution:   Change more declarations to use :var.
This commit is contained in:
Bram Moolenaar 2020-09-27 19:05:33 +02:00
parent 2914a20abc
commit ac564082f1
4 changed files with 209 additions and 198 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/testdir/test_vim9_assign.vim
View File

@ -3,6 +3,9 @@
source check.vim source check.vim
source vim9.vim source vim9.vim
" TODO: remove later
let v:disallow_let = 1
let s:appendToMe = 'xxx' let s:appendToMe = 'xxx'
let s:addToMe = 111 let s:addToMe = 111
let g:existing = 'yes' let g:existing = 'yes'

53
src/testdir/test_vim9_cmd.vim
View File

@ -4,12 +4,15 @@ source check.vim
source vim9.vim source vim9.vim
source view_util.vim source view_util.vim
" TODO: remove later
let v:disallow_let = 1
def Test_edit_wildcards() def Test_edit_wildcards()
let filename = 'Xtest' var filename = 'Xtest'
edit `=filename` edit `=filename`
assert_equal('Xtest', bufname()) assert_equal('Xtest', bufname())
let filenr = 123 var filenr = 123
edit Xtest`=filenr` edit Xtest`=filenr`
assert_equal('Xtest123', bufname()) assert_equal('Xtest123', bufname())
@ -25,7 +28,7 @@ def Test_hardcopy_wildcards()
CheckUnix CheckUnix
CheckFeature postscript CheckFeature postscript
let outfile = 'print' var outfile = 'print'
hardcopy > X`=outfile`.ps hardcopy > X`=outfile`.ps
assert_true(filereadable('Xprint.ps')) assert_true(filereadable('Xprint.ps'))
@ -34,10 +37,10 @@ enddef
def Test_syn_include_wildcards() def Test_syn_include_wildcards()
writefile(['syn keyword Found found'], 'Xthemine.vim') writefile(['syn keyword Found found'], 'Xthemine.vim')
let save_rtp = &rtp var save_rtp = &rtp
&rtp = '.' &rtp = '.'
let fname = 'mine' var fname = 'mine'
syn include @Group Xthe`=fname`.vim syn include @Group Xthe`=fname`.vim
assert_match('Found.* contained found', execute('syn list Found')) assert_match('Found.* contained found', execute('syn list Found'))
@ -46,7 +49,7 @@ def Test_syn_include_wildcards()
enddef enddef
def Test_echo_linebreak() def Test_echo_linebreak()
let lines =<< trim END var lines =<< trim END
vim9script vim9script
redir @a redir @a
echo 'one' echo 'one'
@ -69,7 +72,7 @@ def Test_echo_linebreak()
enddef enddef
def Test_if_linebreak() def Test_if_linebreak()
let lines =<< trim END var lines =<< trim END
vim9script vim9script
if 1 && if 1 &&
2 2
@ -98,9 +101,9 @@ def Test_if_linebreak()
enddef enddef
def Test_while_linebreak() def Test_while_linebreak()
let lines =<< trim END var lines =<< trim END
vim9script vim9script
let nr = 0 var nr = 0
while nr < while nr <
10 + 3 10 + 3
nr = nr nr = nr
@ -112,7 +115,7 @@ def Test_while_linebreak()
lines =<< trim END lines =<< trim END
vim9script vim9script
let nr = 0 var nr = 0
while nr while nr
< <
10 10
@ -128,9 +131,9 @@ def Test_while_linebreak()
enddef enddef
def Test_for_linebreak() def Test_for_linebreak()
let lines =<< trim END var lines =<< trim END
vim9script vim9script
let nr = 0 var nr = 0
for x for x
in in
[1, 2, 3, 4] [1, 2, 3, 4]
@ -142,7 +145,7 @@ def Test_for_linebreak()
lines =<< trim END lines =<< trim END
vim9script vim9script
let nr = 0 var nr = 0
for x for x
in in
[1, 2, [1, 2,
@ -158,9 +161,9 @@ def Test_for_linebreak()
enddef enddef
def Test_method_call_linebreak() def Test_method_call_linebreak()
let lines =<< trim END var lines =<< trim END
vim9script vim9script
let res = [] var res = []
func RetArg( func RetArg(
arg arg
) )
@ -175,16 +178,16 @@ def Test_method_call_linebreak()
enddef enddef
def Test_dict_member() def Test_dict_member()
let test: dict<list<number>> = {'data': [3, 1, 2]} var test: dict<list<number>> = {'data': [3, 1, 2]}
test.data->sort() test.data->sort()
assert_equal(#{data: [1, 2, 3]}, test) assert_equal(#{data: [1, 2, 3]}, test)
test.data test.data
->reverse() ->reverse()
assert_equal(#{data: [3, 2, 1]}, test) assert_equal(#{data: [3, 2, 1]}, test)
let lines =<< trim END var lines =<< trim END
vim9script vim9script
let test: dict<list<number>> = {'data': [3, 1, 2]} var test: dict<list<number>> = {'data': [3, 1, 2]}
test.data->sort() test.data->sort()
assert_equal(#{data: [1, 2, 3]}, test) assert_equal(#{data: [1, 2, 3]}, test)
END END
@ -193,14 +196,14 @@ enddef
def Test_bar_after_command() def Test_bar_after_command()
def RedrawAndEcho() def RedrawAndEcho()
let x = 'did redraw' var x = 'did redraw'
redraw | echo x redraw | echo x
enddef enddef
RedrawAndEcho() RedrawAndEcho()
assert_match('did redraw', Screenline(&lines)) assert_match('did redraw', Screenline(&lines))
def CallAndEcho() def CallAndEcho()
let x = 'did redraw' var x = 'did redraw'
reg_executing() | echo x reg_executing() | echo x
enddef enddef
CallAndEcho() CallAndEcho()
@ -232,14 +235,14 @@ def Test_bar_after_command()
enddef enddef
def Test_filter_is_not_modifier() def Test_filter_is_not_modifier()
let tags = [{'a': 1, 'b': 2}, {'x': 3, 'y': 4}] var tags = [{'a': 1, 'b': 2}, {'x': 3, 'y': 4}]
filter(tags, { _, v -> has_key(v, 'x') ? 1 : 0 }) filter(tags, { _, v -> has_key(v, 'x') ? 1 : 0 })
assert_equal([#{x: 3, y: 4}], tags) assert_equal([#{x: 3, y: 4}], tags)
enddef enddef
def Test_eval_command() def Test_eval_command()
let from = 3 var from = 3
let to = 5 var to = 5
g:val = 111 g:val = 111
def Increment(nrs: list<number>) def Increment(nrs: list<number>)
for nr in nrs for nr in nrs
@ -253,7 +256,7 @@ def Test_eval_command()
enddef enddef
def Test_map_command() def Test_map_command()
let lines =<< trim END var lines =<< trim END
nnoremap <F3> :echo 'hit F3 #'<CR> nnoremap <F3> :echo 'hit F3 #'<CR>
assert_equal(":echo 'hit F3 #'<CR>", maparg("<F3>", "n")) assert_equal(":echo 'hit F3 #'<CR>", maparg("<F3>", "n"))
END END
@ -264,7 +267,7 @@ enddef
def Test_normal_command() def Test_normal_command()
new new
setline(1, 'doesnotexist') setline(1, 'doesnotexist')
let caught = 0 var caught = 0
try try
exe "norm! \<C-]>" exe "norm! \<C-]>"
catch /E433/ catch /E433/

349
src/testdir/test_vim9_disassemble.vim
View File

@ -2,6 +2,9 @@
source check.vim source check.vim
" TODO: remove later
let v:disallow_let = 1
func NotCompiled() func NotCompiled()
echo "not" echo "not"
endfunc endfunc
@ -13,7 +16,7 @@ let w:windowvar = 'w'
let t:tabpagevar = 't' let t:tabpagevar = 't'
def s:ScriptFuncLoad(arg: string) def s:ScriptFuncLoad(arg: string)
let local = 1 var local = 1
buffers buffers
echo arg echo arg
echo local echo local
@ -41,7 +44,7 @@ def Test_disassemble_load()
assert_fails('disass 234', 'E129:') assert_fails('disass 234', 'E129:')
assert_fails('disass <XX>foo', 'E129:') assert_fails('disass <XX>foo', 'E129:')
let res = execute('disass s:ScriptFuncLoad') var res = execute('disass s:ScriptFuncLoad')
assert_match('<SNR>\d*_ScriptFuncLoad.*' .. assert_match('<SNR>\d*_ScriptFuncLoad.*' ..
'buffers.*' .. 'buffers.*' ..
' EXEC \+buffers.*' .. ' EXEC \+buffers.*' ..
@ -76,18 +79,18 @@ def Test_disassemble_load()
enddef enddef
def s:EditExpand() def s:EditExpand()
let filename = "file" var filename = "file"
let filenr = 123 var filenr = 123
edit the`=filename``=filenr`.txt edit the`=filename``=filenr`.txt
enddef enddef
def Test_disassemble_exec_expr() def Test_disassemble_exec_expr()
let res = execute('disass s:EditExpand') var res = execute('disass s:EditExpand')
assert_match('<SNR>\d*_EditExpand\_s*' .. assert_match('<SNR>\d*_EditExpand\_s*' ..
' let filename = "file"\_s*' .. ' var filename = "file"\_s*' ..
'\d PUSHS "file"\_s*' .. '\d PUSHS "file"\_s*' ..
'\d STORE $0\_s*' .. '\d STORE $0\_s*' ..
' let filenr = 123\_s*' .. ' var filenr = 123\_s*' ..
'\d STORE 123 in $1\_s*' .. '\d STORE 123 in $1\_s*' ..
' edit the`=filename``=filenr`.txt\_s*' .. ' edit the`=filename``=filenr`.txt\_s*' ..
'\d PUSHS "edit the"\_s*' .. '\d PUSHS "edit the"\_s*' ..
@ -107,7 +110,7 @@ def s:YankRange()
enddef enddef
def Test_disassemble_yank_range() def Test_disassemble_yank_range()
let res = execute('disass s:YankRange') var res = execute('disass s:YankRange')
assert_match('<SNR>\d*_YankRange.*' .. assert_match('<SNR>\d*_YankRange.*' ..
' norm! m\[jjm\]\_s*' .. ' norm! m\[jjm\]\_s*' ..
'\d EXEC norm! m\[jjm\]\_s*' .. '\d EXEC norm! m\[jjm\]\_s*' ..
@ -123,7 +126,7 @@ def s:PutExpr()
enddef enddef
def Test_disassemble_put_expr() def Test_disassemble_put_expr()
let res = execute('disass s:PutExpr') var res = execute('disass s:PutExpr')
assert_match('<SNR>\d*_PutExpr.*' .. assert_match('<SNR>\d*_PutExpr.*' ..
' :3put ="text"\_s*' .. ' :3put ="text"\_s*' ..
'\d PUSHS "text"\_s*' .. '\d PUSHS "text"\_s*' ..
@ -134,16 +137,16 @@ def Test_disassemble_put_expr()
enddef enddef
def s:ScriptFuncPush() def s:ScriptFuncPush()
let localbool = true var localbool = true
let localspec = v:none var localspec = v:none
let localblob = 0z1234 var localblob = 0z1234
if has('float') if has('float')
let localfloat = 1.234 var localfloat = 1.234
endif endif
enddef enddef
def Test_disassemble_push() def Test_disassemble_push()
let res = execute('disass s:ScriptFuncPush') var res = execute('disass s:ScriptFuncPush')
assert_match('<SNR>\d*_ScriptFuncPush.*' .. assert_match('<SNR>\d*_ScriptFuncPush.*' ..
'localbool = true.*' .. 'localbool = true.*' ..
' PUSH v:true.*' .. ' PUSH v:true.*' ..
@ -161,9 +164,9 @@ def Test_disassemble_push()
enddef enddef
def s:ScriptFuncStore() def s:ScriptFuncStore()
let localnr = 1 var localnr = 1
localnr = 2 localnr = 2
let localstr = 'abc' var localstr = 'abc'
localstr = 'xyz' localstr = 'xyz'
v:char = 'abc' v:char = 'abc'
s:scriptvar = 'sv' s:scriptvar = 'sv'
@ -177,12 +180,12 @@ def s:ScriptFuncStore()
enddef enddef
def Test_disassemble_store() def Test_disassemble_store()
let res = execute('disass s:ScriptFuncStore') var res = execute('disass s:ScriptFuncStore')
assert_match('<SNR>\d*_ScriptFuncStore.*' .. assert_match('<SNR>\d*_ScriptFuncStore.*' ..
'let localnr = 1.*' .. 'var localnr = 1.*' ..
'localnr = 2.*' .. 'localnr = 2.*' ..
' STORE 2 in $0.*' .. ' STORE 2 in $0.*' ..
'let localstr = ''abc''.*' .. 'var localstr = ''abc''.*' ..
'localstr = ''xyz''.*' .. 'localstr = ''xyz''.*' ..
' STORE $1.*' .. ' STORE $1.*' ..
'v:char = ''abc''.*' .. 'v:char = ''abc''.*' ..
@ -207,16 +210,16 @@ def Test_disassemble_store()
enddef enddef
def s:ScriptFuncStoreMember() def s:ScriptFuncStoreMember()
let locallist: list<number> = [] var locallist: list<number> = []
locallist[0] = 123 locallist[0] = 123
let localdict: dict<number> = {} var localdict: dict<number> = {}
localdict["a"] = 456 localdict["a"] = 456
enddef enddef
def Test_disassemble_store_member() def Test_disassemble_store_member()
let res = execute('disass s:ScriptFuncStoreMember') var res = execute('disass s:ScriptFuncStoreMember')
assert_match('<SNR>\d*_ScriptFuncStoreMember\_s*' .. assert_match('<SNR>\d*_ScriptFuncStoreMember\_s*' ..
'let locallist: list<number> = []\_s*' .. 'var locallist: list<number> = []\_s*' ..
'\d NEWLIST size 0\_s*' .. '\d NEWLIST size 0\_s*' ..
'\d STORE $0\_s*' .. '\d STORE $0\_s*' ..
'locallist\[0\] = 123\_s*' .. 'locallist\[0\] = 123\_s*' ..
@ -224,7 +227,7 @@ def Test_disassemble_store_member()
'\d PUSHNR 0\_s*' .. '\d PUSHNR 0\_s*' ..
'\d LOAD $0\_s*' .. '\d LOAD $0\_s*' ..
'\d STORELIST\_s*' .. '\d STORELIST\_s*' ..
'let localdict: dict<number> = {}\_s*' .. 'var localdict: dict<number> = {}\_s*' ..
'\d NEWDICT size 0\_s*' .. '\d NEWDICT size 0\_s*' ..
'\d STORE $1\_s*' .. '\d STORE $1\_s*' ..
'localdict\["a"\] = 456\_s*' .. 'localdict\["a"\] = 456\_s*' ..
@ -238,22 +241,22 @@ def Test_disassemble_store_member()
enddef enddef
def s:ListAssign() def s:ListAssign()
let x: string var x: string
let y: string var y: string
let l: list<any> var l: list<any>
[x, y; l] = g:stringlist [x, y; l] = g:stringlist
enddef enddef
def Test_disassemble_list_assign() def Test_disassemble_list_assign()
let res = execute('disass s:ListAssign') var res = execute('disass s:ListAssign')
assert_match('<SNR>\d*_ListAssign\_s*' .. assert_match('<SNR>\d*_ListAssign\_s*' ..
'let x: string\_s*' .. 'var x: string\_s*' ..
'\d PUSHS "\[NULL\]"\_s*' .. '\d PUSHS "\[NULL\]"\_s*' ..
'\d STORE $0\_s*' .. '\d STORE $0\_s*' ..
'let y: string\_s*' .. 'var y: string\_s*' ..
'\d PUSHS "\[NULL\]"\_s*' .. '\d PUSHS "\[NULL\]"\_s*' ..
'\d STORE $1\_s*' .. '\d STORE $1\_s*' ..
'let l: list<any>\_s*' .. 'var l: list<any>\_s*' ..
'\d NEWLIST size 0\_s*' .. '\d NEWLIST size 0\_s*' ..
'\d STORE $2\_s*' .. '\d STORE $2\_s*' ..
'\[x, y; l\] = g:stringlist\_s*' .. '\[x, y; l\] = g:stringlist\_s*' ..
@ -281,7 +284,7 @@ def s:ScriptFuncUnlet()
enddef enddef
def Test_disassemble_unlet() def Test_disassemble_unlet()
let res = execute('disass s:ScriptFuncUnlet') var res = execute('disass s:ScriptFuncUnlet')
assert_match('<SNR>\d*_ScriptFuncUnlet\_s*' .. assert_match('<SNR>\d*_ScriptFuncUnlet\_s*' ..
'g:somevar = "value"\_s*' .. 'g:somevar = "value"\_s*' ..
'\d PUSHS "value"\_s*' .. '\d PUSHS "value"\_s*' ..
@ -306,7 +309,7 @@ def s:ScriptFuncTry()
enddef enddef
def Test_disassemble_try() def Test_disassemble_try()
let res = execute('disass s:ScriptFuncTry') var res = execute('disass s:ScriptFuncTry')
assert_match('<SNR>\d*_ScriptFuncTry\_s*' .. assert_match('<SNR>\d*_ScriptFuncTry\_s*' ..
'try\_s*' .. 'try\_s*' ..
'\d TRY catch -> \d\+, finally -> \d\+\_s*' .. '\d TRY catch -> \d\+, finally -> \d\+\_s*' ..
@ -333,20 +336,20 @@ def Test_disassemble_try()
enddef enddef
def s:ScriptFuncNew() def s:ScriptFuncNew()
let ll = [1, "two", 333] var ll = [1, "two", 333]
let dd = #{one: 1, two: "val"} var dd = #{one: 1, two: "val"}
enddef enddef
def Test_disassemble_new() def Test_disassemble_new()
let res = execute('disass s:ScriptFuncNew') var res = execute('disass s:ScriptFuncNew')
assert_match('<SNR>\d*_ScriptFuncNew\_s*' .. assert_match('<SNR>\d*_ScriptFuncNew\_s*' ..
'let ll = \[1, "two", 333\]\_s*' .. 'var ll = \[1, "two", 333\]\_s*' ..
'\d PUSHNR 1\_s*' .. '\d PUSHNR 1\_s*' ..
'\d PUSHS "two"\_s*' .. '\d PUSHS "two"\_s*' ..
'\d PUSHNR 333\_s*' .. '\d PUSHNR 333\_s*' ..
'\d NEWLIST size 3\_s*' .. '\d NEWLIST size 3\_s*' ..
'\d STORE $0\_s*' .. '\d STORE $0\_s*' ..
'let dd = #{one: 1, two: "val"}\_s*' .. 'var dd = #{one: 1, two: "val"}\_s*' ..
'\d PUSHS "one"\_s*' .. '\d PUSHS "one"\_s*' ..
'\d PUSHNR 1\_s*' .. '\d PUSHNR 1\_s*' ..
'\d PUSHS "two"\_s*' .. '\d PUSHS "two"\_s*' ..
@ -376,15 +379,15 @@ def s:ScriptFuncCall(): string
s:ScriptFuncNew() s:ScriptFuncNew()
UserFunc() UserFunc()
UserFuncWithArg("foo") UserFuncWithArg("foo")
let FuncRef = function("UserFunc") var FuncRef = function("UserFunc")
FuncRef() FuncRef()
let FuncRefWithArg = function("UserFuncWithArg") var FuncRefWithArg = function("UserFuncWithArg")
FuncRefWithArg("bar") FuncRefWithArg("bar")
return "yes" return "yes"
enddef enddef
def Test_disassemble_call() def Test_disassemble_call()
let res = execute('disass s:ScriptFuncCall') var res = execute('disass s:ScriptFuncCall')
assert_match('<SNR>\d\+_ScriptFuncCall\_s*' .. assert_match('<SNR>\d\+_ScriptFuncCall\_s*' ..
'changenr()\_s*' .. 'changenr()\_s*' ..
'\d BCALL changenr(argc 0)\_s*' .. '\d BCALL changenr(argc 0)\_s*' ..
@ -413,7 +416,7 @@ def Test_disassemble_call()
'\d\+ PUSHS "foo"\_s*' .. '\d\+ PUSHS "foo"\_s*' ..
'\d\+ UCALL UserFuncWithArg(argc 1)\_s*' .. '\d\+ UCALL UserFuncWithArg(argc 1)\_s*' ..
'\d\+ DROP\_s*' .. '\d\+ DROP\_s*' ..
'let FuncRef = function("UserFunc")\_s*' .. 'var FuncRef = function("UserFunc")\_s*' ..
'\d\+ PUSHS "UserFunc"\_s*' .. '\d\+ PUSHS "UserFunc"\_s*' ..
'\d\+ BCALL function(argc 1)\_s*' .. '\d\+ BCALL function(argc 1)\_s*' ..
'\d\+ STORE $0\_s*' .. '\d\+ STORE $0\_s*' ..
@ -421,7 +424,7 @@ def Test_disassemble_call()
'\d\+ LOAD $\d\_s*' .. '\d\+ LOAD $\d\_s*' ..
'\d\+ PCALL (argc 0)\_s*' .. '\d\+ PCALL (argc 0)\_s*' ..
'\d\+ DROP\_s*' .. '\d\+ DROP\_s*' ..
'let FuncRefWithArg = function("UserFuncWithArg")\_s*' .. 'var FuncRefWithArg = function("UserFuncWithArg")\_s*' ..
'\d\+ PUSHS "UserFuncWithArg"\_s*' .. '\d\+ PUSHS "UserFuncWithArg"\_s*' ..
'\d\+ BCALL function(argc 1)\_s*' .. '\d\+ BCALL function(argc 1)\_s*' ..
'\d\+ STORE $1\_s*' .. '\d\+ STORE $1\_s*' ..
@ -437,7 +440,7 @@ def Test_disassemble_call()
enddef enddef
def s:CreateRefs() def s:CreateRefs()
let local = 'a' var local = 'a'
def Append(arg: string) def Append(arg: string)
local ..= arg local ..= arg
enddef enddef
@ -450,7 +453,7 @@ enddef
def Test_disassemble_closure() def Test_disassemble_closure()
CreateRefs() CreateRefs()
let res = execute('disass g:Append') var res = execute('disass g:Append')
assert_match('<lambda>\d\_s*' .. assert_match('<lambda>\d\_s*' ..
'local ..= arg\_s*' .. 'local ..= arg\_s*' ..
'\d LOADOUTER $0\_s*' .. '\d LOADOUTER $0\_s*' ..
@ -484,7 +487,7 @@ def s:ScriptPCall()
enddef enddef
def Test_disassemble_pcall() def Test_disassemble_pcall()
let res = execute('disass s:ScriptPCall') var res = execute('disass s:ScriptPCall')
assert_match('<SNR>\d\+_ScriptPCall\_s*' .. assert_match('<SNR>\d\+_ScriptPCall\_s*' ..
'RefThis()("text")\_s*' .. 'RefThis()("text")\_s*' ..
'\d DCALL RefThis(argc 0)\_s*' .. '\d DCALL RefThis(argc 0)\_s*' ..
@ -507,7 +510,7 @@ def DefinedLater(arg: string): string
enddef enddef
def Test_disassemble_update_instr() def Test_disassemble_update_instr()
let res = execute('disass s:FuncWithForwardCall') var res = execute('disass s:FuncWithForwardCall')
assert_match('FuncWithForwardCall\_s*' .. assert_match('FuncWithForwardCall\_s*' ..
'return g:DefinedLater("yes")\_s*' .. 'return g:DefinedLater("yes")\_s*' ..
'\d PUSHS "yes"\_s*' .. '\d PUSHS "yes"\_s*' ..
@ -533,7 +536,7 @@ def FuncWithDefault(arg: string = 'default'): string
enddef enddef
def Test_disassemble_call_default() def Test_disassemble_call_default()
let res = execute('disass FuncWithDefault') var res = execute('disass FuncWithDefault')
assert_match('FuncWithDefault\_s*' .. assert_match('FuncWithDefault\_s*' ..
'\d PUSHS "default"\_s*' .. '\d PUSHS "default"\_s*' ..
'\d STORE arg\[-1]\_s*' .. '\d STORE arg\[-1]\_s*' ..
@ -574,7 +577,7 @@ enddef
def Test_disassemble_const_expr() def Test_disassemble_const_expr()
assert_equal("\nyes", execute('HasEval()')) assert_equal("\nyes", execute('HasEval()'))
let instr = execute('disassemble HasEval') var instr = execute('disassemble HasEval')
assert_match('HasEval\_s*' .. assert_match('HasEval\_s*' ..
'if has("eval")\_s*' .. 'if has("eval")\_s*' ..
'echo "yes"\_s*' .. 'echo "yes"\_s*' ..
@ -630,7 +633,7 @@ def ReturnInIf(): string
enddef enddef
def Test_disassemble_return_in_if() def Test_disassemble_return_in_if()
let instr = execute('disassemble ReturnInIf') var instr = execute('disassemble ReturnInIf')
assert_match('ReturnInIf\_s*' .. assert_match('ReturnInIf\_s*' ..
'if g:cond\_s*' .. 'if g:cond\_s*' ..
'0 LOADG g:cond\_s*' .. '0 LOADG g:cond\_s*' ..
@ -646,22 +649,22 @@ def Test_disassemble_return_in_if()
enddef enddef
def WithFunc() def WithFunc()
let Funky1: func var Funky1: func
let Funky2: func = function("len") var Funky2: func = function("len")
let Party2: func = funcref("UserFunc") var Party2: func = funcref("UserFunc")
enddef enddef
def Test_disassemble_function() def Test_disassemble_function()
let instr = execute('disassemble WithFunc') var instr = execute('disassemble WithFunc')
assert_match('WithFunc\_s*' .. assert_match('WithFunc\_s*' ..
'let Funky1: func\_s*' .. 'var Funky1: func\_s*' ..
'0 PUSHFUNC "\[none]"\_s*' .. '0 PUSHFUNC "\[none]"\_s*' ..
'1 STORE $0\_s*' .. '1 STORE $0\_s*' ..
'let Funky2: func = function("len")\_s*' .. 'var Funky2: func = function("len")\_s*' ..
'2 PUSHS "len"\_s*' .. '2 PUSHS "len"\_s*' ..
'3 BCALL function(argc 1)\_s*' .. '3 BCALL function(argc 1)\_s*' ..
'4 STORE $1\_s*' .. '4 STORE $1\_s*' ..
'let Party2: func = funcref("UserFunc")\_s*' .. 'var Party2: func = funcref("UserFunc")\_s*' ..
'\d PUSHS "UserFunc"\_s*' .. '\d PUSHS "UserFunc"\_s*' ..
'\d BCALL funcref(argc 1)\_s*' .. '\d BCALL funcref(argc 1)\_s*' ..
'\d STORE $2\_s*' .. '\d STORE $2\_s*' ..
@ -672,25 +675,25 @@ enddef
if has('channel') if has('channel')
def WithChannel() def WithChannel()
let job1: job var job1: job
let job2: job = job_start("donothing") var job2: job = job_start("donothing")
let chan1: channel var chan1: channel
enddef enddef
endif endif
def Test_disassemble_channel() def Test_disassemble_channel()
CheckFeature channel CheckFeature channel
let instr = execute('disassemble WithChannel') var instr = execute('disassemble WithChannel')
assert_match('WithChannel\_s*' .. assert_match('WithChannel\_s*' ..
'let job1: job\_s*' .. 'var job1: job\_s*' ..
'\d PUSHJOB "no process"\_s*' .. '\d PUSHJOB "no process"\_s*' ..
'\d STORE $0\_s*' .. '\d STORE $0\_s*' ..
'let job2: job = job_start("donothing")\_s*' .. 'var job2: job = job_start("donothing")\_s*' ..
'\d PUSHS "donothing"\_s*' .. '\d PUSHS "donothing"\_s*' ..
'\d BCALL job_start(argc 1)\_s*' .. '\d BCALL job_start(argc 1)\_s*' ..
'\d STORE $1\_s*' .. '\d STORE $1\_s*' ..
'let chan1: channel\_s*' .. 'var chan1: channel\_s*' ..
'\d PUSHCHANNEL 0\_s*' .. '\d PUSHCHANNEL 0\_s*' ..
'\d STORE $2\_s*' .. '\d STORE $2\_s*' ..
'\d PUSHNR 0\_s*' .. '\d PUSHNR 0\_s*' ..
@ -699,15 +702,15 @@ def Test_disassemble_channel()
enddef enddef
def WithLambda(): string def WithLambda(): string
let F = {a -> "X" .. a .. "X"} var F = {a -> "X" .. a .. "X"}
return F("x") return F("x")
enddef enddef
def Test_disassemble_lambda() def Test_disassemble_lambda()
assert_equal("XxX", WithLambda()) assert_equal("XxX", WithLambda())
let instr = execute('disassemble WithLambda') var instr = execute('disassemble WithLambda')
assert_match('WithLambda\_s*' .. assert_match('WithLambda\_s*' ..
'let F = {a -> "X" .. a .. "X"}\_s*' .. 'var F = {a -> "X" .. a .. "X"}\_s*' ..
'\d FUNCREF <lambda>\d\+\_s*' .. '\d FUNCREF <lambda>\d\+\_s*' ..
'\d STORE $0\_s*' .. '\d STORE $0\_s*' ..
'return F("x")\_s*' .. 'return F("x")\_s*' ..
@ -717,7 +720,7 @@ def Test_disassemble_lambda()
'\d RETURN', '\d RETURN',
instr) instr)
let name = substitute(instr, '.*\(<lambda>\d\+\).*', '\1', '') var name = substitute(instr, '.*\(<lambda>\d\+\).*', '\1', '')
instr = execute('disassemble ' .. name) instr = execute('disassemble ' .. name)
assert_match('<lambda>\d\+\_s*' .. assert_match('<lambda>\d\+\_s*' ..
'return "X" .. a .. "X"\_s*' .. 'return "X" .. a .. "X"\_s*' ..
@ -738,7 +741,7 @@ def NestedOuter()
enddef enddef
def Test_nested_func() def Test_nested_func()
let instr = execute('disassemble NestedOuter') var instr = execute('disassemble NestedOuter')
assert_match('NestedOuter\_s*' .. assert_match('NestedOuter\_s*' ..
'def g:Inner()\_s*' .. 'def g:Inner()\_s*' ..
'echomsg "inner"\_s*' .. 'echomsg "inner"\_s*' ..
@ -760,7 +763,7 @@ def Test_disassemble_and_or()
assert_equal("yes", AndOr(1)) assert_equal("yes", AndOr(1))
assert_equal("no", AndOr(2)) assert_equal("no", AndOr(2))
assert_equal("yes", AndOr(4)) assert_equal("yes", AndOr(4))
let instr = execute('disassemble AndOr') var instr = execute('disassemble AndOr')
assert_match('AndOr\_s*' .. assert_match('AndOr\_s*' ..
'if arg == 1 && arg != 2 || arg == 4\_s*' .. 'if arg == 1 && arg != 2 || arg == 4\_s*' ..
'\d LOAD arg\[-1]\_s*' .. '\d LOAD arg\[-1]\_s*' ..
@ -779,7 +782,7 @@ def Test_disassemble_and_or()
enddef enddef
def ForLoop(): list<number> def ForLoop(): list<number>
let res: list<number> var res: list<number>
for i in range(3) for i in range(3)
res->add(i) res->add(i)
endfor endfor
@ -788,9 +791,9 @@ enddef
def Test_disassemble_for_loop() def Test_disassemble_for_loop()
assert_equal([0, 1, 2], ForLoop()) assert_equal([0, 1, 2], ForLoop())
let instr = execute('disassemble ForLoop') var instr = execute('disassemble ForLoop')
assert_match('ForLoop\_s*' .. assert_match('ForLoop\_s*' ..
'let res: list<number>\_s*' .. 'var res: list<number>\_s*' ..
'\d NEWLIST size 0\_s*' .. '\d NEWLIST size 0\_s*' ..
'\d STORE $0\_s*' .. '\d STORE $0\_s*' ..
'for i in range(3)\_s*' .. 'for i in range(3)\_s*' ..
@ -811,7 +814,7 @@ def Test_disassemble_for_loop()
enddef enddef
def ForLoopEval(): string def ForLoopEval(): string
let res = "" var res = ""
for str in eval('["one", "two"]') for str in eval('["one", "two"]')
res ..= str res ..= str
endfor endfor
@ -820,9 +823,9 @@ enddef
def Test_disassemble_for_loop_eval() def Test_disassemble_for_loop_eval()
assert_equal('onetwo', ForLoopEval()) assert_equal('onetwo', ForLoopEval())
let instr = execute('disassemble ForLoopEval') var instr = execute('disassemble ForLoopEval')
assert_match('ForLoopEval\_s*' .. assert_match('ForLoopEval\_s*' ..
'let res = ""\_s*' .. 'var res = ""\_s*' ..
'\d PUSHS ""\_s*' .. '\d PUSHS ""\_s*' ..
'\d STORE $0\_s*' .. '\d STORE $0\_s*' ..
'for str in eval(''\["one", "two"\]'')\_s*' .. 'for str in eval(''\["one", "two"\]'')\_s*' ..
@ -850,13 +853,13 @@ enddef
let g:number = 42 let g:number = 42
def TypeCast() def TypeCast()
let l: list<number> = [23, <number>g:number] var l: list<number> = [23, <number>g:number]
enddef enddef
def Test_disassemble_typecast() def Test_disassemble_typecast()
let instr = execute('disassemble TypeCast') var instr = execute('disassemble TypeCast')
assert_match('TypeCast.*' .. assert_match('TypeCast.*' ..
'let l: list<number> = \[23, <number>g:number\].*' .. 'var l: list<number> = \[23, <number>g:number\].*' ..
'\d PUSHNR 23\_s*' .. '\d PUSHNR 23\_s*' ..
'\d LOADG g:number\_s*' .. '\d LOADG g:number\_s*' ..
'\d CHECKTYPE number stack\[-1\]\_s*' .. '\d CHECKTYPE number stack\[-1\]\_s*' ..
@ -868,22 +871,22 @@ def Test_disassemble_typecast()
enddef enddef
def Computing() def Computing()
let nr = 3 var nr = 3
let nrres = nr + 7 var nrres = nr + 7
nrres = nr - 7 nrres = nr - 7
nrres = nr * 7 nrres = nr * 7
nrres = nr / 7 nrres = nr / 7
nrres = nr % 7 nrres = nr % 7
let anyres = g:number + 7 var anyres = g:number + 7
anyres = g:number - 7 anyres = g:number - 7
anyres = g:number * 7 anyres = g:number * 7
anyres = g:number / 7 anyres = g:number / 7
anyres = g:number % 7 anyres = g:number % 7
if has('float') if has('float')
let fl = 3.0 var fl = 3.0
let flres = fl + 7.0 var flres = fl + 7.0
flres = fl - 7.0 flres = fl - 7.0
flres = fl * 7.0 flres = fl * 7.0
flres = fl / 7.0 flres = fl / 7.0
@ -891,11 +894,11 @@ def Computing()
enddef enddef
def Test_disassemble_computing() def Test_disassemble_computing()
let instr = execute('disassemble Computing') var instr = execute('disassemble Computing')
assert_match('Computing.*' .. assert_match('Computing.*' ..
'let nr = 3.*' .. 'var nr = 3.*' ..
'\d STORE 3 in $0.*' .. '\d STORE 3 in $0.*' ..
'let nrres = nr + 7.*' .. 'var nrres = nr + 7.*' ..
'\d LOAD $0.*' .. '\d LOAD $0.*' ..
'\d PUSHNR 7.*' .. '\d PUSHNR 7.*' ..
'\d OPNR +.*' .. '\d OPNR +.*' ..
@ -908,7 +911,7 @@ def Test_disassemble_computing()
'\d OPNR /.*' .. '\d OPNR /.*' ..
'nrres = nr % 7.*' .. 'nrres = nr % 7.*' ..
'\d OPNR %.*' .. '\d OPNR %.*' ..
'let anyres = g:number + 7.*' .. 'var anyres = g:number + 7.*' ..
'\d LOADG g:number.*' .. '\d LOADG g:number.*' ..
'\d PUSHNR 7.*' .. '\d PUSHNR 7.*' ..
'\d OPANY +.*' .. '\d OPANY +.*' ..
@ -924,10 +927,10 @@ def Test_disassemble_computing()
instr) instr)
if has('float') if has('float')
assert_match('Computing.*' .. assert_match('Computing.*' ..
'let fl = 3.0.*' .. 'var fl = 3.0.*' ..
'\d PUSHF 3.0.*' .. '\d PUSHF 3.0.*' ..
'\d STORE $3.*' .. '\d STORE $3.*' ..
'let flres = fl + 7.0.*' .. 'var flres = fl + 7.0.*' ..
'\d LOAD $3.*' .. '\d LOAD $3.*' ..
'\d PUSHF 7.0.*' .. '\d PUSHF 7.0.*' ..
'\d OPFLOAT +.*' .. '\d OPFLOAT +.*' ..
@ -943,14 +946,14 @@ def Test_disassemble_computing()
enddef enddef
def AddListBlob() def AddListBlob()
let reslist = [1, 2] + [3, 4] var reslist = [1, 2] + [3, 4]
let resblob = 0z1122 + 0z3344 var resblob = 0z1122 + 0z3344
enddef enddef
def Test_disassemble_add_list_blob() def Test_disassemble_add_list_blob()
let instr = execute('disassemble AddListBlob') var instr = execute('disassemble AddListBlob')
assert_match('AddListBlob.*' .. assert_match('AddListBlob.*' ..
'let reslist = \[1, 2] + \[3, 4].*' .. 'var reslist = \[1, 2] + \[3, 4].*' ..
'\d PUSHNR 1.*' .. '\d PUSHNR 1.*' ..
'\d PUSHNR 2.*' .. '\d PUSHNR 2.*' ..
'\d NEWLIST size 2.*' .. '\d NEWLIST size 2.*' ..
@ -959,7 +962,7 @@ def Test_disassemble_add_list_blob()
'\d NEWLIST size 2.*' .. '\d NEWLIST size 2.*' ..
'\d ADDLIST.*' .. '\d ADDLIST.*' ..
'\d STORE $.*.*' .. '\d STORE $.*.*' ..
'let resblob = 0z1122 + 0z3344.*' .. 'var resblob = 0z1122 + 0z3344.*' ..
'\d PUSHBLOB 0z1122.*' .. '\d PUSHBLOB 0z1122.*' ..
'\d PUSHBLOB 0z3344.*' .. '\d PUSHBLOB 0z3344.*' ..
'\d ADDBLOB.*' .. '\d ADDBLOB.*' ..
@ -969,14 +972,14 @@ enddef
let g:aa = 'aa' let g:aa = 'aa'
def ConcatString(): string def ConcatString(): string
let res = g:aa .. "bb" var res = g:aa .. "bb"
return res return res
enddef enddef
def Test_disassemble_concat() def Test_disassemble_concat()
let instr = execute('disassemble ConcatString') var instr = execute('disassemble ConcatString')
assert_match('ConcatString.*' .. assert_match('ConcatString.*' ..
'let res = g:aa .. "bb".*' .. 'var res = g:aa .. "bb".*' ..
'\d LOADG g:aa.*' .. '\d LOADG g:aa.*' ..
'\d PUSHS "bb".*' .. '\d PUSHS "bb".*' ..
'\d 2STRING_ANY stack\[-2].*' .. '\d 2STRING_ANY stack\[-2].*' ..
@ -987,18 +990,18 @@ def Test_disassemble_concat()
enddef enddef
def StringIndex(): string def StringIndex(): string
let s = "abcd" var s = "abcd"
let res = s[1] var res = s[1]
return res return res
enddef enddef
def Test_disassemble_string_index() def Test_disassemble_string_index()
let instr = execute('disassemble StringIndex') var instr = execute('disassemble StringIndex')
assert_match('StringIndex\_s*' .. assert_match('StringIndex\_s*' ..
'let s = "abcd"\_s*' .. 'var s = "abcd"\_s*' ..
'\d PUSHS "abcd"\_s*' .. '\d PUSHS "abcd"\_s*' ..
'\d STORE $0\_s*' .. '\d STORE $0\_s*' ..
'let res = s\[1]\_s*' .. 'var res = s\[1]\_s*' ..
'\d LOAD $0\_s*' .. '\d LOAD $0\_s*' ..
'\d PUSHNR 1\_s*' .. '\d PUSHNR 1\_s*' ..
'\d STRINDEX\_s*' .. '\d STRINDEX\_s*' ..
@ -1008,18 +1011,18 @@ def Test_disassemble_string_index()
enddef enddef
def StringSlice(): string def StringSlice(): string
let s = "abcd" var s = "abcd"
let res = s[1:8] var res = s[1:8]
return res return res
enddef enddef
def Test_disassemble_string_slice() def Test_disassemble_string_slice()
let instr = execute('disassemble StringSlice') var instr = execute('disassemble StringSlice')
assert_match('StringSlice\_s*' .. assert_match('StringSlice\_s*' ..
'let s = "abcd"\_s*' .. 'var s = "abcd"\_s*' ..
'\d PUSHS "abcd"\_s*' .. '\d PUSHS "abcd"\_s*' ..
'\d STORE $0\_s*' .. '\d STORE $0\_s*' ..
'let res = s\[1:8]\_s*' .. 'var res = s\[1:8]\_s*' ..
'\d LOAD $0\_s*' .. '\d LOAD $0\_s*' ..
'\d PUSHNR 1\_s*' .. '\d PUSHNR 1\_s*' ..
'\d PUSHNR 8\_s*' .. '\d PUSHNR 8\_s*' ..
@ -1030,21 +1033,21 @@ def Test_disassemble_string_slice()
enddef enddef
def ListIndex(): number def ListIndex(): number
let l = [1, 2, 3] var l = [1, 2, 3]
let res = l[1] var res = l[1]
return res return res
enddef enddef
def Test_disassemble_list_index() def Test_disassemble_list_index()
let instr = execute('disassemble ListIndex') var instr = execute('disassemble ListIndex')
assert_match('ListIndex\_s*' .. assert_match('ListIndex\_s*' ..
'let l = \[1, 2, 3]\_s*' .. 'var l = \[1, 2, 3]\_s*' ..
'\d PUSHNR 1\_s*' .. '\d PUSHNR 1\_s*' ..
'\d PUSHNR 2\_s*' .. '\d PUSHNR 2\_s*' ..
'\d PUSHNR 3\_s*' .. '\d PUSHNR 3\_s*' ..
'\d NEWLIST size 3\_s*' .. '\d NEWLIST size 3\_s*' ..
'\d STORE $0\_s*' .. '\d STORE $0\_s*' ..
'let res = l\[1]\_s*' .. 'var res = l\[1]\_s*' ..
'\d LOAD $0\_s*' .. '\d LOAD $0\_s*' ..
'\d PUSHNR 1\_s*' .. '\d PUSHNR 1\_s*' ..
'\d LISTINDEX\_s*' .. '\d LISTINDEX\_s*' ..
@ -1054,21 +1057,21 @@ def Test_disassemble_list_index()
enddef enddef
def ListSlice(): list<number> def ListSlice(): list<number>
let l = [1, 2, 3] var l = [1, 2, 3]
let res = l[1:8] var res = l[1:8]
return res return res
enddef enddef
def Test_disassemble_list_slice() def Test_disassemble_list_slice()
let instr = execute('disassemble ListSlice') var instr = execute('disassemble ListSlice')
assert_match('ListSlice\_s*' .. assert_match('ListSlice\_s*' ..
'let l = \[1, 2, 3]\_s*' .. 'var l = \[1, 2, 3]\_s*' ..
'\d PUSHNR 1\_s*' .. '\d PUSHNR 1\_s*' ..
'\d PUSHNR 2\_s*' .. '\d PUSHNR 2\_s*' ..
'\d PUSHNR 3\_s*' .. '\d PUSHNR 3\_s*' ..
'\d NEWLIST size 3\_s*' .. '\d NEWLIST size 3\_s*' ..
'\d STORE $0\_s*' .. '\d STORE $0\_s*' ..
'let res = l\[1:8]\_s*' .. 'var res = l\[1:8]\_s*' ..
'\d LOAD $0\_s*' .. '\d LOAD $0\_s*' ..
'\d PUSHNR 1\_s*' .. '\d PUSHNR 1\_s*' ..
'\d PUSHNR 8\_s*' .. '\d PUSHNR 8\_s*' ..
@ -1079,21 +1082,21 @@ def Test_disassemble_list_slice()
enddef enddef
def DictMember(): number def DictMember(): number
let d = #{item: 1} var d = #{item: 1}
let res = d.item var res = d.item
res = d["item"] res = d["item"]
return res return res
enddef enddef
def Test_disassemble_dict_member() def Test_disassemble_dict_member()
let instr = execute('disassemble DictMember') var instr = execute('disassemble DictMember')
assert_match('DictMember\_s*' .. assert_match('DictMember\_s*' ..
'let d = #{item: 1}\_s*' .. 'var d = #{item: 1}\_s*' ..
'\d PUSHS "item"\_s*' .. '\d PUSHS "item"\_s*' ..
'\d PUSHNR 1\_s*' .. '\d PUSHNR 1\_s*' ..
'\d NEWDICT size 1\_s*' .. '\d NEWDICT size 1\_s*' ..
'\d STORE $0\_s*' .. '\d STORE $0\_s*' ..
'let res = d.item\_s*' .. 'var res = d.item\_s*' ..
'\d\+ LOAD $0\_s*' .. '\d\+ LOAD $0\_s*' ..
'\d\+ MEMBER item\_s*' .. '\d\+ MEMBER item\_s*' ..
'\d\+ STORE $1\_s*' .. '\d\+ STORE $1\_s*' ..
@ -1108,14 +1111,14 @@ enddef
let somelist = [1, 2, 3, 4, 5] let somelist = [1, 2, 3, 4, 5]
def AnyIndex(): number def AnyIndex(): number
let res = g:somelist[2] var res = g:somelist[2]
return res return res
enddef enddef
def Test_disassemble_any_index() def Test_disassemble_any_index()
let instr = execute('disassemble AnyIndex') var instr = execute('disassemble AnyIndex')
assert_match('AnyIndex\_s*' .. assert_match('AnyIndex\_s*' ..
'let res = g:somelist\[2\]\_s*' .. 'var res = g:somelist\[2\]\_s*' ..
'\d LOADG g:somelist\_s*' .. '\d LOADG g:somelist\_s*' ..
'\d PUSHNR 2\_s*' .. '\d PUSHNR 2\_s*' ..
'\d ANYINDEX\_s*' .. '\d ANYINDEX\_s*' ..
@ -1129,14 +1132,14 @@ def Test_disassemble_any_index()
enddef enddef
def AnySlice(): list<number> def AnySlice(): list<number>
let res = g:somelist[1:3] var res = g:somelist[1:3]
return res return res
enddef enddef
def Test_disassemble_any_slice() def Test_disassemble_any_slice()
let instr = execute('disassemble AnySlice') var instr = execute('disassemble AnySlice')
assert_match('AnySlice\_s*' .. assert_match('AnySlice\_s*' ..
'let res = g:somelist\[1:3\]\_s*' .. 'var res = g:somelist\[1:3\]\_s*' ..
'\d LOADG g:somelist\_s*' .. '\d LOADG g:somelist\_s*' ..
'\d PUSHNR 1\_s*' .. '\d PUSHNR 1\_s*' ..
'\d PUSHNR 3\_s*' .. '\d PUSHNR 3\_s*' ..
@ -1151,22 +1154,22 @@ def Test_disassemble_any_slice()
enddef enddef
def NegateNumber(): number def NegateNumber(): number
let nr = 9 var nr = 9
let plus = +nr var plus = +nr
let res = -nr var res = -nr
return res return res
enddef enddef
def Test_disassemble_negate_number() def Test_disassemble_negate_number()
let instr = execute('disassemble NegateNumber') var instr = execute('disassemble NegateNumber')
assert_match('NegateNumber\_s*' .. assert_match('NegateNumber\_s*' ..
'let nr = 9\_s*' .. 'var nr = 9\_s*' ..
'\d STORE 9 in $0\_s*' .. '\d STORE 9 in $0\_s*' ..
'let plus = +nr\_s*' .. 'var plus = +nr\_s*' ..
'\d LOAD $0\_s*' .. '\d LOAD $0\_s*' ..
'\d CHECKNR\_s*' .. '\d CHECKNR\_s*' ..
'\d STORE $1\_s*' .. '\d STORE $1\_s*' ..
'let res = -nr\_s*' .. 'var res = -nr\_s*' ..
'\d LOAD $0\_s*' .. '\d LOAD $0\_s*' ..
'\d NEGATENR\_s*' .. '\d NEGATENR\_s*' ..
'\d STORE $2\_s*', '\d STORE $2\_s*',
@ -1175,23 +1178,23 @@ def Test_disassemble_negate_number()
enddef enddef
def InvertBool(): bool def InvertBool(): bool
let flag = true var flag = true
let invert = !flag var invert = !flag
let res = !!flag var res = !!flag
return res return res
enddef enddef
def Test_disassemble_invert_bool() def Test_disassemble_invert_bool()
let instr = execute('disassemble InvertBool') var instr = execute('disassemble InvertBool')
assert_match('InvertBool\_s*' .. assert_match('InvertBool\_s*' ..
'let flag = true\_s*' .. 'var flag = true\_s*' ..
'\d PUSH v:true\_s*' .. '\d PUSH v:true\_s*' ..
'\d STORE $0\_s*' .. '\d STORE $0\_s*' ..
'let invert = !flag\_s*' .. 'var invert = !flag\_s*' ..
'\d LOAD $0\_s*' .. '\d LOAD $0\_s*' ..
'\d INVERT (!val)\_s*' .. '\d INVERT (!val)\_s*' ..
'\d STORE $1\_s*' .. '\d STORE $1\_s*' ..
'let res = !!flag\_s*' .. 'var res = !!flag\_s*' ..
'\d LOAD $0\_s*' .. '\d LOAD $0\_s*' ..
'\d 2BOOL (!!val)\_s*' .. '\d 2BOOL (!!val)\_s*' ..
'\d STORE $2\_s*', '\d STORE $2\_s*',
@ -1200,14 +1203,14 @@ def Test_disassemble_invert_bool()
enddef enddef
def ReturnBool(): bool def ReturnBool(): bool
let var: bool = "no" && [] || 123 var var: bool = "no" && [] || 123
return var return var
enddef enddef
def Test_disassemble_return_bool() def Test_disassemble_return_bool()
let instr = execute('disassemble ReturnBool') var instr = execute('disassemble ReturnBool')
assert_match('ReturnBool\_s*' .. assert_match('ReturnBool\_s*' ..
'let var: bool = "no" && \[\] || 123\_s*' .. 'var var: bool = "no" && \[\] || 123\_s*' ..
'0 PUSHS "no"\_s*' .. '0 PUSHS "no"\_s*' ..
'1 JUMP_AND_KEEP_IF_FALSE -> 3\_s*' .. '1 JUMP_AND_KEEP_IF_FALSE -> 3\_s*' ..
'2 NEWLIST size 0\_s*' .. '2 NEWLIST size 0\_s*' ..
@ -1223,7 +1226,7 @@ def Test_disassemble_return_bool()
enddef enddef
def Test_disassemble_compare() def Test_disassemble_compare()
let cases = [ var cases = [
['true == isFalse', 'COMPAREBOOL =='], ['true == isFalse', 'COMPAREBOOL =='],
['true != isFalse', 'COMPAREBOOL !='], ['true != isFalse', 'COMPAREBOOL !='],
['v:none == isNull', 'COMPARESPECIAL =='], ['v:none == isNull', 'COMPARESPECIAL =='],
@ -1279,7 +1282,7 @@ def Test_disassemble_compare()
['77 is g:xx', 'COMPAREANY is'], ['77 is g:xx', 'COMPAREANY is'],
['77 isnot g:xx', 'COMPAREANY isnot'], ['77 isnot g:xx', 'COMPAREANY isnot'],
] ]
let floatDecl = '' var floatDecl = ''
if has('float') if has('float')
cases->extend([ cases->extend([
['1.1 == aFloat', 'COMPAREFLOAT =='], ['1.1 == aFloat', 'COMPAREFLOAT =='],
@ -1291,27 +1294,27 @@ def Test_disassemble_compare()
['1.1 =~ aFloat', 'COMPAREFLOAT =\~'], ['1.1 =~ aFloat', 'COMPAREFLOAT =\~'],
['1.1 !~ aFloat', 'COMPAREFLOAT !\~'], ['1.1 !~ aFloat', 'COMPAREFLOAT !\~'],
]) ])
floatDecl = 'let aFloat = 2.2' floatDecl = 'var aFloat = 2.2'
endif endif
let nr = 1 var nr = 1
for case in cases for case in cases
# declare local variables to get a non-constant with the right type # declare local variables to get a non-constant with the right type
writefile(['def TestCase' .. nr .. '()', writefile(['def TestCase' .. nr .. '()',
' let isFalse = false', ' var isFalse = false',
' let isNull = v:null', ' var isNull = v:null',
' let aNumber = 222', ' var aNumber = 222',
' let aString = "yy"', ' var aString = "yy"',
' let aBlob = 0z22', ' var aBlob = 0z22',
' let aList = [3, 4]', ' var aList = [3, 4]',
' let aDict = #{x: 2}', ' var aDict = #{x: 2}',
floatDecl, floatDecl,
' if ' .. case[0], ' if ' .. case[0],
' echo 42' ' echo 42'
' endif', ' endif',
'enddef'], 'Xdisassemble') 'enddef'], 'Xdisassemble')
source Xdisassemble source Xdisassemble
let instr = execute('disassemble TestCase' .. nr) var instr = execute('disassemble TestCase' .. nr)
assert_match('TestCase' .. nr .. '.*' .. assert_match('TestCase' .. nr .. '.*' ..
'if ' .. substitute(case[0], '[[~]', '\\\0', 'g') .. '.*' .. 'if ' .. substitute(case[0], '[[~]', '\\\0', 'g') .. '.*' ..
'\d \(PUSH\|FUNCREF\).*' .. '\d \(PUSH\|FUNCREF\).*' ..
@ -1327,14 +1330,14 @@ def Test_disassemble_compare()
enddef enddef
def Test_disassemble_compare_const() def Test_disassemble_compare_const()
let cases = [ var cases = [
['"xx" == "yy"', false], ['"xx" == "yy"', false],
['"aa" == "aa"', true], ['"aa" == "aa"', true],
['has("eval") ? true : false', true], ['has("eval") ? true : false', true],
['has("asdf") ? true : false', false], ['has("asdf") ? true : false', false],
] ]
let nr = 1 var nr = 1
for case in cases for case in cases
writefile(['def TestCase' .. nr .. '()', writefile(['def TestCase' .. nr .. '()',
' if ' .. case[0], ' if ' .. case[0],
@ -1342,7 +1345,7 @@ def Test_disassemble_compare_const()
' endif', ' endif',
'enddef'], 'Xdisassemble') 'enddef'], 'Xdisassemble')
source Xdisassemble source Xdisassemble
let instr = execute('disassemble TestCase' .. nr) var instr = execute('disassemble TestCase' .. nr)
if case[1] if case[1]
# condition true, "echo 42" executed # condition true, "echo 42" executed
assert_match('TestCase' .. nr .. '.*' .. assert_match('TestCase' .. nr .. '.*' ..
@ -1371,25 +1374,25 @@ enddef
def s:Execute() def s:Execute()
execute 'help vim9.txt' execute 'help vim9.txt'
let cmd = 'help vim9.txt' var cmd = 'help vim9.txt'
execute cmd execute cmd
let tag = 'vim9.txt' var tag = 'vim9.txt'
execute 'help ' .. tag execute 'help ' .. tag
enddef enddef
def Test_disassemble_execute() def Test_disassemble_execute()
let res = execute('disass s:Execute') var res = execute('disass s:Execute')
assert_match('\<SNR>\d*_Execute\_s*' .. assert_match('\<SNR>\d*_Execute\_s*' ..
"execute 'help vim9.txt'\\_s*" .. "execute 'help vim9.txt'\\_s*" ..
'\d PUSHS "help vim9.txt"\_s*' .. '\d PUSHS "help vim9.txt"\_s*' ..
'\d EXECUTE 1\_s*' .. '\d EXECUTE 1\_s*' ..
"let cmd = 'help vim9.txt'\\_s*" .. "var cmd = 'help vim9.txt'\\_s*" ..
'\d PUSHS "help vim9.txt"\_s*' .. '\d PUSHS "help vim9.txt"\_s*' ..
'\d STORE $0\_s*' .. '\d STORE $0\_s*' ..
'execute cmd\_s*' .. 'execute cmd\_s*' ..
'\d LOAD $0\_s*' .. '\d LOAD $0\_s*' ..
'\d EXECUTE 1\_s*' .. '\d EXECUTE 1\_s*' ..
"let tag = 'vim9.txt'\\_s*" .. "var tag = 'vim9.txt'\\_s*" ..
'\d PUSHS "vim9.txt"\_s*' .. '\d PUSHS "vim9.txt"\_s*' ..
'\d STORE $1\_s*' .. '\d STORE $1\_s*' ..
"execute 'help ' .. tag\\_s*" .. "execute 'help ' .. tag\\_s*" ..
@ -1408,7 +1411,7 @@ def s:Echomsg()
enddef enddef
def Test_disassemble_echomsg() def Test_disassemble_echomsg()
let res = execute('disass s:Echomsg') var res = execute('disass s:Echomsg')
assert_match('\<SNR>\d*_Echomsg\_s*' .. assert_match('\<SNR>\d*_Echomsg\_s*' ..
"echomsg 'some' 'message'\\_s*" .. "echomsg 'some' 'message'\\_s*" ..
'\d PUSHS "some"\_s*' .. '\d PUSHS "some"\_s*' ..
@ -1435,19 +1438,19 @@ def SomeStringArgAndReturn(arg: string): string
enddef enddef
def Test_display_func() def Test_display_func()
let res1 = execute('function SomeStringArg') var res1 = execute('function SomeStringArg')
assert_match('.* def SomeStringArg(arg: string)\_s*' .. assert_match('.* def SomeStringArg(arg: string)\_s*' ..
'\d *echo arg.*' .. '\d *echo arg.*' ..
' *enddef', ' *enddef',
res1) res1)
let res2 = execute('function SomeAnyArg') var res2 = execute('function SomeAnyArg')
assert_match('.* def SomeAnyArg(arg: any)\_s*' .. assert_match('.* def SomeAnyArg(arg: any)\_s*' ..
'\d *echo arg\_s*' .. '\d *echo arg\_s*' ..
' *enddef', ' *enddef',
res2) res2)
let res3 = execute('function SomeStringArgAndReturn') var res3 = execute('function SomeStringArgAndReturn')
assert_match('.* def SomeStringArgAndReturn(arg: string): string\_s*' .. assert_match('.* def SomeStringArgAndReturn(arg: string): string\_s*' ..
'\d *return arg\_s*' .. '\d *return arg\_s*' ..
' *enddef', ' *enddef',
@ -1455,7 +1458,7 @@ def Test_display_func()
enddef enddef
def Test_vim9script_forward_func() def Test_vim9script_forward_func()
let lines =<< trim END var lines =<< trim END
vim9script vim9script
def FuncOne(): string def FuncOne(): string
return FuncTwo() return FuncTwo()
@ -1492,7 +1495,7 @@ def s:ComputeConstParen(): number
enddef enddef
def Test_simplify_const_expr() def Test_simplify_const_expr()
let res = execute('disass s:ConcatStrings') var res = execute('disass s:ConcatStrings')
assert_match('<SNR>\d*_ConcatStrings\_s*' .. assert_match('<SNR>\d*_ConcatStrings\_s*' ..
"return 'one' .. 'two' .. 'three'\\_s*" .. "return 'one' .. 'two' .. 'three'\\_s*" ..
'\d PUSHS "onetwothree"\_s*' .. '\d PUSHS "onetwothree"\_s*' ..
@ -1519,7 +1522,7 @@ def s:CallAppend()
enddef enddef
def Test_shuffle() def Test_shuffle()
let res = execute('disass s:CallAppend') var res = execute('disass s:CallAppend')
assert_match('<SNR>\d*_CallAppend\_s*' .. assert_match('<SNR>\d*_CallAppend\_s*' ..
'eval "some text"->append(2)\_s*' .. 'eval "some text"->append(2)\_s*' ..
'\d PUSHS "some text"\_s*' .. '\d PUSHS "some text"\_s*' ..

2
src/version.c
View File

@ -750,6 +750,8 @@ static char *(features[]) =
static int included_patches[] = static int included_patches[] =
{ /* Add new patch number below this line */ { /* Add new patch number below this line */
/**/
1761,
/**/ /**/
1760, 1760,
/**/ /**/