aniani/vim
0
0
Fork 1
mirror of https://github.com/vim/vim.git synced 2025-07-24 10:45:12 -04:00
Code
vim/src/testdir/test_vim9_script.vim
Bram Moolenaar ffb7dcdb77 patch 8.2.2582: Vim9: screendump test fails on MS-Windows 
Problem:    Vim9: screendump test fails on MS-Windows.
Solution:   Use :function instead of :def.
2021-03-10 14:00:18 +01:00

3669 lines
79 KiB
VimL
Raw Blame History

" Test various aspects of the Vim9 script language.
source check.vim
source term_util.vim
source view_util.vim
source vim9.vim
source shared.vim
source screendump.vim
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', Screenline(&lines))
:3
list
assert_equal('three$', Screenline(&lines))
# missing command does not print the line
var lines =<< trim END
vim9script
:1|
assert_equal('three$', Screenline(&lines))
:|
assert_equal('three$', Screenline(&lines))
END
CheckScriptSuccess(lines)
bwipe!
# won't generate anything
if false
:123
endif
enddef
let g:alist = [7]
let g:astring = 'text'
let g:anumber = 123
def Test_delfunction()
# Check function is defined in script namespace
CheckScriptSuccess([
'vim9script',
'func CheckMe()',
' return 123',
'endfunc',
'assert_equal(123, s:CheckMe())',
])
# Check function in script namespace cannot be deleted
CheckScriptFailure([
'vim9script',
'func DeleteMe1()',
'endfunc',
'delfunction DeleteMe1',
], 'E1084:')
CheckScriptFailure([
'vim9script',
'func DeleteMe2()',
'endfunc',
'def DoThat()',
' delfunction DeleteMe2',
'enddef',
'DoThat()',
], 'E1084:')
CheckScriptFailure([
'vim9script',
'def DeleteMe3()',
'enddef',
'delfunction DeleteMe3',
], 'E1084:')
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
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
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
CheckScriptSuccess(lines)
enddef
def Test_wrong_type()
CheckDefFailure(['var name: list<nothing>'], 'E1010:')
CheckDefFailure(['var name: list<list<nothing>>'], 'E1010:')
CheckDefFailure(['var name: dict<nothing>'], 'E1010:')
CheckDefFailure(['var name: dict<dict<nothing>>'], 'E1010:')
CheckDefFailure(['var name: dict<number'], 'E1009:')
CheckDefFailure(['var name: dict<list<number>'], 'E1009:')
CheckDefFailure(['var name: ally'], 'E1010:')
CheckDefFailure(['var name: bram'], 'E1010:')
CheckDefFailure(['var name: cathy'], 'E1010:')
CheckDefFailure(['var name: dom'], 'E1010:')
CheckDefFailure(['var name: freddy'], 'E1010:')
CheckDefFailure(['var name: john'], 'E1010:')
CheckDefFailure(['var name: larry'], 'E1010:')
CheckDefFailure(['var name: ned'], 'E1010:')
CheckDefFailure(['var name: pam'], 'E1010:')
CheckDefFailure(['var name: sam'], 'E1010:')
CheckDefFailure(['var name: vim'], 'E1010:')
CheckDefFailure(['var Ref: number', 'Ref()'], 'E1085:')
CheckDefFailure(['var Ref: string', 'var res = Ref()'], 'E1085:')
enddef
def Test_script_wrong_type()
var lines =<< trim END
vim9script
var s:dict: dict<string>
s:dict['a'] = ['x']
END
CheckScriptFailure(lines, 'E1012: Type mismatch; expected string but got list<string>', 3)
enddef
def Test_const()
CheckDefFailure(['final name = 234', 'name = 99'], 'E1018:')
CheckDefFailure(['final one = 234', 'var one = 99'], 'E1017:')
CheckDefFailure(['final list = [1, 2]', 'var list = [3, 4]'], 'E1017:')
CheckDefFailure(['final two'], 'E1125:')
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
# TODO: does not work yet
# 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
# TODO: does not work yet
# constdict['two']['six'] = 66
var cd = constdict['two']
cd['six'] = 66
constdict->assert_equal({one: 1, two: {five: 55, six: 66}, three: 3})
END
CheckDefAndScriptSuccess(lines)
enddef
def Test_const_bang()
var lines =<< trim END
const var = 234
var = 99
END
CheckDefExecFailure(lines, 'E1018:', 2)
CheckScriptFailure(['vim9script'] + lines, 'E46:', 3)
lines =<< trim END
const ll = [2, 3, 4]
ll[0] = 99
END
CheckDefExecFailure(lines, 'E1119:', 2)
CheckScriptFailure(['vim9script'] + lines, 'E741:', 3)
lines =<< trim END
const ll = [2, 3, 4]
ll[3] = 99
END
CheckDefExecFailure(lines, 'E1118:', 2)
CheckScriptFailure(['vim9script'] + lines, 'E684:', 3)
lines =<< trim END
const dd = {one: 1, two: 2}
dd["one"] = 99
END
CheckDefExecFailure(lines, 'E1121:', 2)
CheckScriptFailure(['vim9script'] + lines, 'E741:', 3)
lines =<< trim END
const dd = {one: 1, two: 2}
dd["three"] = 99
END
CheckDefExecFailure(lines, 'E1120:')
CheckScriptFailure(['vim9script'] + lines, 'E741:', 3)
enddef
def Test_range_no_colon()
CheckDefFailure(['%s/a/b/'], 'E1050:')
CheckDefFailure(['+ s/a/b/'], 'E1050:')
CheckDefFailure(['- s/a/b/'], 'E1050:')
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()
CheckDefFailure(['{', 'var inner = 1', '}', 'echo inner'], 'E1001:')
CheckDefFailure(['}'], 'E1025:')
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<string>
return text
enddef
def SetText(v: string)
text = [v]
enddef
endif
if true
var text = ['again']
def SayAgain(): list<string>
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')
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<string>
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
CheckScriptSuccess(lines)
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')
fina
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 /E39:/
n = 233
endtry
assert_equal(233, n)
try
n = +g:astring
catch /E1030:/
n = 244
endtry
assert_equal(244, n)
try
n = +g:alist
catch /E745:/
n = 255
endtry
assert_equal(255, n)
var nd: dict<any>
try
nd = {[g:alist]: 1}
catch /E1105:/
n = 266
endtry
assert_equal(266, n)
try
[n] = [1, 2, 3]
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 = DeletedFunc()
catch /E933:/
n = 344
endtry
assert_equal(344, n)
try
echo len(v:true)
catch /E701:/
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)
# return in finally after empty catch
def ReturnInFinally(): number
try
finally
return 4
endtry
return 2
enddef
assert_equal(4, ReturnInFinally())
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 0
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')
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<any>
return ['delete me']
enddef
defcompile
delfunc DeletedFunc
def ThrowFromDef()
throw "getout" # comment
enddef
func CatchInFunc()
try
call ThrowFromDef()
catch
let g:thrown_func = v:exception
endtry
endfunc
def CatchInDef()
try
ThrowFromDef()
catch
g:thrown_def = v:exception
endtry
enddef
def ReturnFinally(): string
try
return 'intry'
finall
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)
enddef
def TryOne(): number
try
return 0
catch
endtry
return 0
enddef
def 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()
CheckDefFailure(['catch'], 'E603:')
CheckDefFailure(['try', 'echo 0', 'catch', 'catch'], 'E1033:')
CheckDefFailure(['try', 'echo 0', 'catch /pat'], 'E1067:')
CheckDefFailure(['finally'], 'E606:')
CheckDefFailure(['try', 'echo 0', 'finally', 'echo 1', 'finally'], 'E607:')
CheckDefFailure(['endtry'], 'E602:')
CheckDefFailure(['while 1', 'endtry'], 'E170:')
CheckDefFailure(['for i in range(5)', 'endtry'], 'E170:')
CheckDefFailure(['if 1', 'endtry'], 'E171:')
CheckDefFailure(['try', 'echo 1', 'endtry'], 'E1032:')
CheckDefFailure(['throw'], 'E1143:')
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_vimscript()
# only checks line continuation
var lines =<< trim END
vim9script
try
throw 'one'
.. 'two'
catch
assert_equal('onetwo', v:exception)
endtry
END
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
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
CheckScriptFailure(lines, 'E684:')
assert_equal(0, g:test_var)
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
CheckScriptSuccess(lines)
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
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
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
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
let s:export_script_lines =<< trim END
vim9script
var name: string = 'bob'
def Concat(arg: string): string
return name .. arg
enddef
g:result = Concat('bie')
g:localname = name
export const CONST = 1234
export var exported = 9876
export var exp_name = 'John'
export def Exported(): string
return 'Exported'
enddef
export final theList = [1]
END
def Undo_export_script_lines()
unlet g:result
unlet g:localname
enddef
def Test_vim9_import_export()
var import_script_lines =<< trim END
vim9script
import {exported, Exported} from './Xexport.vim'
g:imported = exported
exported += 3
g:imported_added = exported
g:imported_func = Exported()
def GetExported(): string
var local_dict = {ref: Exported}
return local_dict.ref()
enddef
g:funcref_result = GetExported()
import {exp_name} from './Xexport.vim'
g:imported_name = exp_name
exp_name ..= ' Doe'
g:imported_name_appended = exp_name
g:imported_later = exported
import theList from './Xexport.vim'
theList->add(2)
assert_equal([1, 2], theList)
END
writefile(import_script_lines, 'Ximport.vim')
writefile(s:export_script_lines, 'Xexport.vim')
source Ximport.vim
assert_equal('bobbie', g:result)
assert_equal('bob', g:localname)
assert_equal(9876, g:imported)
assert_equal(9879, g:imported_added)
assert_equal(9879, g:imported_later)
assert_equal('Exported', g:imported_func)
assert_equal('Exported', g:funcref_result)
assert_equal('John', g:imported_name)
assert_equal('John Doe', g:imported_name_appended)
assert_false(exists('g:name'))
Undo_export_script_lines()
unlet g:imported
unlet g:imported_added
unlet g:imported_later
unlet g:imported_func
unlet g:imported_name g:imported_name_appended
delete('Ximport.vim')
# similar, with line breaks
var import_line_break_script_lines =<< trim END
vim9script
import {
exported,
Exported,
}
from
'./Xexport.vim'
g:imported = exported
exported += 5
g:imported_added = exported
g:imported_func = Exported()
END
writefile(import_line_break_script_lines, 'Ximport_lbr.vim')
source Ximport_lbr.vim
assert_equal(9876, g:imported)
assert_equal(9881, g:imported_added)
assert_equal('Exported', g:imported_func)
# exported script not sourced again
assert_false(exists('g:result'))
unlet g:imported
unlet g:imported_added
unlet g:imported_func
delete('Ximport_lbr.vim')
# import inside :def function
var import_in_def_lines =<< trim END
vim9script
def ImportInDef()
import exported from './Xexport.vim'
g:imported = exported
exported += 7
g:imported_added = exported
enddef
ImportInDef()
END
writefile(import_in_def_lines, 'Ximport2.vim')
source Ximport2.vim
# TODO: this should be 9879
assert_equal(9876, g:imported)
assert_equal(9883, g:imported_added)
unlet g:imported
unlet g:imported_added
delete('Ximport2.vim')
var import_star_as_lines =<< trim END
vim9script
import * as Export from './Xexport.vim'
def UseExport()
g:imported = Export.exported
enddef
UseExport()
END
writefile(import_star_as_lines, 'Ximport.vim')
source Ximport.vim
assert_equal(9883, g:imported)
var import_star_as_lines_no_dot =<< trim END
vim9script
import * as Export from './Xexport.vim'
def Func()
var dummy = 1
var imported = Export + dummy
enddef
defcompile
END
writefile(import_star_as_lines_no_dot, 'Ximport.vim')
assert_fails('source Ximport.vim', 'E1060:', '', 2, 'Func')
var import_star_as_lines_dot_space =<< trim END
vim9script
import * as Export from './Xexport.vim'
def Func()
var imported = Export . exported
enddef
defcompile
END
writefile(import_star_as_lines_dot_space, 'Ximport.vim')
assert_fails('source Ximport.vim', 'E1074:', '', 1, 'Func')
var import_star_as_duplicated =<< trim END
vim9script
import * as Export from './Xexport.vim'
var some = 'other'
import * as Export from './Xexport.vim'
defcompile
END
writefile(import_star_as_duplicated, 'Ximport.vim')
assert_fails('source Ximport.vim', 'E1073:', '', 4, 'Ximport.vim')
var import_star_as_lines_missing_name =<< trim END
vim9script
import * as Export from './Xexport.vim'
def Func()
var imported = Export.
enddef
defcompile
END
writefile(import_star_as_lines_missing_name, 'Ximport.vim')
assert_fails('source Ximport.vim', 'E1048:', '', 1, 'Func')
var import_star_as_lbr_lines =<< trim END
vim9script
import *
as Export
from
'./Xexport.vim'
def UseExport()
g:imported = Export.exported
enddef
UseExport()
END
writefile(import_star_as_lbr_lines, 'Ximport.vim')
source Ximport.vim
assert_equal(9883, g:imported)
var import_star_lines =<< trim END
vim9script
import * from './Xexport.vim'
END
writefile(import_star_lines, 'Ximport.vim')
assert_fails('source Ximport.vim', 'E1045:', '', 2, 'Ximport.vim')
# try to import something that exists but is not exported
var import_not_exported_lines =<< trim END
vim9script
import name from './Xexport.vim'
END
writefile(import_not_exported_lines, 'Ximport.vim')
assert_fails('source Ximport.vim', 'E1049:', '', 2, 'Ximport.vim')
# try to import something that is already defined
var import_already_defined =<< trim END
vim9script
var exported = 'something'
import exported from './Xexport.vim'
END
writefile(import_already_defined, 'Ximport.vim')
assert_fails('source Ximport.vim', 'E1054:', '', 3, 'Ximport.vim')
# try to import something that is already defined
import_already_defined =<< trim END
vim9script
var exported = 'something'
import * as exported from './Xexport.vim'
END
writefile(import_already_defined, 'Ximport.vim')
assert_fails('source Ximport.vim', 'E1054:', '', 3, 'Ximport.vim')
# try to import something that is already defined
import_already_defined =<< trim END
vim9script
var exported = 'something'
import {exported} from './Xexport.vim'
END
writefile(import_already_defined, 'Ximport.vim')
assert_fails('source Ximport.vim', 'E1054:', '', 3, 'Ximport.vim')
# try changing an imported const
var import_assign_to_const =<< trim END
vim9script
import CONST from './Xexport.vim'
def Assign()
CONST = 987
enddef
defcompile
END
writefile(import_assign_to_const, 'Ximport.vim')
assert_fails('source Ximport.vim', 'E46:', '', 1, '_Assign')
# try changing an imported final
var import_assign_to_final =<< trim END
vim9script
import theList from './Xexport.vim'
def Assign()
theList = [2]
enddef
defcompile
END
writefile(import_assign_to_final, 'Ximport.vim')
assert_fails('source Ximport.vim', 'E46:', '', 1, '_Assign')
# import a very long name, requires making a copy
var import_long_name_lines =<< trim END
vim9script
import name012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789 from './Xexport.vim'
END
writefile(import_long_name_lines, 'Ximport.vim')
assert_fails('source Ximport.vim', 'E1048:', '', 2, 'Ximport.vim')
var import_no_from_lines =<< trim END
vim9script
import name './Xexport.vim'
END
writefile(import_no_from_lines, 'Ximport.vim')
assert_fails('source Ximport.vim', 'E1070:', '', 2, 'Ximport.vim')
var import_invalid_string_lines =<< trim END
vim9script
import name from Xexport.vim
END
writefile(import_invalid_string_lines, 'Ximport.vim')
assert_fails('source Ximport.vim', 'E1071:', '', 2, 'Ximport.vim')
var import_wrong_name_lines =<< trim END
vim9script
import name from './XnoExport.vim'
END
writefile(import_wrong_name_lines, 'Ximport.vim')
assert_fails('source Ximport.vim', 'E1053:', '', 2, 'Ximport.vim')
var import_missing_comma_lines =<< trim END
vim9script
import {exported name} from './Xexport.vim'
END
writefile(import_missing_comma_lines, 'Ximport3.vim')
assert_fails('source Ximport3.vim', 'E1046:', '', 2, 'Ximport3.vim')
delete('Ximport.vim')
delete('Ximport3.vim')
delete('Xexport.vim')
# Check that in a Vim9 script 'cpo' is set to the Vim default.
set cpo&vi
var cpo_before = &cpo
var lines =<< trim END
vim9script
g:cpo_in_vim9script = &cpo
END
writefile(lines, 'Xvim9_script')
source Xvim9_script
assert_equal(cpo_before, &cpo)
set cpo&vim
assert_equal(&cpo, g:cpo_in_vim9script)
delete('Xvim9_script')
enddef
def Test_import_as()
var export_lines =<< trim END
vim9script
export var one = 1
export var yes = 'yes'
END
writefile(export_lines, 'XexportAs')
var import_lines =<< trim END
vim9script
import one as thatOne from './XexportAs'
assert_equal(1, thatOne)
import yes as yesYes from './XexportAs'
assert_equal('yes', yesYes)
END
CheckScriptSuccess(import_lines)
import_lines =<< trim END
vim9script
import {one as thatOne, yes as yesYes} from './XexportAs'
assert_equal(1, thatOne)
assert_equal('yes', yesYes)
assert_fails('echo one', 'E121:')
assert_fails('echo yes', 'E121:')
END
CheckScriptSuccess(import_lines)
delete('XexportAs')
enddef
func g:Trigger()
source Ximport.vim
return "echo 'yes'\<CR>"
endfunc
def Test_import_export_expr_map()
# check that :import and :export work when buffer is locked
var export_lines =<< trim END
vim9script
export def That(): string
return 'yes'
enddef
END
writefile(export_lines, 'Xexport_that.vim')
var import_lines =<< trim END
vim9script
import That from './Xexport_that.vim'
assert_equal('yes', That())
END
writefile(import_lines, 'Ximport.vim')
nnoremap <expr> trigger g:Trigger()
feedkeys('trigger', "xt")
delete('Xexport_that.vim')
delete('Ximport.vim')
nunmap trigger
enddef
def Test_import_in_filetype()
# check that :import works when the buffer is locked
mkdir('ftplugin', 'p')
var export_lines =<< trim END
vim9script
export var That = 'yes'
END
writefile(export_lines, 'ftplugin/Xexport_ft.vim')
var import_lines =<< trim END
vim9script
import That from './Xexport_ft.vim'
assert_equal('yes', That)
g:did_load_mytpe = 1
END
writefile(import_lines, 'ftplugin/qf.vim')
var save_rtp = &rtp
&rtp = getcwd() .. ',' .. &rtp
filetype plugin on
copen
assert_equal(1, g:did_load_mytpe)
quit!
delete('Xexport_ft.vim')
delete('ftplugin', 'rf')
&rtp = save_rtp
enddef
def Test_use_import_in_mapping()
var lines =<< trim END
vim9script
export def Funcx()
g:result = 42
enddef
END
writefile(lines, 'XsomeExport.vim')
lines =<< trim END
vim9script
import Funcx from './XsomeExport.vim'
nnoremap <F3> :call <sid>Funcx()<cr>
END
writefile(lines, 'Xmapscript.vim')
source Xmapscript.vim
feedkeys("\<F3>", "xt")
assert_equal(42, g:result)
unlet g:result
delete('XsomeExport.vim')
delete('Xmapscript.vim')
nunmap <F3>
enddef
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
CheckScriptSuccess(lines)
assert_equal(1, g:legacy)
g:feature = 'noteval'
g:legacy = -1
CheckScriptSuccess(lines)
assert_equal(0, g:legacy)
enddef
def Test_vim9script_fails()
CheckScriptFailure(['scriptversion 2', 'vim9script'], 'E1039:')
CheckScriptFailure(['vim9script', 'scriptversion 2'], 'E1040:')
CheckScriptFailure(['export var some = 123'], 'E1042:')
CheckScriptFailure(['import some from "./Xexport.vim"'], 'E1048:')
CheckScriptFailure(['vim9script', 'export var g:some'], 'E1022:')
CheckScriptFailure(['vim9script', 'export echo 134'], 'E1043:')
CheckScriptFailure(['vim9script', 'var str: string', 'str = 1234'], 'E1012:')
CheckScriptFailure(['vim9script', 'const str = "asdf"', 'str = "xxx"'], 'E46:')
assert_fails('vim9script', 'E1038:')
assert_fails('export something', 'E1043:')
enddef
func Test_import_fails_without_script()
CheckRunVimInTerminal
" call indirectly to avoid compilation error for missing functions
call Run_Test_import_fails_on_command_line()
endfunc
def Run_Test_import_fails_on_command_line()
var export =<< trim END
vim9script
export def Foo(): number
return 0
enddef
END
writefile(export, 'XexportCmd.vim')
var buf = RunVimInTerminal('-c "import Foo from ''./XexportCmd.vim''"', {
rows: 6, wait_for_ruler: 0})
WaitForAssert(() => assert_match('^E1094:', term_getline(buf, 5)))
delete('XexportCmd.vim')
StopVimInTerminal(buf)
enddef
def Test_vim9script_reload_noclear()
var lines =<< trim END
vim9script
export var exported = 'thexport'
END
writefile(lines, 'XExportReload')
lines =<< trim END
vim9script noclear
g:loadCount += 1
var s:reloaded = 'init'
import exported from './XExportReload'
def Again(): string
return 'again'
enddef
if exists('s:loaded') | finish | endif
var s:loaded = true
var s:notReloaded = 'yes'
s:reloaded = 'first'
def g:Values(): list<string>
return [s:reloaded, s:notReloaded, Again(), Once(), exported]
enddef
def Once(): string
return 'once'
enddef
END
writefile(lines, 'XReloaded')
g:loadCount = 0
source XReloaded
assert_equal(1, g:loadCount)
assert_equal(['first', 'yes', 'again', 'once', 'thexport'], g:Values())
source XReloaded
assert_equal(2, g:loadCount)
assert_equal(['init', 'yes', 'again', 'once', 'thexport'], g:Values())
source XReloaded
assert_equal(3, g:loadCount)
assert_equal(['init', 'yes', 'again', 'once', 'thexport'], g:Values())
delete('XReloaded')
delete('XExportReload')
delfunc g:Values
unlet g:loadCount
enddef
def Test_vim9script_reload_import()
var lines =<< trim END
vim9script
const var = ''
var valone = 1234
def MyFunc(arg: string)
valone = 5678
enddef
END
var morelines =<< trim END
var valtwo = 222
export def GetValtwo(): number
return valtwo
enddef
END
writefile(lines + morelines, 'Xreload.vim')
source Xreload.vim
source Xreload.vim
source Xreload.vim
var testlines =<< trim END
vim9script
def TheFunc()
import GetValtwo from './Xreload.vim'
assert_equal(222, GetValtwo())
enddef
TheFunc()
END
writefile(testlines, 'Ximport.vim')
source Ximport.vim
# Test that when not using "morelines" GetValtwo() and valtwo are still
# defined, because import doesn't reload a script.
writefile(lines, 'Xreload.vim')
source Ximport.vim
# cannot declare a var twice
lines =<< trim END
vim9script
var valone = 1234
var valone = 5678
END
writefile(lines, 'Xreload.vim')
assert_fails('source Xreload.vim', 'E1041:', '', 3, 'Xreload.vim')
delete('Xreload.vim')
delete('Ximport.vim')
enddef
" if a script is reloaded with a script-local variable that changed its type, a
" compiled function using that variable must fail.
def Test_script_reload_change_type()
var lines =<< trim END
vim9script noclear
var str = 'string'
def g:GetStr(): string
return str .. 'xxx'
enddef
END
writefile(lines, 'Xreload.vim')
source Xreload.vim
echo g:GetStr()
lines =<< trim END
vim9script noclear
var str = 1234
END
writefile(lines, 'Xreload.vim')
source Xreload.vim
assert_fails('echo g:GetStr()', 'E1150:')
delfunc g:GetStr
delete('Xreload.vim')
enddef
def Test_script_var_shadows_function()
var lines =<< trim END
vim9script
def Func(): number
return 123
enddef
var Func = 1
END
CheckScriptFailure(lines, 'E1041:', 5)
enddef
def s:RetSome(): string
return 'some'
enddef
" Not exported function that is referenced needs to be accessed by the
" script-local name.
def Test_vim9script_funcref()
var sortlines =<< trim END
vim9script
def Compare(i1: number, i2: number): number
return i2 - i1
enddef
export def FastSort(): list<number>
return range(5)->sort(Compare)
enddef
END
writefile(sortlines, 'Xsort.vim')
var lines =<< trim END
vim9script
import FastSort from './Xsort.vim'
def Test()
g:result = FastSort()
enddef
Test()
END
writefile(lines, 'Xscript.vim')
source Xscript.vim
assert_equal([4, 3, 2, 1, 0], g:result)
unlet g:result
delete('Xsort.vim')
delete('Xscript.vim')
var Funcref = function('s:RetSome')
assert_equal('some', Funcref())
enddef
" Check that when searching for "FilterFunc" it finds the import in the
" script where FastFilter() is called from, both as a string and as a direct
" function reference.
def Test_vim9script_funcref_other_script()
var filterLines =<< trim END
vim9script
export def FilterFunc(idx: number, val: number): bool
return idx % 2 == 1
enddef
export def FastFilter(): list<number>
return range(10)->filter('FilterFunc')
enddef
export def FastFilterDirect(): list<number>
return range(10)->filter(FilterFunc)
enddef
END
writefile(filterLines, 'Xfilter.vim')
var lines =<< trim END
vim9script
import {FilterFunc, FastFilter, FastFilterDirect} from './Xfilter.vim'
def Test()
var x: list<number> = FastFilter()
enddef
Test()
def TestDirect()
var x: list<number> = FastFilterDirect()
enddef
TestDirect()
END
CheckScriptSuccess(lines)
delete('Xfilter.vim')
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_import_absolute()
var import_lines = [
'vim9script',
'import exported from "' .. escape(getcwd(), '\') .. '/Xexport_abs.vim"',
'def UseExported()',
' g:imported_abs = exported',
' exported = 8888',
' g:imported_after = exported',
'enddef',
'UseExported()',
'g:import_disassembled = execute("disass UseExported")',
]
writefile(import_lines, 'Ximport_abs.vim')
writefile(s:export_script_lines, 'Xexport_abs.vim')
source Ximport_abs.vim
assert_equal(9876, g:imported_abs)
assert_equal(8888, g:imported_after)
assert_match('<SNR>\d\+_UseExported\_s*' ..
'g:imported_abs = exported\_s*' ..
'0 LOADSCRIPT exported-2 from .*Xexport_abs.vim\_s*' ..
'1 STOREG g:imported_abs\_s*' ..
'exported = 8888\_s*' ..
'2 PUSHNR 8888\_s*' ..
'3 STORESCRIPT exported-2 in .*Xexport_abs.vim\_s*' ..
'g:imported_after = exported\_s*' ..
'4 LOADSCRIPT exported-2 from .*Xexport_abs.vim\_s*' ..
'5 STOREG g:imported_after',
g:import_disassembled)
Undo_export_script_lines()
unlet g:imported_abs
unlet g:import_disassembled
delete('Ximport_abs.vim')
delete('Xexport_abs.vim')
enddef
def Test_import_rtp()
var import_lines = [
'vim9script',
'import exported from "Xexport_rtp.vim"',
'g:imported_rtp = exported',
]
writefile(import_lines, 'Ximport_rtp.vim')
mkdir('import')
writefile(s:export_script_lines, 'import/Xexport_rtp.vim')
var save_rtp = &rtp
&rtp = getcwd()
source Ximport_rtp.vim
&rtp = save_rtp
assert_equal(9876, g:imported_rtp)
Undo_export_script_lines()
unlet g:imported_rtp
delete('Ximport_rtp.vim')
delete('import', 'rf')
enddef
def Test_import_compile_error()
var export_lines = [
'vim9script',
'export def ExpFunc(): string',
' return notDefined',
'enddef',
]
writefile(export_lines, 'Xexported.vim')
var import_lines = [
'vim9script',
'import ExpFunc from "./Xexported.vim"',
'def ImpFunc()',
' echo ExpFunc()',
'enddef',
'defcompile',
]
writefile(import_lines, 'Ximport.vim')
try
source Ximport.vim
catch /E1001/
# Error should be fore the Xexported.vim file.
assert_match('E1001: Variable not found: notDefined', v:exception)
assert_match('function <SNR>\d\+_ImpFunc\[1\]..<SNR>\d\+_ExpFunc, line 1', v:throwpoint)
endtry
delete('Xexported.vim')
delete('Ximport.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 <SNR> every time
assert_match('E684: list index out of range', v:exception)
assert_match('function <SNR>\d\+_Func, line 1', v:throwpoint)
endtry
endfor
delete('Xtestscript.vim')
enddef
def Test_func_overrules_import_fails()
var export_lines =<< trim END
vim9script
export def Func()
echo 'imported'
enddef
END
writefile(export_lines, 'XexportedFunc.vim')
var lines =<< trim END
vim9script
import Func from './XexportedFunc.vim'
def Func()
echo 'local to function'
enddef
END
CheckScriptFailure(lines, 'E1073:')
lines =<< trim END
vim9script
import Func from './XexportedFunc.vim'
def Outer()
def Func()
echo 'local to function'
enddef
enddef
defcompile
END
CheckScriptFailure(lines, 'E1073:')
delete('XexportedFunc.vim')
enddef
def Test_func_redefine_fails()
var lines =<< trim END
vim9script
def Func()
echo 'one'
enddef
def Func()
echo 'two'
enddef
END
CheckScriptFailure(lines, 'E1073:')
lines =<< trim END
vim9script
def Foo(): string
return 'foo'
enddef
def Func()
var Foo = {-> 'lambda'}
enddef
defcompile
END
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()
CheckDefExecFailure(['a = 1'], 'E1100:')
CheckDefExecFailure(['c = 1'], 'E1100:')
CheckDefExecFailure(['i = 1'], 'E1100:')
CheckDefExecFailure(['t = 1'], 'E1100:')
CheckDefExecFailure(['x = 1'], 'E1100:')
CheckScriptFailure(['vim9script', 'a = 1'], 'E488:')
CheckScriptFailure(['vim9script', 'a'], 'E1100:')
CheckScriptFailure(['vim9script', 'c = 1'], 'E488:')
CheckScriptFailure(['vim9script', 'c'], 'E1100:')
CheckScriptFailure(['vim9script', 'i = 1'], 'E488:')
CheckScriptFailure(['vim9script', 'i'], 'E1100:')
CheckScriptFailure(['vim9script', 't'], 'E1100:')
CheckScriptFailure(['vim9script', 't = 1'], 'E1100:')
CheckScriptFailure(['vim9script', 'x = 1'], 'E1100:')
enddef
def 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()
CheckDefFailure(['elseif true'], 'E582:')
CheckDefFailure(['else'], 'E581:')
CheckDefFailure(['endif'], 'E580:')
CheckDefFailure(['if g:abool', 'elseif xxx'], 'E1001:')
CheckDefFailure(['if true', 'echo 1'], 'E171:')
var lines =<< trim END
var s = ''
if s = ''
endif
END
CheckDefFailure(lines, 'E488:')
lines =<< trim END
var s = ''
if s == ''
elseif s = ''
endif
END
CheckDefFailure(lines, 'E488:')
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 0 | endif
if false | eval burp + 234 | endif
if false | echo burp 234 'asd' | endif
if false
burp
endif
enddef
def Test_if_const_expr_fails()
CheckDefFailure(['if "aaa" == "bbb'], 'E114:')
CheckDefFailure(["if 'aaa' == 'bbb"], 'E115:')
CheckDefFailure(["if has('aaa'"], 'E110:')
CheckDefFailure(["if has('aaa') ? true false"], 'E109:')
enddef
def 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$', Screenline(&lines))
echomsg [1, 2, 3] {a: 1, b: 2}
assert_match('^\[1, 2, 3\] {''a'': 1, ''b'': 2}$', Screenline(&lines))
CheckDefFailure(['execute xxx'], 'E1001:', 1)
CheckDefExecFailure(['execute "tabnext " .. 8'], 'E475:', 1)
CheckDefFailure(['execute "cmd"# comment'], 'E488:', 1)
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
CheckScriptSuccess(lines)
enddef
def Test_echo_cmd()
echo 'some' # comment
echon 'thing'
assert_match('^something$', Screenline(&lines))
echo "some" # comment
echon "thing"
assert_match('^something$', Screenline(&lines))
var str1 = 'some'
var str2 = 'more'
echo str1 str2
assert_match('^some more$', Screenline(&lines))
CheckDefFailure(['echo "xxx"# comment'], 'E488:')
enddef
def Test_echomsg_cmd()
echomsg 'some' 'more' # comment
assert_match('^some more$', Screenline(&lines))
echo 'clear'
:1messages
assert_match('^some more$', Screenline(&lines))
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$', Screenline(&lines))
END
CheckScriptSuccess(lines)
enddef
def Test_echoerr_cmd()
try
echoerr 'something' 'wrong' # comment
catch
assert_match('something 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
CheckScriptSuccess(lines)
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!
END
writefile(lines, 'Xvim9for.vim')
source Xvim9for.vim
delete('Xvim9for.vim')
enddef
def Test_for_loop()
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)
var res = ""
for [n: number, s: string] in [[1, 'a'], [2, 'b']]
res ..= n .. s
endfor
assert_equal('1a2b', res)
enddef
def Test_for_loop_fails()
CheckDefFailure(['for '], 'E1097:')
CheckDefFailure(['for x'], 'E1097:')
CheckDefFailure(['for x in'], 'E1097:')
CheckDefFailure(['for # in range(5)'], 'E690:')
CheckDefFailure(['for i In range(5)'], 'E690:')
CheckDefFailure(['var x = 5', 'for x in range(5)'], 'E1017:')
CheckScriptFailure(['def Func(arg: any)', 'for arg in range(5)', 'enddef', 'defcompile'], 'E1006:')
delfunc! g:Func
CheckDefFailure(['for i in "text"'], 'E1012:')
CheckDefFailure(['for i in xxx'], 'E1001:')
CheckDefFailure(['endfor'], 'E588:')
CheckDefFailure(['for i in range(3)', 'echo 3'], 'E170:')
enddef
def Test_for_loop_script_var()
# cannot use s:var in a :def function
CheckDefFailure(['for s:var in range(3)', 'echo 3'], 'E1101:')
# 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<string>
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
END
CheckDefAndScriptSuccess(lines)
lines =<< trim END
for [v1, v2] in [[1, 2, 3], [3, 4]]
echo v1 v2
endfor
END
CheckDefExecFailure(lines, 'E710:', 1)
lines =<< trim END
for [v1, v2] in [[1], [3, 4]]
echo v1 v2
endfor
END
CheckDefExecFailure(lines, 'E711:', 1)
lines =<< trim END
for [v1, v1] in [[1, 2], [3, 4]]
echo v1
endfor
END
CheckDefExecFailure(lines, 'E1017:', 1)
enddef
def Test_for_loop_with_try_continue()
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)
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_fails()
CheckDefFailure(['while xxx'], 'E1001:')
CheckDefFailure(['endwhile'], 'E588:')
CheckDefFailure(['continue'], 'E586:')
CheckDefFailure(['if true', 'continue'], 'E586:')
CheckDefFailure(['break'], 'E587:')
CheckDefFailure(['if true', 'break'], 'E587:')
CheckDefFailure(['while 1', 'echo 3'], 'E170:')
var lines =<< trim END
var s = ''
while s = ''
endwhile
END
CheckDefFailure(lines, 'E488:')
enddef
def Test_interrupt_loop()
var caught = false
var x = 0
try
while 1
x += 1
if x == 100
feedkeys("\<C-C>", '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()
CheckScriptSuccess([
'vim9script',
'# something',
'#something',
'#{something',
])
split Xfile
CheckScriptSuccess([
'vim9script',
'edit #something',
])
CheckScriptSuccess([
'vim9script',
'edit #{something',
])
close
CheckScriptFailure([
'vim9script',
':# something',
], 'E488:')
CheckScriptFailure([
'# something',
], 'E488:')
CheckScriptFailure([
':# something',
], 'E488:')
{ # block start
} # block end
CheckDefFailure([
'{# comment',
], 'E488:')
CheckDefFailure([
'{',
'}# comment',
], 'E488:')
echo "yes" # comment
CheckDefFailure([
'echo "yes"# comment',
], 'E488:')
CheckScriptSuccess([
'vim9script',
'echo "yes" # something',
])
CheckScriptFailure([
'vim9script',
'echo "yes"# something',
], 'E121:')
CheckScriptFailure([
'vim9script',
'echo# something',
], 'E1144:')
CheckScriptFailure([
'echo "yes" # something',
], 'E121:')
exe "echo" # comment
CheckDefFailure([
'exe "echo"# comment',
], 'E488:')
CheckScriptSuccess([
'vim9script',
'exe "echo" # something',
])
CheckScriptFailure([
'vim9script',
'exe "echo"# something',
], 'E121:')
CheckScriptFailure([
'vim9script',
'exe# something',
], 'E1144:')
CheckScriptFailure([
'exe "echo" # something',
], 'E121:')
CheckDefFailure([
'try# comment',
' echo "yes"',
'catch',
'endtry',
], 'E1144:')
CheckScriptFailure([
'vim9script',
'try# comment',
'echo "yes"',
], 'E1144:')
CheckDefFailure([
'try',
' throw#comment',
'catch',
'endtry',
], 'E1144:')
CheckDefFailure([
'try',
' throw "yes"#comment',
'catch',
'endtry',
], 'E488:')
CheckDefFailure([
'try',
' echo "yes"',
'catch# comment',
'endtry',
], 'E1144:')
CheckScriptFailure([
'vim9script',
'try',
' echo "yes"',
'catch# comment',
'endtry',
], 'E1144:')
CheckDefFailure([
'try',
' echo "yes"',
'catch /pat/# comment',
'endtry',
], 'E488:')
CheckDefFailure([
'try',
'echo "yes"',
'catch',
'endtry# comment',
], 'E1144:')
CheckScriptFailure([
'vim9script',
'try',
' echo "yes"',
'catch',
'endtry# comment',
], 'E1144:')
CheckScriptSuccess([
'vim9script',
'hi # comment',
])
CheckScriptFailure([
'vim9script',
'hi# comment',
], 'E1144:')
CheckScriptSuccess([
'vim9script',
'hi Search # comment',
])
CheckScriptFailure([
'vim9script',
'hi Search# comment',
], 'E416:')
CheckScriptSuccess([
'vim9script',
'hi link This Search # comment',
])
CheckScriptFailure([
'vim9script',
'hi link This That# comment',
], 'E413:')
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',
CheckScriptFailure([
'vim9script',
'hi clear# comment',
], 'E416:')
CheckScriptSuccess([
'vim9script',
'hi Group term=bold',
'match Group /todo/ # comment',
])
CheckScriptFailure([
'vim9script',
'hi Group term=bold',
'match Group /todo/# comment',
], 'E488:')
CheckScriptSuccess([
'vim9script',
'match # comment',
])
CheckScriptFailure([
'vim9script',
'match# comment',
], 'E1144:')
CheckScriptSuccess([
'vim9script',
'match none # comment',
])
CheckScriptFailure([
'vim9script',
'match none# comment',
], 'E475:')
CheckScriptSuccess([
'vim9script',
'menutrans clear # comment',
])
CheckScriptFailure([
'vim9script',
'menutrans clear# comment text',
], 'E474:')
CheckScriptSuccess([
'vim9script',
'syntax clear # comment',
])
CheckScriptFailure([
'vim9script',
'syntax clear# comment text',
], 'E28:')
CheckScriptSuccess([
'vim9script',
'syntax keyword Word some',
'syntax clear Word # comment',
])
CheckScriptFailure([
'vim9script',
'syntax keyword Word some',
'syntax clear Word# comment text',
], 'E28:')
CheckScriptSuccess([
'vim9script',
'syntax list # comment',
])
CheckScriptFailure([
'vim9script',
'syntax list# comment text',
], 'E28:')
CheckScriptSuccess([
'vim9script',
'syntax match Word /pat/ oneline # comment',
])
CheckScriptFailure([
'vim9script',
'syntax match Word /pat/ oneline# comment',
], 'E475:')
CheckScriptSuccess([
'vim9script',
'syntax keyword Word word # comm[ent',
])
CheckScriptFailure([
'vim9script',
'syntax keyword Word word# comm[ent',
], 'E789:')
CheckScriptSuccess([
'vim9script',
'syntax match Word /pat/ # comment',
])
CheckScriptFailure([
'vim9script',
'syntax match Word /pat/# comment',
], 'E402:')
CheckScriptSuccess([
'vim9script',
'syntax match Word /pat/ contains=Something # comment',
])
CheckScriptFailure([
'vim9script',
'syntax match Word /pat/ contains=Something# comment',
], 'E475:')
CheckScriptFailure([
'vim9script',
'syntax match Word /pat/ contains= # comment',
], 'E406:')
CheckScriptFailure([
'vim9script',
'syntax match Word /pat/ contains=# comment',
], 'E475:')
CheckScriptSuccess([
'vim9script',
'syntax region Word start=/pat/ end=/pat/ # comment',
])
CheckScriptFailure([
'vim9script',
'syntax region Word start=/pat/ end=/pat/# comment',
], 'E402:')
CheckScriptSuccess([
'vim9script',
'syntax sync # comment',
])
CheckScriptFailure([
'vim9script',
'syntax sync# comment',
], 'E404:')
CheckScriptSuccess([
'vim9script',
'syntax sync ccomment # comment',
])
CheckScriptFailure([
'vim9script',
'syntax sync ccomment# comment',
], 'E404:')
CheckScriptSuccess([
'vim9script',
'syntax cluster Some contains=Word # comment',
])
CheckScriptFailure([
'vim9script',
'syntax cluster Some contains=Word# comment',
], 'E475:')
CheckScriptSuccess([
'vim9script',
'command Echo echo # comment',
'command Echo # comment',
'delcommand Echo',
])
CheckScriptFailure([
'vim9script',
'command Echo echo# comment',
'Echo',
], 'E1144:')
delcommand Echo
var curdir = getcwd()
CheckScriptSuccess([
'command Echo cd " comment',
'Echo',
'delcommand Echo',
])
CheckScriptSuccess([
'vim9script',
'command Echo cd # comment',
'Echo',
'delcommand Echo',
])
CheckScriptFailure([
'vim9script',
'command Echo cd " comment',
'Echo',
], 'E344:')
delcommand Echo
chdir(curdir)
CheckScriptFailure([
'vim9script',
'command Echo# comment',
], 'E182:')
CheckScriptFailure([
'vim9script',
'command Echo echo',
'command Echo# comment',
], 'E182:')
delcommand Echo
CheckScriptSuccess([
'vim9script',
'function # comment',
])
CheckScriptFailure([
'vim9script',
'function " comment',
], 'E129:')
CheckScriptFailure([
'vim9script',
'function# comment',
], 'E1144:')
CheckScriptSuccess([
'vim9script',
'function CheckScriptSuccess # comment',
])
CheckScriptFailure([
'vim9script',
'function CheckScriptSuccess# comment',
], 'E488:')
CheckScriptSuccess([
'vim9script',
'func g:DeleteMeA()',
'endfunc',
'delfunction g:DeleteMeA # comment',
])
CheckScriptFailure([
'vim9script',
'func g:DeleteMeB()',
'endfunc',
'delfunction g:DeleteMeB# comment',
], 'E488:')
CheckScriptSuccess([
'vim9script',
'call execute("ls") # comment',
])
CheckScriptFailure([
'vim9script',
'call execute("ls")# comment',
], 'E488:')
CheckScriptFailure([
'def Test() " comment',
'enddef',
], 'E488:')
CheckScriptFailure([
'vim9script',
'def Test() " comment',
'enddef',
], 'E488:')
CheckScriptSuccess([
'func Test() " comment',
'endfunc',
'delfunc Test',
])
CheckScriptSuccess([
'vim9script',
'func Test() " comment',
'endfunc',
])
CheckScriptSuccess([
'def Test() # comment',
'enddef',
])
CheckScriptFailure([
'func Test() # comment',
'endfunc',
], 'E488:')
enddef
def Test_vim9_comment_gui()
CheckCanRunGui
CheckScriptFailure([
'vim9script',
'gui#comment'
], 'E1144:')
CheckScriptFailure([
'vim9script',
'gui -f#comment'
], 'E499:')
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
CheckScriptSuccess([
'vim9script',
'g:var = 123',
'b:var = 456',
'w:var = 777',
't:var = 888',
'unlet g:var w:var # something',
])
CheckScriptFailure([
'vim9script',
'let var = 123',
], 'E1126: Cannot use :let in Vim9 script')
CheckScriptFailure([
'vim9script',
'var g:var = 123',
], 'E1016: Cannot declare a global variable:')
CheckScriptFailure([
'vim9script',
'var b:var = 123',
], 'E1016: Cannot declare a buffer variable:')
CheckScriptFailure([
'vim9script',
'var w:var = 123',
], 'E1016: Cannot declare a window variable:')
CheckScriptFailure([
'vim9script',
'var t:var = 123',
], 'E1016: Cannot declare a tab variable:')
CheckScriptFailure([
'vim9script',
'var v:version = 123',
], 'E1016: Cannot declare a v: variable:')
CheckScriptFailure([
'vim9script',
'var $VARIABLE = "text"',
], 'E1016: Cannot declare an environment variable:')
CheckScriptFailure([
'vim9script',
'g:var = 123',
'unlet g:var# comment1',
], 'E108:')
CheckScriptFailure([
'let g:var = 123',
'unlet g:var # something',
], 'E488:')
CheckScriptSuccess([
'vim9script',
'if 1 # comment2',
' echo "yes"',
'elseif 2 #comment',
' echo "no"',
'endif',
])
CheckScriptFailure([
'vim9script',
'if 1# comment3',
' echo "yes"',
'endif',
], 'E15:')
CheckScriptFailure([
'vim9script',
'if 0 # comment4',
' echo "yes"',
'elseif 2#comment',
' echo "no"',
'endif',
], 'E15:')
CheckScriptSuccess([
'vim9script',
'var v = 1 # comment5',
])
CheckScriptFailure([
'vim9script',
'var v = 1# comment6',
], 'E15:')
CheckScriptSuccess([
'vim9script',
'new'
'setline(1, ["# define pat", "last"])',
':$',
'dsearch /pat/ #comment',
'bwipe!',
])
CheckScriptFailure([
'vim9script',
'new'
'setline(1, ["# define pat", "last"])',
':$',
'dsearch /pat/#comment',
'bwipe!',
], 'E488:')
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_source_vim9_from_legacy()
var vim9_lines =<< trim END
vim9script
var local = 'local'
g:global = 'global'
export var exported = 'exported'
export def GetText(): string
return 'text'
enddef
END
writefile(vim9_lines, 'Xvim9_script.vim')
var legacy_lines =<< trim END
source Xvim9_script.vim
call assert_false(exists('local'))
call assert_false(exists('exported'))
call assert_false(exists('s:exported'))
call assert_equal('global', global)
call assert_equal('global', g:global)
" imported variable becomes script-local
import exported from './Xvim9_script.vim'
call assert_equal('exported', s:exported)
call assert_false(exists('exported'))
" imported function becomes script-local
import GetText from './Xvim9_script.vim'
call assert_equal('text', s:GetText())
call assert_false(exists('*GetText'))
END
writefile(legacy_lines, 'Xlegacy_script.vim')
source Xlegacy_script.vim
assert_equal('global', g:global)
unlet g:global
delete('Xlegacy_script.vim')
delete('Xvim9_script.vim')
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
" test using an auto-loaded function and variable
def Test_vim9_autoload()
var lines =<< trim END
vim9script
def some#gettest(): string
return 'test'
enddef
g:some#name = 'name'
def some#varargs(a1: string, ...l: list<string>): string
return a1 .. l[0] .. l[1]
enddef
END
mkdir('Xdir/autoload', 'p')
writefile(lines, 'Xdir/autoload/some.vim')
var save_rtp = &rtp
exe 'set rtp^=' .. getcwd() .. '/Xdir'
assert_equal('test', g:some#gettest())
assert_equal('name', g:some#name)
g:some#other = 'other'
assert_equal('other', g:some#other)
assert_equal('abc', some#varargs('a', 'b', 'c'))
# upper case script name works
lines =<< trim END
vim9script
def Other#getOther(): string
return 'other'
enddef
END
writefile(lines, 'Xdir/autoload/Other.vim')
assert_equal('other', g:Other#getOther())
delete('Xdir', 'rf')
&rtp = save_rtp
enddef
" test using a vim9script that is auto-loaded from an autocmd
def Test_vim9_aucmd_autoload()
var lines =<< trim END
vim9script
def foo#test()
echomsg getreg('"')
enddef
END
mkdir('Xdir/autoload', 'p')
writefile(lines, 'Xdir/autoload/foo.vim')
var save_rtp = &rtp
exe 'set rtp^=' .. getcwd() .. '/Xdir'
augroup test
autocmd TextYankPost * call foo#test()
augroup END
normal Y
augroup test
autocmd!
augroup END
delete('Xdir', 'rf')
&rtp = save_rtp
enddef
" This was causing a crash because suppress_errthrow wasn't reset.
def Test_vim9_autoload_error()
var lines =<< trim END
vim9script
def crash#func()
try
for x in List()
endfor
catch
endtry
g:ok = true
enddef
fu List()
invalid
endfu
try
alsoinvalid
catch /wontmatch/
endtry
END
call mkdir('Xruntime/autoload', 'p')
call writefile(lines, 'Xruntime/autoload/crash.vim')
# run in a separate Vim to avoid the side effects of assert_fails()
lines =<< trim END
exe 'set rtp^=' .. getcwd() .. '/Xruntime'
call crash#func()
call writefile(['ok'], 'Xdidit')
qall!
END
writefile(lines, 'Xscript')
RunVim([], [], '-S Xscript')
assert_equal(['ok'], readfile('Xdidit'))
delete('Xdidit')
delete('Xscript')
delete('Xruntime', 'rf')
lines =<< trim END
vim9script
var foo#bar = 'asdf'
END
CheckScriptFailure(lines, 'E461: Illegal variable name: foo#bar', 2)
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
CheckScriptSuccess(lines)
enddef
def Test_cmdline_win()
# if the Vim syntax highlighting uses Vim9 constructs they can be used from
# the command line window.
mkdir('rtp/syntax', 'p')
var export_lines =<< trim END
vim9script
export var That = 'yes'
END
writefile(export_lines, 'rtp/syntax/Xexport.vim')
var import_lines =<< trim END
vim9script
import That from './Xexport.vim'
END
writefile(import_lines, 'rtp/syntax/vim.vim')
var save_rtp = &rtp
&rtp = getcwd() .. '/rtp' .. ',' .. &rtp
syntax on
augroup CmdWin
autocmd CmdwinEnter * g:got_there = 'yes'
augroup END
# this will open and also close the cmdline window
feedkeys('q:', 'xt')
assert_equal('yes', g:got_there)
augroup CmdWin
au!
augroup END
&rtp = save_rtp
delete('rtp', 'rf')
enddef
def Test_invalid_sid()
assert_fails('func <SNR>1234_func', 'E123:')
if RunVim([], ['wq! Xdidit'], '+"func <SNR>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 RunVim([], [], '-u NONE +"set cpo+=a" -S Xsourced -S Xclose')
assert_equal(['done'], readfile('Xdone'))
endif
delete('Xsourced')
delete('Xclose')
delete('Xdone')
writefile(['vim9script'], 'XanotherScript')
set cpo=aABceFsMny>
edit XanotherScript
so %
assert_equal('aABceFsMny>', &cpo)
:1del
w
so %
assert_equal('aABceFsMny>', &cpo)
delete('XanotherScript')
set cpo&vim
enddef
" Use :function so we can use Check commands
func Test_no_redraw_when_restoring_cpo()
CheckScreendump
CheckFeature timers
let lines =<< trim END
vim9script
def script#func()
enddef
END
call mkdir('Xdir/autoload', 'p')
call writefile(lines, 'Xdir/autoload/script.vim')
let 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
call writefile(lines, 'XTest_redraw_cpo')
let buf = RunVimInTerminal('-S XTest_redraw_cpo', {'rows': 6})
call term_sendkeys(buf, "V:")
call VerifyScreenDump(buf, 'Test_vim9_no_redraw', {})
" clean up
call term_sendkeys(buf, "\<Esc>u")
call StopVimInTerminal(buf)
call delete('XTest_redraw_cpo')
call delete('Xdir', 'rf')
endfunc
def Test_unset_any_variable()
var lines =<< trim END
var name: any
assert_equal(0, name)
END
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 = RunVimInTerminal('-S XcallFunc', {rows: 6})
# define Afunc() on the command line
term_sendkeys(buf, ":def Afunc()\<CR>Bfunc()\<CR>enddef\<CR>")
term_sendkeys(buf, ":call CheckAndQuit()\<CR>")
WaitForAssert(() => assert_equal(['errors: []'], readfile('Xdidcmd')))
call 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
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
CheckScriptFailure(lines, 'E121:', 10)
lines =<< trim END
vim9script
while true
var one = 'one'
echo one
break
endwhile
echo one
END
CheckScriptFailure(lines, 'E121:', 7)
lines =<< trim END
vim9script
for i in range(1)
var one = 'one'
echo one
endfor
echo one
END
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
CheckScriptSuccess(lines)
lines =<< trim END
vim9script
{
var one = 'one'
echo one
}
echo one
END
CheckScriptFailure(lines, 'E121:', 6)
enddef
def Test_catch_exception_in_callback()
var lines =<< trim END
vim9script
def Callback(...l: any)
try
var x: string
var y: string
# this error should be caught with CHECKLEN
[x, y] = ['']
catch
g:caught = 'yes'
endtry
enddef
popup_menu('popup', {callback: Callback})
feedkeys("\r", 'xt')
END
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
var lines =<< trim END
vim9script
var source: list<number>
def Out_cb(...l: any)
eval [][0]
enddef
def Exit_cb(...l: any)
sleep 1m
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
sleep 100m
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 <F3> <Cmd>call <SID>InvokeNormal()<CR>
new
setline(1, ['aaa', 'bbb'])
feedkeys("V\<F3>", 'xt')
assert_equal(['bbb', 'aaa'], getline(1, 2))
xunmap <F3>
enddef
def Test_white_space_after_command()
var lines =<< trim END
exit_cb: Func})
END
CheckDefAndScriptFailure(lines, 'E1144:', 1)
lines =<< trim END
e#
END
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_import_gone_when_sourced_twice()
var exportlines =<< trim END
vim9script
if exists('g:guard')
finish
endif
g:guard = 1
export var name = 'someName'
END
writefile(exportlines, 'XexportScript.vim')
var lines =<< trim END
vim9script
import name from './XexportScript.vim'
def g:GetName(): string
return name
enddef
END
writefile(lines, 'XscriptImport.vim')
so XscriptImport.vim
assert_equal('someName', g:GetName())
so XexportScript.vim
assert_fails('call g:GetName()', 'E1149:')
delfunc g:GetName
delete('XexportScript.vim')
delete('XscriptImport.vim')
unlet g:guard
enddef
def Test_unsupported_commands()
var lines =<< trim END
ka
END
CheckDefAndScriptFailure(lines, 'E1100:')
lines =<< trim END
:1ka
END
CheckDefAndScriptFailure(lines, 'E481:')
lines =<< trim END
t
END
CheckDefFailure(lines, 'E1100:')
CheckScriptFailure(['vim9script'] + lines, 'E1100:')
lines =<< trim END
x
END
CheckDefFailure(lines, 'E1100:')
CheckScriptFailure(['vim9script'] + lines, 'E1100:')
lines =<< trim END
xit
END
CheckDefFailure(lines, 'E1100:')
CheckScriptFailure(['vim9script'] + lines, 'E1100:')
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
View Git Blame Copy Permalink