" Test various aspects of the Vim9 script language. source check.vim source term_util.vim import './vim9.vim' as v9 source screendump.vim source shared.vim def Test_vim9script_feature() # example from the help, here the feature is always present var lines =<< trim END " old style comment if !has('vim9script') " legacy commands would go here finish endif vim9script # Vim9 script commands go here g:didit = true END v9.CheckScriptSuccess(lines) assert_equal(true, g:didit) unlet g:didit enddef def Test_range_only() new setline(1, ['blah', 'Blah']) :/Blah/ assert_equal(2, getcurpos()[1]) bwipe! # without range commands use current line new setline(1, ['one', 'two', 'three']) :2 print assert_equal('two', g:Screenline(&lines)) :3 list assert_equal('three$', g:Screenline(&lines)) # missing command does not print the line var lines =<< trim END vim9script :1| assert_equal('three$', g:Screenline(&lines)) :| assert_equal('three$', g:Screenline(&lines)) END v9.CheckScriptSuccess(lines) bwipe! lines =<< trim END set cpo+=- :1,999 END v9.CheckDefExecAndScriptFailure(lines, 'E16:', 2) set cpo&vim v9.CheckDefExecAndScriptFailure([":'x"], 'E20:', 1) # won't generate anything if false :123 endif enddef def Test_invalid_range() var lines =<< trim END :123 eval 1 + 2 END v9.CheckDefAndScriptFailure(lines, 'E481:', 1) lines =<< trim END :123 if true endif END v9.CheckDefAndScriptFailure(lines, 'E481:', 1) lines =<< trim END :123 echo 'yes' END v9.CheckDefAndScriptFailure(lines, 'E481:', 1) lines =<< trim END :123 cd there END v9.CheckDefAndScriptFailure(lines, 'E481:', 1) enddef let g:alist = [7] let g:astring = 'text' let g:anumber = 123 def Test_delfunction() # Check function is defined in script namespace v9.CheckScriptSuccess([ 'vim9script', 'func CheckMe()', ' return 123', 'endfunc', 'func DoTest()', ' call assert_equal(123, s:CheckMe())', 'endfunc', 'DoTest()', ]) # Check function in script namespace cannot be deleted v9.CheckScriptFailure([ 'vim9script', 'func DeleteMe1()', 'endfunc', 'delfunction DeleteMe1', ], 'E1084:') v9.CheckScriptFailure([ 'vim9script', 'func DeleteMe2()', 'endfunc', 'def DoThat()', ' delfunction DeleteMe2', 'enddef', 'DoThat()', ], 'E1084:') v9.CheckScriptFailure([ 'vim9script', 'def DeleteMe3()', 'enddef', 'delfunction DeleteMe3', ], 'E1084:') v9.CheckScriptFailure([ 'vim9script', 'def DeleteMe4()', 'enddef', 'def DoThat()', ' delfunction DeleteMe4', 'enddef', 'DoThat()', ], 'E1084:') # Check that global :def function can be replaced and deleted var lines =<< trim END vim9script def g:Global(): string return "yes" enddef assert_equal("yes", g:Global()) def! g:Global(): string return "no" enddef assert_equal("no", g:Global()) delfunc g:Global assert_false(exists('*g:Global')) END v9.CheckScriptSuccess(lines) # Check that global function can be replaced by a :def function and deleted lines =<< trim END vim9script func g:Global() return "yes" endfunc assert_equal("yes", g:Global()) def! g:Global(): string return "no" enddef assert_equal("no", g:Global()) delfunc g:Global assert_false(exists('*g:Global')) END v9.CheckScriptSuccess(lines) # Check that global :def function can be replaced by a function and deleted lines =<< trim END vim9script def g:Global(): string return "yes" enddef assert_equal("yes", g:Global()) func! g:Global() return "no" endfunc assert_equal("no", g:Global()) delfunc g:Global assert_false(exists('*g:Global')) END v9.CheckScriptSuccess(lines) enddef def Test_wrong_type() v9.CheckDefFailure(['var name: list'], 'E1010:') v9.CheckDefFailure(['var name: list>'], 'E1010:') v9.CheckDefFailure(['var name: dict'], 'E1010:') v9.CheckDefFailure(['var name: dict>'], 'E1010:') v9.CheckDefFailure(['var name: dict'], 'E1009:') v9.CheckDefFailure(['var name: ally'], 'E1010:') v9.CheckDefFailure(['var name: bram'], 'E1010:') v9.CheckDefFailure(['var name: cathy'], 'E1010:') v9.CheckDefFailure(['var name: dom'], 'E1010:') v9.CheckDefFailure(['var name: freddy'], 'E1010:') v9.CheckDefFailure(['var name: john'], 'E1010:') v9.CheckDefFailure(['var name: larry'], 'E1010:') v9.CheckDefFailure(['var name: ned'], 'E1010:') v9.CheckDefFailure(['var name: pam'], 'E1010:') v9.CheckDefFailure(['var name: sam'], 'E1010:') v9.CheckDefFailure(['var name: vim'], 'E1010:') v9.CheckDefFailure(['var Ref: number', 'Ref()'], 'E1085:') v9.CheckDefFailure(['var Ref: string', 'var res = Ref()'], 'E1085:') enddef def Test_script_namespace() # defining a function or variable with s: is not allowed var lines =<< trim END vim9script def s:Function() enddef END v9.CheckScriptFailure(lines, 'E1268:') for decl in ['var', 'const', 'final'] lines =<< trim END vim9script var s:var = 'var' END v9.CheckScriptFailure([ 'vim9script', decl .. ' s:var = "var"', ], 'E1268:') endfor # Calling a function or using a variable with s: is not allowed at script # level lines =<< trim END vim9script def Function() enddef s:Function() END v9.CheckScriptFailure(lines, 'E1268:') lines =<< trim END vim9script def Function() enddef call s:Function() END v9.CheckScriptFailure(lines, 'E1268:') lines =<< trim END vim9script var var = 'var' echo s:var END v9.CheckScriptFailure(lines, 'E1268:') enddef def Test_script_wrong_type() var lines =<< trim END vim9script var dict: dict dict['a'] = ['x'] END v9.CheckScriptFailure(lines, 'E1012: Type mismatch; expected string but got list', 3) enddef def Test_const() v9.CheckDefFailure(['final name = 234', 'name = 99'], 'E1018:') v9.CheckDefFailure(['final one = 234', 'var one = 99'], 'E1017:') v9.CheckDefFailure(['final list = [1, 2]', 'var list = [3, 4]'], 'E1017:') v9.CheckDefFailure(['final two'], 'E1125:') v9.CheckDefFailure(['final &option'], 'E996:') var lines =<< trim END final list = [1, 2, 3] list[0] = 4 list->assert_equal([4, 2, 3]) const other = [5, 6, 7] other->assert_equal([5, 6, 7]) var varlist = [7, 8] const constlist = [1, varlist, 3] varlist[0] = 77 constlist[1][1] = 88 var cl = constlist[1] cl[1] = 88 constlist->assert_equal([1, [77, 88], 3]) var vardict = {five: 5, six: 6} const constdict = {one: 1, two: vardict, three: 3} vardict['five'] = 55 constdict['two']['six'] = 66 var cd = constdict['two'] cd['six'] = 66 constdict->assert_equal({one: 1, two: {five: 55, six: 66}, three: 3}) END v9.CheckDefAndScriptSuccess(lines) enddef def Test_const_bang() var lines =<< trim END const var = 234 var = 99 END v9.CheckDefExecFailure(lines, 'E1018:', 2) v9.CheckScriptFailure(['vim9script'] + lines, 'E46:', 3) lines =<< trim END const ll = [2, 3, 4] ll[0] = 99 END v9.CheckDefExecFailure(lines, 'E1119:', 2) v9.CheckScriptFailure(['vim9script'] + lines, 'E741:', 3) lines =<< trim END const ll = [2, 3, 4] ll[3] = 99 END v9.CheckDefExecFailure(lines, 'E1118:', 2) v9.CheckScriptFailure(['vim9script'] + lines, 'E684:', 3) lines =<< trim END const dd = {one: 1, two: 2} dd["one"] = 99 END v9.CheckDefExecFailure(lines, 'E1121:', 2) v9.CheckScriptFailure(['vim9script'] + lines, 'E741:', 3) lines =<< trim END const dd = {one: 1, two: 2} dd["three"] = 99 END v9.CheckDefExecFailure(lines, 'E1120:') v9.CheckScriptFailure(['vim9script'] + lines, 'E741:', 3) enddef def Test_range_no_colon() v9.CheckDefFailure(['%s/a/b/'], 'E1050:') v9.CheckDefFailure(['+ s/a/b/'], 'E1050:') v9.CheckDefFailure(['- s/a/b/'], 'E1050:') v9.CheckDefFailure(['. s/a/b/'], 'E1050:') enddef def Test_block() var outer = 1 { var inner = 2 assert_equal(1, outer) assert_equal(2, inner) } assert_equal(1, outer) {|echo 'yes'|} enddef def Test_block_failure() v9.CheckDefFailure(['{', 'var inner = 1', '}', 'echo inner'], 'E1001:') v9.CheckDefFailure(['}'], 'E1025:') v9.CheckDefFailure(['{', 'echo 1'], 'E1026:') enddef def Test_block_local_vars() var lines =<< trim END vim9script v:testing = 1 if true var text = ['hello'] def SayHello(): list return text enddef def SetText(v: string) text = [v] enddef endif if true var text = ['again'] def SayAgain(): list return text enddef endif # test that the "text" variables are not cleaned up test_garbagecollect_now() defcompile assert_equal(['hello'], SayHello()) assert_equal(['again'], SayAgain()) SetText('foobar') assert_equal(['foobar'], SayHello()) call writefile(['ok'], 'Xdidit') qall! END # need to execute this with a separate Vim instance to avoid the current # context gets garbage collected. writefile(lines, 'Xscript') g:RunVim([], [], '-S Xscript') assert_equal(['ok'], readfile('Xdidit')) delete('Xscript') delete('Xdidit') enddef def Test_block_local_vars_with_func() var lines =<< trim END vim9script if true var foo = 'foo' if true var bar = 'bar' def Func(): list return [foo, bar] enddef endif endif # function is compiled here, after blocks have finished, can still access # "foo" and "bar" assert_equal(['foo', 'bar'], Func()) END v9.CheckScriptSuccess(lines) enddef " legacy func for command that's defined later func s:InvokeSomeCommand() SomeCommand endfunc def Test_autocommand_block() com SomeCommand { g:someVar = 'some' } InvokeSomeCommand() assert_equal('some', g:someVar) delcommand SomeCommand unlet g:someVar enddef def Test_command_block() au BufNew *.xml { g:otherVar = 'other' } split other.xml assert_equal('other', g:otherVar) bwipe! au! BufNew *.xml unlet g:otherVar enddef func g:NoSuchFunc() echo 'none' endfunc def Test_try_catch_throw() var l = [] try # comment add(l, '1') throw 'wrong' add(l, '2') catch # comment add(l, v:exception) finally # comment add(l, '3') endtry # comment assert_equal(['1', 'wrong', '3'], l) l = [] try try add(l, '1') throw 'wrong' add(l, '2') catch /right/ add(l, v:exception) endtry catch /wrong/ add(l, 'caught') finally add(l, 'finally') endtry assert_equal(['1', 'caught', 'finally'], l) var n: number try n = l[3] catch /E684:/ n = 99 endtry assert_equal(99, n) var done = 'no' if 0 try | catch | endtry else done = 'yes' endif assert_equal('yes', done) done = 'no' if 1 done = 'yes' else try | catch | endtry done = 'never' endif assert_equal('yes', done) if 1 else try | catch /pat/ | endtry try | catch /pat/ endtry try catch /pat/ | endtry try catch /pat/ endtry endif try # string slice returns a string, not a number n = g:astring[3] catch /E1012:/ n = 77 endtry assert_equal(77, n) try n = l[g:astring] catch /E1012:/ n = 88 endtry assert_equal(88, n) try n = s:does_not_exist catch /E121:/ n = 111 endtry assert_equal(111, n) try n = g:does_not_exist catch /E121:/ n = 121 endtry assert_equal(121, n) var d = {one: 1} try n = d[g:astring] catch /E716:/ n = 222 endtry assert_equal(222, n) try n = -g:astring catch /E1012:/ n = 233 endtry assert_equal(233, n) try n = +g:astring catch /E1012:/ n = 244 endtry assert_equal(244, n) try n = +g:alist catch /E1012:/ n = 255 endtry assert_equal(255, n) var nd: dict try nd = {[g:alist]: 1} catch /E1105:/ n = 266 endtry assert_equal(266, n) l = [1, 2, 3] try [n] = l catch /E1093:/ n = 277 endtry assert_equal(277, n) try &ts = g:astring catch /E1012:/ n = 288 endtry assert_equal(288, n) try &backspace = 'asdf' catch /E474:/ n = 299 endtry assert_equal(299, n) l = [1] try l[3] = 3 catch /E684:/ n = 300 endtry assert_equal(300, n) try unlet g:does_not_exist catch /E108:/ n = 322 endtry assert_equal(322, n) try d = {text: 1, [g:astring]: 2} catch /E721:/ n = 333 endtry assert_equal(333, n) try l = g:DeletedFunc() catch /E933:/ n = 344 endtry assert_equal(344, n) try echo range(1, 2, 0) catch /E726:/ n = 355 endtry assert_equal(355, n) var P = function('g:NoSuchFunc') delfunc g:NoSuchFunc try echo P() catch /E117:/ n = 366 endtry assert_equal(366, n) try echo g:NoSuchFunc() catch /E117:/ n = 377 endtry assert_equal(377, n) try echo g:alist + 4 catch /E745:/ n = 388 endtry assert_equal(388, n) try echo 4 + g:alist catch /E745:/ n = 399 endtry assert_equal(399, n) try echo g:alist.member catch /E715:/ n = 400 endtry assert_equal(400, n) try echo d.member catch /E716:/ n = 411 endtry assert_equal(411, n) var counter = 0 for i in range(4) try eval [][0] catch endtry counter += 1 endfor assert_equal(4, counter) # no requirement for spaces before | try|echo 0|catch|endtry # return in try with finally def ReturnInTry(): number var ret = 4 try return ret catch /this/ return -1 catch /that/ return -1 finally # changing ret has no effect ret = 7 endtry return -2 enddef assert_equal(4, ReturnInTry()) # return in catch with finally def ReturnInCatch(): number var ret = 5 try throw 'getout' return -1 catch /getout/ # ret is evaluated here return ret finally # changing ret later has no effect ret = -3 endtry return -2 enddef assert_equal(5, ReturnInCatch()) # return in finally after empty catch def ReturnInFinally(): number try finally return 6 endtry enddef assert_equal(6, ReturnInFinally()) var lines =<< trim END vim9script try acos('0.5') ->setline(1) catch g:caught = v:exception endtry END v9.CheckScriptSuccess(lines) assert_match('E1219: Float or Number required for argument 1', g:caught) unlet g:caught # missing catch and/or finally lines =<< trim END vim9script try echo 'something' endtry END v9.CheckScriptFailure(lines, 'E1032:') # skipping try-finally-endtry when try-finally-endtry is used in another block lines =<< trim END if v:true try finally endtry else try finally endtry endif END v9.CheckDefAndScriptSuccess(lines) enddef def Test_try_var_decl() var lines =<< trim END vim9script try var in_try = 1 assert_equal(1, get(s:, 'in_try', -1)) throw "getout" catch var in_catch = 2 assert_equal(-1, get(s:, 'in_try', -1)) assert_equal(2, get(s:, 'in_catch', -1)) finally var in_finally = 3 assert_equal(-1, get(s:, 'in_try', -1)) assert_equal(-1, get(s:, 'in_catch', -1)) assert_equal(3, get(s:, 'in_finally', -1)) endtry assert_equal(-1, get(s:, 'in_try', -1)) assert_equal(-1, get(s:, 'in_catch', -1)) assert_equal(-1, get(s:, 'in_finally', -1)) END v9.CheckScriptSuccess(lines) enddef def Test_try_ends_in_return() var lines =<< trim END vim9script def Foo(): string try return 'foo' catch return 'caught' endtry enddef assert_equal('foo', Foo()) END v9.CheckScriptSuccess(lines) lines =<< trim END vim9script def Foo(): string try return 'foo' catch return 'caught' endtry echo 'notreached' enddef assert_equal('foo', Foo()) END v9.CheckScriptFailure(lines, 'E1095:') lines =<< trim END vim9script def Foo(): string try return 'foo' catch /x/ return 'caught' endtry enddef assert_equal('foo', Foo()) END v9.CheckScriptFailure(lines, 'E1027:') lines =<< trim END vim9script def Foo(): string try echo 'foo' catch echo 'caught' finally return 'done' endtry enddef assert_equal('done', Foo()) END v9.CheckScriptSuccess(lines) enddef def Test_try_in_catch() var lines =<< trim END vim9script var seq = [] def DoIt() try seq->add('throw 1') eval [][0] seq->add('notreached') catch seq->add('catch') try seq->add('throw 2') eval [][0] seq->add('notreached') catch /nothing/ seq->add('notreached') endtry seq->add('done') endtry enddef DoIt() assert_equal(['throw 1', 'catch', 'throw 2', 'done'], seq) END enddef def Test_error_in_catch() var lines =<< trim END try eval [][0] catch /E684:/ eval [][0] endtry END v9.CheckDefExecFailure(lines, 'E684:', 4) enddef " :while at the very start of a function that :continue jumps to def s:TryContinueFunc() while g:Count < 2 g:sequence ..= 't' try echoerr 'Test' catch g:Count += 1 g:sequence ..= 'c' continue endtry g:sequence ..= 'e' g:Count += 1 endwhile enddef def Test_continue_in_try_in_while() g:Count = 0 g:sequence = '' TryContinueFunc() assert_equal('tctc', g:sequence) unlet g:Count unlet g:sequence enddef def Test_break_in_try_in_for() var lines =<< trim END vim9script def Ls(): list var ls: list for s in ['abc', 'def'] for _ in [123, 456] try eval [][0] catch break endtry endfor ls += [s] endfor return ls enddef assert_equal(['abc', 'def'], Ls()) END v9.CheckScriptSuccess(lines) enddef def Test_nocatch_return_in_try() # return in try block returns normally def ReturnInTry(): string try return '"some message"' catch endtry return 'not reached' enddef exe 'echoerr ' .. ReturnInTry() enddef def Test_cnext_works_in_catch() var lines =<< trim END vim9script au BufEnter * eval 1 + 2 writefile(['text'], 'Xfile1') writefile(['text'], 'Xfile2') var items = [ {lnum: 1, filename: 'Xfile1', valid: true}, {lnum: 1, filename: 'Xfile2', valid: true} ] setqflist([], ' ', {items: items}) cwindow def CnextOrCfirst() # if cnext fails, cfirst is used try cnext catch cfirst endtry enddef CnextOrCfirst() CnextOrCfirst() writefile([getqflist({idx: 0}).idx], 'Xresult') qall END writefile(lines, 'XCatchCnext') g:RunVim([], [], '--clean -S XCatchCnext') assert_equal(['1'], readfile('Xresult')) delete('Xfile1') delete('Xfile2') delete('XCatchCnext') delete('Xresult') enddef def Test_throw_skipped() if 0 throw dontgethere endif enddef def Test_nocatch_throw_silenced() var lines =<< trim END vim9script def Func() throw 'error' enddef silent! Func() END writefile(lines, 'XthrowSilenced') source XthrowSilenced delete('XthrowSilenced') enddef def DeletedFunc(): list return ['delete me'] enddef defcompile delfunc DeletedFunc def s:ThrowFromDef() throw "getout" # comment enddef func s:CatchInFunc() try call s:ThrowFromDef() catch let g:thrown_func = v:exception endtry endfunc def s:CatchInDef() try ThrowFromDef() catch g:thrown_def = v:exception endtry enddef def s:ReturnFinally(): string try return 'intry' finally g:in_finally = 'finally' endtry return 'end' enddef def Test_try_catch_nested() CatchInFunc() assert_equal('getout', g:thrown_func) CatchInDef() assert_equal('getout', g:thrown_def) assert_equal('intry', ReturnFinally()) assert_equal('finally', g:in_finally) var l = [] try l->add('1') throw 'bad' l->add('x') catch /bad/ l->add('2') try l->add('3') throw 'one' l->add('x') catch /one/ l->add('4') try l->add('5') throw 'more' l->add('x') catch /more/ l->add('6') endtry endtry endtry assert_equal(['1', '2', '3', '4', '5', '6'], l) l = [] try try l->add('1') throw 'foo' l->add('x') catch l->add('2') throw 'bar' l->add('x') finally l->add('3') endtry l->add('x') catch /bar/ l->add('4') endtry assert_equal(['1', '2', '3', '4'], l) enddef def s:TryOne(): number try return 0 catch endtry return 0 enddef def s:TryTwo(n: number): string try var x = {} catch endtry return 'text' enddef def Test_try_catch_twice() assert_equal('text', TryOne()->TryTwo()) enddef def Test_try_catch_match() var seq = 'a' try throw 'something' catch /nothing/ seq ..= 'x' catch /some/ seq ..= 'b' catch /asdf/ seq ..= 'x' catch ?a\?sdf? seq ..= 'y' finally seq ..= 'c' endtry assert_equal('abc', seq) enddef def Test_try_catch_fails() v9.CheckDefFailure(['catch'], 'E603:') v9.CheckDefFailure(['try', 'echo 0', 'catch', 'catch'], 'E1033:') v9.CheckDefFailure(['try', 'echo 0', 'catch /pat'], 'E1067:') v9.CheckDefFailure(['finally'], 'E606:') v9.CheckDefFailure(['try', 'echo 0', 'finally', 'echo 1', 'finally'], 'E607:') v9.CheckDefFailure(['endtry'], 'E602:') v9.CheckDefFailure(['while 1', 'endtry'], 'E170:') v9.CheckDefFailure(['for i in range(5)', 'endtry'], 'E170:') v9.CheckDefFailure(['if 1', 'endtry'], 'E171:') v9.CheckDefFailure(['try', 'echo 1', 'endtry'], 'E1032:') v9.CheckDefFailure(['throw'], 'E1143:') v9.CheckDefFailure(['throw xxx'], 'E1001:') enddef def Try_catch_skipped() var l = [] try finally endtry if 1 else try endtry endif enddef " The skipped try/endtry was updating the wrong instruction. def Test_try_catch_skipped() var instr = execute('disassemble Try_catch_skipped') assert_match("NEWLIST size 0\n", instr) enddef def Test_throw_line_number() def Func() eval 1 + 1 eval 2 + 2 throw 'exception' enddef try Func() catch /exception/ assert_match('line 3', v:throwpoint) endtry enddef def Test_throw_vimscript() # only checks line continuation var lines =<< trim END vim9script try throw 'one' .. 'two' catch assert_equal('onetwo', v:exception) endtry END v9.CheckScriptSuccess(lines) lines =<< trim END vim9script @r = '' def Func() throw @r enddef var result = '' try Func() catch /E1129:/ result = 'caught' endtry assert_equal('caught', result) END v9.CheckScriptSuccess(lines) enddef def Test_error_in_nested_function() # an error in a nested :function aborts executing in the calling :def function var lines =<< trim END vim9script def Func() Error() g:test_var = 1 enddef func Error() abort eval [][0] endfunc Func() END g:test_var = 0 v9.CheckScriptFailure(lines, 'E684:') assert_equal(0, g:test_var) enddef def Test_abort_after_error() var lines =<< trim END vim9script while true echo notfound endwhile g:gotthere = true END g:gotthere = false v9.CheckScriptFailure(lines, 'E121:') assert_false(g:gotthere) unlet g:gotthere enddef def Test_cexpr_vimscript() # only checks line continuation set errorformat=File\ %f\ line\ %l var lines =<< trim END vim9script cexpr 'File' .. ' someFile' .. ' line 19' assert_equal(19, getqflist()[0].lnum) END v9.CheckScriptSuccess(lines) lines =<< trim END vim9script def CexprFail() au QuickfixCmdPre * echo g:doesnotexist cexpr 'File otherFile line 99' g:didContinue = 'yes' enddef CexprFail() g:didContinue = 'also' END g:didContinue = 'no' v9.CheckScriptFailure(lines, 'E121: Undefined variable: g:doesnotexist') assert_equal('no', g:didContinue) au! QuickfixCmdPre lines =<< trim END vim9script def CexprFail() cexpr g:aNumber g:didContinue = 'yes' enddef CexprFail() g:didContinue = 'also' END g:aNumber = 123 g:didContinue = 'no' v9.CheckScriptFailure(lines, 'E777: String or List expected') assert_equal('no', g:didContinue) unlet g:didContinue set errorformat& enddef def Test_statusline_syntax() # legacy syntax is used for 'statusline' var lines =<< trim END vim9script func g:Status() return '%{"x" is# "x"}' endfunc set laststatus=2 statusline=%!Status() redrawstatus set laststatus statusline= END v9.CheckScriptSuccess(lines) enddef def Test_list_vimscript() # checks line continuation and comments var lines =<< trim END vim9script var mylist = [ 'one', # comment 'two', # empty line follows 'three', ] assert_equal(['one', 'two', 'three'], mylist) END v9.CheckScriptSuccess(lines) # check all lines from heredoc are kept lines =<< trim END # comment 1 two # comment 3 five # comment 6 END assert_equal(['# comment 1', 'two', '# comment 3', '', 'five', '# comment 6'], lines) lines =<< trim END [{ a: 0}]->string()->assert_equal("[{'a': 0}]") END v9.CheckDefAndScriptSuccess(lines) enddef if has('channel') let someJob = test_null_job() def FuncWithError() echomsg g:someJob enddef func Test_convert_emsg_to_exception() try call FuncWithError() catch call assert_match('Vim:E908:', v:exception) endtry endfunc endif def Test_vim9script_mix() var lines =<< trim END if has(g:feature) " legacy script let g:legacy = 1 finish endif vim9script g:legacy = 0 END g:feature = 'eval' g:legacy = -1 v9.CheckScriptSuccess(lines) assert_equal(1, g:legacy) g:feature = 'noteval' g:legacy = -1 v9.CheckScriptSuccess(lines) assert_equal(0, g:legacy) enddef def Test_vim9script_fails() v9.CheckScriptFailure(['scriptversion 2', 'vim9script'], 'E1039:') v9.CheckScriptFailure(['vim9script', 'scriptversion 2'], 'E1040:') v9.CheckScriptFailure(['vim9script', 'var str: string', 'str = 1234'], 'E1012:') v9.CheckScriptFailure(['vim9script', 'const str = "asdf"', 'str = "xxx"'], 'E46:') assert_fails('vim9script', 'E1038:') v9.CheckDefFailure(['vim9script'], 'E1038:') # no error when skipping if has('nothing') vim9script endif enddef def Test_script_var_shadows_function() var lines =<< trim END vim9script def Func(): number return 123 enddef var Func = 1 END v9.CheckScriptFailure(lines, 'E1041:', 5) enddef def Test_function_shadows_script_var() var lines =<< trim END vim9script var Func = 1 def Func(): number return 123 enddef END v9.CheckScriptFailure(lines, 'E1041:', 3) enddef def Test_script_var_shadows_command() var lines =<< trim END var undo = 1 undo = 2 assert_equal(2, undo) END v9.CheckDefAndScriptSuccess(lines) lines =<< trim END var undo = 1 undo END v9.CheckDefAndScriptFailure(lines, 'E1207:', 2) enddef def Test_vim9script_call_wrong_type() var lines =<< trim END vim9script var Time = 'localtime' Time() END v9.CheckScriptFailure(lines, 'E1085:') enddef def Test_vim9script_reload_delfunc() var first_lines =<< trim END vim9script def FuncYes(): string return 'yes' enddef END var withno_lines =<< trim END def FuncNo(): string return 'no' enddef def g:DoCheck(no_exists: bool) assert_equal('yes', FuncYes()) assert_equal('no', FuncNo()) enddef END var nono_lines =<< trim END def g:DoCheck(no_exists: bool) assert_equal('yes', FuncYes()) assert_fails('FuncNo()', 'E117:', '', 2, 'DoCheck') enddef END # FuncNo() is defined writefile(first_lines + withno_lines, 'Xreloaded.vim') source Xreloaded.vim g:DoCheck(true) # FuncNo() is not redefined writefile(first_lines + nono_lines, 'Xreloaded.vim') source Xreloaded.vim g:DoCheck(false) # FuncNo() is back writefile(first_lines + withno_lines, 'Xreloaded.vim') source Xreloaded.vim g:DoCheck(false) delete('Xreloaded.vim') enddef def Test_vim9script_reload_delvar() # write the script with a script-local variable var lines =<< trim END vim9script var name = 'string' END writefile(lines, 'XreloadVar.vim') source XreloadVar.vim # now write the script using the same variable locally - works lines =<< trim END vim9script def Func() var name = 'string' enddef END writefile(lines, 'XreloadVar.vim') source XreloadVar.vim delete('XreloadVar.vim') enddef def Test_func_redefine_error() var lines = [ 'vim9script', 'def Func()', ' eval [][0]', 'enddef', 'Func()', ] writefile(lines, 'Xtestscript.vim') for count in range(3) try source Xtestscript.vim catch /E684/ # function name should contain every time assert_match('E684: List index out of range', v:exception) assert_match('function \d\+_Func, line 1', v:throwpoint) endtry endfor delete('Xtestscript.vim') enddef def Test_func_redefine_fails() var lines =<< trim END vim9script def Func() echo 'one' enddef def Func() echo 'two' enddef END v9.CheckScriptFailure(lines, 'E1073:') lines =<< trim END vim9script def Foo(): string return 'foo' enddef def Func() var Foo = {-> 'lambda'} enddef defcompile END v9.CheckScriptFailure(lines, 'E1073:') enddef def Test_fixed_size_list() # will be allocated as one piece of memory, check that changes work var l = [1, 2, 3, 4] l->remove(0) l->add(5) l->insert(99, 1) assert_equal([2, 99, 3, 4, 5], l) enddef def Test_no_insert_xit() v9.CheckDefExecFailure(['a = 1'], 'E1100:') v9.CheckDefExecFailure(['c = 1'], 'E1100:') v9.CheckDefExecFailure(['i = 1'], 'E1100:') v9.CheckDefExecFailure(['t = 1'], 'E1100:') v9.CheckDefExecFailure(['x = 1'], 'E1100:') v9.CheckScriptFailure(['vim9script', 'a = 1'], 'E488:') v9.CheckScriptFailure(['vim9script', 'a'], 'E1100:') v9.CheckScriptFailure(['vim9script', 'c = 1'], 'E488:') v9.CheckScriptFailure(['vim9script', 'c'], 'E1100:') v9.CheckScriptFailure(['vim9script', 'i = 1'], 'E488:') v9.CheckScriptFailure(['vim9script', 'i'], 'E1100:') v9.CheckScriptFailure(['vim9script', 'o = 1'], 'E1100:') v9.CheckScriptFailure(['vim9script', 'o'], 'E1100:') v9.CheckScriptFailure(['vim9script', 't'], 'E1100:') v9.CheckScriptFailure(['vim9script', 't = 1'], 'E1100:') v9.CheckScriptFailure(['vim9script', 'x = 1'], 'E1100:') enddef def s:IfElse(what: number): string var res = '' if what == 1 res = "one" elseif what == 2 res = "two" else res = "three" endif return res enddef def Test_if_elseif_else() assert_equal('one', IfElse(1)) assert_equal('two', IfElse(2)) assert_equal('three', IfElse(3)) enddef def Test_if_elseif_else_fails() v9.CheckDefFailure(['elseif true'], 'E582:') v9.CheckDefFailure(['else'], 'E581:') v9.CheckDefFailure(['endif'], 'E580:') v9.CheckDefFailure(['if g:abool', 'elseif xxx'], 'E1001:') v9.CheckDefFailure(['if true', 'echo 1'], 'E171:') var lines =<< trim END var s = '' if s = '' endif END v9.CheckDefFailure(lines, 'E488:') lines =<< trim END var s = '' if s == '' elseif s = '' endif END v9.CheckDefFailure(lines, 'E488:') lines =<< trim END var cond = true if cond echo 'true' elseif echo 'false' endif END v9.CheckDefAndScriptFailure(lines, ['E1143:', 'E15:'], 4) enddef def Test_if_else_func_using_var() var lines =<< trim END vim9script const debug = true if debug var mode_chars = 'something' def Bits2Ascii() var x = mode_chars g:where = 'in true' enddef else def Bits2Ascii() g:where = 'in false' enddef endif Bits2Ascii() END v9.CheckScriptSuccess(lines) assert_equal('in true', g:where) unlet g:where lines =<< trim END vim9script const debug = false if debug var mode_chars = 'something' def Bits2Ascii() g:where = 'in true' enddef else def Bits2Ascii() var x = mode_chars g:where = 'in false' enddef endif Bits2Ascii() END v9.CheckScriptFailure(lines, 'E1001: Variable not found: mode_chars') enddef let g:bool_true = v:true let g:bool_false = v:false def Test_if_const_expr() var res = false if true ? true : false res = true endif assert_equal(true, res) g:glob = 2 if false execute('g:glob = 3') endif assert_equal(2, g:glob) if true execute('g:glob = 3') endif assert_equal(3, g:glob) res = false if g:bool_true ? true : false res = true endif assert_equal(true, res) res = false if true ? g:bool_true : false res = true endif assert_equal(true, res) res = false if true ? true : g:bool_false res = true endif assert_equal(true, res) res = false if true ? false : true res = true endif assert_equal(false, res) res = false if false ? false : true res = true endif assert_equal(true, res) res = false if false ? true : false res = true endif assert_equal(false, res) res = false if has('xyz') ? true : false res = true endif assert_equal(false, res) res = false if true && true res = true endif assert_equal(true, res) res = false if true && false res = true endif assert_equal(false, res) res = false if g:bool_true && false res = true endif assert_equal(false, res) res = false if true && g:bool_false res = true endif assert_equal(false, res) res = false if false && false res = true endif assert_equal(false, res) res = false if true || false res = true endif assert_equal(true, res) res = false if g:bool_true || false res = true endif assert_equal(true, res) res = false if true || g:bool_false res = true endif assert_equal(true, res) res = false if false || false res = true endif assert_equal(false, res) # with constant "false" expression may be invalid so long as the syntax is OK if false | eval 1 + 2 | endif if false | eval burp + 234 | endif if false | echo burp 234 'asd' | endif if false burp endif if 0 if 1 echo nothing elseif 1 echo still nothing endif endif # expression with line breaks skipped if false ('aaa' .. 'bbb' .. 'ccc' )->setline(1) endif enddef def Test_if_const_expr_fails() v9.CheckDefFailure(['if "aaa" == "bbb'], 'E114:') v9.CheckDefFailure(["if 'aaa' == 'bbb"], 'E115:') v9.CheckDefFailure(["if has('aaa'"], 'E110:') v9.CheckDefFailure(["if has('aaa') ? true false"], 'E109:') enddef def s:RunNested(i: number): number var x: number = 0 if i % 2 if 1 # comment else # comment endif x += 1 else x += 1000 endif return x enddef def Test_nested_if() assert_equal(1, RunNested(1)) assert_equal(1000, RunNested(2)) enddef def Test_execute_cmd() # missing argument is ignored execute execute # comment new setline(1, 'default') execute 'setline(1, "execute-string")' assert_equal('execute-string', getline(1)) execute "setline(1, 'execute-string')" assert_equal('execute-string', getline(1)) var cmd1 = 'setline(1,' var cmd2 = '"execute-var")' execute cmd1 cmd2 # comment assert_equal('execute-var', getline(1)) execute cmd1 cmd2 '|setline(1, "execute-var-string")' assert_equal('execute-var-string', getline(1)) var cmd_first = 'call ' var cmd_last = 'setline(1, "execute-var-var")' execute cmd_first .. cmd_last assert_equal('execute-var-var', getline(1)) bwipe! var n = true execute 'echomsg' (n ? '"true"' : '"no"') assert_match('^true$', g:Screenline(&lines)) echomsg [1, 2, 3] {a: 1, b: 2} assert_match('^\[1, 2, 3\] {''a'': 1, ''b'': 2}$', g:Screenline(&lines)) v9.CheckDefFailure(['execute xxx'], 'E1001:', 1) v9.CheckDefExecFailure(['execute "tabnext " .. 8'], 'E475:', 1) v9.CheckDefFailure(['execute "cmd"# comment'], 'E488:', 1) if has('channel') v9.CheckDefExecFailure(['execute test_null_channel()'], 'E908:', 1) endif enddef def Test_execute_cmd_vimscript() # only checks line continuation var lines =<< trim END vim9script execute 'g:someVar' .. ' = ' .. '28' assert_equal(28, g:someVar) unlet g:someVar END v9.CheckScriptSuccess(lines) enddef def Test_execute_finish() # the empty lines are relevant here var lines =<< trim END vim9script var vname = "g:hello" if exists(vname) | finish | endif | execute vname '= "world"' assert_equal('world', g:hello) if exists(vname) | finish | endif | execute vname '= "world"' assert_report('should not be reached') END v9.CheckScriptSuccess(lines) enddef def Test_echo_cmd() echo 'some' # comment echon 'thing' assert_match('^something$', g:Screenline(&lines)) echo "some" # comment echon "thing" assert_match('^something$', g:Screenline(&lines)) var str1 = 'some' var str2 = 'more' echo str1 str2 assert_match('^some more$', g:Screenline(&lines)) echo "one\ntwo" assert_match('^one$', g:Screenline(&lines - 1)) assert_match('^two$', g:Screenline(&lines)) v9.CheckDefFailure(['echo "xxx"# comment'], 'E488:') enddef def Test_echomsg_cmd() echomsg 'some' 'more' # comment assert_match('^some more$', g:Screenline(&lines)) echo 'clear' :1messages assert_match('^some more$', g:Screenline(&lines)) v9.CheckDefFailure(['echomsg "xxx"# comment'], 'E488:') enddef def Test_echomsg_cmd_vimscript() # only checks line continuation var lines =<< trim END vim9script echomsg 'here' .. ' is ' .. 'a message' assert_match('^here is a message$', g:Screenline(&lines)) END v9.CheckScriptSuccess(lines) enddef def Test_echoerr_cmd() var local = 'local' try echoerr 'something' local 'wrong' # comment catch assert_match('something local wrong', v:exception) endtry enddef def Test_echoerr_cmd_vimscript() # only checks line continuation var lines =<< trim END vim9script try echoerr 'this' .. ' is ' .. 'wrong' catch assert_match('this is wrong', v:exception) endtry END v9.CheckScriptSuccess(lines) enddef def Test_echoconsole_cmd() var local = 'local' echoconsole 'something' local # comment # output goes anywhere enddef def Test_for_outside_of_function() var lines =<< trim END vim9script new for var in range(0, 3) append(line('$'), var) endfor assert_equal(['', '0', '1', '2', '3'], getline(1, '$')) bwipe! var result = '' for i in [1, 2, 3] var loop = ' loop ' .. i result ..= loop endfor assert_equal(' loop 1 loop 2 loop 3', result) END writefile(lines, 'Xvim9for.vim') source Xvim9for.vim delete('Xvim9for.vim') enddef def Test_for_skipped_block() # test skipped blocks at outside of function var lines =<< trim END var result = [] if true for n in [1, 2] result += [n] endfor else for n in [3, 4] result += [n] endfor endif assert_equal([1, 2], result) result = [] if false for n in [1, 2] result += [n] endfor else for n in [3, 4] result += [n] endfor endif assert_equal([3, 4], result) END v9.CheckDefAndScriptSuccess(lines) # test skipped blocks at inside of function lines =<< trim END def DefTrue() var result = [] if true for n in [1, 2] result += [n] endfor else for n in [3, 4] result += [n] endfor endif assert_equal([1, 2], result) enddef DefTrue() def DefFalse() var result = [] if false for n in [1, 2] result += [n] endfor else for n in [3, 4] result += [n] endfor endif assert_equal([3, 4], result) enddef DefFalse() def BuildDiagrams() var diagrams: list if false var max = 0 for v in diagrams var l = 3 if max < l | max = l | endif v->add(l) endfor endif enddef BuildDiagrams() END v9.CheckDefAndScriptSuccess(lines) enddef def Test_for_loop() var lines =<< trim END var result = '' for cnt in range(7) if cnt == 4 break endif if cnt == 2 continue endif result ..= cnt .. '_' endfor assert_equal('0_1_3_', result) var concat = '' for str in eval('["one", "two"]') concat ..= str endfor assert_equal('onetwo', concat) var total = 0 for nr in [1, 2, 3] total += nr endfor assert_equal(6, total) total = 0 for nr in [1, 2, 3] total += nr endfor assert_equal(6, total) total = 0 for nr in [1, 2, 3] total += nr endfor assert_equal(6, total) # with type total = 0 for n: number in [1, 2, 3] total += n endfor assert_equal(6, total) total = 0 for b in 0z010203 total += b endfor assert_equal(6, total) var chars = '' for s: string in 'foobar' chars ..= s endfor assert_equal('foobar', chars) chars = '' for x: string in {a: 'a', b: 'b'}->values() chars ..= x endfor assert_equal('ab', chars) # unpack with type var res = '' for [n: number, s: string] in [[1, 'a'], [2, 'b']] res ..= n .. s endfor assert_equal('1a2b', res) # unpack with one var var reslist = [] for [x] in [['aaa'], ['bbb']] reslist->add(x) endfor assert_equal(['aaa', 'bbb'], reslist) # loop over string res = '' for c in 'aéc̀d' res ..= c .. '-' endfor assert_equal('a-é-c̀-d-', res) res = '' for c in '' res ..= c .. '-' endfor assert_equal('', res) res = '' for c in test_null_string() res ..= c .. '-' endfor assert_equal('', res) total = 0 for c in null_list total += 1 endfor assert_equal(0, total) for c in null_blob total += 1 endfor assert_equal(0, total) var foo: list> = [ {a: 'Cat'} ] for dd in foo dd.counter = 12 endfor assert_equal([{a: 'Cat', counter: 12}], foo) reslist = [] for _ in range(3) reslist->add('x') endfor assert_equal(['x', 'x', 'x'], reslist) END v9.CheckDefAndScriptSuccess(lines) enddef def Test_for_loop_with_closure() var lines =<< trim END var flist: list for i in range(5) var inloop = i flist[i] = () => inloop endfor for i in range(5) assert_equal(4, flist[i]()) endfor END v9.CheckDefAndScriptSuccess(lines) lines =<< trim END var flist: list for i in range(5) var inloop = i flist[i] = () => { return inloop } endfor for i in range(5) assert_equal(4, flist[i]()) endfor END v9.CheckDefAndScriptSuccess(lines) enddef def Test_for_loop_fails() v9.CheckDefAndScriptFailure(['for '], ['E1097:', 'E690:']) v9.CheckDefAndScriptFailure(['for x'], ['E1097:', 'E690:']) v9.CheckDefAndScriptFailure(['for x in'], ['E1097:', 'E15:']) v9.CheckDefAndScriptFailure(['for # in range(5)'], 'E690:') v9.CheckDefAndScriptFailure(['for i In range(5)'], 'E690:') v9.CheckDefAndScriptFailure(['var x = 5', 'for x in range(5)', 'endfor'], ['E1017:', 'E1041:']) v9.CheckScriptFailure(['vim9script', 'var x = 5', 'for x in range(5)', '# comment', 'endfor'], 'E1041:', 3) v9.CheckScriptFailure(['def Func(arg: any)', 'for arg in range(5)', 'enddef', 'defcompile'], 'E1006:') delfunc! g:Func v9.CheckDefFailure(['for i in xxx'], 'E1001:') v9.CheckDefFailure(['endfor'], 'E588:') v9.CheckDefFailure(['for i in range(3)', 'echo 3'], 'E170:') # wrong type detected at compile time v9.CheckDefFailure(['for i in {a: 1}', 'echo 3', 'endfor'], 'E1177: For loop on dict not supported') # wrong type detected at runtime g:adict = {a: 1} v9.CheckDefExecFailure(['for i in g:adict', 'echo 3', 'endfor'], 'E1177: For loop on dict not supported') unlet g:adict var lines =<< trim END var d: list> = [{a: 0}] for e in d e = {a: 0, b: ''} endfor END v9.CheckDefAndScriptFailure(lines, ['E1018:', 'E46:'], 3) lines =<< trim END for nr: number in ['foo'] endfor END v9.CheckDefAndScriptFailure(lines, 'E1012: Type mismatch; expected number but got string', 1) lines =<< trim END for n : number in [1, 2] echo n endfor END v9.CheckDefAndScriptFailure(lines, 'E1059:', 1) lines =<< trim END var d: dict = {a: 1, b: 2} for [k: job, v: job] in d->items() echo k v endfor END v9.CheckDefExecAndScriptFailure(lines, ['E1013: Argument 1: type mismatch, expected job but got string', 'E1012: Type mismatch; expected job but got string'], 2) lines =<< trim END var i = 0 for i in [1, 2, 3] echo i endfor END v9.CheckDefExecAndScriptFailure(lines, ['E1017:', 'E1041:']) lines =<< trim END var l = [0] for l[0] in [1, 2, 3] echo l[0] endfor END v9.CheckDefExecAndScriptFailure(lines, ['E461:', 'E1017:']) lines =<< trim END var d = {x: 0} for d.x in [1, 2, 3] echo d.x endfor END v9.CheckDefExecAndScriptFailure(lines, ['E461:', 'E1017:']) lines =<< trim END var l: list> = [{a: 1, b: 'x'}] for item: dict in l echo item endfor END v9.CheckDefExecAndScriptFailure(lines, 'E1012: Type mismatch; expected dict but got dict') lines =<< trim END var l: list> = [{n: 1}] for item: dict in l item->extend({s: ''}) endfor END v9.CheckDefExecAndScriptFailure(lines, 'E1013: Argument 2: type mismatch, expected dict but got dict') enddef def Test_for_loop_script_var() # cannot use s:var in a :def function v9.CheckDefFailure(['for s:var in range(3)', 'echo 3'], 'E1254:') # can use s:var in Vim9 script, with or without s: var lines =<< trim END vim9script var total = 0 for s:var in [1, 2, 3] total += s:var endfor assert_equal(6, total) total = 0 for var in [1, 2, 3] total += var endfor assert_equal(6, total) END enddef def Test_for_loop_unpack() var lines =<< trim END var result = [] for [v1, v2] in [[1, 2], [3, 4]] result->add(v1) result->add(v2) endfor assert_equal([1, 2, 3, 4], result) result = [] for [v1, v2; v3] in [[1, 2], [3, 4, 5, 6]] result->add(v1) result->add(v2) result->add(v3) endfor assert_equal([1, 2, [], 3, 4, [5, 6]], result) result = [] for [&ts, &sw] in [[1, 2], [3, 4]] result->add(&ts) result->add(&sw) endfor assert_equal([1, 2, 3, 4], result) var slist: list for [$LOOPVAR, @r, v:errmsg] in [['a', 'b', 'c'], ['d', 'e', 'f']] slist->add($LOOPVAR) slist->add(@r) slist->add(v:errmsg) endfor assert_equal(['a', 'b', 'c', 'd', 'e', 'f'], slist) slist = [] for [g:globalvar, b:bufvar, w:winvar, t:tabvar] in [['global', 'buf', 'win', 'tab'], ['1', '2', '3', '4']] slist->add(g:globalvar) slist->add(b:bufvar) slist->add(w:winvar) slist->add(t:tabvar) endfor assert_equal(['global', 'buf', 'win', 'tab', '1', '2', '3', '4'], slist) unlet! g:globalvar b:bufvar w:winvar t:tabvar var res = [] for [_, n, _] in [[1, 2, 3], [4, 5, 6]] res->add(n) endfor assert_equal([2, 5], res) var text: list = ["hello there", "goodbye now"] var splitted = '' for [first; next] in mapnew(text, (i, v) => split(v)) splitted ..= string(first) .. string(next) .. '/' endfor assert_equal("'hello'['there']/'goodbye'['now']/", splitted) END v9.CheckDefAndScriptSuccess(lines) lines =<< trim END for [v1, v2] in [[1, 2, 3], [3, 4]] echo v1 v2 endfor END v9.CheckDefExecFailure(lines, 'E710:', 1) lines =<< trim END for [v1, v2] in [[1], [3, 4]] echo v1 v2 endfor END v9.CheckDefExecFailure(lines, 'E711:', 1) lines =<< trim END for [v1, v1] in [[1, 2], [3, 4]] echo v1 endfor END v9.CheckDefExecFailure(lines, 'E1017:', 1) lines =<< trim END for [a, b] in g:listlist echo a endfor END g:listlist = [1, 2, 3] v9.CheckDefExecFailure(lines, 'E1140:', 1) enddef def Test_for_loop_with_try_continue() var lines =<< trim END var looped = 0 var cleanup = 0 for i in range(3) looped += 1 try eval [][0] catch continue finally cleanup += 1 endtry endfor assert_equal(3, looped) assert_equal(3, cleanup) END v9.CheckDefAndScriptSuccess(lines) enddef def Test_while_skipped_block() # test skipped blocks at outside of function var lines =<< trim END var result = [] var n = 0 if true n = 1 while n < 3 result += [n] n += 1 endwhile else n = 3 while n < 5 result += [n] n += 1 endwhile endif assert_equal([1, 2], result) result = [] if false n = 1 while n < 3 result += [n] n += 1 endwhile else n = 3 while n < 5 result += [n] n += 1 endwhile endif assert_equal([3, 4], result) END v9.CheckDefAndScriptSuccess(lines) # test skipped blocks at inside of function lines =<< trim END def DefTrue() var result = [] var n = 0 if true n = 1 while n < 3 result += [n] n += 1 endwhile else n = 3 while n < 5 result += [n] n += 1 endwhile endif assert_equal([1, 2], result) enddef DefTrue() def DefFalse() var result = [] var n = 0 if false n = 1 while n < 3 result += [n] n += 1 endwhile else n = 3 while n < 5 result += [n] n += 1 endwhile endif assert_equal([3, 4], result) enddef DefFalse() END v9.CheckDefAndScriptSuccess(lines) enddef def Test_while_loop() var result = '' var cnt = 0 while cnt < 555 if cnt == 3 break endif cnt += 1 if cnt == 2 continue endif result ..= cnt .. '_' endwhile assert_equal('1_3_', result) var s = '' while s == 'x' # {comment} endwhile enddef def Test_while_loop_in_script() var lines =<< trim END vim9script var result = '' var cnt = 0 while cnt < 3 var s = 'v' .. cnt result ..= s cnt += 1 endwhile assert_equal('v0v1v2', result) END v9.CheckScriptSuccess(lines) enddef def Test_while_loop_fails() v9.CheckDefFailure(['while xxx'], 'E1001:') v9.CheckDefFailure(['endwhile'], 'E588:') v9.CheckDefFailure(['continue'], 'E586:') v9.CheckDefFailure(['if true', 'continue'], 'E586:') v9.CheckDefFailure(['break'], 'E587:') v9.CheckDefFailure(['if true', 'break'], 'E587:') v9.CheckDefFailure(['while 1', 'echo 3'], 'E170:') var lines =<< trim END var s = '' while s = '' endwhile END v9.CheckDefFailure(lines, 'E488:') enddef def Test_interrupt_loop() var caught = false var x = 0 try while 1 x += 1 if x == 100 feedkeys("\", 'Lt') endif endwhile catch caught = true assert_equal(100, x) endtry assert_true(caught, 'should have caught an exception') # consume the CTRL-C getchar(0) enddef def Test_automatic_line_continuation() var mylist = [ 'one', 'two', 'three', ] # comment assert_equal(['one', 'two', 'three'], mylist) var mydict = { ['one']: 1, ['two']: 2, ['three']: 3, } # comment assert_equal({one: 1, two: 2, three: 3}, mydict) mydict = { one: 1, # comment two: # comment 2, # comment three: 3 # comment } assert_equal({one: 1, two: 2, three: 3}, mydict) mydict = { one: 1, two: 2, three: 3 } assert_equal({one: 1, two: 2, three: 3}, mydict) assert_equal( ['one', 'two', 'three'], split('one two three') ) enddef def Test_vim9_comment() v9.CheckScriptSuccess([ 'vim9script', '# something', '#something', '#{something', ]) split Xfile v9.CheckScriptSuccess([ 'vim9script', 'edit #something', ]) v9.CheckScriptSuccess([ 'vim9script', 'edit #{something', ]) close v9.CheckScriptFailure([ 'vim9script', ':# something', ], 'E488:') v9.CheckScriptFailure([ '# something', ], 'E488:') v9.CheckScriptFailure([ ':# something', ], 'E488:') { # block start } # block end v9.CheckDefFailure([ '{# comment', ], 'E488:') v9.CheckDefFailure([ '{', '}# comment', ], 'E488:') echo "yes" # comment v9.CheckDefFailure([ 'echo "yes"# comment', ], 'E488:') v9.CheckScriptSuccess([ 'vim9script', 'echo "yes" # something', ]) v9.CheckScriptFailure([ 'vim9script', 'echo "yes"# something', ], 'E121:') v9.CheckScriptFailure([ 'vim9script', 'echo# something', ], 'E1144:') v9.CheckScriptFailure([ 'echo "yes" # something', ], 'E121:') exe "echo" # comment v9.CheckDefFailure([ 'exe "echo"# comment', ], 'E488:') v9.CheckScriptSuccess([ 'vim9script', 'exe "echo" # something', ]) v9.CheckScriptFailure([ 'vim9script', 'exe "echo"# something', ], 'E121:') v9.CheckScriptFailure([ 'vim9script', 'exe# something', ], 'E1144:') v9.CheckScriptFailure([ 'exe "echo" # something', ], 'E121:') v9.CheckDefFailure([ 'try# comment', ' echo "yes"', 'catch', 'endtry', ], 'E1144:') v9.CheckScriptFailure([ 'vim9script', 'try# comment', 'echo "yes"', ], 'E1144:') v9.CheckDefFailure([ 'try', ' throw#comment', 'catch', 'endtry', ], 'E1144:') v9.CheckDefFailure([ 'try', ' throw "yes"#comment', 'catch', 'endtry', ], 'E488:') v9.CheckDefFailure([ 'try', ' echo "yes"', 'catch# comment', 'endtry', ], 'E1144:') v9.CheckScriptFailure([ 'vim9script', 'try', ' echo "yes"', 'catch# comment', 'endtry', ], 'E1144:') v9.CheckDefFailure([ 'try', ' echo "yes"', 'catch /pat/# comment', 'endtry', ], 'E488:') v9.CheckDefFailure([ 'try', 'echo "yes"', 'catch', 'endtry# comment', ], 'E1144:') v9.CheckScriptFailure([ 'vim9script', 'try', ' echo "yes"', 'catch', 'endtry# comment', ], 'E1144:') v9.CheckScriptSuccess([ 'vim9script', 'hi # comment', ]) v9.CheckScriptFailure([ 'vim9script', 'hi# comment', ], 'E1144:') v9.CheckScriptSuccess([ 'vim9script', 'hi Search # comment', ]) v9.CheckScriptFailure([ 'vim9script', 'hi Search# comment', ], 'E416:') v9.CheckScriptSuccess([ 'vim9script', 'hi link This Search # comment', ]) v9.CheckScriptFailure([ 'vim9script', 'hi link This That# comment', ], 'E413:') v9.CheckScriptSuccess([ 'vim9script', 'hi clear This # comment', 'hi clear # comment', ]) # not tested, because it doesn't give an error but a warning: # hi clear This# comment', v9.CheckScriptFailure([ 'vim9script', 'hi clear# comment', ], 'E416:') v9.CheckScriptSuccess([ 'vim9script', 'hi Group term=bold', 'match Group /todo/ # comment', ]) v9.CheckScriptFailure([ 'vim9script', 'hi Group term=bold', 'match Group /todo/# comment', ], 'E488:') v9.CheckScriptSuccess([ 'vim9script', 'match # comment', ]) v9.CheckScriptFailure([ 'vim9script', 'match# comment', ], 'E1144:') v9.CheckScriptSuccess([ 'vim9script', 'match none # comment', ]) v9.CheckScriptFailure([ 'vim9script', 'match none# comment', ], 'E475:') v9.CheckScriptSuccess([ 'vim9script', 'menutrans clear # comment', ]) v9.CheckScriptFailure([ 'vim9script', 'menutrans clear# comment text', ], 'E474:') v9.CheckScriptSuccess([ 'vim9script', 'syntax clear # comment', ]) v9.CheckScriptFailure([ 'vim9script', 'syntax clear# comment text', ], 'E28:') v9.CheckScriptSuccess([ 'vim9script', 'syntax keyword Word some', 'syntax clear Word # comment', ]) v9.CheckScriptFailure([ 'vim9script', 'syntax keyword Word some', 'syntax clear Word# comment text', ], 'E28:') v9.CheckScriptSuccess([ 'vim9script', 'syntax list # comment', ]) v9.CheckScriptFailure([ 'vim9script', 'syntax list# comment text', ], 'E28:') v9.CheckScriptSuccess([ 'vim9script', 'syntax match Word /pat/ oneline # comment', ]) v9.CheckScriptFailure([ 'vim9script', 'syntax match Word /pat/ oneline# comment', ], 'E475:') v9.CheckScriptSuccess([ 'vim9script', 'syntax keyword Word word # comm[ent', ]) v9.CheckScriptFailure([ 'vim9script', 'syntax keyword Word word# comm[ent', ], 'E789:') v9.CheckScriptSuccess([ 'vim9script', 'syntax match Word /pat/ # comment', ]) v9.CheckScriptFailure([ 'vim9script', 'syntax match Word /pat/# comment', ], 'E402:') v9.CheckScriptSuccess([ 'vim9script', 'syntax match Word /pat/ contains=Something # comment', ]) v9.CheckScriptFailure([ 'vim9script', 'syntax match Word /pat/ contains=Something# comment', ], 'E475:') v9.CheckScriptFailure([ 'vim9script', 'syntax match Word /pat/ contains= # comment', ], 'E406:') v9.CheckScriptFailure([ 'vim9script', 'syntax match Word /pat/ contains=# comment', ], 'E475:') v9.CheckScriptSuccess([ 'vim9script', 'syntax region Word start=/pat/ end=/pat/ # comment', ]) v9.CheckScriptFailure([ 'vim9script', 'syntax region Word start=/pat/ end=/pat/# comment', ], 'E402:') v9.CheckScriptSuccess([ 'vim9script', 'syntax sync # comment', ]) v9.CheckScriptFailure([ 'vim9script', 'syntax sync# comment', ], 'E404:') v9.CheckScriptSuccess([ 'vim9script', 'syntax sync ccomment # comment', ]) v9.CheckScriptFailure([ 'vim9script', 'syntax sync ccomment# comment', ], 'E404:') v9.CheckScriptSuccess([ 'vim9script', 'syntax cluster Some contains=Word # comment', ]) v9.CheckScriptFailure([ 'vim9script', 'syntax cluster Some contains=Word# comment', ], 'E475:') v9.CheckScriptSuccess([ 'vim9script', 'command Echo echo # comment', 'command Echo # comment', 'delcommand Echo', ]) v9.CheckScriptFailure([ 'vim9script', 'command Echo echo# comment', 'Echo', ], 'E1144:') delcommand Echo var curdir = getcwd() v9.CheckScriptSuccess([ 'command Echo cd " comment', 'Echo', 'delcommand Echo', ]) v9.CheckScriptSuccess([ 'vim9script', 'command Echo cd # comment', 'Echo', 'delcommand Echo', ]) v9.CheckScriptFailure([ 'vim9script', 'command Echo cd " comment', 'Echo', ], 'E344:') delcommand Echo chdir(curdir) v9.CheckScriptFailure([ 'vim9script', 'command Echo# comment', ], 'E182:') v9.CheckScriptFailure([ 'vim9script', 'command Echo echo', 'command Echo# comment', ], 'E182:') delcommand Echo v9.CheckScriptSuccess([ 'vim9script', 'function # comment', ]) v9.CheckScriptFailure([ 'vim9script', 'function " comment', ], 'E129:') v9.CheckScriptFailure([ 'vim9script', 'function# comment', ], 'E1144:') v9.CheckScriptSuccess([ 'vim9script', 'import "./vim9.vim" as v9', 'function v9.CheckScriptSuccess # comment', ]) v9.CheckScriptFailure([ 'vim9script', 'import "./vim9.vim" as v9', 'function v9.CheckScriptSuccess# comment', ], 'E1048: Item not found in script: CheckScriptSuccess#') v9.CheckScriptSuccess([ 'vim9script', 'func g:DeleteMeA()', 'endfunc', 'delfunction g:DeleteMeA # comment', ]) v9.CheckScriptFailure([ 'vim9script', 'func g:DeleteMeB()', 'endfunc', 'delfunction g:DeleteMeB# comment', ], 'E488:') v9.CheckScriptSuccess([ 'vim9script', 'call execute("ls") # comment', ]) v9.CheckScriptFailure([ 'vim9script', 'call execute("ls")# comment', ], 'E488:') v9.CheckScriptFailure([ 'def Test() " comment', 'enddef', ], 'E488:') v9.CheckScriptFailure([ 'vim9script', 'def Test() " comment', 'enddef', ], 'E488:') v9.CheckScriptSuccess([ 'func Test() " comment', 'endfunc', 'delfunc Test', ]) v9.CheckScriptSuccess([ 'vim9script', 'func Test() " comment', 'endfunc', ]) v9.CheckScriptSuccess([ 'def Test() # comment', 'enddef', ]) v9.CheckScriptFailure([ 'func Test() # comment', 'endfunc', ], 'E488:') var lines =<< trim END vim9script syn region Text \ start='foo' #\ comment \ end='bar' syn region Text start='foo' #\ comment \ end='bar' END v9.CheckScriptSuccess(lines) lines =<< trim END vim9script syn region Text \ start='foo' "\ comment \ end='bar' END v9.CheckScriptFailure(lines, 'E399:') enddef def Test_vim9_comment_gui() CheckCanRunGui v9.CheckScriptFailure([ 'vim9script', 'gui#comment' ], 'E1144:') v9.CheckScriptFailure([ 'vim9script', 'gui -f#comment' ], 'E194:') enddef def Test_vim9_comment_not_compiled() au TabEnter *.vim g:entered = 1 au TabEnter *.x g:entered = 2 edit test.vim doautocmd TabEnter #comment assert_equal(1, g:entered) doautocmd TabEnter f.x assert_equal(2, g:entered) g:entered = 0 doautocmd TabEnter f.x #comment assert_equal(2, g:entered) assert_fails('doautocmd Syntax#comment', 'E216:') au! TabEnter unlet g:entered v9.CheckScriptSuccess([ 'vim9script', 'g:var = 123', 'b:var = 456', 'w:var = 777', 't:var = 888', 'unlet g:var w:var # something', ]) v9.CheckScriptFailure([ 'vim9script', 'let var = 123', ], 'E1126: Cannot use :let in Vim9 script') v9.CheckScriptFailure([ 'vim9script', 'var g:var = 123', ], 'E1016: Cannot declare a global variable:') v9.CheckScriptFailure([ 'vim9script', 'var b:var = 123', ], 'E1016: Cannot declare a buffer variable:') v9.CheckScriptFailure([ 'vim9script', 'var w:var = 123', ], 'E1016: Cannot declare a window variable:') v9.CheckScriptFailure([ 'vim9script', 'var t:var = 123', ], 'E1016: Cannot declare a tab variable:') v9.CheckScriptFailure([ 'vim9script', 'var v:version = 123', ], 'E1016: Cannot declare a v: variable:') v9.CheckScriptFailure([ 'vim9script', 'var $VARIABLE = "text"', ], 'E1016: Cannot declare an environment variable:') v9.CheckScriptFailure([ 'vim9script', 'g:var = 123', 'unlet g:var# comment1', ], 'E108:') v9.CheckScriptFailure([ 'let g:var = 123', 'unlet g:var # something', ], 'E488:') v9.CheckScriptSuccess([ 'vim9script', 'if 1 # comment2', ' echo "yes"', 'elseif 2 #comment', ' echo "no"', 'endif', ]) v9.CheckScriptFailure([ 'vim9script', 'if 1# comment3', ' echo "yes"', 'endif', ], 'E488:') v9.CheckScriptFailure([ 'vim9script', 'if 0 # comment4', ' echo "yes"', 'elseif 2#comment', ' echo "no"', 'endif', ], 'E488:') v9.CheckScriptSuccess([ 'vim9script', 'var v = 1 # comment5', ]) v9.CheckScriptFailure([ 'vim9script', 'var v = 1# comment6', ], 'E488:') v9.CheckScriptSuccess([ 'vim9script', 'new' 'setline(1, ["# define pat", "last"])', ':$', 'dsearch /pat/ #comment', 'bwipe!', ]) v9.CheckScriptFailure([ 'vim9script', 'new' 'setline(1, ["# define pat", "last"])', ':$', 'dsearch /pat/#comment', 'bwipe!', ], 'E488:') v9.CheckScriptFailure([ 'vim9script', 'func! SomeFunc()', ], 'E477:') enddef def Test_finish() var lines =<< trim END vim9script g:res = 'one' if v:false | finish | endif g:res = 'two' finish g:res = 'three' END writefile(lines, 'Xfinished') source Xfinished assert_equal('two', g:res) unlet g:res delete('Xfinished') enddef def Test_forward_declaration() var lines =<< trim END vim9script def GetValue(): string return theVal enddef var theVal = 'something' g:initVal = GetValue() theVal = 'else' g:laterVal = GetValue() END writefile(lines, 'Xforward') source Xforward assert_equal('something', g:initVal) assert_equal('else', g:laterVal) unlet g:initVal unlet g:laterVal delete('Xforward') enddef def Test_declare_script_var_in_func() var lines =<< trim END vim9script func Declare() let s:local = 123 endfunc Declare() END v9.CheckScriptFailure(lines, 'E1269:') enddef def Test_lock_script_var() var lines =<< trim END vim9script var local = 123 assert_equal(123, local) var error: string try local = 'asdf' catch error = v:exception endtry assert_match('E1012: Type mismatch; expected number but got string', error) lockvar local try local = 999 catch error = v:exception endtry assert_match('E741: Value is locked: local', error) END v9.CheckScriptSuccess(lines) enddef func Test_vim9script_not_global() " check that items defined in Vim9 script are script-local, not global let vim9lines =<< trim END vim9script var name = 'local' func TheFunc() echo 'local' endfunc def DefFunc() echo 'local' enddef END call writefile(vim9lines, 'Xvim9script.vim') source Xvim9script.vim try echo g:var assert_report('did not fail') catch /E121:/ " caught endtry try call TheFunc() assert_report('did not fail') catch /E117:/ " caught endtry try call DefFunc() assert_report('did not fail') catch /E117:/ " caught endtry call delete('Xvim9script.vim') endfunc def Test_vim9_copen() # this was giving an error for setting w:quickfix_title copen quit enddef def Test_script_var_in_autocmd() # using a script variable from an autocommand, defined in a :def function in a # legacy Vim script, cannot check the variable type. var lines =<< trim END let s:counter = 1 def s:Func() au! CursorHold au CursorHold * s:counter += 1 enddef call s:Func() doau CursorHold call assert_equal(2, s:counter) au! CursorHold END v9.CheckScriptSuccess(lines) enddef def Test_error_in_autoload_script() var save_rtp = &rtp var dir = getcwd() .. '/Xruntime' &rtp = dir mkdir(dir .. '/autoload', 'p') var lines =<< trim END vim9script noclear export def Autoloaded() enddef def Broken() var x: any = '' eval x != 0 enddef Broken() END writefile(lines, dir .. '/autoload/script.vim') lines =<< trim END vim9script def CallAutoloaded() script#Autoloaded() enddef function Legacy() try call s:CallAutoloaded() catch call assert_match('E1030: Using a String as a Number', v:exception) endtry endfunction Legacy() END v9.CheckScriptSuccess(lines) &rtp = save_rtp delete(dir, 'rf') enddef def Test_invalid_sid() assert_fails('func 1234_func', 'E123:') if g:RunVim([], ['wq! Xdidit'], '+"func 1_func"') assert_equal([], readfile('Xdidit')) endif delete('Xdidit') enddef def Test_restoring_cpo() writefile(['vim9script', 'set nocp'], 'Xsourced') writefile(['call writefile(["done"], "Xdone")', 'quit!'], 'Xclose') if g:RunVim([], [], '-u NONE +"set cpo+=a" -S Xsourced -S Xclose') assert_equal(['done'], readfile('Xdone')) endif delete('Xsourced') delete('Xclose') delete('Xdone') writefile(['vim9script', 'g:cpoval = &cpo'], 'XanotherScript') set cpo=aABceFsMny> edit XanotherScript so % assert_equal('aABceFsMny>', &cpo) assert_equal('aABceFs', g:cpoval) :1del setline(1, 'let g:cpoval = &cpo') w so % assert_equal('aABceFsMny>', &cpo) assert_equal('aABceFsMny>', g:cpoval) delete('XanotherScript') set cpo&vim unlet g:cpoval if has('unix') # 'cpo' is not restored in main vimrc var save_HOME = $HOME $HOME = getcwd() .. '/Xhome' mkdir('Xhome') var lines =<< trim END vim9script writefile(['before: ' .. &cpo], 'Xresult') set cpo+=M writefile(['after: ' .. &cpo], 'Xresult', 'a') END writefile(lines, 'Xhome/.vimrc') lines =<< trim END call writefile(['later: ' .. &cpo], 'Xresult', 'a') END writefile(lines, 'Xlegacy') lines =<< trim END vim9script call writefile(['vim9: ' .. &cpo], 'Xresult', 'a') qa END writefile(lines, 'Xvim9') var cmd = g:GetVimCommand() .. " -S Xlegacy -S Xvim9" cmd = substitute(cmd, '-u NONE', '', '') exe "silent !" .. cmd assert_equal([ 'before: aABceFs', 'after: aABceFsM', 'later: aABceFsM', 'vim9: aABceFs'], readfile('Xresult')) $HOME = save_HOME delete('Xhome', 'rf') delete('Xlegacy') delete('Xvim9') delete('Xresult') endif enddef " Use :function so we can use Check commands func Test_no_redraw_when_restoring_cpo() CheckScreendump CheckFeature timers call Run_test_no_redraw_when_restoring_cpo() endfunc def Run_test_no_redraw_when_restoring_cpo() var lines =<< trim END vim9script export def Func() enddef END mkdir('Xdir/autoload', 'p') writefile(lines, 'Xdir/autoload/script.vim') lines =<< trim END vim9script set cpo+=M exe 'set rtp^=' .. getcwd() .. '/Xdir' au CmdlineEnter : ++once timer_start(0, (_) => script#Func()) setline(1, 'some text') END writefile(lines, 'XTest_redraw_cpo') var buf = g:RunVimInTerminal('-S XTest_redraw_cpo', {'rows': 6}) term_sendkeys(buf, "V:") g:VerifyScreenDump(buf, 'Test_vim9_no_redraw', {}) # clean up term_sendkeys(buf, "\u") g:StopVimInTerminal(buf) delete('XTest_redraw_cpo') delete('Xdir', 'rf') enddef func Test_reject_declaration() CheckScreendump call Run_test_reject_declaration() endfunc def Run_test_reject_declaration() var buf = g:RunVimInTerminal('', {'rows': 6}) term_sendkeys(buf, ":vim9cmd var x: number\") g:VerifyScreenDump(buf, 'Test_vim9_reject_declaration_1', {}) term_sendkeys(buf, ":\") term_sendkeys(buf, ":vim9cmd g:foo = 123 | echo g:foo\") g:VerifyScreenDump(buf, 'Test_vim9_reject_declaration_2', {}) # clean up g:StopVimInTerminal(buf) enddef def Test_minimal_command_name_length() var names = [ 'cons', 'brea', 'cat', 'catc', 'con', 'cont', 'conti', 'contin', 'continu', 'el', 'els', 'elsei', 'endfo', 'en', 'end', 'endi', 'endw', 'endt', 'endtr', 'exp', 'expo', 'expor', 'fina', 'finall', 'fini', 'finis', 'imp', 'impo', 'impor', 'retu', 'retur', 'th', 'thr', 'thro', 'wh', 'whi', 'whil', ] for name in names v9.CheckDefAndScriptFailure([name .. ' '], 'E1065:') endfor var lines =<< trim END vim9script def SomeFunc() endd END v9.CheckScriptFailure(lines, 'E1065:') lines =<< trim END vim9script def SomeFunc() endde END v9.CheckScriptFailure(lines, 'E1065:') enddef def Test_unset_any_variable() var lines =<< trim END var name: any assert_equal(0, name) END v9.CheckDefAndScriptSuccess(lines) enddef func Test_define_func_at_command_line() CheckRunVimInTerminal " call indirectly to avoid compilation error for missing functions call Run_Test_define_func_at_command_line() endfunc def Run_Test_define_func_at_command_line() # run in a separate Vim instance to avoid the script context var lines =<< trim END func CheckAndQuit() call assert_fails('call Afunc()', 'E117: Unknown function: Bfunc') call writefile(['errors: ' .. string(v:errors)], 'Xdidcmd') endfunc END writefile([''], 'Xdidcmd') writefile(lines, 'XcallFunc') var buf = g:RunVimInTerminal('-S XcallFunc', {rows: 6}) # define Afunc() on the command line term_sendkeys(buf, ":def Afunc()\Bfunc()\enddef\") term_sendkeys(buf, ":call CheckAndQuit()\") g:WaitForAssert(() => assert_equal(['errors: []'], readfile('Xdidcmd'))) call g:StopVimInTerminal(buf) delete('XcallFunc') delete('Xdidcmd') enddef def Test_script_var_scope() var lines =<< trim END vim9script if true if true var one = 'one' echo one endif echo one endif END v9.CheckScriptFailure(lines, 'E121:', 7) lines =<< trim END vim9script if true if false var one = 'one' echo one else var one = 'one' echo one endif echo one endif END v9.CheckScriptFailure(lines, 'E121:', 10) lines =<< trim END vim9script while true var one = 'one' echo one break endwhile echo one END v9.CheckScriptFailure(lines, 'E121:', 7) lines =<< trim END vim9script for i in range(1) var one = 'one' echo one endfor echo one END v9.CheckScriptFailure(lines, 'E121:', 6) lines =<< trim END vim9script { var one = 'one' assert_equal('one', one) } assert_false(exists('one')) assert_false(exists('s:one')) END v9.CheckScriptSuccess(lines) lines =<< trim END vim9script { var one = 'one' echo one } echo one END v9.CheckScriptFailure(lines, 'E121:', 6) enddef def Test_catch_exception_in_callback() var lines =<< trim END vim9script def Callback(...l: list) try var x: string var y: string # this error should be caught with CHECKLEN var sl = [''] [x, y] = sl catch g:caught = 'yes' endtry enddef popup_menu('popup', {callback: Callback}) feedkeys("\r", 'xt') END v9.CheckScriptSuccess(lines) unlet g:caught enddef def Test_no_unknown_error_after_error() if !has('unix') || !has('job') throw 'Skipped: not unix of missing +job feature' endif # FIXME: this check should not be needed if has('win32') throw 'Skipped: does not work on MS-Windows' endif var lines =<< trim END vim9script var source: list def Out_cb(...l: list) eval [][0] enddef def Exit_cb(...l: list) sleep 1m g:did_call_exit_cb = true source += l enddef var myjob = job_start('echo burp', {out_cb: Out_cb, exit_cb: Exit_cb, mode: 'raw'}) while job_status(myjob) == 'run' sleep 10m endwhile # wait for Exit_cb() to be called for x in range(100) if exists('g:did_call_exit_cb') unlet g:did_call_exit_cb break endif sleep 10m endfor END writefile(lines, 'Xdef') assert_fails('so Xdef', ['E684:', 'E1012:']) delete('Xdef') enddef def InvokeNormal() exe "norm! :m+1\r" enddef def Test_invoke_normal_in_visual_mode() xnoremap call InvokeNormal() new setline(1, ['aaa', 'bbb']) feedkeys("V\", 'xt') assert_equal(['bbb', 'aaa'], getline(1, 2)) xunmap enddef def Test_white_space_after_command() var lines =<< trim END exit_cb: Func}) END v9.CheckDefAndScriptFailure(lines, 'E1144:', 1) lines =<< trim END e# END v9.CheckDefAndScriptFailure(lines, 'E1144:', 1) enddef def Test_script_var_gone_when_sourced_twice() var lines =<< trim END vim9script if exists('g:guard') finish endif g:guard = 1 var name = 'thename' def g:GetName(): string return name enddef def g:SetName(arg: string) name = arg enddef END writefile(lines, 'XscriptTwice.vim') so XscriptTwice.vim assert_equal('thename', g:GetName()) g:SetName('newname') assert_equal('newname', g:GetName()) so XscriptTwice.vim assert_fails('call g:GetName()', 'E1149:') assert_fails('call g:SetName("x")', 'E1149:') delfunc g:GetName delfunc g:SetName delete('XscriptTwice.vim') unlet g:guard enddef def Test_unsupported_commands() var lines =<< trim END ka END v9.CheckDefAndScriptFailure(lines, ['E476:', 'E492:']) lines =<< trim END :1ka END v9.CheckDefAndScriptFailure(lines, ['E476:', 'E492:']) lines =<< trim END :k a END v9.CheckDefAndScriptFailure(lines, 'E1100:') lines =<< trim END :1k a END v9.CheckDefAndScriptFailure(lines, 'E481:') lines =<< trim END t END v9.CheckDefAndScriptFailure(lines, 'E1100:') lines =<< trim END x END v9.CheckDefAndScriptFailure(lines, 'E1100:') lines =<< trim END xit END v9.CheckDefAndScriptFailure(lines, 'E1100:') lines =<< trim END Print END v9.CheckDefAndScriptFailure(lines, ['E476: Invalid command: Print', 'E492: Not an editor command: Print']) lines =<< trim END mode 4 END v9.CheckDefAndScriptFailure(lines, ['E476: Invalid command: mode 4', 'E492: Not an editor command: mode 4']) enddef def Test_mapping_line_number() var lines =<< trim END vim9script def g:FuncA() # Some comment FuncB(0) enddef # Some comment def FuncB( # Some comment n: number ) exe 'nno ' # Some comment .. ' a' .. 'b' .. 'c' enddef END v9.CheckScriptSuccess(lines) var res = execute('verbose nmap ') assert_match('No mapping found', res) g:FuncA() res = execute('verbose nmap ') assert_match(' .* abc.*Last set from .*XScriptSuccess\d\+ line 11', res) nunmap delfunc g:FuncA enddef def Test_option_set() # legacy script allows for white space var lines =<< trim END set foldlevel =11 call assert_equal(11, &foldlevel) END v9.CheckScriptSuccess(lines) set foldlevel set foldlevel=12 assert_equal(12, &foldlevel) set foldlevel+=2 assert_equal(14, &foldlevel) set foldlevel-=3 assert_equal(11, &foldlevel) lines =<< trim END set foldlevel =1 END v9.CheckDefExecAndScriptFailure(lines, 'E1205: No white space allowed between option and: =1') lines =<< trim END set foldlevel +=1 END v9.CheckDefExecAndScriptFailure(lines, 'E1205: No white space allowed between option and: +=1') lines =<< trim END set foldlevel ^=1 END v9.CheckDefExecAndScriptFailure(lines, 'E1205: No white space allowed between option and: ^=1') lines =<< trim END set foldlevel -=1 END v9.CheckDefExecAndScriptFailure(lines, 'E1205: No white space allowed between option and: -=1') set foldlevel& enddef def Test_option_modifier() # legacy script allows for white space var lines =<< trim END set hlsearch & hlsearch ! call assert_equal(1, &hlsearch) END v9.CheckScriptSuccess(lines) set hlsearch set hlsearch! assert_equal(false, &hlsearch) set hlsearch set hlsearch& assert_equal(false, &hlsearch) lines =<< trim END set hlsearch & END v9.CheckDefExecAndScriptFailure(lines, 'E1205: No white space allowed between option and: &') lines =<< trim END set hlsearch ! END v9.CheckDefExecAndScriptFailure(lines, 'E1205: No white space allowed between option and: !') set hlsearch& enddef " This must be called last, it may cause following :def functions to fail def Test_xxx_echoerr_line_number() var lines =<< trim END echoerr 'some' .. ' error' .. ' continued' END v9.CheckDefExecAndScriptFailure(lines, 'some error continued', 1) enddef func Test_debug_with_lambda() CheckRunVimInTerminal " call indirectly to avoid compilation error for missing functions call Run_Test_debug_with_lambda() endfunc def Run_Test_debug_with_lambda() var lines =<< trim END vim9script def Func() var n = 0 echo [0]->filter((_, v) => v == n) enddef breakadd func Func Func() END writefile(lines, 'XdebugFunc') var buf = g:RunVimInTerminal('-S XdebugFunc', {rows: 6, wait_for_ruler: 0}) g:WaitForAssert(() => assert_match('^>', term_getline(buf, 6))) term_sendkeys(buf, "cont\") g:WaitForAssert(() => assert_match('\[0\]', term_getline(buf, 5))) g:StopVimInTerminal(buf) delete('XdebugFunc') enddef func Test_debug_running_out_of_lines() CheckRunVimInTerminal " call indirectly to avoid compilation error for missing functions call Run_Test_debug_running_out_of_lines() endfunc def Run_Test_debug_running_out_of_lines() var lines =<< trim END vim9script def Crash() # # # # # # # if true # endif enddef breakadd func Crash Crash() END writefile(lines, 'XdebugFunc') var buf = g:RunVimInTerminal('-S XdebugFunc', {rows: 6, wait_for_ruler: 0}) g:WaitForAssert(() => assert_match('^>', term_getline(buf, 6))) term_sendkeys(buf, "next\") g:TermWait(buf) g:WaitForAssert(() => assert_match('^>', term_getline(buf, 6))) term_sendkeys(buf, "cont\") g:TermWait(buf) g:StopVimInTerminal(buf) delete('XdebugFunc') enddef def Test_ambigous_command_error() var lines =<< trim END vim9script command CmdA echomsg 'CmdA' command CmdB echomsg 'CmdB' Cmd END v9.CheckScriptFailure(lines, 'E464: Ambiguous use of user-defined command: Cmd', 4) lines =<< trim END vim9script def Func() Cmd enddef Func() END v9.CheckScriptFailure(lines, 'E464: Ambiguous use of user-defined command: Cmd', 1) lines =<< trim END vim9script nnoremap Cmd feedkeys("\", 'xt') END v9.CheckScriptFailure(lines, 'E464: Ambiguous use of user-defined command: Cmd', 3) delcommand CmdA delcommand CmdB nunmap enddef " Execute this near the end, profiling doesn't stop until Vim exits. " This only tests that it works, not the profiling output. def Test_profile_with_lambda() CheckFeature profile var lines =<< trim END vim9script def ProfiledWithLambda() var n = 3 echo [[1, 2], [3, 4]]->filter((_, l) => l[0] == n) enddef def ProfiledNested() var x = 0 def Nested(): any return x enddef Nested() enddef def g:ProfiledNestedProfiled() var x = 0 def Nested(): any return x enddef Nested() enddef def Profile() ProfiledWithLambda() ProfiledNested() # Also profile the nested function. Use a different function, although # the contents is the same, to make sure it was not already compiled. profile func * g:ProfiledNestedProfiled() profdel func * profile pause enddef var result = 'done' try # mark functions for profiling now to avoid E1271 profile start Xprofile.log profile func ProfiledWithLambda profile func ProfiledNested Profile() catch result = 'failed: ' .. v:exception finally writefile([result], 'Xdidprofile') endtry END writefile(lines, 'Xprofile.vim') call system(g:GetVimCommand() .. ' --clean' .. ' -c "so Xprofile.vim"' .. ' -c "qall!"') call assert_equal(0, v:shell_error) assert_equal(['done'], readfile('Xdidprofile')) assert_true(filereadable('Xprofile.log')) delete('Xdidprofile') delete('Xprofile.log') delete('Xprofile.vim') enddef func Test_misplaced_type() CheckRunVimInTerminal call Run_Test_misplaced_type() endfunc def Run_Test_misplaced_type() writefile(['let g:somevar = "asdf"'], 'XTest_misplaced_type') var buf = g:RunVimInTerminal('-S XTest_misplaced_type', {'rows': 6}) term_sendkeys(buf, ":vim9cmd echo islocked('g:somevar: string')\") g:VerifyScreenDump(buf, 'Test_misplaced_type', {}) g:StopVimInTerminal(buf) delete('XTest_misplaced_type') enddef " Ensure echo doesn't crash when stringifying empty variables. def Test_echo_uninit_variables() var res: string var var_bool: bool var var_num: number var var_float: float var Var_func: func var var_string: string var var_blob: blob var var_list: list var var_dict: dict redir => res echo var_bool echo var_num echo var_float echo Var_func echo var_string echo var_blob echo var_list echo var_dict redir END assert_equal(['false', '0', '0.0', 'function()', '', '0z', '[]', '{}'], res->split('\n')) if has('job') var var_job: job var var_channel: channel redir => res echo var_job echo var_channel redir END assert_equal(['no process', 'channel fail'], res->split('\n')) endif enddef " Keep this last, it messes up highlighting. def Test_substitute_cmd() new setline(1, 'something') :substitute(some(other( assert_equal('otherthing', getline(1)) bwipe! # also when the context is Vim9 script var lines =<< trim END vim9script new setline(1, 'something') :substitute(some(other( assert_equal('otherthing', getline(1)) bwipe! END writefile(lines, 'Xvim9lines') source Xvim9lines delete('Xvim9lines') enddef " vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker