path: root/src/testdir/test_vim9_disassemble.vim

" Test the :disassemble command, and compilation as a side effect

func NotCompiled()
  echo "not"
endfunc

let s:scriptvar = 4
let g:globalvar = 'g'

def s:ScriptFuncLoad(arg: string)
  let local = 1
  buffers
  echo arg
  echo local
  echo v:version
  echo s:scriptvar
  echo g:globalvar
  echo &tabstop
  echo $ENVVAR
  echo @z
enddef

def Test_disassemble_load()
  assert_fails('disass NoFunc', 'E1061:')
  assert_fails('disass NotCompiled', 'E1062:')

  let res = execute('disass s:ScriptFuncLoad')
  assert_match('<SNR>\d*_ScriptFuncLoad.*'
        \ .. 'buffers.*'
        \ .. ' EXEC \+buffers.*'
        \ .. ' LOAD arg\[-1\].*'
        \ .. ' LOAD $0.*'
        \ .. ' LOADV v:version.*'
        \ .. ' LOADS s:scriptvar from .*test_vim9_disassemble.vim.*'
        \ .. ' LOADG g:globalvar.*'
        \ .. ' LOADENV $ENVVAR.*'
        \ .. ' LOADREG @z.*'
        \, res)
enddef

def s:ScriptFuncPush()
  let localbool = true
  let localspec = v:none
  let localblob = 0z1234
  if has('float')
    let localfloat = 1.234
  endif
enddef

def Test_disassemble_push()
  let res = execute('disass s:ScriptFuncPush')
  assert_match('<SNR>\d*_ScriptFuncPush.*'
        \ .. 'localbool = true.*'
        \ .. ' PUSH v:true.*'
        \ .. 'localspec = v:none.*'
        \ .. ' PUSH v:none.*'
        \ .. 'localblob = 0z1234.*'
        \ .. ' PUSHBLOB 0z1234.*'
        \, res)
  if has('float')
  assert_match('<SNR>\d*_ScriptFuncPush.*'
        \ .. 'localfloat = 1.234.*'
        \ .. ' PUSHF 1.234.*'
        \, res)
  endif
enddef

def s:ScriptFuncStore()
  let localnr = 1
  localnr = 2
  let localstr = 'abc'
  localstr = 'xyz'
  v:char = 'abc'
  s:scriptvar = 'sv'
  g:globalvar = 'gv'
  &tabstop = 8
  $ENVVAR = 'ev'
  @z = 'rv'
enddef

def Test_disassemble_store()
  let res = execute('disass s:ScriptFuncStore')
  assert_match('<SNR>\d*_ScriptFuncStore.*'
        \ .. 'localnr = 2.*'
        \ .. ' STORE 2 in $0.*'
        \ .. 'localstr = ''xyz''.*'
        \ .. ' STORE $1.*'
        \ .. 'v:char = ''abc''.*'
        \ .. 'STOREV v:char.*'
        \ .. 's:scriptvar = ''sv''.*'
        \ .. ' STORES s:scriptvar in .*test_vim9_disassemble.vim.*'
        \ .. 'g:globalvar = ''gv''.*'
        \ .. ' STOREG g:globalvar.*'
        \ .. '&tabstop = 8.*'
        \ .. ' STOREOPT &tabstop.*'
        \ .. '$ENVVAR = ''ev''.*'
        \ .. ' STOREENV $ENVVAR.*'
        \ .. '@z = ''rv''.*'
        \ .. ' STOREREG @z.*'
        \, res)
enddef

def s:ScriptFuncTry()
  try
    echo 'yes'
  catch /fail/
    echo 'no'
  finally
    throw 'end'
  endtry
enddef

def Test_disassemble_try()
  let res = execute('disass s:ScriptFuncTry')
  assert_match('<SNR>\d*_ScriptFuncTry.*'
        \ .. 'try.*'
        \ .. 'TRY catch -> \d\+, finally -> \d\+.*'
        \ .. 'catch /fail/.*'
        \ .. ' JUMP -> \d\+.*'
        \ .. ' PUSH v:exception.*'
        \ .. ' PUSHS "fail".*'
        \ .. ' COMPARESTRING =\~.*'
        \ .. ' JUMP_IF_FALSE -> \d\+.*'
        \ .. ' CATCH.*'
        \ .. 'finally.*'
        \ .. ' PUSHS "end".*'
        \ .. ' THROW.*'
        \ .. 'endtry.*'
        \ .. ' ENDTRY.*'
        \, res)
