1" Test various aspects of the Vim9 script language.
2
3source check.vim
4source view_util.vim
5
6" Check that "lines" inside ":def" results in an "error" message.
7func CheckDefFailure(lines, error)
8  call writefile(['def Func()'] + a:lines + ['enddef'], 'Xdef')
9  call assert_fails('so Xdef', a:error, a:lines)
10  call delete('Xdef')
11endfunc
12
13func CheckScriptFailure(lines, error)
14  call writefile(a:lines, 'Xdef')
15  call assert_fails('so Xdef', a:error, a:lines)
16  call delete('Xdef')
17endfunc
18
19def Test_syntax()
20  let var = 234
21  let other: list<string> = ['asdf']
22enddef
23
24func Test_def_basic()
25  def SomeFunc(): string
26    return 'yes'
27  enddef
28  call assert_equal('yes', SomeFunc())
29endfunc
30
31let s:appendToMe = 'xxx'
32let s:addToMe = 111
33let g:existing = 'yes'
34
35def Test_assignment()
36  let bool1: bool = true
37  assert_equal(v:true, bool1)
38  let bool2: bool = false
39  assert_equal(v:false, bool2)
40
41  let list1: list<bool> = [false, true, false]
42  let list2: list<number> = [1, 2, 3]
43  let list3: list<string> = ['sdf', 'asdf']
44  let list4: list<any> = ['yes', true, 1234]
45  let list5: list<blob> = [0z01, 0z02]
46
47  let listS: list<string> = []
48  let listN: list<number> = []
49
50  let dict1: dict<bool> = #{one: false, two: true}
51  let dict2: dict<number> = #{one: 1, two: 2}
52  let dict3: dict<string> = #{key: 'value'}
53  let dict4: dict<any> = #{one: 1, two: '2'}
54  let dict5: dict<blob> = #{one: 0z01, tw: 0z02}
55
56  if has('channel')
57    let chan1: channel
58    let job1: job
59    let job2: job = job_start('willfail')
60  endif
61  if has('float')
62    let float1: float = 3.4
63  endif
64  let funky1: func
65  let funky2: func = function('len')
66  let party1: partial
67  let party2: partial = funcref('Test_syntax')
68
69  g:newvar = 'new'
70  assert_equal('new', g:newvar)
71
72  assert_equal('yes', g:existing)
73  g:existing = 'no'
74  assert_equal('no', g:existing)
75
76  v:char = 'abc'
77  assert_equal('abc', v:char)
78
79  $ENVVAR = 'foobar'
80  assert_equal('foobar', $ENVVAR)
81  $ENVVAR = ''
82
83  s:appendToMe ..= 'yyy'
84  assert_equal('xxxyyy', s:appendToMe)
85  s:addToMe += 222
86  assert_equal(333, s:addToMe)
87  s:newVar = 'new'
88  assert_equal('new', s:newVar)
89enddef
90
91func Test_assignment_failure()
92  call CheckDefFailure(['let var=234'], 'E1004:')
93  call CheckDefFailure(['let var =234'], 'E1004:')
94  call CheckDefFailure(['let var= 234'], 'E1004:')
95
96  call CheckDefFailure(['let true = 1'], 'E1034:')
97  call CheckDefFailure(['let false = 1'], 'E1034:')
98
99  call CheckDefFailure(['let var: list<string> = [123]'], 'expected list<string> but got list<number>')
100  call CheckDefFailure(['let var: list<number> = ["xx"]'], 'expected list<number> but got list<string>')
101
102  call CheckDefFailure(['let var: dict<string> = #{key: 123}'], 'expected dict<string> but got dict<number>')
103  call CheckDefFailure(['let var: dict<number> = #{key: "xx"}'], 'expected dict<number> but got dict<string>')
104
105  call CheckDefFailure(['let var = feedkeys("0")'], 'E1031:')
106  call CheckDefFailure(['let var: number = feedkeys("0")'], 'expected number but got void')
107
108  call CheckDefFailure(['let var: dict <number>'], 'E1007:')
109  call CheckDefFailure(['let var: dict<number'], 'E1009:')
110
111  call CheckDefFailure(['let var: ally'], 'E1010:')
112  call CheckDefFailure(['let var: bram'], 'E1010:')
113  call CheckDefFailure(['let var: cathy'], 'E1010:')
114  call CheckDefFailure(['let var: dom'], 'E1010:')
115  call CheckDefFailure(['let var: freddy'], 'E1010:')
116  call CheckDefFailure(['let var: john'], 'E1010:')
117  call CheckDefFailure(['let var: larry'], 'E1010:')
118  call CheckDefFailure(['let var: ned'], 'E1010:')
119  call CheckDefFailure(['let var: pam'], 'E1010:')
120  call CheckDefFailure(['let var: sam'], 'E1010:')
121  call CheckDefFailure(['let var: vim'], 'E1010:')
122endfunc
123
124func Test_const()
125  call CheckDefFailure(['const var = 234', 'var = 99'], 'E1018:')
126  call CheckDefFailure(['const one = 234', 'let one = 99'], 'E1017:')
127  call CheckDefFailure(['const two'], 'E1021:')
128endfunc
129
130def Test_block()
131  let outer = 1
132  {
133    let inner = 2
134    assert_equal(1, outer)
135    assert_equal(2, inner)
136  }
137  assert_equal(1, outer)
138enddef
139
140func Test_block_failure()
141  call CheckDefFailure(['{', 'let inner = 1', '}', 'echo inner'], 'E1001:')
142endfunc
143
144def ReturnString(): string
145  return 'string'
146enddef
147
148def ReturnNumber(): number
149  return 123
150enddef
151
152let g:notNumber = 'string'
153
154def ReturnGlobal(): number
155  return g:notNumber
156enddef
157
158def Test_return_string()
159  assert_equal('string', ReturnString())
160  assert_equal(123, ReturnNumber())
161  assert_fails('call ReturnGlobal()', 'E1029: Expected number but got string')
162enddef
163
164func Increment()
165  let g:counter += 1
166endfunc
167
168def Test_call_ufunc_count()
169  g:counter = 1
170  Increment()
171  Increment()
172  Increment()
173  " works with and without :call
174  assert_equal(4, g:counter)
175  call assert_equal(4, g:counter)
176  unlet g:counter
177enddef
178
179def MyVarargs(arg: string, ...rest: list<string>): string
180  let res = arg
181  for s in rest
182    res ..= ',' .. s
183  endfor
184  return res
185enddef
186
187def Test_call_varargs()
188  assert_equal('one', MyVarargs('one'))
189  assert_equal('one,two', MyVarargs('one', 'two'))
190  assert_equal('one,two,three', MyVarargs('one', 'two', 'three'))
191enddef
192
193def MyDefaultArgs(name = 'string'): string
194  return name
195enddef
196
197def Test_call_default_args()
198  assert_equal('string', MyDefaultArgs())
199  assert_equal('one', MyDefaultArgs('one'))
200  assert_fails('call MyDefaultArgs("one", "two")', 'E118:')
201enddef
202
203func Test_call_default_args_from_func()
204  call assert_equal('string', MyDefaultArgs())
205  call assert_equal('one', MyDefaultArgs('one'))
206  call assert_fails('call MyDefaultArgs("one", "two")', 'E118:')
207endfunc
208
209func TakesOneArg(arg)
210  echo a:arg
211endfunc
212
213def Test_call_wrong_arg_count()
214  call CheckDefFailure(['TakesOneArg()'], 'E119:')
215  call CheckDefFailure(['TakesOneArg(11, 22)'], 'E118:')
216enddef
217
218" Default arg and varargs
219def MyDefVarargs(one: string, two = 'foo', ...rest: list<string>): string
220  let res = one .. ',' .. two
221  for s in rest
222    res ..= ',' .. s
223  endfor
224  return res
225enddef
226
227def Test_call_def_varargs()
228  call assert_fails('call MyDefVarargs()', 'E119:')
229  assert_equal('one,foo', MyDefVarargs('one'))
230  assert_equal('one,two', MyDefVarargs('one', 'two'))
231  assert_equal('one,two,three', MyDefVarargs('one', 'two', 'three'))
232enddef
233
234def Test_using_var_as_arg()
235  call writefile(['def Func(x: number)',  'let x = 234', 'enddef'], 'Xdef')
236  call assert_fails('so Xdef', 'E1006:')
237  call delete('Xdef')
238enddef
239
240def Test_call_func_defined_later()
241  call assert_equal('one', DefinedLater('one'))
242  call assert_fails('call NotDefined("one")', 'E117:')
243enddef
244
245func DefinedLater(arg)
246  return a:arg
247endfunc
248
249def FuncWithForwardCall()
250  return DefinedEvenLater("yes")
251enddef
252
253def DefinedEvenLater(arg: string): string
254  return arg
255enddef
256
257def Test_error_in_nested_function()
258  " Error in called function requires unwinding the call stack.
259  assert_fails('call FuncWithForwardCall()', 'E1029')
260enddef
261
262def Test_return_type_wrong()
263  CheckScriptFailure(['def Func(): number', 'return "a"', 'enddef'], 'expected number but got string')
264  CheckScriptFailure(['def Func(): string', 'return 1', 'enddef'], 'expected string but got number')
265  CheckScriptFailure(['def Func(): void', 'return "a"', 'enddef'], 'expected void but got string')
266  CheckScriptFailure(['def Func()', 'return "a"', 'enddef'], 'expected void but got string')
267enddef
268
269def Test_arg_type_wrong()
270  CheckScriptFailure(['def Func3(items: list)', 'echo "a"', 'enddef'], 'E1008: Missing <type>')
271enddef
272
273def Test_try_catch()
274  let l = []
275  try
276    add(l, '1')
277    throw 'wrong'
278    add(l, '2')
279  catch
280    add(l, v:exception)
281  finally
282    add(l, '3')
283  endtry
284  assert_equal(['1', 'wrong', '3'], l)
285enddef
286
287def ThrowFromDef()
288  throw 'getout'
289enddef
290
291func CatchInFunc()
292  try
293    call ThrowFromDef()
294  catch
295    let g:thrown_func = v:exception
296  endtry
297endfunc
298
299def CatchInDef()
300  try
301    ThrowFromDef()
302  catch
303    g:thrown_def = v:exception
304  endtry
305enddef
306
307def ReturnFinally(): string
308  try
309    return 'intry'
310  finally
311    g:in_finally = 'finally'
312  endtry
313  return 'end'
314enddef
315
316def Test_try_catch_nested()
317  CatchInFunc()
318  assert_equal('getout', g:thrown_func)
319
320  CatchInDef()
321  assert_equal('getout', g:thrown_def)
322
323  assert_equal('intry', ReturnFinally())
324  assert_equal('finally', g:in_finally)
325enddef
326
327def Test_try_catch_match()
328  let seq = 'a'
329  try
330    throw 'something'
331  catch /nothing/
332    seq ..= 'x'
333  catch /some/
334    seq ..= 'b'
335  catch /asdf/
336    seq ..= 'x'
337  finally
338    seq ..= 'c'
339  endtry
340  assert_equal('abc', seq)
341enddef
342
343let s:export_script_lines =<< trim END
344  vim9script
345  let name: string = 'bob'
346  def Concat(arg: string): string
347    return name .. arg
348  enddef
349  let g:result = Concat('bie')
350  let g:localname = name
351
352  export const CONST = 1234
353  export let exported = 9876
354  export let exp_name = 'John'
355  export def Exported(): string
356    return 'Exported'
357  enddef
358END
359
360def Test_vim9script()
361  let import_script_lines =<< trim END
362    vim9script
363    import {exported, Exported} from './Xexport.vim'
364    g:imported = exported
365    exported += 3
366    g:imported_added = exported
367    g:imported_func = Exported()
368
369    import {exp_name} from './Xexport.vim'
370    g:imported_name = exp_name
371    exp_name ..= ' Doe'
372    g:imported_name_appended = exp_name
373  END
374
375  writefile(import_script_lines, 'Ximport.vim')
376  writefile(s:export_script_lines, 'Xexport.vim')
377
378  source Ximport.vim
379
380  assert_equal('bobbie', g:result)
381  assert_equal('bob', g:localname)
382  assert_equal(9876, g:imported)
383  assert_equal(9879, g:imported_added)
384  assert_equal('Exported', g:imported_func)
385  assert_equal('John', g:imported_name)
386  assert_equal('John Doe', g:imported_name_appended)
387  assert_false(exists('g:name'))
388
389  unlet g:result
390  unlet g:localname
391  unlet g:imported
392  unlet g:imported_added
393  unlet g:imported_func
394  unlet g:imported_name g:imported_name_appended
395  delete('Ximport.vim')
396
397  let import_star_as_lines =<< trim END
398    vim9script
399    import * as Export from './Xexport.vim'
400    def UseExport()
401      g:imported = Export.exported
402    enddef
403    UseExport()
404  END
405  writefile(import_star_as_lines, 'Ximport.vim')
406  source Ximport.vim
407  assert_equal(9876, g:imported)
408
409  let import_star_lines =<< trim END
410    vim9script
411    import * from './Xexport.vim'
412    g:imported = exported
413  END
414  writefile(import_star_lines, 'Ximport.vim')
415  assert_fails('source Ximport.vim', 'E1045:')
416
417  " try to import something that exists but is not exported
418  let import_not_exported_lines =<< trim END
419    vim9script
420    import name from './Xexport.vim'
421  END
422  writefile(import_not_exported_lines, 'Ximport.vim')
423  assert_fails('source Ximport.vim', 'E1049:')
424
425  " import a very long name, requires making a copy
426  let import_long_name_lines =<< trim END
427    vim9script
428    import name012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789 from './Xexport.vim'
429  END
430  writefile(import_long_name_lines, 'Ximport.vim')
431  assert_fails('source Ximport.vim', 'E1048:')
432
433  let import_no_from_lines =<< trim END
434    vim9script
435    import name './Xexport.vim'
436  END
437  writefile(import_no_from_lines, 'Ximport.vim')
438  assert_fails('source Ximport.vim', 'E1070:')
439
440  let import_invalid_string_lines =<< trim END
441    vim9script
442    import name from Xexport.vim
443  END
444  writefile(import_invalid_string_lines, 'Ximport.vim')
445  assert_fails('source Ximport.vim', 'E1071:')
446
447  let import_wrong_name_lines =<< trim END
448    vim9script
449    import name from './XnoExport.vim'
450  END
451  writefile(import_wrong_name_lines, 'Ximport.vim')
452  assert_fails('source Ximport.vim', 'E1053:')
453
454  let import_missing_comma_lines =<< trim END
455    vim9script
456    import {exported name} from './Xexport.vim'
457  END
458  writefile(import_missing_comma_lines, 'Ximport.vim')
459  assert_fails('source Ximport.vim', 'E1046:')
460
461  delete('Ximport.vim')
462  delete('Xexport.vim')
463
464  " Check that in a Vim9 script 'cpo' is set to the Vim default.
465  set cpo&vi
466  let cpo_before = &cpo
467  let lines =<< trim END
468    vim9script
469    g:cpo_in_vim9script = &cpo
470  END
471  writefile(lines, 'Xvim9_script')
472  source Xvim9_script
473  assert_equal(cpo_before, &cpo)
474  set cpo&vim
475  assert_equal(&cpo, g:cpo_in_vim9script)
476  delete('Xvim9_script')
477enddef
478
479def Test_vim9script_fails()
480  CheckScriptFailure(['scriptversion 2', 'vim9script'], 'E1039:')
481  CheckScriptFailure(['vim9script', 'scriptversion 2'], 'E1040:')
482  CheckScriptFailure(['export let some = 123'], 'E1042:')
483  CheckScriptFailure(['import some from "./Xexport.vim"'], 'E1042:')
484  CheckScriptFailure(['vim9script', 'export let g:some'], 'E1044:')
485  CheckScriptFailure(['vim9script', 'export echo 134'], 'E1043:')
486
487  assert_fails('vim9script', 'E1038')
488  assert_fails('export something', 'E1042')
489enddef
490
491def Test_vim9script_call()
492  let lines =<< trim END
493    vim9script
494    let var = ''
495    def MyFunc(arg: string)
496       var = arg
497    enddef
498    MyFunc('foobar')
499    assert_equal('foobar', var)
500
501    let str = 'barfoo'
502    str->MyFunc()
503    assert_equal('barfoo', var)
504
505    let g:value = 'value'
506    g:value->MyFunc()
507    assert_equal('value', var)
508
509    let listvar = []
510    def ListFunc(arg: list<number>)
511       listvar = arg
512    enddef
513    [1, 2, 3]->ListFunc()
514    assert_equal([1, 2, 3], listvar)
515
516    let dictvar = {}
517    def DictFunc(arg: dict<number>)
518       dictvar = arg
519    enddef
520    {'a': 1, 'b': 2}->DictFunc()
521    assert_equal(#{a: 1, b: 2}, dictvar)
522    #{a: 3, b: 4}->DictFunc()
523    assert_equal(#{a: 3, b: 4}, dictvar)
524
525    ('text')->MyFunc()
526    assert_equal('text', var)
527    ("some")->MyFunc()
528    assert_equal('some', var)
529  END
530  writefile(lines, 'Xcall.vim')
531  source Xcall.vim
532  delete('Xcall.vim')
533enddef
534
535def Test_vim9script_call_fail_decl()
536  let lines =<< trim END
537    vim9script
538    let var = ''
539    def MyFunc(arg: string)
540       let var = 123
541    enddef
542  END
543  writefile(lines, 'Xcall_decl.vim')
544  assert_fails('source Xcall_decl.vim', 'E1054:')
545  delete('Xcall_decl.vim')
546enddef
547
548def Test_vim9script_call_fail_const()
549  let lines =<< trim END
550    vim9script
551    const var = ''
552    def MyFunc(arg: string)
553       var = 'asdf'
554    enddef
555  END
556  writefile(lines, 'Xcall_const.vim')
557  assert_fails('source Xcall_const.vim', 'E46:')
558  delete('Xcall_const.vim')
559enddef
560
561def Test_vim9script_reload()
562  let lines =<< trim END
563    vim9script
564    const var = ''
565    let valone = 1234
566    def MyFunc(arg: string)
567       valone = 5678
568    enddef
569  END
570  let morelines =<< trim END
571    let valtwo = 222
572    export def GetValtwo(): number
573      return valtwo
574    enddef
575  END
576  writefile(lines + morelines, 'Xreload.vim')
577  source Xreload.vim
578  source Xreload.vim
579  source Xreload.vim
580
581  let testlines =<< trim END
582    vim9script
583    def TheFunc()
584      import GetValtwo from './Xreload.vim'
585      assert_equal(222, GetValtwo())
586    enddef
587    TheFunc()
588  END
589  writefile(testlines, 'Ximport.vim')
590  source Ximport.vim
591
592  " test that when not using "morelines" valtwo is still defined
593  " need to source Xreload.vim again, import doesn't reload a script
594  writefile(lines, 'Xreload.vim')
595  source Xreload.vim
596  source Ximport.vim
597
598  " cannot declare a var twice
599  lines =<< trim END
600    vim9script
601    let valone = 1234
602    let valone = 5678
603  END
604  writefile(lines, 'Xreload.vim')
605  assert_fails('source Xreload.vim', 'E1041:')
606
607  delete('Xreload.vim')
608  delete('Ximport.vim')
609enddef
610
611def Test_import_absolute()
612  let import_lines = [
613        \ 'vim9script',
614        \ 'import exported from "' .. escape(getcwd(), '\') .. '/Xexport_abs.vim"',
615        \ 'def UseExported()',
616        \ '  g:imported_abs = exported',
617        \ '  exported = 8888',
618        \ '  g:imported_after = exported',
619        \ 'enddef',
620        \ 'UseExported()',
621        \ 'g:import_disassembled = execute("disass UseExported")',
622        \ ]
623  writefile(import_lines, 'Ximport_abs.vim')
624  writefile(s:export_script_lines, 'Xexport_abs.vim')
625
626  source Ximport_abs.vim
627
628  assert_equal(9876, g:imported_abs)
629  assert_equal(8888, g:imported_after)
630  assert_match('<SNR>\d\+_UseExported.*'
631        \ .. 'g:imported_abs = exported.*'
632        \ .. '0 LOADSCRIPT exported from .*Xexport_abs.vim.*'
633        \ .. '1 STOREG g:imported_abs.*'
634        \ .. 'exported = 8888.*'
635        \ .. '3 STORESCRIPT exported in .*Xexport_abs.vim.*'
636        \ .. 'g:imported_after = exported.*'
637        \ .. '4 LOADSCRIPT exported from .*Xexport_abs.vim.*'
638        \ .. '5 STOREG g:imported_after.*'
639        \, g:import_disassembled)
640  unlet g:imported_abs
641  unlet g:import_disassembled
642
643  delete('Ximport_abs.vim')
644  delete('Xexport_abs.vim')
645enddef
646
647def Test_import_rtp()
648  let import_lines = [
649        \ 'vim9script',
650        \ 'import exported from "Xexport_rtp.vim"',
651        \ 'g:imported_rtp = exported',
652        \ ]
653  writefile(import_lines, 'Ximport_rtp.vim')
654  mkdir('import')
655  writefile(s:export_script_lines, 'import/Xexport_rtp.vim')
656
657  let save_rtp = &rtp
658  &rtp = getcwd()
659  source Ximport_rtp.vim
660  &rtp = save_rtp
661
662  assert_equal(9876, g:imported_rtp)
663  unlet g:imported_rtp
664
665  delete('Ximport_rtp.vim')
666  delete('import/Xexport_rtp.vim')
667  delete('import', 'd')
668enddef
669
670def Test_fixed_size_list()
671  " will be allocated as one piece of memory, check that changes work
672  let l = [1, 2, 3, 4]
673  l->remove(0)
674  l->add(5)
675  l->insert(99, 1)
676  assert_equal([2, 99, 3, 4, 5], l)
677enddef
678
679" Test that inside :function a Python function can be defined, :def is not
680" recognized.
681func Test_function_python()
682  CheckFeature python3
683  let py = 'python3'
684  execute py "<< EOF"
685def do_something():
686  return 1
687EOF
688endfunc
689
690def IfElse(what: number): string
691  let res = ''
692  if what == 1
693    res = "one"
694  elseif what == 2
695    res = "two"
696  else
697    res = "three"
698  endif
699  return res
700enddef
701
702def Test_if_elseif_else()
703  assert_equal('one', IfElse(1))
704  assert_equal('two', IfElse(2))
705  assert_equal('three', IfElse(3))
706enddef
707
708def Test_delfunc()
709  let lines =<< trim END
710    vim9script
711    def GoneSoon()
712      echo 'hello'
713    enddef
714
715    def CallGoneSoon()
716      GoneSoon()
717    enddef
718
719    delfunc GoneSoon
720    CallGoneSoon()
721  END
722  writefile(lines, 'XToDelFunc')
723  assert_fails('so XToDelFunc', 'E933')
724  assert_fails('so XToDelFunc', 'E933')
725
726  delete('XToDelFunc')
727enddef
728
729def Test_substitute_cmd()
730  new
731  setline(1, 'something')
732  :substitute(some(other(
733  assert_equal('otherthing', getline(1))
734  bwipe!
735
736  " also when the context is Vim9 script
737  let lines =<< trim END
738    vim9script
739    new
740    setline(1, 'something')
741    :substitute(some(other(
742    assert_equal('otherthing', getline(1))
743    bwipe!
744  END
745  writefile(lines, 'Xvim9lines')
746  source Xvim9lines
747
748  delete('Xvim9lines')
749enddef
750
751def Test_execute_cmd()
752  new
753  setline(1, 'default')
754  execute 'call setline(1, "execute-string")'
755  assert_equal('execute-string', getline(1))
756  let cmd1 = 'call setline(1,'
757  let cmd2 = '"execute-var")'
758  execute cmd1 cmd2
759  assert_equal('execute-var', getline(1))
760  execute cmd1 cmd2 '|call setline(1, "execute-var-string")'
761  assert_equal('execute-var-string', getline(1))
762  let cmd_first = 'call '
763  let cmd_last = 'setline(1, "execute-var-var")'
764  execute cmd_first .. cmd_last
765  assert_equal('execute-var-var', getline(1))
766  bwipe!
767enddef
768
769def Test_echo_cmd()
770  echo 'something'
771  assert_match('^something$', Screenline(&lines))
772
773  let str1 = 'some'
774  let str2 = 'more'
775  echo str1 str2
776  assert_match('^some more$', Screenline(&lines))
777enddef
778
779def Test_for_outside_of_function()
780  let lines =<< trim END
781    vim9script
782    new
783    for var in range(0, 3)
784      append(line('$'), var)
785    endfor
786    assert_equal(['', '0', '1', '2', '3'], getline(1, '$'))
787    bwipe!
788  END
789  writefile(lines, 'Xvim9for.vim')
790  source Xvim9for.vim
791  delete('Xvim9for.vim')
792enddef
793
794" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker
795