Mercurial > vim

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

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
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 44cb142c8615
children 55613f0d59bc
comparison
equal deleted inserted replaced
27456:a8e2d91995ce 27457:4c16acb2525f
1 " Test various aspects of the Vim9 script language. 1 " Test various aspects of the Vim9 script language.
2 2
3 source check.vim 3 source check.vim
4 source term_util.vim 4 source term_util.vim
5 source vim9.vim 5 import './vim9.vim' as v9
6 source screendump.vim 6 source screendump.vim
7 source shared.vim 7 source shared.vim
8 8
9 def Test_vim9script_feature() 9 def Test_vim9script_feature()
10 # example from the help, here the feature is always present 10 # example from the help, here the feature is always present
16 endif 16 endif
17 vim9script 17 vim9script
18 # Vim9 script commands go here 18 # Vim9 script commands go here
19 g:didit = true 19 g:didit = true
20 END 20 END
21 CheckScriptSuccess(lines) 21 v9.CheckScriptSuccess(lines)
22 assert_equal(true, g:didit) 22 assert_equal(true, g:didit)
23 unlet g:didit 23 unlet g:didit
24 enddef 24 enddef
25 25
26 def Test_range_only() 26 def Test_range_only()
33 # without range commands use current line 33 # without range commands use current line
34 new 34 new
35 setline(1, ['one', 'two', 'three']) 35 setline(1, ['one', 'two', 'three'])
36 :2 36 :2
37 print 37 print
38 assert_equal('two', Screenline(&lines)) 38 assert_equal('two', g:Screenline(&lines))
39 :3 39 :3
40 list 40 list
41 assert_equal('three$', Screenline(&lines)) 41 assert_equal('three$', g:Screenline(&lines))
42 42
43 # missing command does not print the line 43 # missing command does not print the line
44 var lines =<< trim END 44 var lines =<< trim END
45 vim9script 45 vim9script
46 :1| 46 :1|
47 assert_equal('three$', Screenline(&lines)) 47 assert_equal('three$', g:Screenline(&lines))
48 :| 48 :|
49 assert_equal('three$', Screenline(&lines)) 49 assert_equal('three$', g:Screenline(&lines))
50 END 50 END
51 CheckScriptSuccess(lines) 51 v9.CheckScriptSuccess(lines)
52 52
53 bwipe! 53 bwipe!
54 54
55 # won't generate anything 55 # won't generate anything
56 if false 56 if false
62 let g:astring = 'text' 62 let g:astring = 'text'
63 let g:anumber = 123 63 let g:anumber = 123
64 64
65 def Test_delfunction() 65 def Test_delfunction()
66 # Check function is defined in script namespace 66 # Check function is defined in script namespace
67 CheckScriptSuccess([ 67 v9.CheckScriptSuccess([
68 'vim9script', 68 'vim9script',
69 'func CheckMe()', 69 'func CheckMe()',
70 ' return 123', 70 ' return 123',
71 'endfunc', 71 'endfunc',
72 'assert_equal(123, s:CheckMe())', 72 'assert_equal(123, s:CheckMe())',
73 ]) 73 ])
74 74
75 # Check function in script namespace cannot be deleted 75 # Check function in script namespace cannot be deleted
76 CheckScriptFailure([ 76 v9.CheckScriptFailure([
77 'vim9script', 77 'vim9script',
78 'func DeleteMe1()', 78 'func DeleteMe1()',
79 'endfunc', 79 'endfunc',
80 'delfunction DeleteMe1', 80 'delfunction DeleteMe1',
81 ], 'E1084:') 81 ], 'E1084:')
82 CheckScriptFailure([ 82 v9.CheckScriptFailure([
83 'vim9script', 83 'vim9script',
84 'func DeleteMe2()', 84 'func DeleteMe2()',
85 'endfunc', 85 'endfunc',
86 'def DoThat()', 86 'def DoThat()',
87 ' delfunction DeleteMe2', 87 ' delfunction DeleteMe2',
88 'enddef', 88 'enddef',
89 'DoThat()', 89 'DoThat()',
90 ], 'E1084:') 90 ], 'E1084:')
91 CheckScriptFailure([ 91 v9.CheckScriptFailure([
92 'vim9script', 92 'vim9script',
93 'def DeleteMe3()', 93 'def DeleteMe3()',
94 'enddef', 94 'enddef',
95 'delfunction DeleteMe3', 95 'delfunction DeleteMe3',
96 ], 'E1084:') 96 ], 'E1084:')
97 CheckScriptFailure([ 97 v9.CheckScriptFailure([
98 'vim9script', 98 'vim9script',
99 'def DeleteMe4()', 99 'def DeleteMe4()',
100 'enddef', 100 'enddef',
101 'def DoThat()', 101 'def DoThat()',
102 ' delfunction DeleteMe4', 102 ' delfunction DeleteMe4',
116 enddef 116 enddef
117 assert_equal("no", g:Global()) 117 assert_equal("no", g:Global())
118 delfunc g:Global 118 delfunc g:Global
119 assert_false(exists('*g:Global')) 119 assert_false(exists('*g:Global'))
120 END 120 END
121 CheckScriptSuccess(lines) 121 v9.CheckScriptSuccess(lines)
122 122
123 # Check that global function can be replaced by a :def function and deleted 123 # Check that global function can be replaced by a :def function and deleted
124 lines =<< trim END 124 lines =<< trim END
125 vim9script 125 vim9script
126 func g:Global() 126 func g:Global()
132 enddef 132 enddef
133 assert_equal("no", g:Global()) 133 assert_equal("no", g:Global())
134 delfunc g:Global 134 delfunc g:Global
135 assert_false(exists('*g:Global')) 135 assert_false(exists('*g:Global'))
136 END 136 END
137 CheckScriptSuccess(lines) 137 v9.CheckScriptSuccess(lines)
138 138
139 # Check that global :def function can be replaced by a function and deleted 139 # Check that global :def function can be replaced by a function and deleted
140 lines =<< trim END 140 lines =<< trim END
141 vim9script 141 vim9script
142 def g:Global(): string 142 def g:Global(): string
148 endfunc 148 endfunc
149 assert_equal("no", g:Global()) 149 assert_equal("no", g:Global())
150 delfunc g:Global 150 delfunc g:Global
151 assert_false(exists('*g:Global')) 151 assert_false(exists('*g:Global'))
152 END 152 END
153 CheckScriptSuccess(lines) 153 v9.CheckScriptSuccess(lines)
154 enddef 154 enddef
155 155
156 def Test_wrong_type() 156 def Test_wrong_type()
157 CheckDefFailure(['var name: list<nothing>'], 'E1010:') 157 v9.CheckDefFailure(['var name: list<nothing>'], 'E1010:')
158 CheckDefFailure(['var name: list<list<nothing>>'], 'E1010:') 158 v9.CheckDefFailure(['var name: list<list<nothing>>'], 'E1010:')
159 CheckDefFailure(['var name: dict<nothing>'], 'E1010:') 159 v9.CheckDefFailure(['var name: dict<nothing>'], 'E1010:')
160 CheckDefFailure(['var name: dict<dict<nothing>>'], 'E1010:') 160 v9.CheckDefFailure(['var name: dict<dict<nothing>>'], 'E1010:')
161 161
162 CheckDefFailure(['var name: dict<number'], 'E1009:') 162 v9.CheckDefFailure(['var name: dict<number'], 'E1009:')
163 CheckDefFailure(['var name: dict<list<number>'], 'E1009:') 163 v9.CheckDefFailure(['var name: dict<list<number>'], 'E1009:')
164 164
165 CheckDefFailure(['var name: ally'], 'E1010:') 165 v9.CheckDefFailure(['var name: ally'], 'E1010:')
166 CheckDefFailure(['var name: bram'], 'E1010:') 166 v9.CheckDefFailure(['var name: bram'], 'E1010:')
167 CheckDefFailure(['var name: cathy'], 'E1010:') 167 v9.CheckDefFailure(['var name: cathy'], 'E1010:')
168 CheckDefFailure(['var name: dom'], 'E1010:') 168 v9.CheckDefFailure(['var name: dom'], 'E1010:')
169 CheckDefFailure(['var name: freddy'], 'E1010:') 169 v9.CheckDefFailure(['var name: freddy'], 'E1010:')
170 CheckDefFailure(['var name: john'], 'E1010:') 170 v9.CheckDefFailure(['var name: john'], 'E1010:')
171 CheckDefFailure(['var name: larry'], 'E1010:') 171 v9.CheckDefFailure(['var name: larry'], 'E1010:')
172 CheckDefFailure(['var name: ned'], 'E1010:') 172 v9.CheckDefFailure(['var name: ned'], 'E1010:')
173 CheckDefFailure(['var name: pam'], 'E1010:') 173 v9.CheckDefFailure(['var name: pam'], 'E1010:')
174 CheckDefFailure(['var name: sam'], 'E1010:') 174 v9.CheckDefFailure(['var name: sam'], 'E1010:')
175 CheckDefFailure(['var name: vim'], 'E1010:') 175 v9.CheckDefFailure(['var name: vim'], 'E1010:')
176 176
177 CheckDefFailure(['var Ref: number', 'Ref()'], 'E1085:') 177 v9.CheckDefFailure(['var Ref: number', 'Ref()'], 'E1085:')
178 CheckDefFailure(['var Ref: string', 'var res = Ref()'], 'E1085:') 178 v9.CheckDefFailure(['var Ref: string', 'var res = Ref()'], 'E1085:')
179 enddef 179 enddef
180 180
181 def Test_script_wrong_type() 181 def Test_script_wrong_type()
182 var lines =<< trim END 182 var lines =<< trim END
183 vim9script 183 vim9script
184 var s:dict: dict<string> 184 var s:dict: dict<string>
185 s:dict['a'] = ['x'] 185 s:dict['a'] = ['x']
186 END 186 END
187 CheckScriptFailure(lines, 'E1012: Type mismatch; expected string but got list<string>', 3) 187 v9.CheckScriptFailure(lines, 'E1012: Type mismatch; expected string but got list<string>', 3)
188 enddef 188 enddef
189 189
190 def Test_const() 190 def Test_const()
191 CheckDefFailure(['final name = 234', 'name = 99'], 'E1018:') 191 v9.CheckDefFailure(['final name = 234', 'name = 99'], 'E1018:')
192 CheckDefFailure(['final one = 234', 'var one = 99'], 'E1017:') 192 v9.CheckDefFailure(['final one = 234', 'var one = 99'], 'E1017:')
193 CheckDefFailure(['final list = [1, 2]', 'var list = [3, 4]'], 'E1017:') 193 v9.CheckDefFailure(['final list = [1, 2]', 'var list = [3, 4]'], 'E1017:')
194 CheckDefFailure(['final two'], 'E1125:') 194 v9.CheckDefFailure(['final two'], 'E1125:')
195 CheckDefFailure(['final &option'], 'E996:') 195 v9.CheckDefFailure(['final &option'], 'E996:')
196 196
197 var lines =<< trim END 197 var lines =<< trim END
198 final list = [1, 2, 3] 198 final list = [1, 2, 3]
199 list[0] = 4 199 list[0] = 4
200 list->assert_equal([4, 2, 3]) 200 list->assert_equal([4, 2, 3])
215 constdict['two']['six'] = 66 215 constdict['two']['six'] = 66
216 var cd = constdict['two'] 216 var cd = constdict['two']
217 cd['six'] = 66 217 cd['six'] = 66
218 constdict->assert_equal({one: 1, two: {five: 55, six: 66}, three: 3}) 218 constdict->assert_equal({one: 1, two: {five: 55, six: 66}, three: 3})
219 END 219 END
220 CheckDefAndScriptSuccess(lines) 220 v9.CheckDefAndScriptSuccess(lines)
221 enddef 221 enddef
222 222
223 def Test_const_bang() 223 def Test_const_bang()
224 var lines =<< trim END 224 var lines =<< trim END
225 const var = 234 225 const var = 234
226 var = 99 226 var = 99
227 END 227 END
228 CheckDefExecFailure(lines, 'E1018:', 2) 228 v9.CheckDefExecFailure(lines, 'E1018:', 2)
229 CheckScriptFailure(['vim9script'] + lines, 'E46:', 3) 229 v9.CheckScriptFailure(['vim9script'] + lines, 'E46:', 3)
230 230
231 lines =<< trim END 231 lines =<< trim END
232 const ll = [2, 3, 4] 232 const ll = [2, 3, 4]
233 ll[0] = 99 233 ll[0] = 99
234 END 234 END
235 CheckDefExecFailure(lines, 'E1119:', 2) 235 v9.CheckDefExecFailure(lines, 'E1119:', 2)
236 CheckScriptFailure(['vim9script'] + lines, 'E741:', 3) 236 v9.CheckScriptFailure(['vim9script'] + lines, 'E741:', 3)
237 237
238 lines =<< trim END 238 lines =<< trim END
239 const ll = [2, 3, 4] 239 const ll = [2, 3, 4]
240 ll[3] = 99 240 ll[3] = 99
241 END 241 END
242 CheckDefExecFailure(lines, 'E1118:', 2) 242 v9.CheckDefExecFailure(lines, 'E1118:', 2)
243 CheckScriptFailure(['vim9script'] + lines, 'E684:', 3) 243 v9.CheckScriptFailure(['vim9script'] + lines, 'E684:', 3)
244 244
245 lines =<< trim END 245 lines =<< trim END
246 const dd = {one: 1, two: 2} 246 const dd = {one: 1, two: 2}
247 dd["one"] = 99 247 dd["one"] = 99
248 END 248 END
249 CheckDefExecFailure(lines, 'E1121:', 2) 249 v9.CheckDefExecFailure(lines, 'E1121:', 2)
250 CheckScriptFailure(['vim9script'] + lines, 'E741:', 3) 250 v9.CheckScriptFailure(['vim9script'] + lines, 'E741:', 3)
251 251
252 lines =<< trim END 252 lines =<< trim END
253 const dd = {one: 1, two: 2} 253 const dd = {one: 1, two: 2}
254 dd["three"] = 99 254 dd["three"] = 99
255 END 255 END
256 CheckDefExecFailure(lines, 'E1120:') 256 v9.CheckDefExecFailure(lines, 'E1120:')
257 CheckScriptFailure(['vim9script'] + lines, 'E741:', 3) 257 v9.CheckScriptFailure(['vim9script'] + lines, 'E741:', 3)
258 enddef 258 enddef
259 259
260 def Test_range_no_colon() 260 def Test_range_no_colon()
261 CheckDefFailure(['%s/a/b/'], 'E1050:') 261 v9.CheckDefFailure(['%s/a/b/'], 'E1050:')
262 CheckDefFailure(['+ s/a/b/'], 'E1050:') 262 v9.CheckDefFailure(['+ s/a/b/'], 'E1050:')
263 CheckDefFailure(['- s/a/b/'], 'E1050:') 263 v9.CheckDefFailure(['- s/a/b/'], 'E1050:')
264 CheckDefFailure(['. s/a/b/'], 'E1050:') 264 v9.CheckDefFailure(['. s/a/b/'], 'E1050:')
265 enddef 265 enddef
266 266
267 267
268 def Test_block() 268 def Test_block()
269 var outer = 1 269 var outer = 1
276 276
277 {|echo 'yes'|} 277 {|echo 'yes'|}
278 enddef 278 enddef
279 279
280 def Test_block_failure() 280 def Test_block_failure()
281 CheckDefFailure(['{', 'var inner = 1', '}', 'echo inner'], 'E1001:') 281 v9.CheckDefFailure(['{', 'var inner = 1', '}', 'echo inner'], 'E1001:')
282 CheckDefFailure(['}'], 'E1025:') 282 v9.CheckDefFailure(['}'], 'E1025:')
283 CheckDefFailure(['{', 'echo 1'], 'E1026:') 283 v9.CheckDefFailure(['{', 'echo 1'], 'E1026:')
284 enddef 284 enddef
285 285
286 def Test_block_local_vars() 286 def Test_block_local_vars()
287 var lines =<< trim END 287 var lines =<< trim END
288 vim9script 288 vim9script
320 END 320 END
321 321
322 # need to execute this with a separate Vim instance to avoid the current 322 # need to execute this with a separate Vim instance to avoid the current
323 # context gets garbage collected. 323 # context gets garbage collected.
324 writefile(lines, 'Xscript') 324 writefile(lines, 'Xscript')
325 RunVim([], [], '-S Xscript') 325 g:RunVim([], [], '-S Xscript')
326 assert_equal(['ok'], readfile('Xdidit')) 326 assert_equal(['ok'], readfile('Xdidit'))
327 327
328 delete('Xscript') 328 delete('Xscript')
329 delete('Xdidit') 329 delete('Xdidit')
330 enddef 330 enddef
343 endif 343 endif
344 # function is compiled here, after blocks have finished, can still access 344 # function is compiled here, after blocks have finished, can still access
345 # "foo" and "bar" 345 # "foo" and "bar"
346 assert_equal(['foo', 'bar'], Func()) 346 assert_equal(['foo', 'bar'], Func())
347 END 347 END
348 CheckScriptSuccess(lines) 348 v9.CheckScriptSuccess(lines)
349 enddef 349 enddef
350 350
351 " legacy func for command that's defined later 351 " legacy func for command that's defined later
352 func InvokeSomeCommand() 352 func s:InvokeSomeCommand()
353 SomeCommand 353 SomeCommand
354 endfunc 354 endfunc
355 355
356 def Test_autocommand_block() 356 def Test_autocommand_block()
357 com SomeCommand { 357 com SomeCommand {
555 n = 333 555 n = 333
556 endtry 556 endtry
557 assert_equal(333, n) 557 assert_equal(333, n)
558 558
559 try 559 try
560 l = DeletedFunc() 560 l = g:DeletedFunc()
561 catch /E933:/ 561 catch /E933:/
562 n = 344 562 n = 344
563 endtry 563 endtry
564 assert_equal(344, n) 564 assert_equal(344, n)
565 565
677 ->setline(1) 677 ->setline(1)
678 catch 678 catch
679 g:caught = v:exception 679 g:caught = v:exception
680 endtry 680 endtry
681 END 681 END
682 CheckScriptSuccess(lines) 682 v9.CheckScriptSuccess(lines)
683 assert_match('E1219: Float or Number required for argument 1', g:caught) 683 assert_match('E1219: Float or Number required for argument 1', g:caught)
684 unlet g:caught 684 unlet g:caught
685 685
686 # missing catch and/or finally 686 # missing catch and/or finally
687 lines =<< trim END 687 lines =<< trim END
688 vim9script 688 vim9script
689 try 689 try
690 echo 'something' 690 echo 'something'
691 endtry 691 endtry
692 END 692 END
693 CheckScriptFailure(lines, 'E1032:') 693 v9.CheckScriptFailure(lines, 'E1032:')
694 694
695 # skipping try-finally-endtry when try-finally-endtry is used in another block 695 # skipping try-finally-endtry when try-finally-endtry is used in another block
696 lines =<< trim END 696 lines =<< trim END
697 if v:true 697 if v:true
698 try 698 try
702 try 702 try
703 finally 703 finally
704 endtry 704 endtry
705 endif 705 endif
706 END 706 END
707 CheckDefAndScriptSuccess(lines) 707 v9.CheckDefAndScriptSuccess(lines)
708 enddef 708 enddef
709 709
710 def Test_try_ends_in_return() 710 def Test_try_ends_in_return()
711 var lines =<< trim END 711 var lines =<< trim END
712 vim9script 712 vim9script
717 return 'caught' 717 return 'caught'
718 endtry 718 endtry
719 enddef 719 enddef
720 assert_equal('foo', Foo()) 720 assert_equal('foo', Foo())
721 END 721 END
722 CheckScriptSuccess(lines) 722 v9.CheckScriptSuccess(lines)
723 723
724 lines =<< trim END 724 lines =<< trim END
725 vim9script 725 vim9script
726 def Foo(): string 726 def Foo(): string
727 try 727 try
731 endtry 731 endtry
732 echo 'notreached' 732 echo 'notreached'
733 enddef 733 enddef
734 assert_equal('foo', Foo()) 734 assert_equal('foo', Foo())
735 END 735 END
736 CheckScriptFailure(lines, 'E1095:') 736 v9.CheckScriptFailure(lines, 'E1095:')
737 737
738 lines =<< trim END 738 lines =<< trim END
739 vim9script 739 vim9script
740 def Foo(): string 740 def Foo(): string
741 try 741 try
744 return 'caught' 744 return 'caught'
745 endtry 745 endtry
746 enddef 746 enddef
747 assert_equal('foo', Foo()) 747 assert_equal('foo', Foo())
748 END 748 END
749 CheckScriptFailure(lines, 'E1027:') 749 v9.CheckScriptFailure(lines, 'E1027:')
750 750
751 lines =<< trim END 751 lines =<< trim END
752 vim9script 752 vim9script
753 def Foo(): string 753 def Foo(): string
754 try 754 try
759 return 'done' 759 return 'done'
760 endtry 760 endtry
761 enddef 761 enddef
762 assert_equal('done', Foo()) 762 assert_equal('done', Foo())
763 END 763 END
764 CheckScriptSuccess(lines) 764 v9.CheckScriptSuccess(lines)
765 765
766 enddef 766 enddef
767 767
768 def Test_try_in_catch() 768 def Test_try_in_catch()
769 var lines =<< trim END 769 var lines =<< trim END
797 eval [][0] 797 eval [][0]
798 catch /E684:/ 798 catch /E684:/
799 eval [][0] 799 eval [][0]
800 endtry 800 endtry
801 END 801 END
802 CheckDefExecFailure(lines, 'E684:', 4) 802 v9.CheckDefExecFailure(lines, 'E684:', 4)
803 enddef 803 enddef
804 804
805 " :while at the very start of a function that :continue jumps to 805 " :while at the very start of a function that :continue jumps to
806 def TryContinueFunc() 806 def s:TryContinueFunc()
807 while g:Count < 2 807 while g:Count < 2
808 g:sequence ..= 't' 808 g:sequence ..= 't'
809 try 809 try
810 echoerr 'Test' 810 echoerr 'Test'
811 catch 811 catch
865 CnextOrCfirst() 865 CnextOrCfirst()
866 writefile([getqflist({idx: 0}).idx], 'Xresult') 866 writefile([getqflist({idx: 0}).idx], 'Xresult')
867 qall 867 qall
868 END 868 END
869 writefile(lines, 'XCatchCnext') 869 writefile(lines, 'XCatchCnext')
870 RunVim([], [], '--clean -S XCatchCnext') 870 g:RunVim([], [], '--clean -S XCatchCnext')
871 assert_equal(['1'], readfile('Xresult')) 871 assert_equal(['1'], readfile('Xresult'))
872 872
873 delete('Xfile1') 873 delete('Xfile1')
874 delete('Xfile2') 874 delete('Xfile2')
875 delete('XCatchCnext') 875 delete('XCatchCnext')
899 return ['delete me'] 899 return ['delete me']
900 enddef 900 enddef
901 defcompile 901 defcompile
902 delfunc DeletedFunc 902 delfunc DeletedFunc
903 903
904 def ThrowFromDef() 904 def s:ThrowFromDef()
905 throw "getout" # comment 905 throw "getout" # comment
906 enddef 906 enddef
907 907
908 func CatchInFunc() 908 func s:CatchInFunc()
909 try 909 try
910 call ThrowFromDef() 910 call s:ThrowFromDef()
911 catch 911 catch
912 let g:thrown_func = v:exception 912 let g:thrown_func = v:exception
913 endtry 913 endtry
914 endfunc 914 endfunc
915 915
916 def CatchInDef() 916 def s:CatchInDef()
917 try 917 try
918 ThrowFromDef() 918 ThrowFromDef()
919 catch 919 catch
920 g:thrown_def = v:exception 920 g:thrown_def = v:exception
921 endtry 921 endtry
922 enddef 922 enddef
923 923
924 def ReturnFinally(): string 924 def s:ReturnFinally(): string
925 try 925 try
926 return 'intry' 926 return 'intry'
927 finall 927 finall
928 g:in_finally = 'finally' 928 g:in_finally = 'finally'
929 endtry 929 endtry
982 l->add('4') 982 l->add('4')
983 endtry 983 endtry
984 assert_equal(['1', '2', '3', '4'], l) 984 assert_equal(['1', '2', '3', '4'], l)
985 enddef 985 enddef
986 986
987 def TryOne(): number 987 def s:TryOne(): number
988 try 988 try
989 return 0 989 return 0
990 catch 990 catch
991 endtry 991 endtry
992 return 0 992 return 0
993 enddef 993 enddef
994 994
995 def TryTwo(n: number): string 995 def s:TryTwo(n: number): string
996 try 996 try
997 var x = {} 997 var x = {}
998 catch 998 catch
999 endtry 999 endtry
1000 return 'text' 1000 return 'text'
1021 endtry 1021 endtry
1022 assert_equal('abc', seq) 1022 assert_equal('abc', seq)
1023 enddef 1023 enddef
1024 1024
1025 def Test_try_catch_fails() 1025 def Test_try_catch_fails()
1026 CheckDefFailure(['catch'], 'E603:') 1026 v9.CheckDefFailure(['catch'], 'E603:')
1027 CheckDefFailure(['try', 'echo 0', 'catch', 'catch'], 'E1033:') 1027 v9.CheckDefFailure(['try', 'echo 0', 'catch', 'catch'], 'E1033:')
1028 CheckDefFailure(['try', 'echo 0', 'catch /pat'], 'E1067:') 1028 v9.CheckDefFailure(['try', 'echo 0', 'catch /pat'], 'E1067:')
1029 CheckDefFailure(['finally'], 'E606:') 1029 v9.CheckDefFailure(['finally'], 'E606:')
1030 CheckDefFailure(['try', 'echo 0', 'finally', 'echo 1', 'finally'], 'E607:') 1030 v9.CheckDefFailure(['try', 'echo 0', 'finally', 'echo 1', 'finally'], 'E607:')
1031 CheckDefFailure(['endtry'], 'E602:') 1031 v9.CheckDefFailure(['endtry'], 'E602:')
1032 CheckDefFailure(['while 1', 'endtry'], 'E170:') 1032 v9.CheckDefFailure(['while 1', 'endtry'], 'E170:')
1033 CheckDefFailure(['for i in range(5)', 'endtry'], 'E170:') 1033 v9.CheckDefFailure(['for i in range(5)', 'endtry'], 'E170:')
1034 CheckDefFailure(['if 1', 'endtry'], 'E171:') 1034 v9.CheckDefFailure(['if 1', 'endtry'], 'E171:')
1035 CheckDefFailure(['try', 'echo 1', 'endtry'], 'E1032:') 1035 v9.CheckDefFailure(['try', 'echo 1', 'endtry'], 'E1032:')
1036 1036
1037 CheckDefFailure(['throw'], 'E1143:') 1037 v9.CheckDefFailure(['throw'], 'E1143:')
1038 CheckDefFailure(['throw xxx'], 'E1001:') 1038 v9.CheckDefFailure(['throw xxx'], 'E1001:')
1039 enddef 1039 enddef
1040 1040
1041 def Try_catch_skipped() 1041 def Try_catch_skipped()
1042 var l = [] 1042 var l = []
1043 try 1043 try
1068 .. 'two' 1068 .. 'two'
1069 catch 1069 catch
1070 assert_equal('onetwo', v:exception) 1070 assert_equal('onetwo', v:exception)
1071 endtry 1071 endtry
1072 END 1072 END
1073 CheckScriptSuccess(lines) 1073 v9.CheckScriptSuccess(lines)
1074 1074
1075 lines =<< trim END 1075 lines =<< trim END
1076 vim9script 1076 vim9script
1077 @r = '' 1077 @r = ''
1078 def Func() 1078 def Func()
1084 catch /E1129:/ 1084 catch /E1129:/
1085 result = 'caught' 1085 result = 'caught'
1086 endtry 1086 endtry
1087 assert_equal('caught', result) 1087 assert_equal('caught', result)
1088 END 1088 END
1089 CheckScriptSuccess(lines) 1089 v9.CheckScriptSuccess(lines)
1090 enddef 1090 enddef
1091 1091
1092 def Test_error_in_nested_function() 1092 def Test_error_in_nested_function()
1093 # an error in a nested :function aborts executing in the calling :def function 1093 # an error in a nested :function aborts executing in the calling :def function
1094 var lines =<< trim END 1094 var lines =<< trim END
1101 eval [][0] 1101 eval [][0]
1102 endfunc 1102 endfunc
1103 Func() 1103 Func()
1104 END 1104 END
1105 g:test_var = 0 1105 g:test_var = 0
1106 CheckScriptFailure(lines, 'E684:') 1106 v9.CheckScriptFailure(lines, 'E684:')
1107 assert_equal(0, g:test_var) 1107 assert_equal(0, g:test_var)
1108 enddef 1108 enddef
1109 1109
1110 def Test_abort_after_error() 1110 def Test_abort_after_error()
1111 var lines =<< trim END 1111 var lines =<< trim END
1114 echo notfound 1114 echo notfound
1115 endwhile 1115 endwhile
1116 g:gotthere = true 1116 g:gotthere = true
1117 END 1117 END
1118 g:gotthere = false 1118 g:gotthere = false
1119 CheckScriptFailure(lines, 'E121:') 1119 v9.CheckScriptFailure(lines, 'E121:')
1120 assert_false(g:gotthere) 1120 assert_false(g:gotthere)
1121 unlet g:gotthere 1121 unlet g:gotthere
1122 enddef 1122 enddef
1123 1123
1124 def Test_cexpr_vimscript() 1124 def Test_cexpr_vimscript()
1129 cexpr 'File' 1129 cexpr 'File'
1130 .. ' someFile' .. 1130 .. ' someFile' ..
1131 ' line 19' 1131 ' line 19'
1132 assert_equal(19, getqflist()[0].lnum) 1132 assert_equal(19, getqflist()[0].lnum)
1133 END 1133 END
1134 CheckScriptSuccess(lines) 1134 v9.CheckScriptSuccess(lines)
1135 set errorformat& 1135 set errorformat&
1136 enddef 1136 enddef
1137 1137
1138 def Test_statusline_syntax() 1138 def Test_statusline_syntax()
1139 # legacy syntax is used for 'statusline' 1139 # legacy syntax is used for 'statusline'
1144 endfunc 1144 endfunc
1145 set laststatus=2 statusline=%!Status() 1145 set laststatus=2 statusline=%!Status()
1146 redrawstatus 1146 redrawstatus
1147 set laststatus statusline= 1147 set laststatus statusline=
1148 END 1148 END
1149 CheckScriptSuccess(lines) 1149 v9.CheckScriptSuccess(lines)
1150 enddef 1150 enddef
1151 1151
1152 def Test_list_vimscript() 1152 def Test_list_vimscript()
1153 # checks line continuation and comments 1153 # checks line continuation and comments
1154 var lines =<< trim END 1154 var lines =<< trim END
1160 1160
1161 'three', 1161 'three',
1162 ] 1162 ]
1163 assert_equal(['one', 'two', 'three'], mylist) 1163 assert_equal(['one', 'two', 'three'], mylist)
1164 END 1164 END
1165 CheckScriptSuccess(lines) 1165 v9.CheckScriptSuccess(lines)
1166 1166
1167 # check all lines from heredoc are kept 1167 # check all lines from heredoc are kept
1168 lines =<< trim END 1168 lines =<< trim END
1169 # comment 1 1169 # comment 1
1170 two 1170 two
1177 1177
1178 lines =<< trim END 1178 lines =<< trim END
1179 [{ 1179 [{
1180 a: 0}]->string()->assert_equal("[{'a': 0}]") 1180 a: 0}]->string()->assert_equal("[{'a': 0}]")
1181 END 1181 END
1182 CheckDefAndScriptSuccess(lines) 1182 v9.CheckDefAndScriptSuccess(lines)
1183 enddef 1183 enddef
1184 1184
1185 if has('channel') 1185 if has('channel')
1186 let someJob = test_null_job() 1186 let someJob = test_null_job()
1187 1187
1208 vim9script 1208 vim9script
1209 g:legacy = 0 1209 g:legacy = 0
1210 END 1210 END
1211 g:feature = 'eval' 1211 g:feature = 'eval'
1212 g:legacy = -1 1212 g:legacy = -1
1213 CheckScriptSuccess(lines) 1213 v9.CheckScriptSuccess(lines)
1214 assert_equal(1, g:legacy) 1214 assert_equal(1, g:legacy)
1215 1215
1216 g:feature = 'noteval' 1216 g:feature = 'noteval'
1217 g:legacy = -1 1217 g:legacy = -1
1218 CheckScriptSuccess(lines) 1218 v9.CheckScriptSuccess(lines)
1219 assert_equal(0, g:legacy) 1219 assert_equal(0, g:legacy)
1220 enddef 1220 enddef
1221 1221
1222 def Test_vim9script_fails() 1222 def Test_vim9script_fails()
1223 CheckScriptFailure(['scriptversion 2', 'vim9script'], 'E1039:') 1223 v9.CheckScriptFailure(['scriptversion 2', 'vim9script'], 'E1039:')
1224 CheckScriptFailure(['vim9script', 'scriptversion 2'], 'E1040:') 1224 v9.CheckScriptFailure(['vim9script', 'scriptversion 2'], 'E1040:')
1225 1225
1226 CheckScriptFailure(['vim9script', 'var str: string', 'str = 1234'], 'E1012:') 1226 v9.CheckScriptFailure(['vim9script', 'var str: string', 'str = 1234'], 'E1012:')
1227 CheckScriptFailure(['vim9script', 'const str = "asdf"', 'str = "xxx"'], 'E46:') 1227 v9.CheckScriptFailure(['vim9script', 'const str = "asdf"', 'str = "xxx"'], 'E46:')
1228 1228
1229 assert_fails('vim9script', 'E1038:') 1229 assert_fails('vim9script', 'E1038:')
1230 enddef 1230 enddef
1231 1231
1232 def Test_script_var_shadows_function() 1232 def Test_script_var_shadows_function()
1235 def Func(): number 1235 def Func(): number
1236 return 123 1236 return 123
1237 enddef 1237 enddef
1238 var Func = 1 1238 var Func = 1
1239 END 1239 END
1240 CheckScriptFailure(lines, 'E1041:', 5) 1240 v9.CheckScriptFailure(lines, 'E1041:', 5)
1241 enddef 1241 enddef
1242 1242
1243 def Test_function_shadows_script_var() 1243 def Test_function_shadows_script_var()
1244 var lines =<< trim END 1244 var lines =<< trim END
1245 vim9script 1245 vim9script
1246 var Func = 1 1246 var Func = 1
1247 def Func(): number 1247 def Func(): number
1248 return 123 1248 return 123
1249 enddef 1249 enddef
1250 END 1250 END
1251 CheckScriptFailure(lines, 'E1041:', 3) 1251 v9.CheckScriptFailure(lines, 'E1041:', 3)
1252 enddef 1252 enddef
1253 1253
1254 def Test_script_var_shadows_command() 1254 def Test_script_var_shadows_command()
1255 var lines =<< trim END 1255 var lines =<< trim END
1256 var undo = 1 1256 var undo = 1
1257 undo = 2 1257 undo = 2
1258 assert_equal(2, undo) 1258 assert_equal(2, undo)
1259 END 1259 END
1260 CheckDefAndScriptSuccess(lines) 1260 v9.CheckDefAndScriptSuccess(lines)
1261 1261
1262 lines =<< trim END 1262 lines =<< trim END
1263 var undo = 1 1263 var undo = 1
1264 undo 1264 undo
1265 END 1265 END
1266 CheckDefAndScriptFailure(lines, 'E1207:', 2) 1266 v9.CheckDefAndScriptFailure(lines, 'E1207:', 2)
1267 enddef 1267 enddef
1268 1268
1269 def Test_vim9script_call_wrong_type() 1269 def Test_vim9script_call_wrong_type()
1270 var lines =<< trim END 1270 var lines =<< trim END
1271 vim9script 1271 vim9script
1272 var Time = 'localtime' 1272 var Time = 'localtime'
1273 Time() 1273 Time()
1274 END 1274 END
1275 CheckScriptFailure(lines, 'E1085:') 1275 v9.CheckScriptFailure(lines, 'E1085:')
1276 enddef 1276 enddef
1277 1277
1278 def Test_vim9script_reload_delfunc() 1278 def Test_vim9script_reload_delfunc()
1279 var first_lines =<< trim END 1279 var first_lines =<< trim END
1280 vim9script 1280 vim9script
1369 enddef 1369 enddef
1370 def Func() 1370 def Func()
1371 echo 'two' 1371 echo 'two'
1372 enddef 1372 enddef
1373 END 1373 END
1374 CheckScriptFailure(lines, 'E1073:') 1374 v9.CheckScriptFailure(lines, 'E1073:')
1375 1375
1376 lines =<< trim END 1376 lines =<< trim END
1377 vim9script 1377 vim9script
1378 def Foo(): string 1378 def Foo(): string
1379 return 'foo' 1379 return 'foo'
1381 def Func() 1381 def Func()
1382 var Foo = {-> 'lambda'} 1382 var Foo = {-> 'lambda'}
1383 enddef 1383 enddef
1384 defcompile 1384 defcompile
1385 END 1385 END
1386 CheckScriptFailure(lines, 'E1073:') 1386 v9.CheckScriptFailure(lines, 'E1073:')
1387 enddef 1387 enddef
1388 1388
1389 def Test_fixed_size_list() 1389 def Test_fixed_size_list()
1390 # will be allocated as one piece of memory, check that changes work 1390 # will be allocated as one piece of memory, check that changes work
1391 var l = [1, 2, 3, 4] 1391 var l = [1, 2, 3, 4]
1394 l->insert(99, 1) 1394 l->insert(99, 1)
1395 assert_equal([2, 99, 3, 4, 5], l) 1395 assert_equal([2, 99, 3, 4, 5], l)
1396 enddef 1396 enddef
1397 1397
1398 def Test_no_insert_xit() 1398 def Test_no_insert_xit()
1399 CheckDefExecFailure(['a = 1'], 'E1100:') 1399 v9.CheckDefExecFailure(['a = 1'], 'E1100:')
1400 CheckDefExecFailure(['c = 1'], 'E1100:') 1400 v9.CheckDefExecFailure(['c = 1'], 'E1100:')
1401 CheckDefExecFailure(['i = 1'], 'E1100:') 1401 v9.CheckDefExecFailure(['i = 1'], 'E1100:')
1402 CheckDefExecFailure(['t = 1'], 'E1100:') 1402 v9.CheckDefExecFailure(['t = 1'], 'E1100:')
1403 CheckDefExecFailure(['x = 1'], 'E1100:') 1403 v9.CheckDefExecFailure(['x = 1'], 'E1100:')
1404 1404
1405 CheckScriptFailure(['vim9script', 'a = 1'], 'E488:') 1405 v9.CheckScriptFailure(['vim9script', 'a = 1'], 'E488:')
1406 CheckScriptFailure(['vim9script', 'a'], 'E1100:') 1406 v9.CheckScriptFailure(['vim9script', 'a'], 'E1100:')
1407 CheckScriptFailure(['vim9script', 'c = 1'], 'E488:') 1407 v9.CheckScriptFailure(['vim9script', 'c = 1'], 'E488:')
1408 CheckScriptFailure(['vim9script', 'c'], 'E1100:') 1408 v9.CheckScriptFailure(['vim9script', 'c'], 'E1100:')
1409 CheckScriptFailure(['vim9script', 'i = 1'], 'E488:') 1409 v9.CheckScriptFailure(['vim9script', 'i = 1'], 'E488:')
1410 CheckScriptFailure(['vim9script', 'i'], 'E1100:') 1410 v9.CheckScriptFailure(['vim9script', 'i'], 'E1100:')
1411 CheckScriptFailure(['vim9script', 'o = 1'], 'E1100:') 1411 v9.CheckScriptFailure(['vim9script', 'o = 1'], 'E1100:')
1412 CheckScriptFailure(['vim9script', 'o'], 'E1100:') 1412 v9.CheckScriptFailure(['vim9script', 'o'], 'E1100:')
1413 CheckScriptFailure(['vim9script', 't'], 'E1100:') 1413 v9.CheckScriptFailure(['vim9script', 't'], 'E1100:')
1414 CheckScriptFailure(['vim9script', 't = 1'], 'E1100:') 1414 v9.CheckScriptFailure(['vim9script', 't = 1'], 'E1100:')
1415 CheckScriptFailure(['vim9script', 'x = 1'], 'E1100:') 1415 v9.CheckScriptFailure(['vim9script', 'x = 1'], 'E1100:')
1416 enddef 1416 enddef
1417 1417
1418 def IfElse(what: number): string 1418 def s:IfElse(what: number): string
1419 var res = '' 1419 var res = ''
1420 if what == 1 1420 if what == 1
1421 res = "one" 1421 res = "one"
1422 elseif what == 2 1422 elseif what == 2
1423 res = "two" 1423 res = "two"
1432 assert_equal('two', IfElse(2)) 1432 assert_equal('two', IfElse(2))
1433 assert_equal('three', IfElse(3)) 1433 assert_equal('three', IfElse(3))
1434 enddef 1434 enddef
1435 1435
1436 def Test_if_elseif_else_fails() 1436 def Test_if_elseif_else_fails()
1437 CheckDefFailure(['elseif true'], 'E582:') 1437 v9.CheckDefFailure(['elseif true'], 'E582:')
1438 CheckDefFailure(['else'], 'E581:') 1438 v9.CheckDefFailure(['else'], 'E581:')
1439 CheckDefFailure(['endif'], 'E580:') 1439 v9.CheckDefFailure(['endif'], 'E580:')
1440 CheckDefFailure(['if g:abool', 'elseif xxx'], 'E1001:') 1440 v9.CheckDefFailure(['if g:abool', 'elseif xxx'], 'E1001:')
1441 CheckDefFailure(['if true', 'echo 1'], 'E171:') 1441 v9.CheckDefFailure(['if true', 'echo 1'], 'E171:')
1442 1442
1443 var lines =<< trim END 1443 var lines =<< trim END
1444 var s = '' 1444 var s = ''
1445 if s = '' 1445 if s = ''
1446 endif 1446 endif
1447 END 1447 END
1448 CheckDefFailure(lines, 'E488:') 1448 v9.CheckDefFailure(lines, 'E488:')
1449 1449
1450 lines =<< trim END 1450 lines =<< trim END
1451 var s = '' 1451 var s = ''
1452 if s == '' 1452 if s == ''
1453 elseif s = '' 1453 elseif s = ''
1454 endif 1454 endif
1455 END 1455 END
1456 CheckDefFailure(lines, 'E488:') 1456 v9.CheckDefFailure(lines, 'E488:')
1457 enddef 1457 enddef
1458 1458
1459 let g:bool_true = v:true 1459 let g:bool_true = v:true
1460 let g:bool_false = v:false 1460 let g:bool_false = v:false
1461 1461
1588 )->setline(1) 1588 )->setline(1)
1589 endif 1589 endif
1590 enddef 1590 enddef
1591 1591
1592 def Test_if_const_expr_fails() 1592 def Test_if_const_expr_fails()
1593 CheckDefFailure(['if "aaa" == "bbb'], 'E114:') 1593 v9.CheckDefFailure(['if "aaa" == "bbb'], 'E114:')
1594 CheckDefFailure(["if 'aaa' == 'bbb"], 'E115:') 1594 v9.CheckDefFailure(["if 'aaa' == 'bbb"], 'E115:')
1595 CheckDefFailure(["if has('aaa'"], 'E110:') 1595 v9.CheckDefFailure(["if has('aaa'"], 'E110:')
1596 CheckDefFailure(["if has('aaa') ? true false"], 'E109:') 1596 v9.CheckDefFailure(["if has('aaa') ? true false"], 'E109:')
1597 enddef 1597 enddef
1598 1598
1599 def RunNested(i: number): number 1599 def s:RunNested(i: number): number
1600 var x: number = 0 1600 var x: number = 0
1601 if i % 2 1601 if i % 2
1602 if 1 1602 if 1
1603 # comment 1603 # comment
1604 else 1604 else
1643 assert_equal('execute-var-var', getline(1)) 1643 assert_equal('execute-var-var', getline(1))
1644 bwipe! 1644 bwipe!
1645 1645
1646 var n = true 1646 var n = true
1647 execute 'echomsg' (n ? '"true"' : '"no"') 1647 execute 'echomsg' (n ? '"true"' : '"no"')
1648 assert_match('^true$', Screenline(&lines)) 1648 assert_match('^true$', g:Screenline(&lines))
1649 1649
1650 echomsg [1, 2, 3] {a: 1, b: 2} 1650 echomsg [1, 2, 3] {a: 1, b: 2}
1651 assert_match('^\[1, 2, 3\] {''a'': 1, ''b'': 2}$', Screenline(&lines)) 1651 assert_match('^\[1, 2, 3\] {''a'': 1, ''b'': 2}$', g:Screenline(&lines))
1652 1652
1653 CheckDefFailure(['execute xxx'], 'E1001:', 1) 1653 v9.CheckDefFailure(['execute xxx'], 'E1001:', 1)
1654 CheckDefExecFailure(['execute "tabnext " .. 8'], 'E475:', 1) 1654 v9.CheckDefExecFailure(['execute "tabnext " .. 8'], 'E475:', 1)
1655 CheckDefFailure(['execute "cmd"# comment'], 'E488:', 1) 1655 v9.CheckDefFailure(['execute "cmd"# comment'], 'E488:', 1)
1656 enddef 1656 enddef
1657 1657
1658 def Test_execute_cmd_vimscript() 1658 def Test_execute_cmd_vimscript()
1659 # only checks line continuation 1659 # only checks line continuation
1660 var lines =<< trim END 1660 var lines =<< trim END
1663 .. ' = ' .. 1663 .. ' = ' ..
1664 '28' 1664 '28'
1665 assert_equal(28, g:someVar) 1665 assert_equal(28, g:someVar)
1666 unlet g:someVar 1666 unlet g:someVar
1667 END 1667 END
1668 CheckScriptSuccess(lines) 1668 v9.CheckScriptSuccess(lines)
1669 enddef 1669 enddef
1670 1670
1671 def Test_echo_cmd() 1671 def Test_echo_cmd()
1672 echo 'some' # comment 1672 echo 'some' # comment
1673 echon 'thing' 1673 echon 'thing'
1674 assert_match('^something$', Screenline(&lines)) 1674 assert_match('^something$', g:Screenline(&lines))
1675 1675
1676 echo "some" # comment 1676 echo "some" # comment
1677 echon "thing" 1677 echon "thing"
1678 assert_match('^something$', Screenline(&lines)) 1678 assert_match('^something$', g:Screenline(&lines))
1679 1679
1680 var str1 = 'some' 1680 var str1 = 'some'
1681 var str2 = 'more' 1681 var str2 = 'more'
1682 echo str1 str2 1682 echo str1 str2
1683 assert_match('^some more$', Screenline(&lines)) 1683 assert_match('^some more$', g:Screenline(&lines))
1684 1684
1685 CheckDefFailure(['echo "xxx"# comment'], 'E488:') 1685 v9.CheckDefFailure(['echo "xxx"# comment'], 'E488:')
1686 enddef 1686 enddef
1687 1687
1688 def Test_echomsg_cmd() 1688 def Test_echomsg_cmd()
1689 echomsg 'some' 'more' # comment 1689 echomsg 'some' 'more' # comment
1690 assert_match('^some more$', Screenline(&lines)) 1690 assert_match('^some more$', g:Screenline(&lines))
1691 echo 'clear' 1691 echo 'clear'
1692 :1messages 1692 :1messages
1693 assert_match('^some more$', Screenline(&lines)) 1693 assert_match('^some more$', g:Screenline(&lines))
1694 1694
1695 CheckDefFailure(['echomsg "xxx"# comment'], 'E488:') 1695 v9.CheckDefFailure(['echomsg "xxx"# comment'], 'E488:')
1696 enddef 1696 enddef
1697 1697
1698 def Test_echomsg_cmd_vimscript() 1698 def Test_echomsg_cmd_vimscript()
1699 # only checks line continuation 1699 # only checks line continuation
1700 var lines =<< trim END 1700 var lines =<< trim END
1701 vim9script 1701 vim9script
1702 echomsg 'here' 1702 echomsg 'here'
1703 .. ' is ' .. 1703 .. ' is ' ..
1704 'a message' 1704 'a message'
1705 assert_match('^here is a message$', Screenline(&lines)) 1705 assert_match('^here is a message$', g:Screenline(&lines))
1706 END 1706 END
1707 CheckScriptSuccess(lines) 1707 v9.CheckScriptSuccess(lines)
1708 enddef 1708 enddef
1709 1709
1710 def Test_echoerr_cmd() 1710 def Test_echoerr_cmd()
1711 var local = 'local' 1711 var local = 'local'
1712 try 1712 try
1726 'wrong' 1726 'wrong'
1727 catch 1727 catch
1728 assert_match('this is wrong', v:exception) 1728 assert_match('this is wrong', v:exception)
1729 endtry 1729 endtry
1730 END 1730 END
1731 CheckScriptSuccess(lines) 1731 v9.CheckScriptSuccess(lines)
1732 enddef 1732 enddef
1733 1733
1734 def Test_echoconsole_cmd() 1734 def Test_echoconsole_cmd()
1735 var local = 'local' 1735 var local = 'local'
1736 echoconsole 'something' local # comment 1736 echoconsole 'something' local # comment
1784 result += [n] 1784 result += [n]
1785 endfor 1785 endfor
1786 endif 1786 endif
1787 assert_equal([3, 4], result) 1787 assert_equal([3, 4], result)
1788 END 1788 END
1789 CheckDefAndScriptSuccess(lines) 1789 v9.CheckDefAndScriptSuccess(lines)
1790 1790
1791 # test skipped blocks at inside of function 1791 # test skipped blocks at inside of function
1792 lines =<< trim END 1792 lines =<< trim END
1793 def DefTrue() 1793 def DefTrue()
1794 var result = [] 1794 var result = []
1818 endif 1818 endif
1819 assert_equal([3, 4], result) 1819 assert_equal([3, 4], result)
1820 enddef 1820 enddef
1821 DefFalse() 1821 DefFalse()
1822 END 1822 END
1823 CheckDefAndScriptSuccess(lines) 1823 v9.CheckDefAndScriptSuccess(lines)
1824 enddef 1824 enddef
1825 1825
1826 def Test_for_loop() 1826 def Test_for_loop()
1827 var lines =<< trim END 1827 var lines =<< trim END
1828 var result = '' 1828 var result = ''
1929 for _ in range(3) 1929 for _ in range(3)
1930 reslist->add('x') 1930 reslist->add('x')
1931 endfor 1931 endfor
1932 assert_equal(['x', 'x', 'x'], reslist) 1932 assert_equal(['x', 'x', 'x'], reslist)
1933 END 1933 END
1934 CheckDefAndScriptSuccess(lines) 1934 v9.CheckDefAndScriptSuccess(lines)
1935 enddef 1935 enddef
1936 1936
1937 def Test_for_loop_with_closure() 1937 def Test_for_loop_with_closure()
1938 var lines =<< trim END 1938 var lines =<< trim END
1939 var flist: list<func> 1939 var flist: list<func>
1943 endfor 1943 endfor
1944 for i in range(5) 1944 for i in range(5)
1945 assert_equal(4, flist[i]()) 1945 assert_equal(4, flist[i]())
1946 endfor 1946 endfor
1947 END 1947 END
1948 CheckDefAndScriptSuccess(lines) 1948 v9.CheckDefAndScriptSuccess(lines)
1949 1949
1950 lines =<< trim END 1950 lines =<< trim END
1951 var flist: list<func> 1951 var flist: list<func>
1952 for i in range(5) 1952 for i in range(5)
1953 var inloop = i 1953 var inloop = i
1957 endfor 1957 endfor
1958 for i in range(5) 1958 for i in range(5)
1959 assert_equal(4, flist[i]()) 1959 assert_equal(4, flist[i]())
1960 endfor 1960 endfor
1961 END 1961 END
1962 CheckDefAndScriptSuccess(lines) 1962 v9.CheckDefAndScriptSuccess(lines)
1963 enddef 1963 enddef
1964 1964
1965 def Test_for_loop_fails() 1965 def Test_for_loop_fails()
1966 CheckDefAndScriptFailure(['for '], ['E1097:', 'E690:']) 1966 v9.CheckDefAndScriptFailure(['for '], ['E1097:', 'E690:'])
1967 CheckDefAndScriptFailure(['for x'], ['E1097:', 'E690:']) 1967 v9.CheckDefAndScriptFailure(['for x'], ['E1097:', 'E690:'])
1968 CheckDefAndScriptFailure(['for x in'], ['E1097:', 'E15:']) 1968 v9.CheckDefAndScriptFailure(['for x in'], ['E1097:', 'E15:'])
1969 CheckDefAndScriptFailure(['for # in range(5)'], 'E690:') 1969 v9.CheckDefAndScriptFailure(['for # in range(5)'], 'E690:')
1970 CheckDefAndScriptFailure(['for i In range(5)'], 'E690:') 1970 v9.CheckDefAndScriptFailure(['for i In range(5)'], 'E690:')
1971 CheckDefAndScriptFailure(['var x = 5', 'for x in range(5)', 'endfor'], ['E1017:', 'E1041:']) 1971 v9.CheckDefAndScriptFailure(['var x = 5', 'for x in range(5)', 'endfor'], ['E1017:', 'E1041:'])
1972 CheckScriptFailure(['vim9script', 'var x = 5', 'for x in range(5)', '# comment', 'endfor'], 'E1041:', 3) 1972 v9.CheckScriptFailure(['vim9script', 'var x = 5', 'for x in range(5)', '# comment', 'endfor'], 'E1041:', 3)
1973 CheckScriptFailure(['def Func(arg: any)', 'for arg in range(5)', 'enddef', 'defcompile'], 'E1006:') 1973 v9.CheckScriptFailure(['def Func(arg: any)', 'for arg in range(5)', 'enddef', 'defcompile'], 'E1006:')
1974 delfunc! g:Func 1974 delfunc! g:Func
1975 CheckDefFailure(['for i in xxx'], 'E1001:') 1975 v9.CheckDefFailure(['for i in xxx'], 'E1001:')
1976 CheckDefFailure(['endfor'], 'E588:') 1976 v9.CheckDefFailure(['endfor'], 'E588:')
1977 CheckDefFailure(['for i in range(3)', 'echo 3'], 'E170:') 1977 v9.CheckDefFailure(['for i in range(3)', 'echo 3'], 'E170:')
1978 1978
1979 # wrong type detected at compile time 1979 # wrong type detected at compile time
1980 CheckDefFailure(['for i in {a: 1}', 'echo 3', 'endfor'], 'E1177: For loop on dict not supported') 1980 v9.CheckDefFailure(['for i in {a: 1}', 'echo 3', 'endfor'], 'E1177: For loop on dict not supported')
1981 1981
1982 # wrong type detected at runtime 1982 # wrong type detected at runtime
1983 g:adict = {a: 1} 1983 g:adict = {a: 1}
1984 CheckDefExecFailure(['for i in g:adict', 'echo 3', 'endfor'], 'E1177: For loop on dict not supported') 1984 v9.CheckDefExecFailure(['for i in g:adict', 'echo 3', 'endfor'], 'E1177: For loop on dict not supported')
1985 unlet g:adict 1985 unlet g:adict
1986 1986
1987 var lines =<< trim END 1987 var lines =<< trim END
1988 var d: list<dict<any>> = [{a: 0}] 1988 var d: list<dict<any>> = [{a: 0}]
1989 for e in d 1989 for e in d
1990 e = {a: 0, b: ''} 1990 e = {a: 0, b: ''}
1991 endfor 1991 endfor
1992 END 1992 END
1993 CheckDefAndScriptFailure(lines, ['E1018:', 'E46:'], 3) 1993 v9.CheckDefAndScriptFailure(lines, ['E1018:', 'E46:'], 3)
1994 1994
1995 lines =<< trim END 1995 lines =<< trim END
1996 for nr: number in ['foo'] 1996 for nr: number in ['foo']
1997 endfor 1997 endfor
1998 END 1998 END
1999 CheckDefAndScriptFailure(lines, 'E1012: Type mismatch; expected number but got string', 1) 1999 v9.CheckDefAndScriptFailure(lines, 'E1012: Type mismatch; expected number but got string', 1)
2000 2000
2001 lines =<< trim END 2001 lines =<< trim END
2002 for n : number in [1, 2] 2002 for n : number in [1, 2]
2003 echo n 2003 echo n
2004 endfor 2004 endfor
2005 END 2005 END
2006 CheckDefAndScriptFailure(lines, 'E1059:', 1) 2006 v9.CheckDefAndScriptFailure(lines, 'E1059:', 1)
2007 2007
2008 lines =<< trim END 2008 lines =<< trim END
2009 var d: dict<number> = {a: 1, b: 2} 2009 var d: dict<number> = {a: 1, b: 2}
2010 for [k: job, v: job] in d->items() 2010 for [k: job, v: job] in d->items()
2011 echo k v 2011 echo k v
2012 endfor 2012 endfor
2013 END 2013 END
2014 CheckDefExecAndScriptFailure(lines, 'E1012: Type mismatch; expected job but got string', 2) 2014 v9.CheckDefExecAndScriptFailure(lines, 'E1012: Type mismatch; expected job but got string', 2)
2015 2015
2016 lines =<< trim END 2016 lines =<< trim END
2017 var i = 0 2017 var i = 0
2018 for i in [1, 2, 3] 2018 for i in [1, 2, 3]
2019 echo i 2019 echo i
2020 endfor 2020 endfor
2021 END 2021 END
2022 CheckDefExecAndScriptFailure(lines, ['E1017:', 'E1041:']) 2022 v9.CheckDefExecAndScriptFailure(lines, ['E1017:', 'E1041:'])
2023 2023
2024 lines =<< trim END 2024 lines =<< trim END
2025 var l = [0] 2025 var l = [0]
2026 for l[0] in [1, 2, 3] 2026 for l[0] in [1, 2, 3]
2027 echo l[0] 2027 echo l[0]
2028 endfor 2028 endfor
2029 END 2029 END
2030 CheckDefExecAndScriptFailure(lines, ['E461:', 'E1017:']) 2030 v9.CheckDefExecAndScriptFailure(lines, ['E461:', 'E1017:'])
2031 2031
2032 lines =<< trim END 2032 lines =<< trim END
2033 var d = {x: 0} 2033 var d = {x: 0}
2034 for d.x in [1, 2, 3] 2034 for d.x in [1, 2, 3]
2035 echo d.x 2035 echo d.x
2036 endfor 2036 endfor
2037 END 2037 END
2038 CheckDefExecAndScriptFailure(lines, ['E461:', 'E1017:']) 2038 v9.CheckDefExecAndScriptFailure(lines, ['E461:', 'E1017:'])
2039 enddef 2039 enddef
2040 2040
2041 def Test_for_loop_script_var() 2041 def Test_for_loop_script_var()
2042 # cannot use s:var in a :def function 2042 # cannot use s:var in a :def function
2043 CheckDefFailure(['for s:var in range(3)', 'echo 3'], 'E1254:') 2043 v9.CheckDefFailure(['for s:var in range(3)', 'echo 3'], 'E1254:')
2044 2044
2045 # can use s:var in Vim9 script, with or without s: 2045 # can use s:var in Vim9 script, with or without s:
2046 var lines =<< trim END 2046 var lines =<< trim END
2047 vim9script 2047 vim9script
2048 var total = 0 2048 var total = 0
2105 for [_, n, _] in [[1, 2, 3], [4, 5, 6]] 2105 for [_, n, _] in [[1, 2, 3], [4, 5, 6]]
2106 res->add(n) 2106 res->add(n)
2107 endfor 2107 endfor
2108 assert_equal([2, 5], res) 2108 assert_equal([2, 5], res)
2109 END 2109 END
2110 CheckDefAndScriptSuccess(lines) 2110 v9.CheckDefAndScriptSuccess(lines)
2111 2111
2112 lines =<< trim END 2112 lines =<< trim END
2113 for [v1, v2] in [[1, 2, 3], [3, 4]] 2113 for [v1, v2] in [[1, 2, 3], [3, 4]]
2114 echo v1 v2 2114 echo v1 v2
2115 endfor 2115 endfor
2116 END 2116 END
2117 CheckDefExecFailure(lines, 'E710:', 1) 2117 v9.CheckDefExecFailure(lines, 'E710:', 1)
2118 2118
2119 lines =<< trim END 2119 lines =<< trim END
2120 for [v1, v2] in [[1], [3, 4]] 2120 for [v1, v2] in [[1], [3, 4]]
2121 echo v1 v2 2121 echo v1 v2
2122 endfor 2122 endfor
2123 END 2123 END
2124 CheckDefExecFailure(lines, 'E711:', 1) 2124 v9.CheckDefExecFailure(lines, 'E711:', 1)
2125 2125
2126 lines =<< trim END 2126 lines =<< trim END
2127 for [v1, v1] in [[1, 2], [3, 4]] 2127 for [v1, v1] in [[1, 2], [3, 4]]
2128 echo v1 2128 echo v1
2129 endfor 2129 endfor
2130 END 2130 END
2131 CheckDefExecFailure(lines, 'E1017:', 1) 2131 v9.CheckDefExecFailure(lines, 'E1017:', 1)
2132 enddef 2132 enddef
2133 2133
2134 def Test_for_loop_with_try_continue() 2134 def Test_for_loop_with_try_continue()
2135 var lines =<< trim END 2135 var lines =<< trim END
2136 var looped = 0 2136 var looped = 0
2146 endtry 2146 endtry
2147 endfor 2147 endfor
2148 assert_equal(3, looped) 2148 assert_equal(3, looped)
2149 assert_equal(3, cleanup) 2149 assert_equal(3, cleanup)
2150 END 2150 END
2151 CheckDefAndScriptSuccess(lines) 2151 v9.CheckDefAndScriptSuccess(lines)
2152 enddef 2152 enddef
2153 2153
2154 def Test_while_skipped_block() 2154 def Test_while_skipped_block()
2155 # test skipped blocks at outside of function 2155 # test skipped blocks at outside of function
2156 var lines =<< trim END 2156 var lines =<< trim END
2185 n += 1 2185 n += 1
2186 endwhile 2186 endwhile
2187 endif 2187 endif
2188 assert_equal([3, 4], result) 2188 assert_equal([3, 4], result)
2189 END 2189 END
2190 CheckDefAndScriptSuccess(lines) 2190 v9.CheckDefAndScriptSuccess(lines)
2191 2191
2192 # test skipped blocks at inside of function 2192 # test skipped blocks at inside of function
2193 lines =<< trim END 2193 lines =<< trim END
2194 def DefTrue() 2194 def DefTrue()
2195 var result = [] 2195 var result = []
2229 endif 2229 endif
2230 assert_equal([3, 4], result) 2230 assert_equal([3, 4], result)
2231 enddef 2231 enddef
2232 DefFalse() 2232 DefFalse()
2233 END 2233 END
2234 CheckDefAndScriptSuccess(lines) 2234 v9.CheckDefAndScriptSuccess(lines)
2235 enddef 2235 enddef
2236 2236
2237 def Test_while_loop() 2237 def Test_while_loop()
2238 var result = '' 2238 var result = ''
2239 var cnt = 0 2239 var cnt = 0
2264 result ..= s 2264 result ..= s
2265 cnt += 1 2265 cnt += 1
2266 endwhile 2266 endwhile
2267 assert_equal('v0v1v2', result) 2267 assert_equal('v0v1v2', result)
2268 END 2268 END
2269 CheckScriptSuccess(lines) 2269 v9.CheckScriptSuccess(lines)
2270 enddef 2270 enddef
2271 2271
2272 def Test_while_loop_fails() 2272 def Test_while_loop_fails()
2273 CheckDefFailure(['while xxx'], 'E1001:') 2273 v9.CheckDefFailure(['while xxx'], 'E1001:')
2274 CheckDefFailure(['endwhile'], 'E588:') 2274 v9.CheckDefFailure(['endwhile'], 'E588:')
2275 CheckDefFailure(['continue'], 'E586:') 2275 v9.CheckDefFailure(['continue'], 'E586:')
2276 CheckDefFailure(['if true', 'continue'], 'E586:') 2276 v9.CheckDefFailure(['if true', 'continue'], 'E586:')
2277 CheckDefFailure(['break'], 'E587:') 2277 v9.CheckDefFailure(['break'], 'E587:')
2278 CheckDefFailure(['if true', 'break'], 'E587:') 2278 v9.CheckDefFailure(['if true', 'break'], 'E587:')
2279 CheckDefFailure(['while 1', 'echo 3'], 'E170:') 2279 v9.CheckDefFailure(['while 1', 'echo 3'], 'E170:')
2280 2280
2281 var lines =<< trim END 2281 var lines =<< trim END
2282 var s = '' 2282 var s = ''
2283 while s = '' 2283 while s = ''
2284 endwhile 2284 endwhile
2285 END 2285 END
2286 CheckDefFailure(lines, 'E488:') 2286 v9.CheckDefFailure(lines, 'E488:')
2287 enddef 2287 enddef
2288 2288
2289 def Test_interrupt_loop() 2289 def Test_interrupt_loop()
2290 var caught = false 2290 var caught = false
2291 var x = 0 2291 var x = 0
2340 split('one two three') 2340 split('one two three')
2341 ) 2341 )
2342 enddef 2342 enddef
2343 2343
2344 def Test_vim9_comment() 2344 def Test_vim9_comment()
2345 CheckScriptSuccess([ 2345 v9.CheckScriptSuccess([
2346 'vim9script', 2346 'vim9script',
2347 '# something', 2347 '# something',
2348 '#something', 2348 '#something',
2349 '#{something', 2349 '#{something',
2350 ]) 2350 ])
2351 2351
2352 split Xfile 2352 split Xfile
2353 CheckScriptSuccess([ 2353 v9.CheckScriptSuccess([
2354 'vim9script', 2354 'vim9script',
2355 'edit #something', 2355 'edit #something',
2356 ]) 2356 ])
2357 CheckScriptSuccess([ 2357 v9.CheckScriptSuccess([
2358 'vim9script', 2358 'vim9script',
2359 'edit #{something', 2359 'edit #{something',
2360 ]) 2360 ])
2361 close 2361 close
2362 2362
2363 CheckScriptFailure([ 2363 v9.CheckScriptFailure([
2364 'vim9script', 2364 'vim9script',
2365 ':# something', 2365 ':# something',
2366 ], 'E488:') 2366 ], 'E488:')
2367 CheckScriptFailure([ 2367 v9.CheckScriptFailure([
2368 '# something', 2368 '# something',
2369 ], 'E488:') 2369 ], 'E488:')
2370 CheckScriptFailure([ 2370 v9.CheckScriptFailure([
2371 ':# something', 2371 ':# something',
2372 ], 'E488:') 2372 ], 'E488:')
2373 2373
2374 { # block start 2374 { # block start
2375 } # block end 2375 } # block end
2376 CheckDefFailure([ 2376 v9.CheckDefFailure([
2377 '{# comment', 2377 '{# comment',
2378 ], 'E488:') 2378 ], 'E488:')
2379 CheckDefFailure([ 2379 v9.CheckDefFailure([
2380 '{', 2380 '{',
2381 '}# comment', 2381 '}# comment',
2382 ], 'E488:') 2382 ], 'E488:')
2383 2383
2384 echo "yes" # comment 2384 echo "yes" # comment
2385 CheckDefFailure([ 2385 v9.CheckDefFailure([
2386 'echo "yes"# comment', 2386 'echo "yes"# comment',
2387 ], 'E488:') 2387 ], 'E488:')
2388 CheckScriptSuccess([ 2388 v9.CheckScriptSuccess([
2389 'vim9script', 2389 'vim9script',
2390 'echo "yes" # something', 2390 'echo "yes" # something',
2391 ]) 2391 ])
2392 CheckScriptFailure([ 2392 v9.CheckScriptFailure([
2393 'vim9script', 2393 'vim9script',
2394 'echo "yes"# something', 2394 'echo "yes"# something',
2395 ], 'E121:') 2395 ], 'E121:')
2396 CheckScriptFailure([ 2396 v9.CheckScriptFailure([
2397 'vim9script', 2397 'vim9script',
2398 'echo# something', 2398 'echo# something',
2399 ], 'E1144:') 2399 ], 'E1144:')
2400 CheckScriptFailure([ 2400 v9.CheckScriptFailure([
2401 'echo "yes" # something', 2401 'echo "yes" # something',
2402 ], 'E121:') 2402 ], 'E121:')
2403 2403
2404 exe "echo" # comment 2404 exe "echo" # comment
2405 CheckDefFailure([ 2405 v9.CheckDefFailure([
2406 'exe "echo"# comment', 2406 'exe "echo"# comment',
2407 ], 'E488:') 2407 ], 'E488:')
2408 CheckScriptSuccess([ 2408 v9.CheckScriptSuccess([
2409 'vim9script', 2409 'vim9script',
2410 'exe "echo" # something', 2410 'exe "echo" # something',
2411 ]) 2411 ])
2412 CheckScriptFailure([ 2412 v9.CheckScriptFailure([
2413 'vim9script', 2413 'vim9script',
2414 'exe "echo"# something', 2414 'exe "echo"# something',
2415 ], 'E121:') 2415 ], 'E121:')
2416 CheckScriptFailure([ 2416 v9.CheckScriptFailure([
2417 'vim9script', 2417 'vim9script',
2418 'exe# something', 2418 'exe# something',
2419 ], 'E1144:') 2419 ], 'E1144:')
2420 CheckScriptFailure([ 2420 v9.CheckScriptFailure([
2421 'exe "echo" # something', 2421 'exe "echo" # something',
2422 ], 'E121:') 2422 ], 'E121:')
2423 2423
2424 CheckDefFailure([ 2424 v9.CheckDefFailure([
2425 'try# comment', 2425 'try# comment',
2426 ' echo "yes"', 2426 ' echo "yes"',
2427 'catch', 2427 'catch',
2428 'endtry', 2428 'endtry',
2429 ], 'E1144:') 2429 ], 'E1144:')
2430 CheckScriptFailure([ 2430 v9.CheckScriptFailure([
2431 'vim9script', 2431 'vim9script',
2432 'try# comment', 2432 'try# comment',
2433 'echo "yes"', 2433 'echo "yes"',
2434 ], 'E1144:') 2434 ], 'E1144:')
2435 CheckDefFailure([ 2435 v9.CheckDefFailure([
2436 'try', 2436 'try',
2437 ' throw#comment', 2437 ' throw#comment',
2438 'catch', 2438 'catch',
2439 'endtry', 2439 'endtry',
2440 ], 'E1144:') 2440 ], 'E1144:')
2441 CheckDefFailure([ 2441 v9.CheckDefFailure([
2442 'try', 2442 'try',
2443 ' throw "yes"#comment', 2443 ' throw "yes"#comment',
2444 'catch', 2444 'catch',
2445 'endtry', 2445 'endtry',
2446 ], 'E488:') 2446 ], 'E488:')
2447 CheckDefFailure([ 2447 v9.CheckDefFailure([
2448 'try', 2448 'try',
2449 ' echo "yes"', 2449 ' echo "yes"',
2450 'catch# comment', 2450 'catch# comment',
2451 'endtry', 2451 'endtry',
2452 ], 'E1144:') 2452 ], 'E1144:')
2453 CheckScriptFailure([ 2453 v9.CheckScriptFailure([
2454 'vim9script', 2454 'vim9script',
2455 'try', 2455 'try',
2456 ' echo "yes"', 2456 ' echo "yes"',
2457 'catch# comment', 2457 'catch# comment',
2458 'endtry', 2458 'endtry',
2459 ], 'E1144:') 2459 ], 'E1144:')
2460 CheckDefFailure([ 2460 v9.CheckDefFailure([
2461 'try', 2461 'try',
2462 ' echo "yes"', 2462 ' echo "yes"',
2463 'catch /pat/# comment', 2463 'catch /pat/# comment',
2464 'endtry', 2464 'endtry',
2465 ], 'E488:') 2465 ], 'E488:')
2466 CheckDefFailure([ 2466 v9.CheckDefFailure([
2467 'try', 2467 'try',
2468 'echo "yes"', 2468 'echo "yes"',
2469 'catch', 2469 'catch',
2470 'endtry# comment', 2470 'endtry# comment',
2471 ], 'E1144:') 2471 ], 'E1144:')
2472 CheckScriptFailure([ 2472 v9.CheckScriptFailure([
2473 'vim9script', 2473 'vim9script',
2474 'try', 2474 'try',
2475 ' echo "yes"', 2475 ' echo "yes"',
2476 'catch', 2476 'catch',
2477 'endtry# comment', 2477 'endtry# comment',
2478 ], 'E1144:') 2478 ], 'E1144:')
2479 2479
2480 CheckScriptSuccess([ 2480 v9.CheckScriptSuccess([
2481 'vim9script', 2481 'vim9script',
2482 'hi # comment', 2482 'hi # comment',
2483 ]) 2483 ])
2484 CheckScriptFailure([ 2484 v9.CheckScriptFailure([
2485 'vim9script', 2485 'vim9script',
2486 'hi# comment', 2486 'hi# comment',
2487 ], 'E1144:') 2487 ], 'E1144:')
2488 CheckScriptSuccess([ 2488 v9.CheckScriptSuccess([
2489 'vim9script', 2489 'vim9script',
2490 'hi Search # comment', 2490 'hi Search # comment',
2491 ]) 2491 ])
2492 CheckScriptFailure([ 2492 v9.CheckScriptFailure([
2493 'vim9script', 2493 'vim9script',
2494 'hi Search# comment', 2494 'hi Search# comment',
2495 ], 'E416:') 2495 ], 'E416:')
2496 CheckScriptSuccess([ 2496 v9.CheckScriptSuccess([
2497 'vim9script', 2497 'vim9script',
2498 'hi link This Search # comment', 2498 'hi link This Search # comment',
2499 ]) 2499 ])
2500 CheckScriptFailure([ 2500 v9.CheckScriptFailure([
2501 'vim9script', 2501 'vim9script',
2502 'hi link This That# comment', 2502 'hi link This That# comment',
2503 ], 'E413:') 2503 ], 'E413:')
2504 CheckScriptSuccess([ 2504 v9.CheckScriptSuccess([
2505 'vim9script', 2505 'vim9script',
2506 'hi clear This # comment', 2506 'hi clear This # comment',
2507 'hi clear # comment', 2507 'hi clear # comment',
2508 ]) 2508 ])
2509 # not tested, because it doesn't give an error but a warning: 2509 # not tested, because it doesn't give an error but a warning:
2510 # hi clear This# comment', 2510 # hi clear This# comment',
2511 CheckScriptFailure([ 2511 v9.CheckScriptFailure([
2512 'vim9script', 2512 'vim9script',
2513 'hi clear# comment', 2513 'hi clear# comment',
2514 ], 'E416:') 2514 ], 'E416:')
2515 2515
2516 CheckScriptSuccess([ 2516 v9.CheckScriptSuccess([
2517 'vim9script', 2517 'vim9script',
2518 'hi Group term=bold', 2518 'hi Group term=bold',
2519 'match Group /todo/ # comment', 2519 'match Group /todo/ # comment',
2520 ]) 2520 ])
2521 CheckScriptFailure([ 2521 v9.CheckScriptFailure([
2522 'vim9script', 2522 'vim9script',
2523 'hi Group term=bold', 2523 'hi Group term=bold',
2524 'match Group /todo/# comment', 2524 'match Group /todo/# comment',
2525 ], 'E488:') 2525 ], 'E488:')
2526 CheckScriptSuccess([ 2526 v9.CheckScriptSuccess([
2527 'vim9script', 2527 'vim9script',
2528 'match # comment', 2528 'match # comment',
2529 ]) 2529 ])
2530 CheckScriptFailure([ 2530 v9.CheckScriptFailure([
2531 'vim9script', 2531 'vim9script',
2532 'match# comment', 2532 'match# comment',
2533 ], 'E1144:') 2533 ], 'E1144:')
2534 CheckScriptSuccess([ 2534 v9.CheckScriptSuccess([
2535 'vim9script', 2535 'vim9script',
2536 'match none # comment', 2536 'match none # comment',
2537 ]) 2537 ])
2538 CheckScriptFailure([ 2538 v9.CheckScriptFailure([
2539 'vim9script', 2539 'vim9script',
2540 'match none# comment', 2540 'match none# comment',
2541 ], 'E475:') 2541 ], 'E475:')
2542 2542
2543 CheckScriptSuccess([ 2543 v9.CheckScriptSuccess([
2544 'vim9script', 2544 'vim9script',
2545 'menutrans clear # comment', 2545 'menutrans clear # comment',
2546 ]) 2546 ])
2547 CheckScriptFailure([ 2547 v9.CheckScriptFailure([
2548 'vim9script', 2548 'vim9script',
2549 'menutrans clear# comment text', 2549 'menutrans clear# comment text',
2550 ], 'E474:') 2550 ], 'E474:')
2551 2551
2552 CheckScriptSuccess([ 2552 v9.CheckScriptSuccess([
2553 'vim9script', 2553 'vim9script',
2554 'syntax clear # comment', 2554 'syntax clear # comment',
2555 ]) 2555 ])
2556 CheckScriptFailure([ 2556 v9.CheckScriptFailure([
2557 'vim9script', 2557 'vim9script',
2558 'syntax clear# comment text', 2558 'syntax clear# comment text',
2559 ], 'E28:') 2559 ], 'E28:')
2560 CheckScriptSuccess([ 2560 v9.CheckScriptSuccess([
2561 'vim9script', 2561 'vim9script',
2562 'syntax keyword Word some', 2562 'syntax keyword Word some',
2563 'syntax clear Word # comment', 2563 'syntax clear Word # comment',
2564 ]) 2564 ])
2565 CheckScriptFailure([ 2565 v9.CheckScriptFailure([
2566 'vim9script', 2566 'vim9script',
2567 'syntax keyword Word some', 2567 'syntax keyword Word some',
2568 'syntax clear Word# comment text', 2568 'syntax clear Word# comment text',
2569 ], 'E28:') 2569 ], 'E28:')
2570 2570
2571 CheckScriptSuccess([ 2571 v9.CheckScriptSuccess([
2572 'vim9script', 2572 'vim9script',
2573 'syntax list # comment', 2573 'syntax list # comment',
2574 ]) 2574 ])
2575 CheckScriptFailure([ 2575 v9.CheckScriptFailure([
2576 'vim9script', 2576 'vim9script',
2577 'syntax list# comment text', 2577 'syntax list# comment text',
2578 ], 'E28:') 2578 ], 'E28:')
2579 2579
2580 CheckScriptSuccess([ 2580 v9.CheckScriptSuccess([
2581 'vim9script', 2581 'vim9script',
2582 'syntax match Word /pat/ oneline # comment', 2582 'syntax match Word /pat/ oneline # comment',
2583 ]) 2583 ])
2584 CheckScriptFailure([ 2584 v9.CheckScriptFailure([
2585 'vim9script', 2585 'vim9script',
2586 'syntax match Word /pat/ oneline# comment', 2586 'syntax match Word /pat/ oneline# comment',
2587 ], 'E475:') 2587 ], 'E475:')
2588 2588
2589 CheckScriptSuccess([ 2589 v9.CheckScriptSuccess([
2590 'vim9script', 2590 'vim9script',
2591 'syntax keyword Word word # comm[ent', 2591 'syntax keyword Word word # comm[ent',
2592 ]) 2592 ])
2593 CheckScriptFailure([ 2593 v9.CheckScriptFailure([
2594 'vim9script', 2594 'vim9script',
2595 'syntax keyword Word word# comm[ent', 2595 'syntax keyword Word word# comm[ent',
2596 ], 'E789:') 2596 ], 'E789:')
2597 2597
2598 CheckScriptSuccess([ 2598 v9.CheckScriptSuccess([
2599 'vim9script', 2599 'vim9script',
2600 'syntax match Word /pat/ # comment', 2600 'syntax match Word /pat/ # comment',
2601 ]) 2601 ])
2602 CheckScriptFailure([ 2602 v9.CheckScriptFailure([
2603 'vim9script', 2603 'vim9script',
2604 'syntax match Word /pat/# comment', 2604 'syntax match Word /pat/# comment',
2605 ], 'E402:') 2605 ], 'E402:')
2606 2606
2607 CheckScriptSuccess([ 2607 v9.CheckScriptSuccess([
2608 'vim9script', 2608 'vim9script',
2609 'syntax match Word /pat/ contains=Something # comment', 2609 'syntax match Word /pat/ contains=Something # comment',
2610 ]) 2610 ])
2611 CheckScriptFailure([ 2611 v9.CheckScriptFailure([
2612 'vim9script', 2612 'vim9script',
2613 'syntax match Word /pat/ contains=Something# comment', 2613 'syntax match Word /pat/ contains=Something# comment',
2614 ], 'E475:') 2614 ], 'E475:')
2615 CheckScriptFailure([ 2615 v9.CheckScriptFailure([
2616 'vim9script', 2616 'vim9script',
2617 'syntax match Word /pat/ contains= # comment', 2617 'syntax match Word /pat/ contains= # comment',
2618 ], 'E406:') 2618 ], 'E406:')
2619 CheckScriptFailure([ 2619 v9.CheckScriptFailure([
2620 'vim9script', 2620 'vim9script',
2621 'syntax match Word /pat/ contains=# comment', 2621 'syntax match Word /pat/ contains=# comment',
2622 ], 'E475:') 2622 ], 'E475:')
2623 2623
2624 CheckScriptSuccess([ 2624 v9.CheckScriptSuccess([
2625 'vim9script', 2625 'vim9script',
2626 'syntax region Word start=/pat/ end=/pat/ # comment', 2626 'syntax region Word start=/pat/ end=/pat/ # comment',
2627 ]) 2627 ])
2628 CheckScriptFailure([ 2628 v9.CheckScriptFailure([
2629 'vim9script', 2629 'vim9script',
2630 'syntax region Word start=/pat/ end=/pat/# comment', 2630 'syntax region Word start=/pat/ end=/pat/# comment',
2631 ], 'E402:') 2631 ], 'E402:')
2632 2632
2633 CheckScriptSuccess([ 2633 v9.CheckScriptSuccess([
2634 'vim9script', 2634 'vim9script',
2635 'syntax sync # comment', 2635 'syntax sync # comment',
2636 ]) 2636 ])
2637 CheckScriptFailure([ 2637 v9.CheckScriptFailure([
2638 'vim9script', 2638 'vim9script',
2639 'syntax sync# comment', 2639 'syntax sync# comment',
2640 ], 'E404:') 2640 ], 'E404:')
2641 CheckScriptSuccess([ 2641 v9.CheckScriptSuccess([
2642 'vim9script', 2642 'vim9script',
2643 'syntax sync ccomment # comment', 2643 'syntax sync ccomment # comment',
2644 ]) 2644 ])
2645 CheckScriptFailure([ 2645 v9.CheckScriptFailure([
2646 'vim9script', 2646 'vim9script',
2647 'syntax sync ccomment# comment', 2647 'syntax sync ccomment# comment',
2648 ], 'E404:') 2648 ], 'E404:')
2649 2649
2650 CheckScriptSuccess([ 2650 v9.CheckScriptSuccess([
2651 'vim9script', 2651 'vim9script',
2652 'syntax cluster Some contains=Word # comment', 2652 'syntax cluster Some contains=Word # comment',
2653 ]) 2653 ])
2654 CheckScriptFailure([ 2654 v9.CheckScriptFailure([
2655 'vim9script', 2655 'vim9script',
2656 'syntax cluster Some contains=Word# comment', 2656 'syntax cluster Some contains=Word# comment',
2657 ], 'E475:') 2657 ], 'E475:')
2658 2658
2659 CheckScriptSuccess([ 2659 v9.CheckScriptSuccess([
2660 'vim9script', 2660 'vim9script',
2661 'command Echo echo # comment', 2661 'command Echo echo # comment',
2662 'command Echo # comment', 2662 'command Echo # comment',
2663 'delcommand Echo', 2663 'delcommand Echo',
2664 ]) 2664 ])
2665 CheckScriptFailure([ 2665 v9.CheckScriptFailure([
2666 'vim9script', 2666 'vim9script',
2667 'command Echo echo# comment', 2667 'command Echo echo# comment',
2668 'Echo', 2668 'Echo',
2669 ], 'E1144:') 2669 ], 'E1144:')
2670 delcommand Echo 2670 delcommand Echo
2671 2671
2672 var curdir = getcwd() 2672 var curdir = getcwd()
2673 CheckScriptSuccess([ 2673 v9.CheckScriptSuccess([
2674 'command Echo cd " comment', 2674 'command Echo cd " comment',
2675 'Echo', 2675 'Echo',
2676 'delcommand Echo', 2676 'delcommand Echo',
2677 ]) 2677 ])
2678 CheckScriptSuccess([ 2678 v9.CheckScriptSuccess([
2679 'vim9script', 2679 'vim9script',
2680 'command Echo cd # comment', 2680 'command Echo cd # comment',
2681 'Echo', 2681 'Echo',
2682 'delcommand Echo', 2682 'delcommand Echo',
2683 ]) 2683 ])
2684 CheckScriptFailure([ 2684 v9.CheckScriptFailure([
2685 'vim9script', 2685 'vim9script',
2686 'command Echo cd " comment', 2686 'command Echo cd " comment',
2687 'Echo', 2687 'Echo',
2688 ], 'E344:') 2688 ], 'E344:')
2689 delcommand Echo 2689 delcommand Echo
2690 chdir(curdir) 2690 chdir(curdir)
2691 2691
2692 CheckScriptFailure([ 2692 v9.CheckScriptFailure([
2693 'vim9script', 2693 'vim9script',
2694 'command Echo# comment', 2694 'command Echo# comment',
2695 ], 'E182:') 2695 ], 'E182:')
2696 CheckScriptFailure([ 2696 v9.CheckScriptFailure([
2697 'vim9script', 2697 'vim9script',
2698 'command Echo echo', 2698 'command Echo echo',
2699 'command Echo# comment', 2699 'command Echo# comment',
2700 ], 'E182:') 2700 ], 'E182:')
2701 delcommand Echo 2701 delcommand Echo
2702 2702
2703 CheckScriptSuccess([ 2703 v9.CheckScriptSuccess([
2704 'vim9script', 2704 'vim9script',
2705 'function # comment', 2705 'function # comment',
2706 ]) 2706 ])
2707 CheckScriptFailure([ 2707 v9.CheckScriptFailure([
2708 'vim9script', 2708 'vim9script',
2709 'function " comment', 2709 'function " comment',
2710 ], 'E129:') 2710 ], 'E129:')
2711 CheckScriptFailure([ 2711 v9.CheckScriptFailure([
2712 'vim9script', 2712 'vim9script',
2713 'function# comment', 2713 'function# comment',
2714 ], 'E1144:') 2714 ], 'E1144:')
2715 CheckScriptSuccess([ 2715 v9.CheckScriptSuccess([
2716 'vim9script', 2716 'vim9script',
2717 'function CheckScriptSuccess # comment', 2717 'import "./vim9.vim" as v9',
2718 ]) 2718 'function v9.CheckScriptSuccess # comment',
2719 CheckScriptFailure([ 2719 ])
2720 'vim9script', 2720 v9.CheckScriptFailure([
2721 'function CheckScriptSuccess# comment', 2721 'vim9script',
2722 ], 'E488:') 2722 'import "./vim9.vim" as v9',
2723 2723 'function v9.CheckScriptSuccess# comment',
2724 CheckScriptSuccess([ 2724 ], 'E1048: Item not found in script: CheckScriptSuccess#')
2725
2726 v9.CheckScriptSuccess([
2725 'vim9script', 2727 'vim9script',
2726 'func g:DeleteMeA()', 2728 'func g:DeleteMeA()',
2727 'endfunc', 2729 'endfunc',
2728 'delfunction g:DeleteMeA # comment', 2730 'delfunction g:DeleteMeA # comment',
2729 ]) 2731 ])
2730 CheckScriptFailure([ 2732 v9.CheckScriptFailure([
2731 'vim9script', 2733 'vim9script',
2732 'func g:DeleteMeB()', 2734 'func g:DeleteMeB()',
2733 'endfunc', 2735 'endfunc',
2734 'delfunction g:DeleteMeB# comment', 2736 'delfunction g:DeleteMeB# comment',
2735 ], 'E488:') 2737 ], 'E488:')
2736 2738
2737 CheckScriptSuccess([ 2739 v9.CheckScriptSuccess([
2738 'vim9script', 2740 'vim9script',
2739 'call execute("ls") # comment', 2741 'call execute("ls") # comment',
2740 ]) 2742 ])
2741 CheckScriptFailure([ 2743 v9.CheckScriptFailure([
2742 'vim9script', 2744 'vim9script',
2743 'call execute("ls")# comment', 2745 'call execute("ls")# comment',
2744 ], 'E488:') 2746 ], 'E488:')
2745 2747
2746 CheckScriptFailure([ 2748 v9.CheckScriptFailure([
2747 'def Test() " comment', 2749 'def Test() " comment',
2748 'enddef', 2750 'enddef',
2749 ], 'E488:') 2751 ], 'E488:')
2750 CheckScriptFailure([ 2752 v9.CheckScriptFailure([
2751 'vim9script', 2753 'vim9script',
2752 'def Test() " comment', 2754 'def Test() " comment',
2753 'enddef', 2755 'enddef',
2754 ], 'E488:') 2756 ], 'E488:')
2755 2757
2756 CheckScriptSuccess([ 2758 v9.CheckScriptSuccess([
2757 'func Test() " comment', 2759 'func Test() " comment',
2758 'endfunc', 2760 'endfunc',
2759 'delfunc Test', 2761 'delfunc Test',
2760 ]) 2762 ])
2761 CheckScriptSuccess([ 2763 v9.CheckScriptSuccess([
2762 'vim9script', 2764 'vim9script',
2763 'func Test() " comment', 2765 'func Test() " comment',
2764 'endfunc', 2766 'endfunc',
2765 ]) 2767 ])
2766 2768
2767 CheckScriptSuccess([ 2769 v9.CheckScriptSuccess([
2768 'def Test() # comment', 2770 'def Test() # comment',
2769 'enddef', 2771 'enddef',
2770 ]) 2772 ])
2771 CheckScriptFailure([ 2773 v9.CheckScriptFailure([
2772 'func Test() # comment', 2774 'func Test() # comment',
2773 'endfunc', 2775 'endfunc',
2774 ], 'E488:') 2776 ], 'E488:')
2775 2777
2776 var lines =<< trim END 2778 var lines =<< trim END
2781 \ end='bar' 2783 \ end='bar'
2782 syn region Text start='foo' 2784 syn region Text start='foo'
2783 #\ comment 2785 #\ comment
2784 \ end='bar' 2786 \ end='bar'
2785 END 2787 END
2786 CheckScriptSuccess(lines) 2788 v9.CheckScriptSuccess(lines)
2787 2789
2788 lines =<< trim END 2790 lines =<< trim END
2789 vim9script 2791 vim9script
2790 syn region Text 2792 syn region Text
2791 \ start='foo' 2793 \ start='foo'
2792 "\ comment 2794 "\ comment
2793 \ end='bar' 2795 \ end='bar'
2794 END 2796 END
2795 CheckScriptFailure(lines, 'E399:') 2797 v9.CheckScriptFailure(lines, 'E399:')
2796 enddef 2798 enddef
2797 2799
2798 def Test_vim9_comment_gui() 2800 def Test_vim9_comment_gui()
2799 CheckCanRunGui 2801 CheckCanRunGui
2800 2802
2801 CheckScriptFailure([ 2803 v9.CheckScriptFailure([
2802 'vim9script', 2804 'vim9script',
2803 'gui#comment' 2805 'gui#comment'
2804 ], 'E1144:') 2806 ], 'E1144:')
2805 CheckScriptFailure([ 2807 v9.CheckScriptFailure([
2806 'vim9script', 2808 'vim9script',
2807 'gui -f#comment' 2809 'gui -f#comment'
2808 ], 'E194:') 2810 ], 'E194:')
2809 enddef 2811 enddef
2810 2812
2826 assert_fails('doautocmd Syntax#comment', 'E216:') 2828 assert_fails('doautocmd Syntax#comment', 'E216:')
2827 2829
2828 au! TabEnter 2830 au! TabEnter
2829 unlet g:entered 2831 unlet g:entered
2830 2832
2831 CheckScriptSuccess([ 2833 v9.CheckScriptSuccess([
2832 'vim9script', 2834 'vim9script',
2833 'g:var = 123', 2835 'g:var = 123',
2834 'b:var = 456', 2836 'b:var = 456',
2835 'w:var = 777', 2837 'w:var = 777',
2836 't:var = 888', 2838 't:var = 888',
2837 'unlet g:var w:var # something', 2839 'unlet g:var w:var # something',
2838 ]) 2840 ])
2839 2841
2840 CheckScriptFailure([ 2842 v9.CheckScriptFailure([
2841 'vim9script', 2843 'vim9script',
2842 'let var = 123', 2844 'let var = 123',
2843 ], 'E1126: Cannot use :let in Vim9 script') 2845 ], 'E1126: Cannot use :let in Vim9 script')
2844 2846
2845 CheckScriptFailure([ 2847 v9.CheckScriptFailure([
2846 'vim9script', 2848 'vim9script',
2847 'var g:var = 123', 2849 'var g:var = 123',
2848 ], 'E1016: Cannot declare a global variable:') 2850 ], 'E1016: Cannot declare a global variable:')
2849 2851
2850 CheckScriptFailure([ 2852 v9.CheckScriptFailure([
2851 'vim9script', 2853 'vim9script',
2852 'var b:var = 123', 2854 'var b:var = 123',
2853 ], 'E1016: Cannot declare a buffer variable:') 2855 ], 'E1016: Cannot declare a buffer variable:')
2854 2856
2855 CheckScriptFailure([ 2857 v9.CheckScriptFailure([
2856 'vim9script', 2858 'vim9script',
2857 'var w:var = 123', 2859 'var w:var = 123',
2858 ], 'E1016: Cannot declare a window variable:') 2860 ], 'E1016: Cannot declare a window variable:')
2859 2861
2860 CheckScriptFailure([ 2862 v9.CheckScriptFailure([
2861 'vim9script', 2863 'vim9script',
2862 'var t:var = 123', 2864 'var t:var = 123',
2863 ], 'E1016: Cannot declare a tab variable:') 2865 ], 'E1016: Cannot declare a tab variable:')
2864 2866
2865 CheckScriptFailure([ 2867 v9.CheckScriptFailure([
2866 'vim9script', 2868 'vim9script',
2867 'var v:version = 123', 2869 'var v:version = 123',
2868 ], 'E1016: Cannot declare a v: variable:') 2870 ], 'E1016: Cannot declare a v: variable:')
2869 2871
2870 CheckScriptFailure([ 2872 v9.CheckScriptFailure([
2871 'vim9script', 2873 'vim9script',
2872 'var $VARIABLE = "text"', 2874 'var $VARIABLE = "text"',
2873 ], 'E1016: Cannot declare an environment variable:') 2875 ], 'E1016: Cannot declare an environment variable:')
2874 2876
2875 CheckScriptFailure([ 2877 v9.CheckScriptFailure([
2876 'vim9script', 2878 'vim9script',
2877 'g:var = 123', 2879 'g:var = 123',
2878 'unlet g:var# comment1', 2880 'unlet g:var# comment1',
2879 ], 'E108:') 2881 ], 'E108:')
2880 2882
2881 CheckScriptFailure([ 2883 v9.CheckScriptFailure([
2882 'let g:var = 123', 2884 'let g:var = 123',
2883 'unlet g:var # something', 2885 'unlet g:var # something',
2884 ], 'E488:') 2886 ], 'E488:')
2885 2887
2886 CheckScriptSuccess([ 2888 v9.CheckScriptSuccess([
2887 'vim9script', 2889 'vim9script',
2888 'if 1 # comment2', 2890 'if 1 # comment2',
2889 ' echo "yes"', 2891 ' echo "yes"',
2890 'elseif 2 #comment', 2892 'elseif 2 #comment',
2891 ' echo "no"', 2893 ' echo "no"',
2892 'endif', 2894 'endif',
2893 ]) 2895 ])
2894 2896
2895 CheckScriptFailure([ 2897 v9.CheckScriptFailure([
2896 'vim9script', 2898 'vim9script',
2897 'if 1# comment3', 2899 'if 1# comment3',
2898 ' echo "yes"', 2900 ' echo "yes"',
2899 'endif', 2901 'endif',
2900 ], 'E488:') 2902 ], 'E488:')
2901 2903
2902 CheckScriptFailure([ 2904 v9.CheckScriptFailure([
2903 'vim9script', 2905 'vim9script',
2904 'if 0 # comment4', 2906 'if 0 # comment4',
2905 ' echo "yes"', 2907 ' echo "yes"',
2906 'elseif 2#comment', 2908 'elseif 2#comment',
2907 ' echo "no"', 2909 ' echo "no"',
2908 'endif', 2910 'endif',
2909 ], 'E488:') 2911 ], 'E488:')
2910 2912
2911 CheckScriptSuccess([ 2913 v9.CheckScriptSuccess([
2912 'vim9script', 2914 'vim9script',
2913 'var v = 1 # comment5', 2915 'var v = 1 # comment5',
2914 ]) 2916 ])
2915 2917
2916 CheckScriptFailure([ 2918 v9.CheckScriptFailure([
2917 'vim9script', 2919 'vim9script',
2918 'var v = 1# comment6', 2920 'var v = 1# comment6',
2919 ], 'E488:') 2921 ], 'E488:')
2920 2922
2921 CheckScriptSuccess([ 2923 v9.CheckScriptSuccess([
2922 'vim9script', 2924 'vim9script',
2923 'new' 2925 'new'
2924 'setline(1, ["# define pat", "last"])', 2926 'setline(1, ["# define pat", "last"])',
2925 ':$', 2927 ':$',
2926 'dsearch /pat/ #comment', 2928 'dsearch /pat/ #comment',
2927 'bwipe!', 2929 'bwipe!',
2928 ]) 2930 ])
2929 2931
2930 CheckScriptFailure([ 2932 v9.CheckScriptFailure([
2931 'vim9script', 2933 'vim9script',
2932 'new' 2934 'new'
2933 'setline(1, ["# define pat", "last"])', 2935 'setline(1, ["# define pat", "last"])',
2934 ':$', 2936 ':$',
2935 'dsearch /pat/#comment', 2937 'dsearch /pat/#comment',
2936 'bwipe!', 2938 'bwipe!',
2937 ], 'E488:') 2939 ], 'E488:')
2938 2940
2939 CheckScriptFailure([ 2941 v9.CheckScriptFailure([
2940 'vim9script', 2942 'vim9script',
2941 'func! SomeFunc()', 2943 'func! SomeFunc()',
2942 ], 'E477:') 2944 ], 'E477:')
2943 enddef 2945 enddef
2944 2946
3003 catch 3005 catch
3004 error = v:exception 3006 error = v:exception
3005 endtry 3007 endtry
3006 assert_match('E741: Value is locked: local', error) 3008 assert_match('E741: Value is locked: local', error)
3007 END 3009 END
3008 CheckScriptSuccess(lines) 3010 v9.CheckScriptSuccess(lines)
3009 enddef 3011 enddef
3010 3012
3011 3013
3012 func Test_vim9script_not_global() 3014 func Test_vim9script_not_global()
3013 " check that items defined in Vim9 script are script-local, not global 3015 " check that items defined in Vim9 script are script-local, not global
3063 call s:Func() 3065 call s:Func()
3064 doau CursorHold 3066 doau CursorHold
3065 call assert_equal(2, s:counter) 3067 call assert_equal(2, s:counter)
3066 au! CursorHold 3068 au! CursorHold
3067 END 3069 END
3068 CheckScriptSuccess(lines) 3070 v9.CheckScriptSuccess(lines)
3069 enddef 3071 enddef
3070 3072
3071 def Test_error_in_autoload_script() 3073 def Test_error_in_autoload_script()
3072 var save_rtp = &rtp 3074 var save_rtp = &rtp
3073 var dir = getcwd() .. '/Xruntime' 3075 var dir = getcwd() .. '/Xruntime'
3100 endtry 3102 endtry
3101 endfunction 3103 endfunction
3102 3104
3103 Legacy() 3105 Legacy()
3104 END 3106 END
3105 CheckScriptSuccess(lines) 3107 v9.CheckScriptSuccess(lines)
3106 3108
3107 &rtp = save_rtp 3109 &rtp = save_rtp
3108 delete(dir, 'rf') 3110 delete(dir, 'rf')
3109 enddef 3111 enddef
3110 3112
3111 def Test_invalid_sid() 3113 def Test_invalid_sid()
3112 assert_fails('func <SNR>1234_func', 'E123:') 3114 assert_fails('func <SNR>1234_func', 'E123:')
3113 3115
3114 if RunVim([], ['wq! Xdidit'], '+"func <SNR>1_func"') 3116 if g:RunVim([], ['wq! Xdidit'], '+"func <SNR>1_func"')
3115 assert_equal([], readfile('Xdidit')) 3117 assert_equal([], readfile('Xdidit'))
3116 endif 3118 endif
3117 delete('Xdidit') 3119 delete('Xdidit')
3118 enddef 3120 enddef
3119 3121
3120 def Test_restoring_cpo() 3122 def Test_restoring_cpo()
3121 writefile(['vim9script', 'set nocp'], 'Xsourced') 3123 writefile(['vim9script', 'set nocp'], 'Xsourced')
3122 writefile(['call writefile(["done"], "Xdone")', 'quit!'], 'Xclose') 3124 writefile(['call writefile(["done"], "Xdone")', 'quit!'], 'Xclose')
3123 if RunVim([], [], '-u NONE +"set cpo+=a" -S Xsourced -S Xclose') 3125 if g:RunVim([], [], '-u NONE +"set cpo+=a" -S Xsourced -S Xclose')
3124 assert_equal(['done'], readfile('Xdone')) 3126 assert_equal(['done'], readfile('Xdone'))
3125 endif 3127 endif
3126 delete('Xsourced') 3128 delete('Xsourced')
3127 delete('Xclose') 3129 delete('Xclose')
3128 delete('Xdone') 3130 delete('Xdone')
3167 call writefile(['vim9: ' .. &cpo], 'Xresult', 'a') 3169 call writefile(['vim9: ' .. &cpo], 'Xresult', 'a')
3168 qa 3170 qa
3169 END 3171 END
3170 writefile(lines, 'Xvim9') 3172 writefile(lines, 'Xvim9')
3171 3173
3172 var cmd = GetVimCommand() .. " -S Xlegacy -S Xvim9" 3174 var cmd = g:GetVimCommand() .. " -S Xlegacy -S Xvim9"
3173 cmd = substitute(cmd, '-u NONE', '', '') 3175 cmd = substitute(cmd, '-u NONE', '', '')
3174 exe "silent !" .. cmd 3176 exe "silent !" .. cmd
3175 3177
3176 assert_equal([ 3178 assert_equal([
3177 'before: aABceFs', 3179 'before: aABceFs',
3206 exe 'set rtp^=' .. getcwd() .. '/Xdir' 3208 exe 'set rtp^=' .. getcwd() .. '/Xdir'
3207 au CmdlineEnter : ++once timer_start(0, (_) => script#func()) 3209 au CmdlineEnter : ++once timer_start(0, (_) => script#func())
3208 setline(1, 'some text') 3210 setline(1, 'some text')
3209 END 3211 END
3210 call writefile(lines, 'XTest_redraw_cpo') 3212 call writefile(lines, 'XTest_redraw_cpo')
3211 let buf = RunVimInTerminal('-S XTest_redraw_cpo', {'rows': 6}) 3213 let buf = g:RunVimInTerminal('-S XTest_redraw_cpo', {'rows': 6})
3212 call term_sendkeys(buf, "V:") 3214 call term_sendkeys(buf, "V:")
3213 call VerifyScreenDump(buf, 'Test_vim9_no_redraw', {}) 3215 call VerifyScreenDump(buf, 'Test_vim9_no_redraw', {})
3214 3216
3215 " clean up 3217 " clean up
3216 call term_sendkeys(buf, "\<Esc>u") 3218 call term_sendkeys(buf, "\<Esc>u")
3217 call StopVimInTerminal(buf) 3219 call g:StopVimInTerminal(buf)
3218 call delete('XTest_redraw_cpo') 3220 call delete('XTest_redraw_cpo')
3219 call delete('Xdir', 'rf') 3221 call delete('Xdir', 'rf')
3220 endfunc 3222 endfunc
3221 3223
3222 3224
3223 def Test_unset_any_variable() 3225 def Test_unset_any_variable()
3224 var lines =<< trim END 3226 var lines =<< trim END
3225 var name: any 3227 var name: any
3226 assert_equal(0, name) 3228 assert_equal(0, name)
3227 END 3229 END
3228 CheckDefAndScriptSuccess(lines) 3230 v9.CheckDefAndScriptSuccess(lines)
3229 enddef 3231 enddef
3230 3232
3231 func Test_define_func_at_command_line() 3233 func Test_define_func_at_command_line()
3232 CheckRunVimInTerminal 3234 CheckRunVimInTerminal
3233 3235
3243 call writefile(['errors: ' .. string(v:errors)], 'Xdidcmd') 3245 call writefile(['errors: ' .. string(v:errors)], 'Xdidcmd')
3244 endfunc 3246 endfunc
3245 END 3247 END
3246 writefile([''], 'Xdidcmd') 3248 writefile([''], 'Xdidcmd')
3247 writefile(lines, 'XcallFunc') 3249 writefile(lines, 'XcallFunc')
3248 var buf = RunVimInTerminal('-S XcallFunc', {rows: 6}) 3250 var buf = g:RunVimInTerminal('-S XcallFunc', {rows: 6})
3249 # define Afunc() on the command line 3251 # define Afunc() on the command line
3250 term_sendkeys(buf, ":def Afunc()\<CR>Bfunc()\<CR>enddef\<CR>") 3252 term_sendkeys(buf, ":def Afunc()\<CR>Bfunc()\<CR>enddef\<CR>")
3251 term_sendkeys(buf, ":call CheckAndQuit()\<CR>") 3253 term_sendkeys(buf, ":call CheckAndQuit()\<CR>")
3252 WaitForAssert(() => assert_equal(['errors: []'], readfile('Xdidcmd'))) 3254 g:WaitForAssert(() => assert_equal(['errors: []'], readfile('Xdidcmd')))
3253 3255
3254 call StopVimInTerminal(buf) 3256 call g:StopVimInTerminal(buf)
3255 delete('XcallFunc') 3257 delete('XcallFunc')
3256 delete('Xdidcmd') 3258 delete('Xdidcmd')
3257 enddef 3259 enddef
3258 3260
3259 def Test_script_var_scope() 3261 def Test_script_var_scope()
3265 echo one 3267 echo one
3266 endif 3268 endif
3267 echo one 3269 echo one
3268 endif 3270 endif
3269 END 3271 END
3270 CheckScriptFailure(lines, 'E121:', 7) 3272 v9.CheckScriptFailure(lines, 'E121:', 7)
3271 3273
3272 lines =<< trim END 3274 lines =<< trim END
3273 vim9script 3275 vim9script
3274 if true 3276 if true
3275 if false 3277 if false
3280 echo one 3282 echo one
3281 endif 3283 endif
3282 echo one 3284 echo one
3283 endif 3285 endif
3284 END 3286 END
3285 CheckScriptFailure(lines, 'E121:', 10) 3287 v9.CheckScriptFailure(lines, 'E121:', 10)
3286 3288
3287 lines =<< trim END 3289 lines =<< trim END
3288 vim9script 3290 vim9script
3289 while true 3291 while true
3290 var one = 'one' 3292 var one = 'one'
3291 echo one 3293 echo one
3292 break 3294 break
3293 endwhile 3295 endwhile
3294 echo one 3296 echo one
3295 END 3297 END
3296 CheckScriptFailure(lines, 'E121:', 7) 3298 v9.CheckScriptFailure(lines, 'E121:', 7)
3297 3299
3298 lines =<< trim END 3300 lines =<< trim END
3299 vim9script 3301 vim9script
3300 for i in range(1) 3302 for i in range(1)
3301 var one = 'one' 3303 var one = 'one'
3302 echo one 3304 echo one
3303 endfor 3305 endfor
3304 echo one 3306 echo one
3305 END 3307 END
3306 CheckScriptFailure(lines, 'E121:', 6) 3308 v9.CheckScriptFailure(lines, 'E121:', 6)
3307 3309
3308 lines =<< trim END 3310 lines =<< trim END
3309 vim9script 3311 vim9script
3310 { 3312 {
3311 var one = 'one' 3313 var one = 'one'
3312 assert_equal('one', one) 3314 assert_equal('one', one)
3313 } 3315 }
3314 assert_false(exists('one')) 3316 assert_false(exists('one'))
3315 assert_false(exists('s:one')) 3317 assert_false(exists('s:one'))
3316 END 3318 END
3317 CheckScriptSuccess(lines) 3319 v9.CheckScriptSuccess(lines)
3318 3320
3319 lines =<< trim END 3321 lines =<< trim END
3320 vim9script 3322 vim9script
3321 { 3323 {
3322 var one = 'one' 3324 var one = 'one'
3323 echo one 3325 echo one
3324 } 3326 }
3325 echo one 3327 echo one
3326 END 3328 END
3327 CheckScriptFailure(lines, 'E121:', 6) 3329 v9.CheckScriptFailure(lines, 'E121:', 6)
3328 enddef 3330 enddef
3329 3331
3330 def Test_catch_exception_in_callback() 3332 def Test_catch_exception_in_callback()
3331 var lines =<< trim END 3333 var lines =<< trim END
3332 vim9script 3334 vim9script
3342 endtry 3344 endtry
3343 enddef 3345 enddef
3344 popup_menu('popup', {callback: Callback}) 3346 popup_menu('popup', {callback: Callback})
3345 feedkeys("\r", 'xt') 3347 feedkeys("\r", 'xt')
3346 END 3348 END
3347 CheckScriptSuccess(lines) 3349 v9.CheckScriptSuccess(lines)
3348 3350
3349 unlet g:caught 3351 unlet g:caught
3350 enddef 3352 enddef
3351 3353
3352 def Test_no_unknown_error_after_error() 3354 def Test_no_unknown_error_after_error()
3394 3396
3395 def Test_white_space_after_command() 3397 def Test_white_space_after_command()
3396 var lines =<< trim END 3398 var lines =<< trim END
3397 exit_cb: Func}) 3399 exit_cb: Func})
3398 END 3400 END
3399 CheckDefAndScriptFailure(lines, 'E1144:', 1) 3401 v9.CheckDefAndScriptFailure(lines, 'E1144:', 1)
3400 3402
3401 lines =<< trim END 3403 lines =<< trim END
3402 e# 3404 e#
3403 END 3405 END
3404 CheckDefAndScriptFailure(lines, 'E1144:', 1) 3406 v9.CheckDefAndScriptFailure(lines, 'E1144:', 1)
3405 enddef 3407 enddef
3406 3408
3407 def Test_script_var_gone_when_sourced_twice() 3409 def Test_script_var_gone_when_sourced_twice()
3408 var lines =<< trim END 3410 var lines =<< trim END
3409 vim9script 3411 vim9script
3436 3438
3437 def Test_unsupported_commands() 3439 def Test_unsupported_commands()
3438 var lines =<< trim END 3440 var lines =<< trim END
3439 ka 3441 ka
3440 END 3442 END
3441 CheckDefFailure(lines, 'E476:') 3443 v9.CheckDefFailure(lines, 'E476:')
3442 CheckScriptFailure(['vim9script'] + lines, 'E492:') 3444 v9.CheckScriptFailure(['vim9script'] + lines, 'E492:')
3443 3445
3444 lines =<< trim END 3446 lines =<< trim END
3445 :1ka 3447 :1ka
3446 END 3448 END
3447 CheckDefFailure(lines, 'E476:') 3449 v9.CheckDefFailure(lines, 'E476:')
3448 CheckScriptFailure(['vim9script'] + lines, 'E492:') 3450 v9.CheckScriptFailure(['vim9script'] + lines, 'E492:')
3449 3451
3450 lines =<< trim END 3452 lines =<< trim END
3451 t 3453 t
3452 END 3454 END
3453 CheckDefFailure(lines, 'E1100:') 3455 v9.CheckDefFailure(lines, 'E1100:')
3454 CheckScriptFailure(['vim9script'] + lines, 'E1100:') 3456 v9.CheckScriptFailure(['vim9script'] + lines, 'E1100:')
3455 3457
3456 lines =<< trim END 3458 lines =<< trim END
3457 x 3459 x
3458 END 3460 END
3459 CheckDefFailure(lines, 'E1100:') 3461 v9.CheckDefFailure(lines, 'E1100:')
3460 CheckScriptFailure(['vim9script'] + lines, 'E1100:') 3462 v9.CheckScriptFailure(['vim9script'] + lines, 'E1100:')
3461 3463
3462 lines =<< trim END 3464 lines =<< trim END
3463 xit 3465 xit
3464 END 3466 END
3465 CheckDefFailure(lines, 'E1100:') 3467 v9.CheckDefFailure(lines, 'E1100:')
3466 CheckScriptFailure(['vim9script'] + lines, 'E1100:') 3468 v9.CheckScriptFailure(['vim9script'] + lines, 'E1100:')
3467 enddef 3469 enddef
3468 3470
3469 def Test_mapping_line_number() 3471 def Test_mapping_line_number()
3470 var lines =<< trim END 3472 var lines =<< trim END
3471 vim9script 3473 vim9script
3483 .. '<F3> a' 3485 .. '<F3> a'
3484 .. 'b' 3486 .. 'b'
3485 .. 'c' 3487 .. 'c'
3486 enddef 3488 enddef
3487 END 3489 END
3488 CheckScriptSuccess(lines) 3490 v9.CheckScriptSuccess(lines)
3489 var res = execute('verbose nmap <F3>') 3491 var res = execute('verbose nmap <F3>')
3490 assert_match('No mapping found', res) 3492 assert_match('No mapping found', res)
3491 3493
3492 g:FuncA() 3494 g:FuncA()
3493 res = execute('verbose nmap <F3>') 3495 res = execute('verbose nmap <F3>')
3501 # legacy script allows for white space 3503 # legacy script allows for white space
3502 var lines =<< trim END 3504 var lines =<< trim END
3503 set foldlevel =11 3505 set foldlevel =11
3504 call assert_equal(11, &foldlevel) 3506 call assert_equal(11, &foldlevel)
3505 END 3507 END
3506 CheckScriptSuccess(lines) 3508 v9.CheckScriptSuccess(lines)
3507 3509
3508 set foldlevel 3510 set foldlevel
3509 set foldlevel=12 3511 set foldlevel=12
3510 assert_equal(12, &foldlevel) 3512 assert_equal(12, &foldlevel)
3511 set foldlevel+=2 3513 set foldlevel+=2
3514 assert_equal(11, &foldlevel) 3516 assert_equal(11, &foldlevel)
3515 3517
3516 lines =<< trim END 3518 lines =<< trim END
3517 set foldlevel =1 3519 set foldlevel =1
3518 END 3520 END
3519 CheckDefExecAndScriptFailure(lines, 'E1205: No white space allowed between option and: =1') 3521 v9.CheckDefExecAndScriptFailure(lines, 'E1205: No white space allowed between option and: =1')
3520 3522
3521 lines =<< trim END 3523 lines =<< trim END
3522 set foldlevel +=1 3524 set foldlevel +=1
3523 END 3525 END
3524 CheckDefExecAndScriptFailure(lines, 'E1205: No white space allowed between option and: +=1') 3526 v9.CheckDefExecAndScriptFailure(lines, 'E1205: No white space allowed between option and: +=1')
3525 3527
3526 lines =<< trim END 3528 lines =<< trim END
3527 set foldlevel ^=1 3529 set foldlevel ^=1
3528 END 3530 END
3529 CheckDefExecAndScriptFailure(lines, 'E1205: No white space allowed between option and: ^=1') 3531 v9.CheckDefExecAndScriptFailure(lines, 'E1205: No white space allowed between option and: ^=1')
3530 3532
3531 lines =<< trim END 3533 lines =<< trim END
3532 set foldlevel -=1 3534 set foldlevel -=1
3533 END 3535 END
3534 CheckDefExecAndScriptFailure(lines, 'E1205: No white space allowed between option and: -=1') 3536 v9.CheckDefExecAndScriptFailure(lines, 'E1205: No white space allowed between option and: -=1')
3535 3537
3536 set foldlevel& 3538 set foldlevel&
3537 enddef 3539 enddef
3538 3540
3539 def Test_option_modifier() 3541 def Test_option_modifier()
3540 # legacy script allows for white space 3542 # legacy script allows for white space
3541 var lines =<< trim END 3543 var lines =<< trim END
3542 set hlsearch & hlsearch ! 3544 set hlsearch & hlsearch !
3543 call assert_equal(1, &hlsearch) 3545 call assert_equal(1, &hlsearch)
3544 END 3546 END
3545 CheckScriptSuccess(lines) 3547 v9.CheckScriptSuccess(lines)
3546 3548
3547 set hlsearch 3549 set hlsearch
3548 set hlsearch! 3550 set hlsearch!
3549 assert_equal(false, &hlsearch) 3551 assert_equal(false, &hlsearch)
3550 3552
3553 assert_equal(false, &hlsearch) 3555 assert_equal(false, &hlsearch)
3554 3556
3555 lines =<< trim END 3557 lines =<< trim END
3556 set hlsearch & 3558 set hlsearch &
3557 END 3559 END
3558 CheckDefExecAndScriptFailure(lines, 'E1205: No white space allowed between option and: &') 3560 v9.CheckDefExecAndScriptFailure(lines, 'E1205: No white space allowed between option and: &')
3559 3561
3560 lines =<< trim END 3562 lines =<< trim END
3561 set hlsearch ! 3563 set hlsearch !
3562 END 3564 END
3563 CheckDefExecAndScriptFailure(lines, 'E1205: No white space allowed between option and: !') 3565 v9.CheckDefExecAndScriptFailure(lines, 'E1205: No white space allowed between option and: !')
3564 3566
3565 set hlsearch& 3567 set hlsearch&
3566 enddef 3568 enddef
3567 3569
3568 " This must be called last, it may cause following :def functions to fail 3570 " This must be called last, it may cause following :def functions to fail
3570 var lines =<< trim END 3572 var lines =<< trim END
3571 echoerr 'some' 3573 echoerr 'some'
3572 .. ' error' 3574 .. ' error'
3573 .. ' continued' 3575 .. ' continued'
3574 END 3576 END
3575 CheckDefExecAndScriptFailure(lines, 'some error continued', 1) 3577 v9.CheckDefExecAndScriptFailure(lines, 'some error continued', 1)
3576 enddef 3578 enddef
3577 3579
3578 func Test_debug_with_lambda() 3580 func Test_debug_with_lambda()
3579 CheckRunVimInTerminal 3581 CheckRunVimInTerminal
3580 3582
3591 enddef 3593 enddef
3592 breakadd func Func 3594 breakadd func Func
3593 Func() 3595 Func()
3594 END 3596 END
3595 writefile(lines, 'XdebugFunc') 3597 writefile(lines, 'XdebugFunc')
3596 var buf = RunVimInTerminal('-S XdebugFunc', {rows: 6, wait_for_ruler: 0}) 3598 var buf = g:RunVimInTerminal('-S XdebugFunc', {rows: 6, wait_for_ruler: 0})
3597 WaitForAssert(() => assert_match('^>', term_getline(buf, 6))) 3599 g:WaitForAssert(() => assert_match('^>', term_getline(buf, 6)))
3598 3600
3599 term_sendkeys(buf, "cont\<CR>") 3601 term_sendkeys(buf, "cont\<CR>")
3600 WaitForAssert(() => assert_match('\[0\]', term_getline(buf, 5))) 3602 g:WaitForAssert(() => assert_match('\[0\]', term_getline(buf, 5)))
3601 3603
3602 StopVimInTerminal(buf) 3604 g:StopVimInTerminal(buf)
3603 delete('XdebugFunc') 3605 delete('XdebugFunc')
3604 enddef 3606 enddef
3605 3607
3606 func Test_debug_running_out_of_lines() 3608 func Test_debug_running_out_of_lines()
3607 CheckRunVimInTerminal 3609 CheckRunVimInTerminal
3627 enddef 3629 enddef
3628 breakadd func Crash 3630 breakadd func Crash
3629 Crash() 3631 Crash()
3630 END 3632 END
3631 writefile(lines, 'XdebugFunc') 3633 writefile(lines, 'XdebugFunc')
3632 var buf = RunVimInTerminal('-S XdebugFunc', {rows: 6, wait_for_ruler: 0}) 3634 var buf = g:RunVimInTerminal('-S XdebugFunc', {rows: 6, wait_for_ruler: 0})
3633 WaitForAssert(() => assert_match('^>', term_getline(buf, 6))) 3635 g:WaitForAssert(() => assert_match('^>', term_getline(buf, 6)))
3634 3636
3635 term_sendkeys(buf, "next\<CR>") 3637 term_sendkeys(buf, "next\<CR>")
3636 TermWait(buf) 3638 g:TermWait(buf)
3637 WaitForAssert(() => assert_match('^>', term_getline(buf, 6))) 3639 g:WaitForAssert(() => assert_match('^>', term_getline(buf, 6)))
3638 3640
3639 term_sendkeys(buf, "cont\<CR>") 3641 term_sendkeys(buf, "cont\<CR>")
3640 TermWait(buf) 3642 g:TermWait(buf)
3641 3643
3642 StopVimInTerminal(buf) 3644 g:StopVimInTerminal(buf)
3643 delete('XdebugFunc') 3645 delete('XdebugFunc')
3644 enddef 3646 enddef
3645 3647
3646 def ProfiledWithLambda() 3648 def s:ProfiledWithLambda()
3647 var n = 3 3649 var n = 3
3648 echo [[1, 2], [3, 4]]->filter((_, l) => l[0] == n) 3650 echo [[1, 2], [3, 4]]->filter((_, l) => l[0] == n)
3649 enddef 3651 enddef
3650 3652
3651 def ProfiledNested() 3653 def s:ProfiledNested()
3652 var x = 0 3654 var x = 0
3653 def Nested(): any 3655 def Nested(): any
3654 return x 3656 return x
3655 enddef 3657 enddef
3656 Nested() 3658 Nested()
3669 vim9script 3671 vim9script
3670 command CmdA echomsg 'CmdA' 3672 command CmdA echomsg 'CmdA'
3671 command CmdB echomsg 'CmdB' 3673 command CmdB echomsg 'CmdB'
3672 Cmd 3674 Cmd
3673 END 3675 END
3674 CheckScriptFailure(lines, 'E464: Ambiguous use of user-defined command: Cmd', 4) 3676 v9.CheckScriptFailure(lines, 'E464: Ambiguous use of user-defined command: Cmd', 4)
3675 3677
3676 lines =<< trim END 3678 lines =<< trim END
3677 vim9script 3679 vim9script
3678 def Func() 3680 def Func()
3679 Cmd 3681 Cmd
3680 enddef 3682 enddef
3681 Func() 3683 Func()
3682 END 3684 END
3683 CheckScriptFailure(lines, 'E464: Ambiguous use of user-defined command: Cmd', 1) 3685 v9.CheckScriptFailure(lines, 'E464: Ambiguous use of user-defined command: Cmd', 1)
3684 3686
3685 lines =<< trim END 3687 lines =<< trim END
3686 vim9script 3688 vim9script
3687 nnoremap <F3> <ScriptCmd>Cmd<CR> 3689 nnoremap <F3> <ScriptCmd>Cmd<CR>
3688 feedkeys("\<F3>", 'xt') 3690 feedkeys("\<F3>", 'xt')
3689 END 3691 END
3690 CheckScriptFailure(lines, 'E464: Ambiguous use of user-defined command: Cmd', 3) 3692 v9.CheckScriptFailure(lines, 'E464: Ambiguous use of user-defined command: Cmd', 3)
3691 3693
3692 delcommand CmdA 3694 delcommand CmdA
3693 delcommand CmdB 3695 delcommand CmdB
3694 nunmap <F3> 3696 nunmap <F3>
3695 enddef 3697 enddef
3707 ProfiledNested() 3709 ProfiledNested()
3708 3710
3709 # Also profile the nested function. Use a different function, although the 3711 # Also profile the nested function. Use a different function, although the
3710 # contents is the same, to make sure it was not already compiled. 3712 # contents is the same, to make sure it was not already compiled.
3711 profile func * 3713 profile func *
3712 ProfiledNestedProfiled() 3714 g:ProfiledNestedProfiled()
3713 3715
3714 profdel func * 3716 profdel func *
3715 profile pause 3717 profile pause
3716 enddef 3718 enddef
3717 3719