enddef

def s:ScriptFuncNew()
  let ll = [1, "two", 333]
  let dd = #{one: 1, two: "val"}
enddef

def Test_disassemble_new()
  let res = execute('disass s:ScriptFuncNew')
  assert_match('<SNR>\d*_ScriptFuncNew.*'
        \ .. 'let ll = \[1, "two", 333].*'
        \ .. 'PUSHNR 1.*'
        \ .. 'PUSHS "two".*'
        \ .. 'PUSHNR 333.*'
        \ .. 'NEWLIST size 3.*'
        \ .. 'let dd = #{one: 1, two: "val"}.*'
        \ .. 'PUSHS "one".*'
        \ .. 'PUSHNR 1.*'
        \ .. 'PUSHS "two".*'
        \ .. 'PUSHS "val".*'
        \ .. 'NEWDICT size 2.*'
        \, res)
enddef

def FuncWithArg(arg)
  echo arg
enddef

func UserFunc()
  echo 'nothing'
endfunc

func UserFuncWithArg(arg)
  echo a:arg
endfunc

def s:ScriptFuncCall(): string
  changenr()
  char2nr("abc")
  Test_disassemble_new()
  FuncWithArg(343)
  ScriptFuncNew()
  s:ScriptFuncNew()
  UserFunc()
  UserFuncWithArg("foo")
  let FuncRef = function("UserFunc")
  FuncRef()
  let FuncRefWithArg = function("UserFuncWithArg")
  FuncRefWithArg("bar")
  return "yes"
enddef

def Test_disassemble_call()
  let res = execute('disass s:ScriptFuncCall')
  assert_match('<SNR>\d\+_ScriptFuncCall.*'
        \ .. 'changenr().*'
        \ .. ' BCALL changenr(argc 0).*'
        \ .. 'char2nr("abc").*'
        \ .. ' PUSHS "abc".*'
        \ .. ' BCALL char2nr(argc 1).*'
        \ .. 'Test_disassemble_new().*'
        \ .. ' DCALL Test_disassemble_new(argc 0).*'
        \ .. 'FuncWithArg(343).*'
        \ .. ' PUSHNR 343.*'
        \ .. ' DCALL FuncWithArg(argc 1).*'
        \ .. 'ScriptFuncNew().*'
        \ .. ' DCALL <SNR>\d\+_ScriptFuncNew(argc 0).*'
        \ .. 's:ScriptFuncNew().*'
        \ .. ' DCALL <SNR>\d\+_ScriptFuncNew(argc 0).*'
        \ .. 'UserFunc().*'
        \ .. ' UCALL UserFunc(argc 0).*'
        \ .. 'UserFuncWithArg("foo").*'
        \ .. ' PUSHS "foo".*'
        \ .. ' UCALL UserFuncWithArg(argc 1).*'
        \ .. 'let FuncRef = function("UserFunc").*'
        \ .. 'FuncRef().*'
        \ .. ' LOAD $\d.*'
        \ .. ' PCALL (argc 0).*'
        \ .. 'let FuncRefWithArg = function("UserFuncWithArg").*'
        \ .. 'FuncRefWithArg("bar").*'
        \ .. ' PUSHS "bar".*'
        \ .. ' LOAD $\d.*'
        \ .. ' PCALL (argc 1).*'
        \ .. 'return "yes".*'
        \ .. ' PUSHS "yes".*'
        \ .. ' RETURN.*'
        \, res)
enddef

def HasEval()
  if has("eval")
    echo "yes"
  else
    echo "no"
  endif
enddef

def HasNothing()
  if has("nothing")
    echo "yes"
  else
    echo "no"
  endif
enddef

def HasSomething()
  if has("nothing")
    echo "nothing"
  elseif has("something")
    echo "something"
  elseif has("eval")
    echo "eval"
  elseif has("less")
    echo "less"
  endif
