patch 8.2.1761: Vim9: Some tests are still using :letv8.2.1761

Problem:    Vim9: Some tests are still using :let.
Solution:   Change more declarations to use :var.

4 files changed, 209 insertions, 198 deletions

diff --git a/src/testdir/test_vim9_assign.vim b/src/testdir/test_vim9_assign.vim
index eddc8c5f34..5d6dec1106 100644
--- a/src/testdir/test_vim9_assign.vim
+++ b/src/testdir/test_vim9_assign.vim
@@ -3,6 +3,9 @@
 source check.vim
 source vim9.vim
 
+" TODO: remove later
+let v:disallow_let = 1
+
 let s:appendToMe = 'xxx'
 let s:addToMe = 111
 let g:existing = 'yes'
diff --git a/src/testdir/test_vim9_cmd.vim b/src/testdir/test_vim9_cmd.vim
index da52dc2f81..2e59286369 100644
--- a/src/testdir/test_vim9_cmd.vim
+++ b/src/testdir/test_vim9_cmd.vim
@@ -4,12 +4,15 @@ source check.vim
 source vim9.vim
 source view_util.vim
 
+" TODO: remove later
+let v:disallow_let = 1
+
 def Test_edit_wildcards()
-  let filename = 'Xtest'
+  var filename = 'Xtest'
   edit `=filename`
   assert_equal('Xtest', bufname())
 
-  let filenr = 123
+  var filenr = 123
   edit Xtest`=filenr`
   assert_equal('Xtest123', bufname())
 
@@ -25,7 +28,7 @@ def Test_hardcopy_wildcards()
   CheckUnix
   CheckFeature postscript
 
-  let outfile = 'print'
+  var outfile = 'print'
   hardcopy > X`=outfile`.ps
   assert_true(filereadable('Xprint.ps'))
 
@@ -34,10 +37,10 @@ enddef
 
 def Test_syn_include_wildcards()
   writefile(['syn keyword Found found'], 'Xthemine.vim')
-  let save_rtp = &rtp
+  var save_rtp = &rtp
   &rtp = '.'
 
-  let fname = 'mine'
+  var fname = 'mine'
   syn include @Group Xthe`=fname`.vim
   assert_match('Found.* contained found', execute('syn list Found'))
 
@@ -46,7 +49,7 @@ def Test_syn_include_wildcards()
 enddef
 
 def Test_echo_linebreak()
-  let lines =<< trim END
+  var lines =<< trim END
       vim9script
       redir @a
       echo 'one'
@@ -69,7 +72,7 @@ def Test_echo_linebreak()
 enddef
 
 def Test_if_linebreak()
-  let lines =<< trim END
+  var lines =<< trim END
       vim9script
       if 1 &&
             2
@@ -98,9 +101,9 @@ def Test_if_linebreak()
 enddef
 
 def Test_while_linebreak()
-  let lines =<< trim END
+  var lines =<< trim END
       vim9script
-      let nr = 0
+      var nr = 0
       while nr <
               10 + 3
             nr = nr
@@ -112,7 +115,7 @@ def Test_while_linebreak()
 
   lines =<< trim END
       vim9script
-      let nr = 0
+      var nr = 0
       while nr
             <
               10
@@ -128,9 +131,9 @@ def Test_while_linebreak()
 enddef
 
 def Test_for_linebreak()
-  let lines =<< trim END
+  var lines =<< trim END
       vim9script
-      let nr = 0
+      var nr = 0
       for x
             in
               [1, 2, 3, 4]
@@ -142,7 +145,7 @@ def Test_for_linebreak()
 
   lines =<< trim END
       vim9script
