vim: src/testdir/test_vim9_func.vim comparison

comparison src/testdir/test_vim9_func.vim @ 27457:4c16acb2525f v8.2.4257

patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent Commit: https://github.com/vim/vim/commit/62aec93bfdb9e1b40d03a6d2e8e9511f8b1bdb2d Author: Bram Moolenaar <Bram@vim.org> Date: Sat Jan 29 21:45:34 2022 +0000 patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent Problem: Vim9: finding global function without g: prefix but not finding global variable is inconsistent. Solution: Require using g: for a global function. Change the vim9.vim script into a Vim9 script with exports. Fix that import in legacy script does not work.

author	Bram Moolenaar <Bram@vim.org>
date	Sat, 29 Jan 2022 23:00:05 +0100
parents	47dbeda35910
children	a14c4d3e3260

comparison

equal deleted inserted replaced

-:a8e2d91995ce
+:4c16acb2525f
 " Test various aspects of the Vim9 script language.
 source check.vim
 source term_util.vim
 source view_util.vim
-source vim9.vim
+import './vim9.vim' as v9
 source screendump.vim
 func Test_def_basic()
 def SomeFunc(): string
 return 'yes'
 echo nothing
 enddef
 defcompile
 END
 writefile(lines, 'XTest_compile_error')