enddef

def Test_disassemble_const_expr()
  assert_equal("\nyes", execute('call HasEval()'))
  let instr = execute('disassemble HasEval')
  assert_match('HasEval.*'
        \ .. 'if has("eval").*'
        \ .. ' PUSHS "yes".*'
        \, instr)
  assert_notmatch('JUMP', instr)

  assert_equal("\nno", execute('call HasNothing()'))
  instr = execute('disassemble HasNothing')
  assert_match('HasNothing.*'
        \ .. 'if has("nothing").*'
        \ .. 'else.*'
        \ .. ' PUSHS "no".*'
        \, instr)
  assert_notmatch('PUSHS "yes"', instr)
  assert_notmatch('JUMP', instr)

  assert_equal("\neval", execute('call HasSomething()'))
  instr = execute('disassemble HasSomething')
  assert_match('HasSomething.*'
        \ .. 'if has("nothing").*'
        \ .. 'elseif has("something").*'
        \ .. 'elseif has("eval").*'
        \ .. ' PUSHS "eval".*'
        \ .. 'elseif has("less").*'
        \, instr)
  assert_notmatch('PUSHS "nothing"', instr)
  assert_notmatch('PUSHS "something"', instr)
  assert_notmatch('PUSHS "less"', instr)
  assert_notmatch('JUMP', instr)
enddef

def WithLambda(): string
  let F = {a -> "X" .. a .. "X"}
  return F("x")
enddef

def Test_disassemble_lambda()
  assert_equal("XxX", WithLambda())
  let instr = execute('disassemble WithLambda')
  assert_match('WithLambda.*'
        \ .. 'let F = {a -> "X" .. a .. "X"}.*'
        \ .. ' FUNCREF <lambda>\d\+.*'
        \ .. 'PUSHS "x".*'
        \ .. ' LOAD $0.*'
        \ .. ' PCALL (argc 1).*'
        \ .. ' CHECKTYPE string stack\[-1].*'
        \, instr)
enddef

def AndOr(arg): string
  if arg == 1 && arg != 2 || arg == 4
    return 'yes'
  endif
  return 'no'
enddef

def Test_disassemble_and_or()
  assert_equal("yes", AndOr(1))
  assert_equal("no", AndOr(2))
  assert_equal("yes", AndOr(4))
  let instr = execute('disassemble AndOr')
  assert_match('AndOr.*'
        \ .. 'if arg == 1 && arg != 2 || arg == 4.*'
        \ .. '\d LOAD arg\[-1].*'
        \ .. '\d PUSHNR 1.*'
        \ .. '\d COMPAREANY ==.*'
        \ .. '\d JUMP_AND_KEEP_IF_FALSE -> \d\+.*'
        \ .. '\d LOAD arg\[-1].*'
        \ .. '\d PUSHNR 2.*'
        \ .. '\d COMPAREANY !=.*'
        \ .. '\d JUMP_AND_KEEP_IF_TRUE -> \d\+.*'
        \ .. '\d LOAD arg\[-1].*'
        \ .. '\d PUSHNR 4.*'
        \ .. '\d COMPAREANY ==.*'
        \ .. '\d JUMP_IF_FALSE -> \d\+.*'
        \, instr)
enddef

def ForLoop(): list<number>
  let res: list<number>
  for i in range(3)
    res->add(i)
  endfor
  return res
enddef

def Test_disassemble_for_loop()
  assert_equal([0, 1, 2], ForLoop())
  let instr = execute('disassemble ForLoop')
  assert_match('ForLoop.*'
        \ .. 'let res: list<number>.*'
        \ .. ' NEWLIST size 0.*'
        \ .. '\d STORE $0.*'
        \ .. 'for i in range(3).*'
        \ .. '\d STORE -1 in $1.*'
        \ .. '\d PUSHNR 3.*'
        \ .. '\d BCALL range(argc 1).*'
        \ .. '\d FOR $1 -> \d\+.*'
        \ .. '\d STORE $2.*'
        \ .. 'res->add(i).*'
        \ .. '\d LOAD $0.*'
        \ .. '\d LOAD $2.*'
        \ .. '\d BCALL add(argc 2).*'
        \ .. '\d DROP.*'
        \ .. 'endfor.*'
        \ .. '\d JUMP -> \d\+.*'
        \ .. '\d DROP.*'
        \, instr)