-      let nr = 0
+      var nr = 0
       for x
             in
               [1, 2,
@@ -158,9 +161,9 @@ def Test_for_linebreak()
 enddef
 
 def Test_method_call_linebreak()
-  let lines =<< trim END
+  var lines =<< trim END
       vim9script
-      let res = []
+      var res = []
       func RetArg(
             arg
             )
@@ -175,16 +178,16 @@ def Test_method_call_linebreak()
 enddef
 
 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()
    assert_equal(#{data: [1, 2, 3]}, test)
    test.data
       ->reverse()
    assert_equal(#{data: [3, 2, 1]}, test)
 
-  let lines =<< trim END
+  var lines =<< trim END
       vim9script
-      let test: dict<list<number>> = {'data': [3, 1, 2]}
+      var test: dict<list<number>> = {'data': [3, 1, 2]}
       test.data->sort()
       assert_equal(#{data: [1, 2, 3]}, test)
   END
@@ -193,14 +196,14 @@ enddef
 
 def Test_bar_after_command()
   def RedrawAndEcho()
-    let x = 'did redraw'
+    var x = 'did redraw'
     redraw | echo x
   enddef
   RedrawAndEcho()
   assert_match('did redraw', Screenline(&lines))
 
   def CallAndEcho()
-    let x = 'did redraw'
+    var x = 'did redraw'
     reg_executing() | echo x
   enddef
   CallAndEcho()
@@ -232,14 +235,14 @@ def Test_bar_after_command()
 enddef
 
 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 })
   assert_equal([#{x: 3, y: 4}], tags)
 enddef
 
 def Test_eval_command()
-  let from = 3
-  let to = 5
+  var from = 3
+  var to = 5
   g:val = 111
   def Increment(nrs: list<number>)
     for nr in nrs
@@ -253,7 +256,7 @@ def Test_eval_command()
 enddef
 
 def Test_map_command()
-  let lines =<< trim END
+  var lines =<< trim END
       nnoremap <F3> :echo 'hit F3 #'<CR>
       assert_equal(":echo 'hit F3 #'<CR>", maparg("<F3>", "n"))
   END
@@ -264,7 +267,7 @@ enddef
 def Test_normal_command()
   new
   setline(1, 'doesnotexist')
-  let caught = 0
+  var caught = 0
   try
     exe "norm! \<C-]>"
   catch /E433/
diff --git a/src/testdir/test_vim9_disassemble.vim b/src/testdir/test_vim9_disassemble.vim
index 39dd513676..1c24f77acc 100644
--- a/src/testdir/test_vim9_disassemble.vim
+++ b/src/testdir/test_vim9_disassemble.vim
@@ -2,6 +2,9 @@
 
 source check.vim
 
+" TODO: remove later
+let v:disallow_let = 1
+
 func NotCompiled()
   echo "not"
 endfunc
@@ -13,7 +16,7 @@ let w:windowvar = 'w'
 let t:tabpagevar = 't'
 
 def s:ScriptFuncLoad(arg: string)
-  let local = 1
+  var local = 1
   buffers
   echo arg
   echo local
@@ -41,7 +44,7 @@ def Test_disassemble_load()
   assert_fails('disass 234', 'E129:')
   assert_fails('disass <XX>foo', 'E129:')
 
-  let res = execute('disass s:ScriptFuncLoad')
+  var res = execute('disass s:ScriptFuncLoad')
   assert_match('<SNR>\d*_ScriptFuncLoad.*' ..
         'buffers.*' ..
         ' EXEC \+buffers.*' ..
@@ -76,18 +79,18 @@ def Test_disassemble_load()
 enddef
 
 def s:EditExpand()
-  let filename = "file"
-  let filenr = 123
+  var filename = "file"
+  var filenr = 123
   edit the`=filename``=filenr`.txt
 enddef
 
 def Test_disassemble_exec_expr()
-  let res = execute('disass s:EditExpand')
+  var res = execute('disass s:EditExpand')
   assert_match('<SNR>\d*_EditExpand\_s*' ..
-        ' let filename = "file"\_s*' ..
+        ' var filename = "file"\_s*' ..
         '\d PUSHS "file"\_s*' ..
         '\d STORE $0\_s*' ..
-        ' let filenr = 123\_s*' ..
+        ' var filenr = 123\_s*' ..
         '\d STORE 123 in $1\_s*' ..
         ' edit the`=filename``=filenr`.txt\_s*' ..
         '\d PUSHS "edit the"\_s*' ..
@@ -107,7 +110,7 @@ def s:YankRange()
 enddef
 
 def Test_disassemble_yank_range()
-  let res = execute('disass s:YankRange')
+  var res = execute('disass s:YankRange')
   assert_match('<SNR>\d*_YankRange.*' ..
         ' norm! m\[jjm\]\_s*' ..
         '\d EXEC   norm! m\[jjm\]\_s*' ..
@@ -123,7 +126,7 @@ def s:PutExpr()
 enddef
 
 def Test_disassemble_put_expr()
-  let res = execute('disass s:PutExpr')
+  var res = execute('disass s:PutExpr')
   assert_match('<SNR>\d*_PutExpr.*' ..
         ' :3put ="text"\_s*' ..
         '\d PUSHS "text"\_s*' ..
@@ -134,16 +137,16 @@ def Test_disassemble_put_expr()
 enddef
 
 def s:ScriptFuncPush()
-  let localbool = true
-  let localspec = v:none
-  let localblob = 0z1234
+  var localbool = true
+  var localspec = v:none
+  var localblob = 0z1234
   if has('float')
-    let localfloat = 1.234
+    var localfloat = 1.234
   endif
 enddef
 
 def Test_disassemble_push()
-  let res = execute('disass s:ScriptFuncPush')
+  var res = execute('disass s:ScriptFuncPush')
   assert_match('<SNR>\d*_ScriptFuncPush.*' ..
         'localbool = true.*' ..
         ' PUSH v:true.*' ..
@@ -161,9 +164,9 @@ def Test_disassemble_push()
 enddef
 
 def s:ScriptFuncStore()
-  let localnr = 1
+  var localnr = 1
   localnr = 2
-  let localstr = 'abc'
+  var localstr = 'abc'
   localstr = 'xyz'
   v:char = 'abc'
   s:scriptvar = 'sv'
@@ -177,12 +180,12 @@ def s:ScriptFuncStore()
 enddef
 
 def Test_disassemble_store()
-  let res = execute('disass s:ScriptFuncStore')
+  var res = execute('disass s:ScriptFuncStore')
   assert_match('<SNR>\d*_ScriptFuncStore.*' ..
-        'let localnr = 1.*' ..
+        'var localnr = 1.*' ..
         'localnr = 2.*' ..
         ' STORE 2 in $0.*' ..
-        'let localstr = ''abc''.*' ..
+        'var localstr = ''abc''.*' ..
         'localstr = ''xyz''.*' ..
         ' STORE $1.*' ..
         'v:char = ''abc''.*' ..
@@ -207,16 +210,16 @@ def Test_disassemble_store()
 enddef
 
 def s:ScriptFuncStoreMember()
-  let locallist: list<number> = []
+  var locallist: list<number> = []
   locallist[0] = 123
-  let localdict: dict<number> = {}
+  var localdict: dict<number> = {}
   localdict["a"] = 456
 enddef
 
 def Test_disassemble_store_member()
-  let res = execute('disass s:ScriptFuncStoreMember')
+  var res = execute('disass s:ScriptFuncStoreMember')
   assert_match('<SNR>\d*_ScriptFuncStoreMember\_s*' ..
-        'let locallist: list<number> = []\_s*' ..
+        'var locallist: list<number> = []\_s*' ..
         '\d NEWLIST size 0\_s*' ..
         '\d STORE $0\_s*' ..
         'locallist\[0\] = 123\_s*' ..
@@ -224,7 +227,7 @@ def Test_disassemble_store_member()
         '\d PUSHNR 0\_s*' ..
         '\d LOAD $0\_s*' ..
         '\d STORELIST\_s*' ..
-        'let localdict: dict<number> = {}\_s*' ..
+        'var localdict: dict<number> = {}\_s*' ..
         '\d NEWDICT size 0\_s*' ..
         '\d STORE $1\_s*' ..
         'localdict\["a"\] = 456\_s*' ..
@@ -238,22 +241,22 @@ def Test_disassemble_store_member()
 enddef
 
 def s:ListAssign()
-  let x: string
-  let y: string
-  let l: list<any>
+  var x: string
+  var y: string
+  var l: list<any>
   [x, y; l] = g:stringlist
 enddef
 
 def Test_disassemble_list_assign()
-  let res = execute('disass s:ListAssign')
+  var res = execute('disass s:ListAssign')
   assert_match('<SNR>\d*_ListAssign\_s*' ..
-        'let x: string\_s*' ..
+        'var x: string\_s*' ..
         '\d PUSHS "\[NULL\]"\_s*' ..
         '\d STORE $0\_s*' ..
-        'let y: string\_s*' ..
+        'var y: string\_s*' ..
         '\d PUSHS "\[NULL\]"\_s*' ..
         '\d STORE $1\_s*' ..
-        'let l: list<any>\_s*' ..
+        'var l: list<any>\_s*' ..
         '\d NEWLIST size 0\_s*' ..
         '\d STORE $2\_s*' ..
         '\[x, y; l\] = g:stringlist\_s*' ..
@@ -281,7 +284,7 @@ def s:ScriptFuncUnlet()
 enddef
 
 def Test_disassemble_unlet()
-  let res = execute('disass s:ScriptFuncUnlet')
+  var res = execute('disass s:ScriptFuncUnlet')
   assert_match('<SNR>\d*_ScriptFuncUnlet\_s*' ..
         'g:somevar = "value"\_s*' ..
         '\d PUSHS "value"\_s*' ..
@@ -306,7 +309,7 @@ def s:ScriptFuncTry()
 enddef
 
 def Test_disassemble_try()
-  let res = execute('disass s:ScriptFuncTry')
+  var res = execute('disass s:ScriptFuncTry')
   assert_match('<SNR>\d*_ScriptFuncTry\_s*' ..
         'try\_s*' ..
         '\d TRY catch -> \d\+, finally -> \d\+\_s*' ..
@@ -333,20 +336,20 @@ def Test_disassemble_try()
 enddef
 
 def s:ScriptFuncNew()
-  let ll = [1, "two", 333]
-  let dd = #{one: 1, two: "val"}
+  var ll = [1, "two", 333]
+  var dd = #{one: 1, two: "val"}
 enddef
 
 def Test_disassemble_new()
-  let res = execute('disass s:ScriptFuncNew')
+  var res = execute('disass s:ScriptFuncNew')
   assert_match('<SNR>\d*_ScriptFuncNew\_s*' ..
-        'let ll = \[1, "two", 333\]\_s*' ..
+        'var ll = \[1, "two", 333\]\_s*' ..
         '\d PUSHNR 1\_s*' ..
         '\d PUSHS "two"\_s*' ..
         '\d PUSHNR 333\_s*' ..
         '\d NEWLIST size 3\_s*' ..
         '\d STORE $0\_s*' ..
-        'let dd = #{one: 1, two: "val"}\_s*' ..
+        'var dd = #{one: 1, two: "val"}\_s*' ..
         '\d PUSHS "one"\_s*' ..
         '\d PUSHNR 1\_s*' ..
         '\d PUSHS "two"\_s*' ..
@@ -376,15 +379,15 @@ def s:ScriptFuncCall(): string
   s:ScriptFuncNew()
   UserFunc()
   UserFuncWithArg("foo")
-  let FuncRef = function("UserFunc")
+  var FuncRef = function("UserFunc")
   FuncRef()
-  let FuncRefWithArg = function("UserFuncWithArg")
+  var FuncRefWithArg = function("UserFuncWithArg")
   FuncRefWithArg("bar")
   return "yes"
 enddef
 
 def Test_disassemble_call()
-  let res = execute('disass s:ScriptFuncCall')
+  var res = execute('disass s:ScriptFuncCall')
   assert_match('<SNR>\d\+_ScriptFuncCall\_s*' ..
         'changenr()\_s*' ..
         '\d BCALL changenr(argc 0)\_s*' ..
@@ -413,7 +416,7 @@ def Test_disassemble_call()
         '\d\+ PUSHS "foo"\_s*' ..
         '\d\+ UCALL UserFuncWithArg(argc 1)\_s*' ..
         '\d\+ DROP\_s*' ..
-        'let FuncRef = function("UserFunc")\_s*' ..
+        'var FuncRef = function("UserFunc")\_s*' ..
         '\d\+ PUSHS "UserFunc"\_s*' ..
         '\d\+ BCALL function(argc 1)\_s*' ..
         '\d\+ STORE $0\_s*' ..
@@ -421,7 +424,7 @@ def Test_disassemble_call()
         '\d\+ LOAD $\d\_s*' ..
         '\d\+ PCALL (argc 0)\_s*' ..
         '\d\+ DROP\_s*' ..
-        'let FuncRefWithArg = function("UserFuncWithArg")\_s*' ..
+        'var FuncRefWithArg = function("UserFuncWithArg")\_s*' ..
         '\d\+ PUSHS "UserFuncWithArg"\_s*' ..
         '\d\+ BCALL function(argc 1)\_s*' ..
         '\d\+ STORE $1\_s*' ..
@@ -437,7 +440,7 @@ def Test_disassemble_call()
 enddef
 
 def s:CreateRefs()
-  let local = 'a'
+  var local = 'a'
   def Append(arg: string)
     local ..= arg
   enddef
@@ -450,7 +453,7 @@ enddef
 
 def Test_disassemble_closure()
   CreateRefs()
-  let res = execute('disass g:Append')
+  var res = execute('disass g:Append')
   assert_match('<lambda>\d\_s*' ..
         'local ..= arg\_s*' ..
         '\d LOADOUTER $0\_s*' ..
@@ -484,7 +487,7 @@ def s:ScriptPCall()
 enddef
 
 def Test_disassemble_pcall()
-  let res = execute('disass s:ScriptPCall')
+  var res = execute('disass s:ScriptPCall')
   assert_match('<SNR>\d\+_ScriptPCall\_s*' ..
         'RefThis()("text")\_s*' ..
         '\d DCALL RefThis(argc 0)\_s*' ..
@@ -507,7 +510,7 @@ def DefinedLater(arg: string): string
 enddef
 
 def Test_disassemble_update_instr()
-  let res = execute('disass s:FuncWithForwardCall')
+  var res = execute('disass s:FuncWithForwardCall')
   assert_match('FuncWithForwardCall\_s*' ..
         'return g:DefinedLater("yes")\_s*' ..
         '\d PUSHS "yes"\_s*' ..
@@ -533,7 +536,7 @@ def FuncWithDefault(arg: string = 'default'): string
 enddef
 
 def Test_disassemble_call_default()
-  let res = execute('disass FuncWithDefault')
+  var res = execute('disass FuncWithDefault')
   assert_match('FuncWithDefault\_s*' ..
         '\d PUSHS "default"\_s*' ..
         '\d STORE arg\[-1]\_s*' ..
@@ -574,7 +577,7 @@ enddef
 
 def Test_disassemble_const_expr()
   assert_equal("\nyes", execute('HasEval()'))
-  let instr = execute('disassemble HasEval')
+  var instr = execute('disassemble HasEval')
   assert_match('HasEval\_s*' ..
         'if has("eval")\_s*' ..
         'echo "yes"\_s*' ..
@@ -630,7 +633,7 @@ def ReturnInIf(): string
 enddef
 
 def Test_disassemble_return_in_if()
-  let instr = execute('disassemble ReturnInIf')
+  var instr = execute('disassemble ReturnInIf')
   assert_match('ReturnInIf\_s*' ..
         'if g:cond\_s*' ..
         '0 LOADG g:cond\_s*' ..
@@ -646,22 +649,22 @@ def Test_disassemble_return_in_if()
 enddef
 
 def WithFunc()
-  let Funky1: func
-  let Funky2: func = function("len")
-  let Party2: func = funcref("UserFunc")
+  var Funky1: func
+  var Funky2: func = function("len")
+  var Party2: func = funcref("UserFunc")
 enddef
 
 def Test_disassemble_function()
-  let instr = execute('disassemble WithFunc')
+  var instr = execute('disassemble WithFunc')
   assert_match('WithFunc\_s*' ..
-        'let Funky1: func\_s*' ..
+        'var Funky1: func\_s*' ..
         '0 PUSHFUNC "\[none]"\_s*' ..
         '1 STORE $0\_s*' ..
-        'let Funky2: func = function("len")\_s*' ..
+        'var Funky2: func = function("len")\_s*' ..
         '2 PUSHS "len"\_s*' ..
         '3 BCALL function(argc 1)\_s*' ..
         '4 STORE $1\_s*' ..
-        'let Party2: func = funcref("UserFunc")\_s*' ..
+        'var Party2: func = funcref("UserFunc")\_s*' ..
         '\d PUSHS "UserFunc"\_s*' ..
         '\d BCALL funcref(argc 1)\_s*' ..
         '\d STORE $2\_s*' ..
@@ -672,25 +675,25 @@ enddef
 
 if has('channel')
   def WithChannel()
-    let job1: job
-    let job2: job = job_start("donothing")
-    let chan1: channel
+    var job1: job
+    var job2: job = job_start("donothing")
+    var chan1: channel
   enddef
 endif
 
 def Test_disassemble_channel()
   CheckFeature channel
 
-  let instr = execute('disassemble WithChannel')
+  var instr = execute('disassemble WithChannel')
   assert_match('WithChannel\_s*' ..
-        'let job1: job\_s*' ..
+        'var job1: job\_s*' ..
         '\d PUSHJOB "no process"\_s*' ..
         '\d STORE $0\_s*' ..
-        'let job2: job = job_start("donothing")\_s*' ..
+        'var job2: job = job_start("donothing")\_s*' ..
         '\d PUSHS "donothing"\_s*' ..
         '\d BCALL job_start(argc 1)\_s*' ..
         '\d STORE $1\_s*' ..
-        'let chan1: channel\_s*' ..
+        'var chan1: channel\_s*' ..
         '\d PUSHCHANNEL 0\_s*' ..
         '\d STORE $2\_s*' ..
         '\d PUSHNR 0\_s*' ..
@@ -699,15 +702,15 @@ def Test_disassemble_channel()
 enddef
 
 def WithLambda(): string
-  let F = {a -> "X" .. a .. "X"}
+  var F = {a -> "X" .. a .. "X"}
   return F("x")
 enddef
 
 def Test_disassemble_lambda()
   assert_equal("XxX", WithLambda())
-  let instr = execute('disassemble WithLambda')
+  var instr = execute('disassemble WithLambda')
   assert_match('WithLambda\_s*' ..
-        'let F = {a -> "X" .. a .. "X"}\_s*' ..
+        'var F = {a -> "X" .. a .. "X"}\_s*' ..
         '\d FUNCREF <lambda>\d\+\_s*' ..
         '\d STORE $0\_s*' ..
         'return F("x")\_s*' ..
@@ -717,7 +720,7 @@ def Test_disassemble_lambda()
         '\d RETURN',
         instr)
 
-   let name = substitute(instr, '.*\(<lambda>\d\+\).*', '\1', '')
+   var name = substitute(instr, '.*\(<lambda>\d\+\).*', '\1', '')
    instr = execute('disassemble ' .. name)
    assert_match('<lambda>\d\+\_s*' ..
         'return "X" .. a .. "X"\_s*' ..
@@ -738,7 +741,7 @@ def NestedOuter()
 enddef
 
 def Test_nested_func()
-   let instr = execute('disassemble NestedOuter')
+   var instr = execute('disassemble NestedOuter')
    assert_match('NestedOuter\_s*' ..
         'def g:Inner()\_s*' ..
         'echomsg "inner"\_s*' ..
@@ -760,7 +763,7 @@ 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')
+  var instr = execute('disassemble AndOr')
   assert_match('AndOr\_s*' ..
         'if arg == 1 && arg != 2 || arg == 4\_s*' ..
         '\d LOAD arg\[-1]\_s*' ..
@@ -779,7 +782,7 @@ def Test_disassemble_and_or()
 enddef
 
 def ForLoop(): list<number>
-  let res: list<number>
+  var res: list<number>
   for i in range(3)
     res->add(i)
   endfor
@@ -788,9 +791,9 @@ enddef
 
 def Test_disassemble_for_loop()
   assert_equal([0, 1, 2], ForLoop())
-  let instr = execute('disassemble ForLoop')
+  var instr = execute('disassemble ForLoop')
   assert_match('ForLoop\_s*' ..
-        'let res: list<number>\_s*' ..
+        'var res: list<number>\_s*' ..
         '\d NEWLIST size 0\_s*' ..
         '\d STORE $0\_s*' ..
         'for i in range(3)\_s*' ..
@@ -811,7 +814,7 @@ def Test_disassemble_for_loop()
 enddef
 
 def ForLoopEval(): string
-  let res = ""
+  var res = ""
   for str in eval('["one", "two"]')
     res ..= str
   endfor
@@ -820,9 +823,9 @@ enddef
 
 def Test_disassemble_for_loop_eval()
   assert_equal('onetwo', ForLoopEval())
-  let instr = execute('disassemble ForLoopEval')
+  var instr = execute('disassemble ForLoopEval')
   assert_match('ForLoopEval\_s*' ..
-        'let res = ""\_s*' ..
+        'var res = ""\_s*' ..
         '\d PUSHS ""\_s*' ..
         '\d STORE $0\_s*' ..
         'for str in eval(''\["one", "two"\]'')\_s*' ..
@@ -850,13 +853,13 @@ enddef
 let g:number = 42
 
 def TypeCast()
-  let l: list<number> = [23, <number>g:number]
+  var l: list<number> = [23, <number>g:number]
 enddef
 
 def Test_disassemble_typecast()
-  let instr = execute('disassemble TypeCast')
+  var instr = execute('disassemble 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 LOADG g:number\_s*' ..
         '\d CHECKTYPE number stack\[-1\]\_s*' ..
@@ -868,22 +871,22 @@ def Test_disassemble_typecast()
 enddef
 
 def Computing()
-  let nr = 3
-  let nrres = nr + 7
+  var nr = 3
+  var 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
 
   if has('float')
-    let fl = 3.0
-    let flres = fl + 7.0
+    var fl = 3.0
+    var flres = fl + 7.0
     flres = fl - 7.0
     flres = fl * 7.0
     flres = fl / 7.0
@@ -891,11 +894,11 @@ def Computing()
 enddef
 
 def Test_disassemble_computing()
-  let instr = execute('disassemble Computing')
+  var instr = execute('disassemble Computing')
   assert_match('Computing.*' ..
-        'let nr = 3.*' ..
+        'var nr = 3.*' ..
         '\d STORE 3 in $0.*' ..
-        'let nrres = nr + 7.*' ..
+        'var nrres = nr + 7.*' ..
         '\d LOAD $0.*' ..
         '\d PUSHNR 7.*' ..
         '\d OPNR +.*' ..
@@ -908,7 +911,7 @@ def Test_disassemble_computing()
         '\d OPNR /.*' ..
         'nrres = nr % 7.*' ..
         '\d OPNR %.*' ..
-        'let anyres = g:number + 7.*' ..
+        'var anyres = g:number + 7.*' ..
         '\d LOADG g:number.*' ..
         '\d PUSHNR 7.*' ..
         '\d OPANY +.*' ..
@@ -924,10 +927,10 @@ def Test_disassemble_computing()
         instr)
   if has('float')
     assert_match('Computing.*' ..
-        'let fl = 3.0.*' ..
+        'var fl = 3.0.*' ..
         '\d PUSHF 3.0.*' ..
         '\d STORE $3.*' ..
-        'let flres = fl + 7.0.*' ..
+        'var flres = fl + 7.0.*' ..
         '\d LOAD $3.*' ..
         '\d PUSHF 7.0.*' ..
         '\d OPFLOAT +.*' ..
@@ -943,14 +946,14 @@ def Test_disassemble_computing()
 enddef
 
 def AddListBlob()
-  let reslist = [1, 2] + [3, 4]
-  let resblob = 0z1122 + 0z3344
+  var reslist = [1, 2] + [3, 4]
+  var resblob = 0z1122 + 0z3344
 enddef
 
 def Test_disassemble_add_list_blob()
-  let instr = execute('disassemble AddListBlob')
+  var instr = execute('disassemble AddListBlob')
   assert_match('AddListBlob.*' ..
-        'let reslist = \[1, 2] + \[3, 4].*' ..
+        'var reslist = \[1, 2] + \[3, 4].*' ..
         '\d PUSHNR 1.*' ..
         '\d PUSHNR 2.*' ..
         '\d NEWLIST size 2.*' ..
@@ -959,7 +962,7 @@ def Test_disassemble_add_list_blob()
         '\d NEWLIST size 2.*' ..
         '\d ADDLIST.*' ..
         '\d STORE $.*.*' ..
-        'let resblob = 0z1122 + 0z3344.*' ..
+        'var resblob = 0z1122 + 0z3344.*' ..
         '\d PUSHBLOB 0z1122.*' ..
         '\d PUSHBLOB 0z3344.*' ..
         '\d ADDBLOB.*' ..
@@ -969,14 +972,14 @@ enddef
 
 let g:aa = 'aa'
 def ConcatString(): string
-  let res = g:aa .. "bb"
+  var res = g:aa .. "bb"
   return res
 enddef
 
 def Test_disassemble_concat()
-  let instr = execute('disassemble ConcatString')
+  var instr = execute('disassemble ConcatString')
   assert_match('ConcatString.*' ..
-        'let res = g:aa .. "bb".*' ..
+        'var res = g:aa .. "bb".*' ..
         '\d LOADG g:aa.*' ..
         '\d PUSHS "bb".*' ..
         '\d 2STRING_ANY stack\[-2].*' ..
@@ -987,18 +990,18 @@ def Test_disassemble_concat()
 enddef
 
 def StringIndex(): string
-  let s = "abcd"
-  let res = s[1]
+  var s = "abcd"
+  var res = s[1]
   return res
 enddef
 
 def Test_disassemble_string_index()
-  let instr = execute('disassemble StringIndex')
+  var instr = execute('disassemble StringIndex')
   assert_match('StringIndex\_s*' ..
-        'let s = "abcd"\_s*' ..
+        'var s = "abcd"\_s*' ..
         '\d PUSHS "abcd"\_s*' ..
         '\d STORE $0\_s*' ..
-        'let res = s\[1]\_s*' ..
+        'var res = s\[1]\_s*' ..
         '\d LOAD $0\_s*' ..
         '\d PUSHNR 1\_s*' ..
         '\d STRINDEX\_s*' ..
@@ -1008,18 +1011,18 @@ def Test_disassemble_string_index()
 enddef
 
 def StringSlice(): string
-  let s = "abcd"
-  let res = s[1:8]
+  var s = "abcd"
+  var res = s[1:8]
   return res
 enddef
 
 def Test_disassemble_string_slice()
-  let instr = execute('disassemble StringSlice')
+  var instr = execute('disassemble StringSlice')
   assert_match('StringSlice\_s*' ..
-        'let s = "abcd"\_s*' ..
+        'var s = "abcd"\_s*' ..
         '\d PUSHS "abcd"\_s*' ..
         '\d STORE $0\_s*' ..
-        'let res = s\[1:8]\_s*' ..
+        'var res = s\[1:8]\_s*' ..
         '\d LOAD $0\_s*' ..
         '\d PUSHNR 1\_s*' ..
         '\d PUSHNR 8\_s*' ..
@@ -1030,21 +1033,21 @@ def Test_disassemble_string_slice()
 enddef
 
 def ListIndex(): number
-  let l = [1, 2, 3]
-  let res = l[1]
+  var l = [1, 2, 3]
+  var res = l[1]
   return res
 enddef
 
 def Test_disassemble_list_index()
-  let instr = execute('disassemble ListIndex')
+  var instr = execute('disassemble ListIndex')
   assert_match('ListIndex\_s*' ..
-        'let l = \[1, 2, 3]\_s*' ..
+        'var l = \[1, 2, 3]\_s*' ..
         '\d PUSHNR 1\_s*' ..
         '\d PUSHNR 2\_s*' ..
         '\d PUSHNR 3\_s*' ..
         '\d NEWLIST size 3\_s*' ..
         '\d STORE $0\_s*' ..
-        'let res = l\[1]\_s*' ..
+        'var res = l\[1]\_s*' ..
         '\d LOAD $0\_s*' ..
         '\d PUSHNR 1\_s*' ..
         '\d LISTINDEX\_s*' ..
@@ -1054,21 +1057,21 @@ def Test_disassemble_list_index()
 enddef
 
 def ListSlice(): list<number>
-  let l = [1, 2, 3]
-  let res = l[1:8]
+  var l = [1, 2, 3]
+  var res = l[1:8]
   return res
 enddef
 
 def Test_disassemble_list_slice()
-  let instr = execute('disassemble ListSlice')
+  var instr = execute('disassemble ListSlice')
   assert_match('ListSlice\_s*' ..
-        'let l = \[1, 2, 3]\_s*' ..
+        'var l = \[1, 2, 3]\_s*' ..
         '\d PUSHNR 1\_s*' ..
         '\d PUSHNR 2\_s*' ..
         '\d PUSHNR 3\_s*' ..
         '\d NEWLIST size 3\_s*' ..
         '\d STORE $0\_s*' ..
-        'let res = l\[1:8]\_s*' ..
+        'var res = l\[1:8]\_s*' ..
         '\d LOAD $0\_s*' ..
         '\d PUSHNR 1\_s*' ..
         '\d PUSHNR 8\_s*' ..
@@ -1079,21 +1082,21 @@ def Test_disassemble_list_slice()
 enddef
 
 def DictMember(): number
-  let d = #{item: 1}
-  let res = d.item
+  var d = #{item: 1}
+  var res = d.item
   res = d["item"]
   return res
 enddef
 
 def Test_disassemble_dict_member()
-  let instr = execute('disassemble DictMember')
+  var instr = execute('disassemble DictMember')
   assert_match('DictMember\_s*' ..
-        'let d = #{item: 1}\_s*' ..
+        'var d = #{item: 1}\_s*' ..
         '\d PUSHS "item"\_s*' ..
         '\d PUSHNR 1\_s*' ..
         '\d NEWDICT size 1\_s*' ..
         '\d STORE $0\_s*' ..
-        'let res = d.item\_s*' ..
+        'var res = d.item\_s*' ..
         '\d\+ LOAD $0\_s*' ..
         '\d\+ MEMBER item\_s*' ..
         '\d\+ STORE $1\_s*' ..
@@ -1108,14 +1111,14 @@ enddef
 
 let somelist = [1, 2, 3, 4, 5]
 def AnyIndex(): number
-  let res = g:somelist[2]
+  var res = g:somelist[2]
   return res
 enddef
 
 def Test_disassemble_any_index()
-  let instr = execute('disassemble AnyIndex')
+  var instr = execute('disassemble AnyIndex')
   assert_match('AnyIndex\_s*' ..
-        'let res = g:somelist\[2\]\_s*' ..
+        'var res = g:somelist\[2\]\_s*' ..
         '\d LOADG g:somelist\_s*' ..
         '\d PUSHNR 2\_s*' ..
         '\d ANYINDEX\_s*' ..
@@ -1129,14 +1132,14 @@ def Test_disassemble_any_index()
 enddef
 
 def AnySlice(): list<number>
-  let res = g:somelist[1:3]
+  var res = g:somelist[1:3]
   return res
 enddef
 
 def Test_disassemble_any_slice()
-  let instr = execute('disassemble AnySlice')
+  var instr = execute('disassemble AnySlice')
   assert_match('AnySlice\_s*' ..
-        'let res = g:somelist\[1:3\]\_s*' ..
+        'var res = g:somelist\[1:3\]\_s*' ..
         '\d LOADG g:somelist\_s*' ..
         '\d PUSHNR 1\_s*' ..
         '\d PUSHNR 3\_s*' ..
@@ -1151,22 +1154,22 @@ def Test_disassemble_any_slice()
 enddef
 
 def NegateNumber(): number
-  let nr = 9
-  let plus = +nr
-  let res = -nr
+  var nr = 9
+  var plus = +nr
+  var res = -nr
   return res
 enddef
 
 def Test_disassemble_negate_number()
-  let instr = execute('disassemble NegateNumber')
+  var instr = execute('disassemble NegateNumber')
   assert_match('NegateNumber\_s*' ..
-        'let nr = 9\_s*' ..
+        'var nr = 9\_s*' ..
         '\d STORE 9 in $0\_s*' ..
-        'let plus = +nr\_s*' ..
+        'var plus = +nr\_s*' ..
         '\d LOAD $0\_s*' ..
         '\d CHECKNR\_s*' ..
         '\d STORE $1\_s*' ..
-        'let res = -nr\_s*' ..
+        'var res = -nr\_s*' ..
         '\d LOAD $0\_s*' ..
         '\d NEGATENR\_s*' ..
         '\d STORE $2\_s*',
@@ -1175,23 +1178,23 @@ def Test_disassemble_negate_number()
 enddef
 
 def InvertBool(): bool
-  let flag = true
-  let invert = !flag
-  let res = !!flag
+  var flag = true
+  var invert = !flag
+  var res = !!flag
   return res
 enddef
 
 def Test_disassemble_invert_bool()
-  let instr = execute('disassemble InvertBool')
+  var instr = execute('disassemble InvertBool')
   assert_match('InvertBool\_s*' ..
-        'let flag = true\_s*' ..
+        'var flag = true\_s*' ..
         '\d PUSH v:true\_s*' ..
         '\d STORE $0\_s*' ..
-        'let invert = !flag\_s*' ..
+        'var invert = !flag\_s*' ..
         '\d LOAD $0\_s*' ..
         '\d INVERT (!val)\_s*' ..
         '\d STORE $1\_s*' ..
-        'let res = !!flag\_s*' ..
+        'var res = !!flag\_s*' ..
         '\d LOAD $0\_s*' ..
         '\d 2BOOL (!!val)\_s*' ..
         '\d STORE $2\_s*',
@@ -1200,14 +1203,14 @@ def Test_disassemble_invert_bool()
 enddef
 
 def ReturnBool(): bool
-  let var: bool = "no" && [] || 123
+  var var: bool = "no" && [] || 123
   return var
 enddef
 
 def Test_disassemble_return_bool()
-  let instr = execute('disassemble ReturnBool')
+  var instr = execute('disassemble ReturnBool')
   assert_match('ReturnBool\_s*' ..
-        'let var: bool = "no" && \[\] || 123\_s*' ..
+        'var var: bool = "no" && \[\] || 123\_s*' ..
         '0 PUSHS "no"\_s*' ..
         '1 JUMP_AND_KEEP_IF_FALSE -> 3\_s*' ..
         '2 NEWLIST size 0\_s*' ..
@@ -1223,7 +1226,7 @@ def Test_disassemble_return_bool()
 enddef
 
 def Test_disassemble_compare()
-  let cases = [
+  var cases = [
         ['true == isFalse', 'COMPAREBOOL =='],
         ['true != isFalse', 'COMPAREBOOL !='],
         ['v:none == isNull', 'COMPARESPECIAL =='],
@@ -1279,7 +1282,7 @@ def Test_disassemble_compare()
         ['77 is g:xx', 'COMPAREANY is'],
         ['77 isnot g:xx', 'COMPAREANY isnot'],
         ]
-  let floatDecl = ''
+  var floatDecl = ''
   if has('float')
     cases->extend([
         ['1.1 == aFloat', 'COMPAREFLOAT =='],
@@ -1291,27 +1294,27 @@ def Test_disassemble_compare()
         ['1.1 =~ aFloat', 'COMPAREFLOAT =\~'],
         ['1.1 !~ aFloat', 'COMPAREFLOAT !\~'],
         ])
-    floatDecl = 'let aFloat = 2.2'
+    floatDecl = 'var aFloat = 2.2'
   endif
 
-  let nr = 1
+  var nr = 1
   for case in cases
     # declare local variables to get a non-constant with the right type
     writefile(['def TestCase' .. nr .. '()',
-             '  let isFalse = false',
-             '  let isNull = v:null',
-             '  let aNumber = 222',
-             '  let aString = "yy"',
-             '  let aBlob = 0z22',
-             '  let aList = [3, 4]',
-             '  let aDict = #{x: 2}',
+             '  var isFalse = false',
+             '  var isNull = v:null',
+             '  var aNumber = 222',
+             '  var aString = "yy"',
+             '  var aBlob = 0z22',
+             '  var aList = [3, 4]',
+             '  var aDict = #{x: 2}',
              floatDecl,
              '  if ' .. case[0],
              '    echo 42'
              '  endif',
              'enddef'], 'Xdisassemble')
     source Xdisassemble
-    let instr = execute('disassemble TestCase' .. nr)
+    var instr = execute('disassemble TestCase' .. nr)
     assert_match('TestCase' .. nr .. '.*' ..
         'if ' .. substitute(case[0], '[[~]', '\\\0', 'g') .. '.*' ..
         '\d \(PUSH\|FUNCREF\).*' ..
@@ -1327,14 +1330,14 @@ def Test_disassemble_compare()
 enddef
 
 def Test_disassemble_compare_const()