-var buf = RunVimInTerminal('-S XTest_compile_error',
+var buf = g:RunVimInTerminal('-S XTest_compile_error',
 {rows: 10, wait_for_ruler: 0})
-WaitForAssert(() => assert_match('Error detected while compiling command line.*Fails.*Variable not found: nothing',
+g:WaitForAssert(() => assert_match('Error detected while compiling command line.*Fails.*Variable not found: nothing',
-Term_getlines(buf, range(1, 9))))
+g:Term_getlines(buf, range(1, 9))))
 # clean up
-StopVimInTerminal(buf)
+g:StopVimInTerminal(buf)
 delete('XTest_compile_error')
 enddef
 def TestCompilingErrorInTry()
 var dir = 'Xdir/autoload'
 endtry
 END
 lines[1] = 'set rtp=' .. getcwd() .. '/Xdir'
 writefile(lines, 'XTest_compile_error')
-var buf = RunVimInTerminal('-S XTest_compile_error', {rows: 10, wait_for_ruler: 0})
+var buf = g:RunVimInTerminal('-S XTest_compile_error', {rows: 10, wait_for_ruler: 0})
-WaitForAssert(() => assert_match('Error detected while compiling command line.*function script#OnlyCompiled.*Invalid command: invalid',
+g:WaitForAssert(() => assert_match('Error detected while compiling command line.*function script#OnlyCompiled.*Invalid command: invalid',
-Term_getlines(buf, range(1, 9))))
+g:Term_getlines(buf, range(1, 9))))
 # clean up
-StopVimInTerminal(buf)
+g:StopVimInTerminal(buf)
 delete('XTest_compile_error')
 delete('Xdir', 'rf')
 enddef
 def Test_compile_error_in_called_function()
 Foo()
 enddef
 silent! Foo()
 Bar()
 END
-CheckScriptFailureList(lines, ['E1012:', 'E1191:'])
+v9.CheckScriptFailureList(lines, ['E1012:', 'E1191:'])
 enddef
 def Test_wrong_function_name()
 var lines =<< trim END
 vim9script
 func _Foo()
 echo 'foo'
 endfunc
 END
-CheckScriptFailure(lines, 'E128:')
+v9.CheckScriptFailure(lines, 'E128:')
 lines =<< trim END
 vim9script
 def _Foo()
 echo 'foo'
 enddef
 END
-CheckScriptFailure(lines, 'E128:')
+v9.CheckScriptFailure(lines, 'E128:')
 enddef
 def Test_autoload_name_mismatch()
 var dir = 'Xdir/autoload'
 mkdir(dir, 'p')
 var save_rtp = &rtp
 exe 'set rtp=' .. getcwd() .. '/Xdir'
 lines =<< trim END
 call script#Function()
 END
-CheckScriptFailure(lines, 'E746:', 2)
+v9.CheckScriptFailure(lines, 'E746:', 2)
 &rtp = save_rtp
 delete(dir, 'rf')
 enddef
 var Function = foobar#function
 assert_equal('yes', Function())
 assert_equal('no', foobar#var)
 END
-CheckDefAndScriptSuccess(lines)
+v9.CheckDefAndScriptSuccess(lines)
 &rtp = save_rtp
 delete(dir, 'rf')
 enddef
 g:called_function = 'no'
 # The error in the autoload script cannot be checked with assert_fails(), use
 # CheckDefSuccess() instead of CheckDefFailure()
 try
-CheckDefSuccess(['scripterror#function()'])
+v9.CheckDefSuccess(['scripterror#function()'])
 catch
 assert_match('E121: Undefined variable: 0', v:exception)
 endtry
 assert_equal('no', g:called_function)
 endtry
 END
 writefile(lines, dir .. '/scriptcaught.vim')
 g:called_function = 'no'
-CheckDefSuccess(['scriptcaught#function()'])
+v9.CheckDefSuccess(['scriptcaught#function()'])
 assert_match('E121: Undefined variable: 0', g:caught)
 assert_equal('yes', g:called_function)
 &rtp = save_rtp
 delete(dir, 'rf')
 enddef
-def CallRecursive(n: number): number
+def s:CallRecursive(n: number): number
 return CallRecursive(n + 1)
 enddef
-def CallMapRecursive(l: list<number>): number
+def s:CallMapRecursive(l: list<number>): number
 return map(l, (_, v) => CallMapRecursive([v]))[0]
 enddef
 def Test_funcdepth_error()
 set maxfuncdepth=10
 def Test()
 echo 'test'
 endfunc
 enddef
 END
-CheckScriptFailure(lines, 'E1151:', 3)
+v9.CheckScriptFailure(lines, 'E1151:', 3)
 lines =<< trim END
 def Test()
 func Nested()
 echo 'test'
 enddef
 enddef
 END
-CheckScriptFailure(lines, 'E1152:', 4)
+v9.CheckScriptFailure(lines, 'E1152:', 4)
 lines =<< trim END
 def Ok()
 echo 'hello'
 enddef | echo 'there'
 def Bad()
 echo 'hello'
 enddef there
 END
-CheckScriptFailure(lines, 'E1173: Text found after enddef: there', 6)
+v9.CheckScriptFailure(lines, 'E1173: Text found after enddef: there', 6)
 enddef
 def Test_missing_endfunc_enddef()
 var lines =<< trim END
 vim9script
 def Test()
 echo 'test'
 endef
 END
-CheckScriptFailure(lines, 'E1057:', 2)
+v9.CheckScriptFailure(lines, 'E1057:', 2)
 lines =<< trim END
 vim9script
 func Some()
 echo 'test'
 enfffunc
 END
-CheckScriptFailure(lines, 'E126:', 2)
+v9.CheckScriptFailure(lines, 'E126:', 2)
 enddef
 def Test_white_space_before_paren()
 var lines =<< trim END
 vim9script
 def Test ()
 echo 'test'
 enddef
 END
-CheckScriptFailure(lines, 'E1068:', 2)
+v9.CheckScriptFailure(lines, 'E1068:', 2)
 lines =<< trim END
 vim9script
 func Test ()
 echo 'test'
 endfunc
 END
-CheckScriptFailure(lines, 'E1068:', 2)
+v9.CheckScriptFailure(lines, 'E1068:', 2)
 lines =<< trim END
 def Test ()
 echo 'test'
 enddef
 END
-CheckScriptFailure(lines, 'E1068:', 1)
+v9.CheckScriptFailure(lines, 'E1068:', 1)
 lines =<< trim END
 func Test ()
 echo 'test'
 endfunc
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 enddef
 def Test_enddef_dict_key()
 var d = {
 enddef: 'x',
 def ReturnGlobal(): number
 return g:notNumber
 enddef
 def Test_return_something()
-ReturnString()->assert_equal('string')
+g:ReturnString()->assert_equal('string')
-ReturnNumber()->assert_equal(123)
+g:ReturnNumber()->assert_equal(123)
 assert_fails('ReturnGlobal()', 'E1012: Type mismatch; expected number but got string', '', 1, 'ReturnGlobal')
 var lines =<< trim END
 vim9script
 def Func()
 return Msg()
 enddef
 defcompile
 END
-CheckScriptFailure(lines, 'E1096:')
+v9.CheckScriptFailure(lines, 'E1096:')
 enddef
 def Test_check_argument_type()
 var lines =<< trim END
 vim9script
 Val(0, x)
 enddef
 disass Func
 Func()
 END
-CheckScriptFailure(lines, 'E1013: Argument 2: type mismatch, expected number but got bool', 2)
+v9.CheckScriptFailure(lines, 'E1013: Argument 2: type mismatch, expected number but got bool', 2)
 enddef
 def Test_missing_return()
-CheckDefFailure(['def Missing(): number',
+v9.CheckDefFailure(['def Missing(): number',
 '  if g:cond',
 '    echo "no return"',
 '  else',
 '    return 0',
 '  endif'
 'enddef'], 'E1027:')
-CheckDefFailure(['def Missing(): number',
+v9.CheckDefFailure(['def Missing(): number',
 '  if g:cond',
 '    return 1',
 '  else',
 '    echo "no return"',
 '  endif'
 'enddef'], 'E1027:')
-CheckDefFailure(['def Missing(): number',
+v9.CheckDefFailure(['def Missing(): number',
 '  if g:cond',
 '    return 1',
 '  else',
 '    return 2',
 '  endif'
 def YesnoFilter(id: number, key: string): bool
 return popup_filter_yesno(id, key)
 enddef
 defcompile
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 enddef
 let s:nothing = 0
 def ReturnNothing()
 s:nothing = 1
 endif
 s:nothing = 2
 enddef
 def Test_return_nothing()
-ReturnNothing()
+g:ReturnNothing()
 s:nothing->assert_equal(1)
 enddef
 def Test_return_invalid()
 var lines =<< trim END
 def Func(): invalid
 return xxx
 enddef
 defcompile
 END
-CheckScriptFailure(lines, 'E1010:', 2)
+v9.CheckScriptFailure(lines, 'E1010:', 2)
 lines =<< trim END
 vim9script
 def Test(Fun: func(number): number): list<number>
 return map([1, 2, 3], (_, i) => Fun(i))
 return nr + 2
 enddef
 echo Test(Inc)
 END
 # doing this twice was leaking memory
-CheckScriptFailure(lines, 'E1010:')
+v9.CheckScriptFailure(lines, 'E1010:')
-CheckScriptFailure(lines, 'E1010:')
+v9.CheckScriptFailure(lines, 'E1010:')
 enddef
 def Test_return_list_any()
 # This used to fail but now the actual list type is checked, and since it has
 # an item of type string it can be used as list<string>.
 l->add('string')
 return l
 enddef
 echo Func()
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 lines =<< trim END
 vim9script
 def Func(): list<string>
 var l: list<any>
 l += ['string']
 return l
 enddef
 echo Func()
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 enddef
-func Increment()
+func s:Increment()
 let g:counter += 1
 endfunc
 def Test_call_ufunc_count()
 g:counter = 1
 g:counter->assert_equal(4)
 eval g:counter->assert_equal(4)
 unlet g:counter
 enddef
-def MyVarargs(arg: string, ...rest: list<string>): string
+def s:MyVarargs(arg: string, ...rest: list<string>): string
 var res = arg
 for s in rest
 res ..= ',' .. s
 endfor
 return res
 MyVarargs('one', 'two')->assert_equal('one,two')
 MyVarargs('one', 'two', 'three')->assert_equal('one,two,three')
 enddef
 def Test_call_white_space()
-CheckDefAndScriptFailure(["call Test ('text')"], ['E476:', 'E1068:'])
+v9.CheckDefAndScriptFailure(["call Test ('text')"], ['E476:', 'E1068:'])
 enddef
 def MyDefaultArgs(name = 'string'): string
 return name
 enddef
-def MyDefaultSecond(name: string, second: bool  = true): string
+def s:MyDefaultSecond(name: string, second: bool  = true): string
 return second ? name : 'none'
 enddef
 def Test_call_default_args()
-MyDefaultArgs()->assert_equal('string')
+g:MyDefaultArgs()->assert_equal('string')
-MyDefaultArgs(v:none)->assert_equal('string')
+g:MyDefaultArgs(v:none)->assert_equal('string')
-MyDefaultArgs('one')->assert_equal('one')
+g:MyDefaultArgs('one')->assert_equal('one')
-assert_fails('MyDefaultArgs("one", "two")', 'E118:', '', 4, 'Test_call_default_args')
+assert_fails('g:MyDefaultArgs("one", "two")', 'E118:', '', 4, 'Test_call_default_args')
 MyDefaultSecond('test')->assert_equal('test')
 MyDefaultSecond('test', true)->assert_equal('test')
 MyDefaultSecond('test', false)->assert_equal('none')
 return mandatory .. optional
 enddef
 DefArg(1234)->assert_equal('12341234')
 DefArg("ok")->assert_equal('okok')
 END
-CheckDefAndScriptSuccess(lines)
+v9.CheckDefAndScriptSuccess(lines)
-CheckScriptFailure(['def Func(arg: number = asdf)', 'enddef', 'defcompile'], 'E1001:')
+v9.CheckScriptFailure(['def Func(arg: number = asdf)', 'enddef', 'defcompile'], 'E1001:')
 delfunc g:Func
-CheckScriptFailure(['def Func(arg: number = "text")', 'enddef', 'defcompile'], 'E1013: Argument 1: type mismatch, expected number but got string')
+v9.CheckScriptFailure(['def Func(arg: number = "text")', 'enddef', 'defcompile'], 'E1013: Argument 1: type mismatch, expected number but got string')
 delfunc g:Func
-CheckDefFailure(['def Func(x: number = )', 'enddef'], 'E15:')
+v9.CheckDefFailure(['def Func(x: number = )', 'enddef'], 'E15:')
 lines =<< trim END
 vim9script
 def Func(a = b == 0 ? 1 : 2, b = 0)
 enddef
 defcompile
 END
-CheckScriptFailure(lines, 'E1001: Variable not found: b')
+v9.CheckScriptFailure(lines, 'E1001: Variable not found: b')
 # using script variable requires matching type or type cast when executed
 lines =<< trim END
 vim9script
 var a: any
 def Func(arg: string = a)
 echo arg
 enddef
 defcompile
 END
-CheckScriptSuccess(lines + ['a = "text"', 'Func()'])
+v9.CheckScriptSuccess(lines + ['a = "text"', 'Func()'])
-CheckScriptFailure(lines + ['a = 123', 'Func()'], 'E1013: Argument 1: type mismatch, expected string but got number')
+v9.CheckScriptFailure(lines + ['a = 123', 'Func()'], 'E1013: Argument 1: type mismatch, expected string but got number')
 # using global variable does not require type cast
 lines =<< trim END
 vim9script
 def Func(arg: string = g:str)
 echo arg
 enddef
 g:str = 'works'
 Func()
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 enddef
-def FuncWithComment(  # comment
+def s:FuncWithComment(  # comment
 a: number, #comment
 b: bool, # comment
 c: string) #comment
 assert_equal(4, a)
 assert_equal(true, b)
 var lines =<< trim END
 def Func(# comment
 arg: string)
 enddef
 END
-CheckScriptFailure(lines, 'E125:', 1)
+v9.CheckScriptFailure(lines, 'E125:', 1)
 lines =<< trim END
 def Func(
 arg: string# comment
 )
 enddef
 END
-CheckScriptFailure(lines, 'E475:', 2)
+v9.CheckScriptFailure(lines, 'E475:', 2)
 lines =<< trim END
 def Func(
 arg: string
 )# comment
 enddef
 END
-CheckScriptFailure(lines, 'E488:', 3)
+v9.CheckScriptFailure(lines, 'E488:', 3)
 enddef
 def Test_nested_function()
 def NestedDef(arg: string): string
 return 'nested ' .. arg
 func NestedFunc(arg)
 return 'nested ' .. a:arg
 endfunc
 NestedFunc(':func')->assert_equal('nested :func')
-CheckDefFailure(['def Nested()', 'enddef', 'Nested(66)'], 'E118:')
+v9.CheckDefFailure(['def Nested()', 'enddef', 'Nested(66)'], 'E118:')
-CheckDefFailure(['def Nested(arg: string)', 'enddef', 'Nested()'], 'E119:')
+v9.CheckDefFailure(['def Nested(arg: string)', 'enddef', 'Nested()'], 'E119:')
-CheckDefFailure(['def s:Nested()', 'enddef'], 'E1075:')
+v9.CheckDefFailure(['def s:Nested()', 'enddef'], 'E1075:')
-CheckDefFailure(['def b:Nested()', 'enddef'], 'E1075:')
+v9.CheckDefFailure(['def b:Nested()', 'enddef'], 'E1075:')
 var lines =<< trim END
 def Outer()
 def Inner()
 # comment
 enddef
 def Inner()
 enddef
 enddef
 END
-CheckDefFailure(lines, 'E1073:')
+v9.CheckDefFailure(lines, 'E1073:')
 lines =<< trim END
 def Outer()
 def Inner()
 # comment
 enddef
 def! Inner()
 enddef
 enddef
 END
-CheckDefFailure(lines, 'E1117:')
+v9.CheckDefFailure(lines, 'E1117:')
 lines =<< trim END
 vim9script
 def Outer()
 def Inner()
 Inner()
 enddef
 Outer()
 Inner()
 END
-CheckScriptFailure(lines, 'E117: Unknown function: Inner')
+v9.CheckScriptFailure(lines, 'E117: Unknown function: Inner')
 assert_equal('ok', g:result)
 unlet g:result
 # nested function inside conditional
 lines =<< trim END
 endif
 defcompile
 assert_equal(1, Test())
 assert_equal(2, Test())
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 # also works when "thecount" is inside the "if" block
 lines =<< trim END
 vim9script
 if true
 endif
 defcompile
 assert_equal(1, Test())
 assert_equal(2, Test())
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 lines =<< trim END
 vim9script
 def Outer()
 def Inner()
 echo 'hello'
 enddef burp
 enddef
 defcompile
 END
-CheckScriptFailure(lines, 'E1173: Text found after enddef: burp', 3)
+v9.CheckScriptFailure(lines, 'E1173: Text found after enddef: burp', 3)
 enddef
 def Test_not_nested_function()
 echo printf('%d',
 function('len')('xxx'))
 delfunc g:Inner
 Outer()
 g:Inner()->assert_equal('inner')
 delfunc g:Inner
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 lines =<< trim END
 vim9script
 def Outer()
 func g:Inner()
 delfunc g:Inner
 Outer()
 g:Inner()->assert_equal('inner')
 delfunc g:Inner
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 lines =<< trim END
 vim9script
 def Outer()
 def g:Inner(): string
 enddef
 defcompile
 Outer()
 Outer()
 END
-CheckScriptFailure(lines, "E122:")
+v9.CheckScriptFailure(lines, "E122:")
 delfunc g:Inner
 lines =<< trim END
 vim9script
 def Outer()
 enddef
 g:Inner()
 enddef
 Outer()
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 delfunc g:Inner
 lines =<< trim END
 vim9script
 def Func()
 echo 'inner'
 enddef
 enddef
 defcompile
 END
-CheckScriptFailure(lines, "E1073:", 1)
+v9.CheckScriptFailure(lines, "E1073:", 1)
 lines =<< trim END
 vim9script
 def Func()
 echo 'script'
 enddef
 def Func()
 echo 'script'
 enddef
 END
-CheckScriptFailure(lines, "E1073:", 5)
+v9.CheckScriptFailure(lines, "E1073:", 5)
 enddef
 def DefListAll()
 def
 enddef
 def Func()
 def +Func+
 enddef
 defcompile
 END
-CheckScriptFailure(lines, 'E476:', 1)
+v9.CheckScriptFailure(lines, 'E476:', 1)
 enddef
 def Test_global_local_function()
 var lines =<< trim END
 vim9script
 enddef
 g:Func()->assert_equal('global')
 Func()->assert_equal('local')
 delfunc g:Func
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 lines =<< trim END
 vim9script
 def g:Funcy()
 echo 'funcy'
 enddef
 s:Funcy()
 END
-CheckScriptFailure(lines, 'E117:')
+v9.CheckScriptFailure(lines, 'E117:')
 enddef
 def Test_local_function_shadows_global()
 var lines =<< trim END
 vim9script
 enddef
 g:Gfunc()->assert_equal('global')
 AnotherFunc()->assert_equal(7)
 delfunc g:Gfunc
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 lines =<< trim END
 vim9script
 def g:Func(): string
 return 'global'
 def AnotherFunc()
 g:Func = function('len')
 enddef
 AnotherFunc()
 END
-CheckScriptFailure(lines, 'E705:')
+v9.CheckScriptFailure(lines, 'E705:')
 delfunc g:Func
-# global function is found without g: prefix
+# global function is not found with g: prefix
 lines =<< trim END
 vim9script
 def g:Func(): string
 return 'global'
 enddef
 def AnotherFunc(): string
 return Func()
 enddef
 assert_equal('global', AnotherFunc())
-delfunc g:Func
+END
-END
+v9.CheckScriptFailure(lines, 'E117:')
-CheckScriptSuccess(lines)
+delfunc g:Func
 lines =<< trim END
 vim9script
 def g:Func(): string
 return 'global'
 enddef
 assert_equal('global', Func())
 delfunc g:Func
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 # This does not shadow "i" which is visible only inside the for loop
 lines =<< trim END
 vim9script
 for i in range(3)
 # Foo() is compiled here
 Foo(i)
 endfor
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 enddef
 func TakesOneArg(arg)
 echo a:arg
 endfunc
 def Test_call_wrong_args()
-CheckDefFailure(['TakesOneArg()'], 'E119:')
+v9.CheckDefFailure(['g:TakesOneArg()'], 'E119:')
-CheckDefFailure(['TakesOneArg(11, 22)'], 'E118:')
+v9.CheckDefFailure(['g:TakesOneArg(11, 22)'], 'E118:')
-CheckDefFailure(['bufnr(xxx)'], 'E1001:')
+v9.CheckDefFailure(['bufnr(xxx)'], 'E1001:')
-CheckScriptFailure(['def Func(Ref: func(s: string))'], 'E475:')
+v9.CheckScriptFailure(['def Func(Ref: func(s: string))'], 'E475:')
 var lines =<< trim END
 vim9script
 def Func(s: string)
 echo s
 enddef
 Func([])
 END
-CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected string but got list<unknown>', 5)
+v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected string but got list<unknown>', 5)
 # argument name declared earlier is found when declaring a function
 lines =<< trim END
 vim9script
 var name = 'piet'
 def FuncOne(name: string)
 echo nr
 enddef
 END
-CheckScriptFailure(lines, 'E1168:')
+v9.CheckScriptFailure(lines, 'E1168:')
 # argument name declared later is only found when compiling
 lines =<< trim END
 vim9script
 def FuncOne(name: string)
 echo nr
 enddef
 var name = 'piet'
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
-CheckScriptFailure(lines + ['defcompile'], 'E1168:')
+v9.CheckScriptFailure(lines + ['defcompile'], 'E1168:')
 lines =<< trim END
 vim9script
 def FuncOne(nr: number)
 echo nr
 END
 var tail =<< trim END
 enddef
 Testme()
 END
-CheckScriptSuccess(head + ["funcMap['func']('str', 123, [1, 2, 3])"] + tail)
+v9.CheckScriptSuccess(head + ["funcMap['func']('str', 123, [1, 2, 3])"] + tail)
-CheckScriptFailure(head + ["funcMap['func']('str', 123)"] + tail, 'E119:')
+v9.CheckScriptFailure(head + ["funcMap['func']('str', 123)"] + tail, 'E119:')
-CheckScriptFailure(head + ["funcMap['func']('str', 123, [1], 4)"] + tail, 'E118:')
+v9.CheckScriptFailure(head + ["funcMap['func']('str', 123, [1], 4)"] + tail, 'E118:')
 var lines =<< trim END
 vim9script
 var Ref: func(number): any
 Ref = (j) => !j
 echo Ref(false)
 END
-CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected number but got bool', 4)
+v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected number but got bool', 4)
 lines =<< trim END
 vim9script
 var Ref: func(number): any
 Ref = (j) => !j
 call Ref(false)
 END
-CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected number but got bool', 4)
+v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected number but got bool', 4)
 enddef
 def Test_call_lambda_args()
 var lines =<< trim END
 var Callback = (..._) => 'anything'
 assert_equal('anything', Callback(1))
 assert_equal('anything', Callback('a', 2))
 assert_equal('xyz', ((a: string): string => a)('xyz'))
 END
-CheckDefAndScriptSuccess(lines)
+v9.CheckDefAndScriptSuccess(lines)
-CheckDefFailure(['echo ((i) => 0)()'],
+v9.CheckDefFailure(['echo ((i) => 0)()'],
 'E119: Not enough arguments for function: ((i) => 0)()')
 lines =<< trim END
 var Ref = (x: number, y: number) => x + y
 echo Ref(1, 'x')
 END
-CheckDefFailure(lines, 'E1013: Argument 2: type mismatch, expected number but got string')
+v9.CheckDefFailure(lines, 'E1013: Argument 2: type mismatch, expected number but got string')
 lines =<< trim END
 var Ref: func(job, string, number)
 Ref = (x, y) => 0
 END
-CheckDefAndScriptFailure(lines, 'E1012:')
+v9.CheckDefAndScriptFailure(lines, 'E1012:')
 lines =<< trim END
 var Ref: func(job, string)
 Ref = (x, y, z) => 0
 END
-CheckDefAndScriptFailure(lines, 'E1012:')
+v9.CheckDefAndScriptFailure(lines, 'E1012:')
 lines =<< trim END
 var one = 1
 var l = [1, 2, 3]
 echo map(l, (one) => one)
 END
-CheckDefFailure(lines, 'E1167:')
+v9.CheckDefFailure(lines, 'E1167:')
-CheckScriptFailure(['vim9script'] + lines, 'E1168:')
+v9.CheckScriptFailure(['vim9script'] + lines, 'E1168:')
 lines =<< trim END
 var Ref: func(any, ?any): bool
 Ref = (_, y = 1) => false
 END
-CheckDefAndScriptFailure(lines, 'E1172:')
+v9.CheckDefAndScriptFailure(lines, 'E1172:')
 lines =<< trim END
 var a = 0
 var b = (a == 0 ? 1 : 2)
 assert_equal(1, b)
 var txt = 'a'
 b = (txt =~ 'x' ? 1 : 2)
 assert_equal(2, b)
 END
-CheckDefAndScriptSuccess(lines)
+v9.CheckDefAndScriptSuccess(lines)
 lines =<< trim END
 def ShadowLocal()
 var one = 1
 var l = [1, 2, 3]
 echo map(l, (one) => one)
 enddef
 END
-CheckDefFailure(lines, 'E1167:')
+v9.CheckDefFailure(lines, 'E1167:')
 lines =<< trim END
 def Shadowarg(one: number)
 var l = [1, 2, 3]
 echo map(l, (one) => one)
 enddef
 END
-CheckDefFailure(lines, 'E1167:')
+v9.CheckDefFailure(lines, 'E1167:')
 lines =<< trim END
 echo ((a) => a)('aa', 'bb')
 END
-CheckDefAndScriptFailure(lines, 'E118:', 1)
+v9.CheckDefAndScriptFailure(lines, 'E118:', 1)
 lines =<< trim END
 echo 'aa'->((a) => a)('bb')
 END
-CheckDefFailure(lines, 'E118: Too many arguments for function: ->((a) => a)(''bb'')', 1)
+v9.CheckDefFailure(lines, 'E118: Too many arguments for function: ->((a) => a)(''bb'')', 1)
-CheckScriptFailure(['vim9script'] + lines, 'E118: Too many arguments for function: <lambda>', 2)
+v9.CheckScriptFailure(['vim9script'] + lines, 'E118: Too many arguments for function: <lambda>', 2)
 enddef
 def Test_lambda_line_nr()
 var lines =<< trim END
 vim9script
 var out = execute('verbose ' .. timer_info(id)[0].callback
 ->string()
 ->substitute("('\\|')", ' ', 'g'))
 assert_match('Last set from .* line 4', out)
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 enddef
 def FilterWithCond(x: string, Cond: func(string): bool): bool
 return Cond(x)
 enddef
 def Test_lambda_return_type()
 var lines =<< trim END
 var Ref = (): => 123
 END
-CheckDefAndScriptFailure(lines, 'E1157:', 1)
+v9.CheckDefAndScriptFailure(lines, 'E1157:', 1)
 # no space before the return type
 lines =<< trim END
 var Ref = (x):number => x + 1
 END
-CheckDefAndScriptFailure(lines, 'E1069:', 1)
+v9.CheckDefAndScriptFailure(lines, 'E1069:', 1)
 # this works
 for x in ['foo', 'boo']
-echo FilterWithCond(x, (v) => v =~ '^b')
+echo g:FilterWithCond(x, (v) => v =~ '^b')
 endfor
 # this fails
 lines =<< trim END
-echo FilterWithCond('foo', (v) => v .. '^b')
+echo g:FilterWithCond('foo', (v) => v .. '^b')
 END
-CheckDefAndScriptFailure(lines, 'E1013: Argument 2: type mismatch, expected func(string): bool but got func(any): string', 1)
+v9.CheckDefAndScriptFailure(lines, 'E1013: Argument 2: type mismatch, expected func(string): bool but got func(any): string', 1)
 lines =<< trim END
 var Lambda1 = (x) => {
 return x
 }
 var Lambda2 = (x): string => {
 return x
 }
 assert_equal('foo', Lambda2('foo'))
 END
-CheckDefAndScriptSuccess(lines)
+v9.CheckDefAndScriptSuccess(lines)
 lines =<< trim END
 var Lambda = (x): string => {
 return x
 }
 echo Lambda(['foo'])
 END
-CheckDefExecAndScriptFailure(lines, 'E1012:')
+v9.CheckDefExecAndScriptFailure(lines, 'E1012:')
 enddef
 def Test_lambda_uses_assigned_var()
-CheckDefSuccess([
+v9.CheckDefSuccess([
 'var x: any = "aaa"'
 'x = filter(["bbb"], (_, v) => v =~ x)'])
 enddef
 def Test_pass_legacy_lambda_to_def_func()
 endfunc
 def Bar(y: any)
 enddef
 Foo()
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 lines =<< trim END
 vim9script
 def g:TestFunc(f: func)
 enddef
 def g:TestFunc(f: func(number))
 enddef
 legacy call g:TestFunc({nr -> 0})
 delfunc g:TestFunc
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 enddef
 def Test_lambda_in_reduce_line_break()
 # this was using freed memory
 var lines =<< trim END
 return acc
 endif
 }, {})
 assert_equal({Bob: 2, Sam: 1, Cat: 3}, result)
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 enddef
 def Test_set_opfunc_to_lambda()
 var lines =<< trim END
 vim9script
 'a b c d e'->setline(1)
 feedkeys("\<F4>", 'x')
 assert_equal(4, g:result)
 bwipe!
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 enddef
 def Test_set_opfunc_to_global_function()
 var lines =<< trim END
 vim9script
 feedkeys("g@_", 'x')
 assert_equal(4, g:result)
 bwipe!
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 &operatorfunc = ''
 enddef
 def Test_use_script_func_name_with_prefix()
 var lines =<< trim END
 return 'it'
 endfunc
 var Fn = s:Getit
 assert_equal('it', Fn())
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 enddef
 def Test_lambda_type_allocated()
 # Check that unreferencing a partial using a lambda can use the variable type
 # after the lambda has been freed and does not leak memory.
 &omnifunc = Lambda
 Lambda = (a, b) => MyomniFunc1(20, a, b)
 &omnifunc = string(Lambda)
 Lambda = (a, b) => strlen(a)
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 enddef
 " Default arg and varargs
 def MyDefVarargs(one: string, two = 'foo', ...rest: list<string>): string
 var res = one .. ',' .. two
 endfor
 return res
 enddef
 def Test_call_def_varargs()
-assert_fails('MyDefVarargs()', 'E119:', '', 1, 'Test_call_def_varargs')
+assert_fails('g:MyDefVarargs()', 'E119:', '', 1, 'Test_call_def_varargs')
-MyDefVarargs('one')->assert_equal('one,foo')
+g:MyDefVarargs('one')->assert_equal('one,foo')
-MyDefVarargs('one', 'two')->assert_equal('one,two')
+g:MyDefVarargs('one', 'two')->assert_equal('one,two')
-MyDefVarargs('one', 'two', 'three')->assert_equal('one,two,three')
+g:MyDefVarargs('one', 'two', 'three')->assert_equal('one,two,three')
-CheckDefFailure(['MyDefVarargs("one", 22)'],
+v9.CheckDefFailure(['g:MyDefVarargs("one", 22)'],
 'E1013: Argument 2: type mismatch, expected string but got number')
-CheckDefFailure(['MyDefVarargs("one", "two", 123)'],
+v9.CheckDefFailure(['g:MyDefVarargs("one", "two", 123)'],
 'E1013: Argument 3: type mismatch, expected string but got number')
 var lines =<< trim END
 vim9script
 def Func(...l: list<string>)
 echo l
 enddef
 Func('a', 'b', 'c')
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 lines =<< trim END
 vim9script
 def Func(...l: list<string>)
 echo l
 enddef
 Func()
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 lines =<< trim END
 vim9script
 def Func(...l: list<any>)
 echo l
 enddef
 Func(0)
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 lines =<< trim END
 vim9script
 def Func(...l: any)
 echo l
 enddef
 Func(0)
 END
-CheckScriptFailure(lines, 'E1180:', 2)
+v9.CheckScriptFailure(lines, 'E1180:', 2)
 lines =<< trim END
 vim9script
 def Func(..._l: list<string>)
 echo _l
 enddef
 Func('a', 'b', 'c')
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 lines =<< trim END
 vim9script
 def Func(...l: list<string>)
 echo l
 enddef
 Func(1, 2, 3)
 END
-CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch')
+v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch')
 lines =<< trim END
 vim9script
 def Func(...l: list<string>)
 echo l
 enddef
 Func('a', 9)
 END
-CheckScriptFailure(lines, 'E1013: Argument 2: type mismatch')
+v9.CheckScriptFailure(lines, 'E1013: Argument 2: type mismatch')
 lines =<< trim END
 vim9script
 def Func(...l: list<string>)
 echo l
 enddef
 Func(1, 'a')
 END
-CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch')
+v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch')
 lines =<< trim END
 vim9script
 def Func(  # some comment
 ...l = []
 )
 echo l
 enddef
 END
-CheckScriptFailure(lines, 'E1160:')
+v9.CheckScriptFailure(lines, 'E1160:')
 lines =<< trim END
 vim9script
 def DoIt()
 g:Later('')
 defcompile
 def g:Later(...l:  list<number>)
 enddef
 DoIt()
 END
-CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected number but got string')
+v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected number but got string')
 enddef
 let s:value = ''
 def FuncOneDefArg(opt = 'text')
 RefDef2Arg = FuncTwoDefArg
 RefDef2Arg()->assert_equal('123text')
 RefDef2Arg(99)->assert_equal('99text')
 RefDef2Arg(77, 'some')->assert_equal('77some')
-CheckDefFailure(['var RefWrong: func(string?)'], 'E1010:')
+v9.CheckDefFailure(['var RefWrong: func(string?)'], 'E1010:')
-CheckDefFailure(['var RefWrong: func(?string, string)'], 'E1007:')
+v9.CheckDefFailure(['var RefWrong: func(?string, string)'], 'E1007:')
 var RefVarargs: func(...list<string>): string
 RefVarargs = FuncVarargs
 RefVarargs()->assert_equal('')
 RefVarargs('one')->assert_equal('one')
 RefVarargs('one', 'two')->assert_equal('one,two')
-CheckDefFailure(['var RefWrong: func(...list<string>, string)'], 'E110:')
+v9.CheckDefFailure(['var RefWrong: func(...list<string>, string)'], 'E110:')
-CheckDefFailure(['var RefWrong: func(...list<string>, ?string)'], 'E110:')
+v9.CheckDefFailure(['var RefWrong: func(...list<string>, ?string)'], 'E110:')
 enddef
 " Only varargs
 def MyVarargsOnly(...args: list<string>): string
 return join(args, ',')
 enddef
 def Test_call_varargs_only()
-MyVarargsOnly()->assert_equal('')
+g:MyVarargsOnly()->assert_equal('')
-MyVarargsOnly('one')->assert_equal('one')
+g:MyVarargsOnly('one')->assert_equal('one')
-MyVarargsOnly('one', 'two')->assert_equal('one,two')
+g:MyVarargsOnly('one', 'two')->assert_equal('one,two')
-CheckDefFailure(['MyVarargsOnly(1)'], 'E1013: Argument 1: type mismatch, expected string but got number')
+v9.CheckDefFailure(['g:MyVarargsOnly(1)'], 'E1013: Argument 1: type mismatch, expected string but got number')
-CheckDefFailure(['MyVarargsOnly("one", 2)'], 'E1013: Argument 2: type mismatch, expected string but got number')
+v9.CheckDefFailure(['g:MyVarargsOnly("one", 2)'], 'E1013: Argument 2: type mismatch, expected string but got number')
 enddef
 def Test_using_var_as_arg()
 var lines =<< trim END
 def Func(x: number)
 var x = 234
 enddef
 END
-CheckDefFailure(lines, 'E1006:')
+v9.CheckDefFailure(lines, 'E1006:')
 lines =<< trim END
 def Func(Ref: number)
 def Ref()
 enddef
 enddef
 END
-CheckDefFailure(lines, 'E1073:')
+v9.CheckDefFailure(lines, 'E1073:')
 enddef
-def DictArg(arg: dict<string>)
+def s:DictArg(arg: dict<string>)
 arg['key'] = 'value'
 enddef
-def ListArg(arg: list<string>)
+def s:ListArg(arg: list<string>)
 arg[0] = 'value'
 enddef
 def Test_assign_to_argument()
 # works for dict and list
 d['key']->assert_equal('value')
 var l: list<string> = []
 ListArg(l)
 l[0]->assert_equal('value')
-CheckScriptFailure(['def Func(arg: number)', 'arg = 3', 'enddef', 'defcompile'], 'E1090:')
+v9.CheckScriptFailure(['def Func(arg: number)', 'arg = 3', 'enddef', 'defcompile'], 'E1090:')
 delfunc! g:Func
 enddef
 " These argument names are reserved in legacy functions.
-def WithReservedNames(firstline: string, lastline: string): string
+def s:WithReservedNames(firstline: string, lastline: string): string
 return firstline .. lastline
 enddef
 def Test_argument_names()
 assert_equal('OK', WithReservedNames('O', 'K'))
 return 123
 enddef
 var Funcref: func: number = function('RetNumber')
 Funcref()->assert_equal(123)
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 lines =<< trim END
 vim9script
 def RetNumber(): number
 return 123
 return F()
 enddef
 var Funcref = function('RetNumber')
 Bar(Funcref)->assert_equal(123)
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 lines =<< trim END
 vim9script
 def UseNumber(nr: number)
 echo nr
 enddef
 var Funcref: func(number) = function('UseNumber')
 Funcref(123)
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 lines =<< trim END
 vim9script
 def UseNumber(nr: number)
 echo nr
 enddef
 var Funcref: func(string) = function('UseNumber')
 END
-CheckScriptFailure(lines, 'E1012: Type mismatch; expected func(string) but got func(number)')
+v9.CheckScriptFailure(lines, 'E1012: Type mismatch; expected func(string) but got func(number)')
 lines =<< trim END
 vim9script
 def EchoNr(nr = 34)
 g:echo = nr
 Funcref()
 g:echo->assert_equal(34)
 Funcref(123)
 g:echo->assert_equal(123)
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 lines =<< trim END
 vim9script
 def EchoList(...l: list<number>)
 g:echo = l
 Funcref()
 g:echo->assert_equal([])
 Funcref(1, 2, 3)
 g:echo->assert_equal([1, 2, 3])
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 lines =<< trim END
 vim9script
 def OptAndVar(nr: number, opt = 12, ...l: list<number>): number
 g:optarg = opt
 Funcref(17, 18, 1, 2, 3)->assert_equal(17)
 g:optarg->assert_equal(18)
 g:listarg->assert_equal([1, 2, 3])
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 enddef
 let SomeFunc = function('len')
 let NotAFunc = 'text'
 enddef
 # Compile all functions
 defcompile
 END
-CheckScriptFailure(lines, 'E1173: Text found after enddef: BBBB')
+v9.CheckScriptFailure(lines, 'E1173: Text found after enddef: BBBB')
 enddef
 def Test_nested_function_with_args_split()
 var lines =<< trim END
 vim9script
 enddef|BBBB
 enddef
 # Compile all functions
 defcompile
 END
-CheckScriptFailure(lines, 'E1173: Text found after enddef: BBBB')
+v9.CheckScriptFailure(lines, 'E1173: Text found after enddef: BBBB')
 lines =<< trim END
 vim9script
 def FirstFunction()
 func SecondFunction()
 endfunc|BBBB
 enddef
 defcompile
 END
-CheckScriptFailure(lines, 'E1173: Text found after endfunction: BBBB')
+v9.CheckScriptFailure(lines, 'E1173: Text found after endfunction: BBBB')
 enddef
 def Test_error_in_function_args()
 var lines =<< trim END
 def FirstFunction()
 enddef|BBBB
 enddef
 # Compile all functions
 defcompile
 END
-CheckScriptFailure(lines, 'E488:')
+v9.CheckScriptFailure(lines, 'E488:')
 enddef
 def Test_return_type_wrong()
-CheckScriptFailure([
+v9.CheckScriptFailure([
 'def Func(): number',
 'return "a"',
 'enddef',
 'defcompile'], 'expected number but got string')
 delfunc! g:Func
-CheckScriptFailure([
+v9.CheckScriptFailure([
 'def Func(): string',
 'return 1',
 'enddef',
 'defcompile'], 'expected string but got number')
 delfunc! g:Func
-CheckScriptFailure([
+v9.CheckScriptFailure([
 'def Func(): void',
 'return "a"',
 'enddef',
 'defcompile'],
 'E1096: Returning a value in a function without a return type')
 delfunc! g:Func
-CheckScriptFailure([
+v9.CheckScriptFailure([
 'def Func()',
 'return "a"',
 'enddef',
 'defcompile'],
 'E1096: Returning a value in a function without a return type')
 delfunc! g:Func
-CheckScriptFailure([
+v9.CheckScriptFailure([
 'def Func(): number',
 'return',
 'enddef',
 'defcompile'], 'E1003:')
 delfunc! g:Func
-CheckScriptFailure([
+v9.CheckScriptFailure([
 'def Func():number',
 'return 123',
 'enddef',
 'defcompile'], 'E1069:')
 delfunc! g:Func
-CheckScriptFailure([
+v9.CheckScriptFailure([
 'def Func() :number',
 'return 123',
 'enddef',
 'defcompile'], 'E1059:')
 delfunc! g:Func
-CheckScriptFailure([
+v9.CheckScriptFailure([
 'def Func() : number',
 'return 123',
 'enddef',
 'defcompile'], 'E1059:')
 delfunc! g:Func
-CheckScriptFailure(['def Func(): list', 'return []', 'enddef'], 'E1008:')
+v9.CheckScriptFailure(['def Func(): list', 'return []', 'enddef'], 'E1008:')
 delfunc! g:Func
-CheckScriptFailure(['def Func(): dict', 'return {}', 'enddef'], 'E1008:')
+v9.CheckScriptFailure(['def Func(): dict', 'return {}', 'enddef'], 'E1008:')
 delfunc! g:Func
-CheckScriptFailure(['def Func()', 'return 1'], 'E1057:')
+v9.CheckScriptFailure(['def Func()', 'return 1'], 'E1057:')
 delfunc! g:Func
-CheckScriptFailure([
+v9.CheckScriptFailure([
 'vim9script',
 'def FuncB()',
 '  return 123',
 'enddef',
 'def FuncA()',
 'enddef',
 'defcompile'], 'E1096:')
 enddef
 def Test_arg_type_wrong()
-CheckScriptFailure(['def Func3(items: list)', 'echo "a"', 'enddef'], 'E1008: Missing <type>')
+v9.CheckScriptFailure(['def Func3(items: list)', 'echo "a"', 'enddef'], 'E1008: Missing <type>')
-CheckScriptFailure(['def Func4(...)', 'echo "a"', 'enddef'], 'E1055: Missing name after ...')
+v9.CheckScriptFailure(['def Func4(...)', 'echo "a"', 'enddef'], 'E1055: Missing name after ...')
-CheckScriptFailure(['def Func5(items:string)', 'echo "a"'], 'E1069:')
+v9.CheckScriptFailure(['def Func5(items:string)', 'echo "a"'], 'E1069:')
-CheckScriptFailure(['def Func5(items)', 'echo "a"'], 'E1077:')
+v9.CheckScriptFailure(['def Func5(items)', 'echo "a"'], 'E1077:')
-CheckScriptFailure(['def Func6(...x:list<number>)', 'echo "a"', 'enddef'], 'E1069:')
+v9.CheckScriptFailure(['def Func6(...x:list<number>)', 'echo "a"', 'enddef'], 'E1069:')
-CheckScriptFailure(['def Func7(...x: int)', 'echo "a"', 'enddef'], 'E1010:')
+v9.CheckScriptFailure(['def Func7(...x: int)', 'echo "a"', 'enddef'], 'E1010:')
 enddef
 def Test_white_space_before_comma()
 var lines =<< trim END
 vim9script
 def Func(a: number , b: number)
 enddef
 END
-CheckScriptFailure(lines, 'E1068:')
+v9.CheckScriptFailure(lines, 'E1068:')
 call assert_fails('vim9cmd echo stridx("a" .. "b" , "a")', 'E1068:')
 enddef
 def Test_white_space_after_comma()
 var lines =<< trim END
 vim9script
 def Func(a: number,b: number)
 enddef
 END
-CheckScriptFailure(lines, 'E1069:')
+v9.CheckScriptFailure(lines, 'E1069:')
 # OK in legacy function
 lines =<< trim END
 vim9script
 func Func(a,b)
 endfunc
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 enddef
 def Test_vim9script_call()
 var lines =<< trim END
 vim9script
 def MyFunc(arg: string)
 var name = 123
 enddef
 defcompile
 END
-CheckScriptFailure(lines, 'E1054:')
+v9.CheckScriptFailure(lines, 'E1054:')
 enddef
 def Test_vim9script_call_fail_type()
 var lines =<< trim END
 vim9script
 def MyFunc(arg: string)
 echo arg
 enddef
 MyFunc(1234)
 END
-CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected string but got number')
+v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected string but got number')
 enddef
 def Test_vim9script_call_fail_const()
 var lines =<< trim END
 vim9script
 g:Aconst = 99
 enddef
 call Change()
 unlet g:Aconst
 END
-CheckScriptFailure(lines, 'E741: Value is locked: Aconst', 2)
+v9.CheckScriptFailure(lines, 'E741: Value is locked: Aconst', 2)
 enddef
 " Test that inside :function a Python function can be defined, :def is not
 " recognized.
 func Test_function_python()
 def g:GoneSoon()
 echo 'hello'
 enddef
 def CallGoneSoon()
-GoneSoon()
+g:GoneSoon()
 enddef
 defcompile
 delfunc g:GoneSoon
 CallGoneSoon()
 nnoremap <F4> <Cmd>call <SID>TermRun()<CR>
 timer_start(100, (_) => feedkeys("\<F4>"))
 timer_start(1000, (_) => feedkeys("\<F4>"))
 sleep 1500m
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 nunmap <F4>
 set updatetime&
 enddef
 def Test_redef_failure()
 def FuncTwoArgNoRet(one: bool, two: number)
 s:funcResult = two
 enddef
-def FuncOneArgRetString(arg: string): string
+def s:FuncOneArgRetString(arg: string): string
 return arg
 enddef
-def FuncOneArgRetAny(arg: any): any
+def s:FuncOneArgRetAny(arg: any): any
 return arg
 enddef
 def Test_func_type()
 var Ref1: func()
 s:funcResult = 0
-Ref1 = FuncNoArgNoRet
+Ref1 = g:FuncNoArgNoRet
 Ref1()
 s:funcResult->assert_equal(11)
 var Ref2: func
 s:funcResult = 0
-Ref2 = FuncNoArgNoRet
+Ref2 = g:FuncNoArgNoRet
 Ref2()
 s:funcResult->assert_equal(11)
 s:funcResult = 0
-Ref2 = FuncOneArgNoRet
+Ref2 = g:FuncOneArgNoRet
 Ref2(12)
 s:funcResult->assert_equal(12)
 s:funcResult = 0
-Ref2 = FuncNoArgRetNumber
+Ref2 = g:FuncNoArgRetNumber
 Ref2()->assert_equal(1234)
 s:funcResult->assert_equal(22)
 s:funcResult = 0
 Ref2 = FuncOneArgRetNumber
 res->assert_equal('fileonefiletwo')
 enddef
 def Test_func_type_part()
 var RefVoid: func: void
-RefVoid = FuncNoArgNoRet
+RefVoid = g:FuncNoArgNoRet
-RefVoid = FuncOneArgNoRet
+RefVoid = g:FuncOneArgNoRet
-CheckDefFailure(['var RefVoid: func: void', 'RefVoid = FuncNoArgRetNumber'], 'E1012: Type mismatch; expected func(...) but got func(): number')
+v9.CheckDefFailure(['var RefVoid: func: void', 'RefVoid = g:FuncNoArgRetNumber'], 'E1012: Type mismatch; expected func(...) but got func(): number')
-CheckDefFailure(['var RefVoid: func: void', 'RefVoid = FuncNoArgRetString'], 'E1012: Type mismatch; expected func(...) but got func(): string')
+v9.CheckDefFailure(['var RefVoid: func: void', 'RefVoid = FuncNoArgRetString'], 'E1012: Type mismatch; expected func(...) but got func(): string')
 var RefAny: func(): any
-RefAny = FuncNoArgRetNumber
+RefAny = g:FuncNoArgRetNumber
 RefAny = FuncNoArgRetString
-CheckDefFailure(['var RefAny: func(): any', 'RefAny = FuncNoArgNoRet'], 'E1012: Type mismatch; expected func(): any but got func()')
+v9.CheckDefFailure(['var RefAny: func(): any', 'RefAny = g:FuncNoArgNoRet'], 'E1012: Type mismatch; expected func(): any but got func()')
-CheckDefFailure(['var RefAny: func(): any', 'RefAny = FuncOneArgNoRet'], 'E1012: Type mismatch; expected func(): any but got func(number)')
+v9.CheckDefFailure(['var RefAny: func(): any', 'RefAny = g:FuncOneArgNoRet'], 'E1012: Type mismatch; expected func(): any but got func(number)')
 var RefAnyNoArgs: func: any = RefAny
 var RefNr: func: number
-RefNr = FuncNoArgRetNumber
+RefNr = g:FuncNoArgRetNumber
 RefNr = FuncOneArgRetNumber
-CheckDefFailure(['var RefNr: func: number', 'RefNr = FuncNoArgNoRet'], 'E1012: Type mismatch; expected func(...): number but got func()')
+v9.CheckDefFailure(['var RefNr: func: number', 'RefNr = g:FuncNoArgNoRet'], 'E1012: Type mismatch; expected func(...): number but got func()')
-CheckDefFailure(['var RefNr: func: number', 'RefNr = FuncNoArgRetString'], 'E1012: Type mismatch; expected func(...): number but got func(): string')
+v9.CheckDefFailure(['var RefNr: func: number', 'RefNr = FuncNoArgRetString'], 'E1012: Type mismatch; expected func(...): number but got func(): string')
 var RefStr: func: string
 RefStr = FuncNoArgRetString
 RefStr = FuncOneArgRetString
-CheckDefFailure(['var RefStr: func: string', 'RefStr = FuncNoArgNoRet'], 'E1012: Type mismatch; expected func(...): string but got func()')
+v9.CheckDefFailure(['var RefStr: func: string', 'RefStr = g:FuncNoArgNoRet'], 'E1012: Type mismatch; expected func(...): string but got func()')
-CheckDefFailure(['var RefStr: func: string', 'RefStr = FuncNoArgRetNumber'], 'E1012: Type mismatch; expected func(...): string but got func(): number')
+v9.CheckDefFailure(['var RefStr: func: string', 'RefStr = g:FuncNoArgRetNumber'], 'E1012: Type mismatch; expected func(...): string but got func(): number')
 enddef
 def Test_func_type_fails()
-CheckDefFailure(['var ref1: func()'], 'E704:')
+v9.CheckDefFailure(['var ref1: func()'], 'E704:')
-CheckDefFailure(['var Ref1: func()', 'Ref1 = FuncNoArgRetNumber'], 'E1012: Type mismatch; expected func() but got func(): number')
+v9.CheckDefFailure(['var Ref1: func()', 'Ref1 = g:FuncNoArgRetNumber'], 'E1012: Type mismatch; expected func() but got func(): number')
-CheckDefFailure(['var Ref1: func()', 'Ref1 = FuncOneArgNoRet'], 'E1012: Type mismatch; expected func() but got func(number)')
+v9.CheckDefFailure(['var Ref1: func()', 'Ref1 = g:FuncOneArgNoRet'], 'E1012: Type mismatch; expected func() but got func(number)')
-CheckDefFailure(['var Ref1: func()', 'Ref1 = FuncOneArgRetNumber'], 'E1012: Type mismatch; expected func() but got func(number): number')
+v9.CheckDefFailure(['var Ref1: func()', 'Ref1 = FuncOneArgRetNumber'], 'E1012: Type mismatch; expected func() but got func(number): number')
-CheckDefFailure(['var Ref1: func(bool)', 'Ref1 = FuncTwoArgNoRet'], 'E1012: Type mismatch; expected func(bool) but got func(bool, number)')
+v9.CheckDefFailure(['var Ref1: func(bool)', 'Ref1 = g:FuncTwoArgNoRet'], 'E1012: Type mismatch; expected func(bool) but got func(bool, number)')
-CheckDefFailure(['var Ref1: func(?bool)', 'Ref1 = FuncTwoArgNoRet'], 'E1012: Type mismatch; expected func(?bool) but got func(bool, number)')
+v9.CheckDefFailure(['var Ref1: func(?bool)', 'Ref1 = g:FuncTwoArgNoRet'], 'E1012: Type mismatch; expected func(?bool) but got func(bool, number)')
-CheckDefFailure(['var Ref1: func(...bool)', 'Ref1 = FuncTwoArgNoRet'], 'E1012: Type mismatch; expected func(...bool) but got func(bool, number)')
+v9.CheckDefFailure(['var Ref1: func(...bool)', 'Ref1 = g:FuncTwoArgNoRet'], 'E1012: Type mismatch; expected func(...bool) but got func(bool, number)')
-CheckDefFailure(['var RefWrong: func(string ,number)'], 'E1068:')
+v9.CheckDefFailure(['var RefWrong: func(string ,number)'], 'E1068:')
-CheckDefFailure(['var RefWrong: func(string,number)'], 'E1069:')
+v9.CheckDefFailure(['var RefWrong: func(string,number)'], 'E1069:')
-CheckDefFailure(['var RefWrong: func(bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool)'], 'E1005:')
+v9.CheckDefFailure(['var RefWrong: func(bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool)'], 'E1005:')
-CheckDefFailure(['var RefWrong: func(bool):string'], 'E1069:')
+v9.CheckDefFailure(['var RefWrong: func(bool):string'], 'E1069:')
 enddef
 def Test_func_return_type()
 var nr: number
-nr = FuncNoArgRetNumber()
+nr = g:FuncNoArgRetNumber()
 nr->assert_equal(1234)
 nr = FuncOneArgRetAny(122)
 nr->assert_equal(122)
 var str: string
 str = FuncOneArgRetAny('yes')
 str->assert_equal('yes')
-CheckDefFailure(['var str: string', 'str = FuncNoArgRetNumber()'], 'E1012: Type mismatch; expected string but got number')
+v9.CheckDefFailure(['var str: string', 'str = g:FuncNoArgRetNumber()'], 'E1012: Type mismatch; expected string but got number')
 enddef
 def Test_func_common_type()
 def FuncOne(n: number): number
 return n
 assert_equal(8, list[0](8))
 assert_equal(4, list[1]('word'))
 assert_equal(7, list[2](3, 'word'))
 enddef
-def MultiLine(
+def s:MultiLine(
 arg1: string,
 arg2 = 1234,
 ...rest: list<string>
 ): string
 return arg1 .. arg2 .. join(rest, '-')
 MultiLine('text', 777, 'one')->assert_equal('text777one')
 MultiLine('text', 777, 'one', 'two')->assert_equal('text777one-two')
 enddef
 func Test_multiline_not_vim9()
-call MultiLine('text')->assert_equal('text1234')
+call s:MultiLine('text')->assert_equal('text1234')
-call MultiLine('text', 777)->assert_equal('text777')
+call s:MultiLine('text', 777)->assert_equal('text777')
-call MultiLine('text', 777, 'one')->assert_equal('text777one')
+call s:MultiLine('text', 777, 'one')->assert_equal('text777one')
-call MultiLine('text', 777, 'one', 'two')->assert_equal('text777one-two')
+call s:MultiLine('text', 777, 'one', 'two')->assert_equal('text777one-two')
 endfunc
 " When using CheckScriptFailure() for the below test, E1010 is generated instead
 " of E1056.
 delete('Xdef')
 enddef
 def Test_deleted_function()
-CheckDefExecFailure([
+v9.CheckDefExecFailure([
 'var RefMe: func = function("g:DelMe")',
 'delfunc g:DelMe',
 'echo RefMe()'], 'E117:')
 enddef
 def Test_unknown_function()
-CheckDefExecFailure([
+v9.CheckDefExecFailure([
 'var Ref: func = function("NotExist")',
 'delfunc g:NotExist'], 'E700:')
 enddef
-def RefFunc(Ref: func(any): any): string
+def s:RefFunc(Ref: func(any): any): string
 return Ref('more')
 enddef
 def Test_closure_simple()
 var local = 'some '
 RefFunc((s) => local .. s)->assert_equal('some more')
 enddef
-def MakeRef()
+def s:MakeRef()
 var local = 'some '
 g:Ref = (s) => local .. s
 enddef
 def Test_closure_ref_after_return()
 MakeRef()
 g:Ref('thing')->assert_equal('some thing')
 unlet g:Ref
 enddef
-def MakeTwoRefs()
+def s:MakeTwoRefs()
 var local = ['some']
 g:Extend = (s) => local->add(s)
 g:Read = () => local
 enddef
 unlet g:Extend
 unlet g:Read
 enddef
-def ReadRef(Ref: func(): list<string>): string
+def s:ReadRef(Ref: func(): list<string>): string
 return join(Ref(), ' ')
 enddef
-def ExtendRef(Ref: func(string): list<string>, add: string)
+def s:ExtendRef(Ref: func(string): list<string>, add: string)
 Ref(add)
 enddef
 def Test_closure_two_indirect_refs()
 MakeTwoRefs()
 unlet g:Extend
 unlet g:Read
 enddef
-def MakeArgRefs(theArg: string)
+def s:MakeArgRefs(theArg: string)
 var local = 'loc_val'
 g:UseArg = (s) => theArg .. '/' .. local .. '/' .. s
 enddef
-def MakeArgRefsVarargs(theArg: string, ...rest: list<string>)
+def s:MakeArgRefsVarargs(theArg: string, ...rest: list<string>)
 var local = 'the_loc'
 g:UseVararg = (s) => theArg .. '/' .. local .. '/' .. s .. '/' .. join(rest)
 enddef
 def Test_closure_using_argument()
 def Inc(nr: number): number
 return nr + 2
 enddef
 assert_equal([3, 4, 5], Test(Inc))
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 enddef
-def MakeGetAndAppendRefs()
+def s:MakeGetAndAppendRefs()
 var local = 'a'
 def Append(arg: string)
 local ..= arg
 enddef
 return local .. arg
 enddef
 Closure('!!!')->assert_equal('text!!!')
 enddef
-func GetResult(Ref)
+func s:GetResult(Ref)
 return a:Ref('some')
 endfunc
 def Test_call_closure_not_compiled()
 var text = 'text'
 timer_start(0, () => name)
 endfor
 enddef
 Func()
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 enddef
 def Test_nested_closure_used()
 var lines =<< trim END
 vim9script
 g:Myclosure = () => Closure()
 enddef
 Func()
 assert_equal('hello', g:Myclosure())
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 enddef
 def Test_nested_closure_fails()
 var lines =<< trim END
 vim9script
 def FuncB(n: number): list<string>
 return map([0], (_, v) => n)
 enddef
 FuncA()
 END
-CheckScriptFailure(lines, 'E1012:')
+v9.CheckScriptFailure(lines, 'E1012:')
 enddef
 def Test_global_closure()
 var lines =<< trim END
 vim9script
 new
 repeat(['aaa', 'bbb', 'ccc'], 3)->setline(1)
 ReverseEveryNLines(3, 1, 9)
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 var expected = repeat(['ccc', 'bbb', 'aaa'], 3)
 assert_equal(expected, getline(1, 9))
 bwipe!
 enddef
 g:Inner()
 assert_equal(2, x)
 enddef
 Outer()
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 delfunc g:Inner
 enddef
 def Test_closure_called_from_legacy()
 var lines =<< trim END
 }
 execute printf('call %s()', string(F))
 enddef
 Func()
 END
-CheckScriptFailure(lines, 'E1248')
+v9.CheckScriptFailure(lines, 'E1248')
 enddef
 def Test_failure_in_called_function()
 # this was using the frame index as the return value
 var lines =<< trim END
 call PopupTerm(0)
 catch
 endtry
 au! TerminalWinOpen
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 enddef
 def Test_nested_lambda()
 var lines =<< trim END
 vim9script
 var res = Lambda2()
 assert_equal([7, 4], res)
 enddef
 Func()
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 enddef
 def Test_double_nested_lambda()
 var lines =<< trim END
 vim9script
 return head .. sep .. tail
 })
 enddef
 assert_equal('hello-there', F('hello')('-')('there'))
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 enddef
 def Test_nested_inline_lambda()
 var lines =<< trim END
 vim9script
 return sep .. arg .. text
 })
 enddef
 assert_equal('--there++', F('++')('there')('--'))
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 lines =<< trim END
 vim9script
 echo range(4)->mapnew((_, v) => {
 return range(v) ->mapnew((_, s) => {
 return string(s)
 })
 })
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 lines =<< trim END
 vim9script
 def s:func()
 }))
 enddef
 defcomp
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 enddef
 def Shadowed(): list<number>
 var FuncList: list<func: number> = [() => 42]
 return FuncList->mapnew((_, Shadowed) => Shadowed())
 enddef
 def Test_lambda_arg_shadows_func()
-assert_equal([42], Shadowed())
+assert_equal([42], g:Shadowed())
 enddef
-def Line_continuation_in_def(dir: string = ''): string
+def s:Line_continuation_in_def(dir: string = ''): string
 var path: string = empty(dir)
 \ ? 'empty'
 \ : 'full'
 return path
 enddef
 var lines =<< trim END
 vim9script
 var script = 'test'
 assert_equal(['test'], map(['one'], (_, _) => script))
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 enddef
-def Line_continuation_in_lambda(): list<string>
+def s:Line_continuation_in_lambda(): list<string>
 var x = range(97, 100)
 ->mapnew((_, v) => nr2char(v)
 ->toupper())
 ->reverse()
 return x
 v.m,
 substitute(v.s, '.*', 'yyy', '')
 ))
 assert_equal(['1:2:yyy'], res)
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 enddef
 def Test_list_lambda()
 timer_start(1000, (_) => 0)
 var body = execute(timer_info()[0].callback
 for i in range(10)
 var inloop = i
 flist[i] = () => inloop
 endfor
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 lines =<< trim END
 vim9script
 if true
 var outloop = 5
 for i in range(10)
 flist[i] = () => outloop
 endfor
 endif
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 lines =<< trim END
 vim9script
 if true
 var outloop = 5
 var flist: list<func>
 for i in range(10)
 flist[i] = () => outloop
 endfor
 END
-CheckScriptFailure(lines, 'E1001: Variable not found: outloop', 1)
+v9.CheckScriptFailure(lines, 'E1001: Variable not found: outloop', 1)
 lines =<< trim END
 vim9script
 for i in range(10)
 var Ref = () => 0
 endfor
 assert_equal(0, ((i) => 0)(0))
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 enddef
 def Test_legacy_lambda()
 legacy echo {x -> 'hello ' .. x}('foo')
 var lines =<< trim END
 echo {x -> 'hello ' .. x}('foo')
 END
-CheckDefAndScriptFailure(lines, 'E720:')
+v9.CheckDefAndScriptFailure(lines, 'E720:')
 lines =<< trim END
 vim9script
 def Func()
 echo (() => 'no error')()
 enddef
 legacy call s:Func()
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 enddef
 def Test_legacy()
 var lines =<< trim END
 vim9script
 Testit()
 assert_equal(1, g:legacyvar)
 unlet g:legacyvar
 delfunc g:LegacyFunction
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 enddef
 def Test_legacy_errors()
 for cmd in ['if', 'elseif', 'else', 'endif',
 'for', 'endfor', 'continue', 'break',
 'while', 'endwhile',
 'try', 'catch', 'finally', 'endtry']
-CheckDefFailure(['legacy ' .. cmd .. ' expr'], 'E1189:')
+v9.CheckDefFailure(['legacy ' .. cmd .. ' expr'], 'E1189:')
 endfor
 enddef
 def Test_call_legacy_with_dict()
 var lines =<< trim END
 var d = {value: 'bar', func: Legacy}
 d.func()
 assert_equal('bar', g:result)
 unlet g:result
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 enddef
-def DoFilterThis(a: string): list<string>
+def s:DoFilterThis(a: string): list<string>
 # closure nested inside another closure using argument
 var Filter = (l) => filter(l, (_, v) => stridx(v, a) == 0)
 return ['x', 'y', 'a', 'x2', 'c']->Filter()
 enddef
 defcompile
 END
 writefile(lines, 'XTest_silent_echo')
 # Check that the balloon shows up after a mouse move
-var buf = RunVimInTerminal('-S XTest_silent_echo', {'rows': 6})
+var buf = g:RunVimInTerminal('-S XTest_silent_echo', {'rows': 6})
 term_sendkeys(buf, ":abc")
-VerifyScreenDump(buf, 'Test_vim9_silent_echo', {})
+g:VerifyScreenDump(buf, 'Test_vim9_silent_echo', {})
 # clean up
-StopVimInTerminal(buf)
+g:StopVimInTerminal(buf)
 delete('XTest_silent_echo')
 enddef
 def SilentlyError()
 execute('silent! invalid')
 g:did_it = 'yes'
 enddef
-func UserError()
+func s:UserError()
 silent! invalid
 endfunc
 def SilentlyUserError()
 UserError()
 enddef
 popup_create('popup', {filter: Filter})
 feedkeys("o\r", 'xnt')
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 enddef
-def Fibonacci(n: number): number
+def s:Fibonacci(n: number): number
 if n < 2
 return n
 else
 return Fibonacci(n - 1) + Fibonacci(n - 2)
 endif
 def Test_recursive_call()
 Fibonacci(20)->assert_equal(6765)
 enddef
-def TreeWalk(dir: string): list<any>
+def s:TreeWalk(dir: string): list<any>
 return readdir(dir)->mapnew((_, val) =>
 fnamemodify(dir .. '/' .. val, ':p')->isdirectory()
 ? {[val]: TreeWalk(dir .. '/' .. val)}
 : val
 )
 def Test_invalid_function_name()
 var lines =<< trim END
 vim9script
 def s: list<string>
 END
-CheckScriptFailure(lines, 'E129:')
+v9.CheckScriptFailure(lines, 'E129:')
 lines =<< trim END
 vim9script
 def g: list<string>
 END
-CheckScriptFailure(lines, 'E129:')
+v9.CheckScriptFailure(lines, 'E129:')
 lines =<< trim END
 vim9script
 def <SID>: list<string>
 END
-CheckScriptFailure(lines, 'E884:')
+v9.CheckScriptFailure(lines, 'E884:')
 lines =<< trim END
 vim9script
 def F list<string>
 END
-CheckScriptFailure(lines, 'E488:')
+v9.CheckScriptFailure(lines, 'E488:')
 enddef
 def Test_partial_call()
 var lines =<< trim END
 var Xsetlist: func
 assert_equal(4, Len())
 var RepeatFunc = function('repeat', ['o'])
 assert_equal('ooooo', RepeatFunc(5))
 END
-CheckDefAndScriptSuccess(lines)
+v9.CheckDefAndScriptSuccess(lines)
 lines =<< trim END
 vim9script
 def Foo(Parser: any)
 enddef
 var Expr: func(dict<any>): dict<any>
 const Call = Foo(Expr)
 END
-CheckScriptFailure(lines, 'E1235:')
+v9.CheckScriptFailure(lines, 'E1235:')
 enddef
 def Test_cmd_modifier()
 tab echo '0'
-CheckDefFailure(['5tab echo 3'], 'E16:')
+v9.CheckDefFailure(['5tab echo 3'], 'E16:')
 enddef
 def Test_restore_modifiers()
 # check that when compiling a :def function command modifiers are not messed
 # up.
 noautocmd call s:AutocmdsDisabled()
 let g:ei_after = &eventignore
 endfunc
 Func()
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 g:ei_after->assert_equal('')
 enddef
 def StackTop()
 eval 1 + 2
 eval 2 + 3
 # call not on fourth line
-StackBot()
+g:StackBot()
 enddef
 def StackBot()
 # throw an error
 eval [][0]
 enddef
 def Test_callstack_def()
 try
-StackTop()
+g:StackTop()
 catch
 v:throwpoint->assert_match('Test_callstack_def\[2\]..StackTop\[4\]..StackBot, line 2')
 endtry
 enddef
 var z = x
 assert_equal(['x', 'x', 'x'], z)
 enddef
 Func()
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 enddef
 def Test_reset_did_emsg()
 var lines =<< trim END
 @s = 'blah'
 exe '*s'
 popup_close(winid)
 enddef
 Func()
 END
-CheckScriptFailure(lines, 'E492:', 8)
+v9.CheckScriptFailure(lines, 'E492:', 8)
 delfunc! g:Func
 enddef
 def Test_did_emsg_reset()
 # executing an autocommand resets did_emsg, this should not result in a
 # error is silenced, but function aborts on error
 silent! Func()
 assert_equal('none', g:result)
 unlet g:result
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 enddef
 def Test_continues_with_silent_error()
 var lines =<< trim END
 vim9script
 # error is silenced, function does not abort
 Func()
 assert_equal('yes', g:result)
 unlet g:result
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 enddef
 def Test_abort_even_with_silent()
 var lines =<< trim END
 vim9script
 enddef
 silent! Func()
 assert_equal('none', g:result)
 unlet g:result
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 enddef
 def Test_cmdmod_silent_restored()
 var lines =<< trim END
 vim9script
 enddef
 Crash()
 assert_equal('CbEbEaCa', result)
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 enddef
 def Test_dict_member_with_silent()
 var lines =<< trim END
 vim9script
 enddef
 silent! Func()
 assert_equal('0', g:result)
 unlet g:result
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 enddef
 def Test_skip_cmds_with_silent()
 var lines =<< trim END
 vim9script
 sil! :/not found/put _
 enddef
 Func(true)
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 enddef
 def Test_opfunc()
 nnoremap <F3> <cmd>set opfunc=Opfunc<cr>g@
 def g:Opfunc(_: any): string
 feedkeys('g@l', 'n')
 feedkeys('llll')
 END
 call writefile(lines, 'XTest_opfunc_error')
-var buf = RunVimInTerminal('-S XTest_opfunc_error', {rows: 6, wait_for_ruler: 0})
+var buf = g:RunVimInTerminal('-S XTest_opfunc_error', {rows: 6, wait_for_ruler: 0})
-WaitForAssert(() => assert_match('Press ENTER', term_getline(buf, 6)))
+g:WaitForAssert(() => assert_match('Press ENTER', term_getline(buf, 6)))
-WaitForAssert(() => assert_match('E684: list index out of range: 0', term_getline(buf, 5)))
+g:WaitForAssert(() => assert_match('E684: list index out of range: 0', term_getline(buf, 5)))
 # clean up
-StopVimInTerminal(buf)
+g:StopVimInTerminal(buf)
 delete('XTest_opfunc_error')
 enddef
 " this was crashing on exit
 def Test_nested_lambda_in_closure()
 g:Inner()
 enddef
 defcompile
 # not reached
 END
-if !RunVim([], lines, '--clean -c WriteDone -c quit')
+if !g:RunVim([], lines, '--clean -c WriteDone -c quit')
 return
 endif
 assert_equal(['Done'], readfile('XnestedDone'))
 delete('XnestedDone')
 enddef
 def H(d: dict<func>): string
 return d.f('a')
 enddef
 END
-CheckScriptSuccess(lines + ['echo H(G(F1))'])
+v9.CheckScriptSuccess(lines + ['echo H(G(F1))'])
-CheckScriptFailure(lines + ['echo H(G(F2))'], 'E1013:')
+v9.CheckScriptFailure(lines + ['echo H(G(F2))'], 'E1013:')
 enddef
 def Test_list_any_type_checked()
 var lines =<< trim END
 vim9script
 def Bar(ll: list<dict<any>>)
 enddef
 Foo()
 END
 lines[2] = 'var l: list<any>'
-CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected list<dict<any>> but got list<any>', 2)
+v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected list<dict<any>> but got list<any>', 2)
 lines[2] = 'var l: list<any> = []'
-CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected list<dict<any>> but got list<any>', 2)
+v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected list<dict<any>> but got list<any>', 2)
 lines[2] = 'var l: list<any> = [11]'
-CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected list<dict<any>> but got list<number>', 2)
+v9.CheckScriptFailure(lines, 'E1013: Argument 1: type mismatch, expected list<dict<any>> but got list<number>', 2)
 enddef
 def Test_compile_error()
 var lines =<< trim END
 def g:Broken()
 echo 'a' + {}
 enddef
 call g:Broken()
 END
 # First call: compilation error
-CheckScriptFailure(lines, 'E1051: Wrong argument type for +')
+v9.CheckScriptFailure(lines, 'E1051: Wrong argument type for +')
 # Second call won't try compiling again
 assert_fails('call g:Broken()', 'E1091: Function is not compiled: Broken')
 delfunc g:Broken
 def g:Broken()
 echo 'a' + []
 enddef
 silent! defcompile
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 # Calling the function won't try compiling again
 assert_fails('call g:Broken()', 'E1091: Function is not compiled: Broken')
 delfunc g:Broken
 enddef
 endfunc
 assert_equal('too', Oktoo())
 assert_equal([[1], [2], [3]], range(3)->mapnew((_, v) => [v]->map((_, w) => w + 1)))
 END
-CheckScriptSuccess(lines)
+v9.CheckScriptSuccess(lines)
 lines =<< trim END
 def Ignore(_: string): string
 return _
 enddef
 defcompile
 END
-CheckScriptFailure(lines, 'E1181:', 1)
+v9.CheckScriptFailure(lines, 'E1181:', 1)
 lines =<< trim END
 var _ = 1
 END
-CheckDefAndScriptFailure(lines, 'E1181:', 1)
+v9.CheckDefAndScriptFailure(lines, 'E1181:', 1)
 lines =<< trim END
 var x = _
 END
-CheckDefAndScriptFailure(lines, 'E1181:', 1)
+v9.CheckDefAndScriptFailure(lines, 'E1181:', 1)
 enddef
 def Test_too_many_arguments()
 var lines =<< trim END
 echo [0, 1, 2]->map(() => 123)
 END
-CheckDefExecAndScriptFailure(lines, 'E1106: 2 arguments too many', 1)
+v9.CheckDefExecAndScriptFailure(lines, 'E1106: 2 arguments too many', 1)
 lines =<< trim END
 echo [0, 1, 2]->map((_) => 123)
 END
-CheckDefExecAndScriptFailure(lines, 'E1106: One argument too many', 1)
+v9.CheckDefExecAndScriptFailure(lines, 'E1106: One argument too many', 1)
 enddef
 def Test_closing_brace_at_start_of_line()
 var lines =<< trim END
 def Func()
 enddef
 Func(
 )
 END
-call CheckDefAndScriptSuccess(lines)
+v9.CheckDefAndScriptSuccess(lines)
 enddef
-func CreateMydict()
+func s:CreateMydict()
 let g:mydict = {}
 func g:mydict.afunc()
 let g:result = self.key
 endfunc
 endfunc
 def F()
 cal
 enddef
 defcompile
 END
-CheckScriptFailure(lines, 'E476:')
+v9.CheckScriptFailure(lines, 'E476:')
 enddef
 if has('python3')
 def Test_python3_heredoc()
 py3 << trim EOF

Mercurial > vim

comparison src/testdir/test_vim9_func.vim @ 27457:4c16acb2525f v8.2.4257