enddef

let g:number = 42

def Computing()
  let nr = 3
  let nrres = nr + 7
  nrres = nr - 7
  nrres = nr * 7
  nrres = nr / 7
  nrres = nr % 7

  let anyres = g:number + 7
  anyres = g:number - 7
  anyres = g:number * 7
  anyres = g:number / 7
  anyres = g:number % 7

  if has('float')
    let fl = 3.0
    let flres = fl + 7.0
    flres = fl - 7.0
    flres = fl * 7.0
    flres = fl / 7.0
  endif
enddef

def Test_disassemble_computing()
  let instr = execute('disassemble Computing')
  assert_match('Computing.*'
        \ .. 'let nr = 3.*'
        \ .. '\d STORE 3 in $0.*'
        \ .. 'let nrres = nr + 7.*'
        \ .. '\d LOAD $0.*'
        \ .. '\d PUSHNR 7.*'
        \ .. '\d OPNR +.*'
        \ .. '\d STORE $1.*'
        \ .. 'nrres = nr - 7.*'
        \ .. '\d OPNR -.*'
        \ .. 'nrres = nr \* 7.*'
        \ .. '\d OPNR \*.*'
        \ .. 'nrres = nr / 7.*'
        \ .. '\d OPNR /.*'
        \ .. 'nrres = nr % 7.*'
        \ .. '\d OPNR %.*'
        \ .. 'let anyres = g:number + 7.*'
        \ .. '\d LOADG g:number.*'
        \ .. '\d PUSHNR 7.*'
        \ .. '\d OPANY +.*'
        \ .. '\d STORE $2.*'
        \ .. 'anyres = g:number - 7.*'
        \ .. '\d OPANY -.*'
        \ .. 'anyres = g:number \* 7.*'
        \ .. '\d OPANY \*.*'
        \ .. 'anyres = g:number / 7.*'
        \ .. '\d OPANY /.*'
        \ .. 'anyres = g:number % 7.*'
        \ .. '\d OPANY %.*'
        \, instr)
  if has('float')
    assert_match('Computing.*'
        \ .. 'let fl = 3.0.*'
        \ .. '\d PUSHF 3.0.*'
        \ .. '\d STORE $3.*'
        \ .. 'let flres = fl + 7.0.*'
        \ .. '\d LOAD $3.*'
        \ .. '\d PUSHF 7.0.*'
        \ .. '\d OPFLOAT +.*'
        \ .. '\d STORE $4.*'
        \ .. 'flres = fl - 7.0.*'
        \ .. '\d OPFLOAT -.*'
        \ .. 'flres = fl \* 7.0.*'
        \ .. '\d OPFLOAT \*.*'
        \ .. 'flres = fl / 7.0.*'
        \ .. '\d OPFLOAT /.*'
        \, instr)
  endif
enddef

def Test_disassemble_compare()
  " TODO: COMPAREFUNC
  let cases = [
        \ ['true == false', 'COMPAREBOOL =='],
        \ ['true != false', 'COMPAREBOOL !='],
        \ ['v:none == v:null', 'COMPARESPECIAL =='],
        \ ['v:none != v:null', 'COMPARESPECIAL !='],
        \
        \ ['111 == 222', 'COMPARENR =='],
        \ ['111 != 222', 'COMPARENR !='],
        \ ['111 > 222', 'COMPARENR >'],
        \ ['111 < 222', 'COMPARENR <'],
        \ ['111 >= 222', 'COMPARENR >='],
        \ ['111 <= 222', 'COMPARENR <='],
        \ ['111 =~ 222', 'COMPARENR =\~'],
        \ ['111 !~ 222', 'COMPARENR !\~'],
        \
        \ ['"xx" == "yy"', 'COMPARESTRING =='],
        \ ['"xx" != "yy"', 'COMPARESTRING !='],
        \ ['"xx" > "yy"', 'COMPARESTRING >'],
        \ ['"xx" < "yy"', 'COMPARESTRING <'],
        \ ['"xx" >= "yy"', 'COMPARESTRING >='],
        \ ['"xx" <= "yy"', 'COMPARESTRING <='],
        \ ['"xx" =~ "yy"', 'COMPARESTRING =\~'],
        \ ['"xx" !~ "yy"', 'COMPARESTRING !\~'],
        \ ['"xx" is "yy"', 'COMPARESTRING is'],
        \ ['"xx" isnot "yy"', 'COMPARESTRING isnot'],
        \
        \ ['0z11 == 0z22', 'COMPAREBLOB =='],
        \ ['0z11 != 0z22', 'COMPAREBLOB !='],
        \ ['0z11 is 0z22', 'COMPAREBLOB is'],
        \ ['0z11 isnot 0z22', 'COMPAREBLOB isnot'],
        \
        \ ['[1,2] == [3,4]', 'COMPARELIST =='],
        \ ['[1,2] != [3,4]', 'COMPARELIST !='],
        \ ['[1,2] is [3,4]', 'COMPARELIST is'],
        \ ['[1,2] isnot [3,4]', 'COMPARELIST isnot'],
        \
        \ ['#{a:1} == #{x:2}', 'COMPAREDICT =='],
        \ ['#{a:1} != #{x:2}', 'COMPAREDICT !='],
        \ ['#{a:1} is #{x:2}', 'COMPAREDICT is'],
        \ ['#{a:1} isnot #{x:2}', 'COMPAREDICT isnot'],
        \
        \ ['{->33} == {->44}', 'COMPAREPARTIAL =='],
        \ ['{->33} != {->44}', 'COMPAREPARTIAL !='],
        \ ['{->33} is {->44}', 'COMPAREPARTIAL is'],
        \ ['{->33} isnot {->44}', 'COMPAREPARTIAL isnot'],
        \
        \ ['77 == g:xx', 'COMPAREANY =='],
        \ ['77 != g:xx', 'COMPAREANY !='],
        \ ['77 > g:xx', 'COMPAREANY >'],
        \ ['77 < g:xx', 'COMPAREANY <'],
        \ ['77 >= g:xx', 'COMPAREANY >='],
        \ ['77 <= g:xx', 'COMPAREANY <='],
        \ ['77 =~ g:xx', 'COMPAREANY =\~'],
        \ ['77 !~ g:xx', 'COMPAREANY !\~'],
        \ ['77 is g:xx', 'COMPAREANY is'],
        \ ['77 isnot g:xx', 'COMPAREANY isnot'],
        \ ]
  if has('float')
    cases->extend([
        \ ['1.1 == 2.2', 'COMPAREFLOAT =='],
        \ ['1.1 != 2.2', 'COMPAREFLOAT !='],
        \ ['1.1 > 2.2', 'COMPAREFLOAT >'],
        \ ['1.1 < 2.2', 'COMPAREFLOAT <'],
        \ ['1.1 >= 2.2', 'COMPAREFLOAT >='],
        \ ['1.1 <= 2.2', 'COMPAREFLOAT <='],
        \ ['1.1 =~ 2.2', 'COMPAREFLOAT =\~'],
        \ ['1.1 !~ 2.2', 'COMPAREFLOAT !\~'],
        \ ])
  endif

  let nr = 1
  for case in cases
    writefile(['def TestCase' .. nr .. '()',
             \ '  if ' .. case[0],
             \ '    echo 42'
             \ '  endif',
             \ 'enddef'], 'Xdisassemble')
    source Xdisassemble
    let instr = execute('disassemble TestCase' .. nr)
    assert_match('TestCase' .. nr .. '.*'
        \ .. 'if ' .. substitute(case[0], '[[~]', '\\\0', 'g') .. '.*'
        \ .. '\d \(PUSH\|FUNCREF\).*'
        \ .. '\d \(PUSH\|FUNCREF\|LOADG\).*'
        \ .. '\d ' .. case[1] .. '.*'
        \ .. '\d JUMP_IF_FALSE -> \d\+.*'
        \, instr)

    nr += 1
  endfor

  " delete('Xdisassemble')
enddef

" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker