1" Test various aspects of the Vim9 script language.
2
3source check.vim
4source term_util.vim
5source view_util.vim
6source vim9.vim
7source shared.vim
8
9def Test_range_only()
10  new
11  setline(1, ['blah', 'Blah'])
12  :/Blah/
13  assert_equal(2, getcurpos()[1])
14  bwipe!
15
16  # without range commands use current line
17  new
18  setline(1, ['one', 'two', 'three'])
19  :2
20  print
21  assert_equal('two', Screenline(&lines))
22  :3
23  list
24  assert_equal('three$', Screenline(&lines))
25  bwipe!
26enddef
27
28let g:alist = [7]
29let g:astring = 'text'
30let g:anumber = 123
31
32def Test_delfunction()
33  # Check function is defined in script namespace
34  CheckScriptSuccess([
35      'vim9script',
36      'func CheckMe()',
37      '  return 123',
38      'endfunc',
39      'assert_equal(123, s:CheckMe())',
40      ])
41
42  # Check function in script namespace cannot be deleted
43  CheckScriptFailure([
44      'vim9script',
45      'func DeleteMe1()',
46      'endfunc',
47      'delfunction DeleteMe1',
48      ], 'E1084:')
49  CheckScriptFailure([
50      'vim9script',
51      'func DeleteMe2()',
52      'endfunc',
53      'def DoThat()',
54      '  delfunction DeleteMe2',
55      'enddef',
56      'DoThat()',
57      ], 'E1084:')
58  CheckScriptFailure([
59      'vim9script',
60      'def DeleteMe3()',
61      'enddef',
62      'delfunction DeleteMe3',
63      ], 'E1084:')
64  CheckScriptFailure([
65      'vim9script',
66      'def DeleteMe4()',
67      'enddef',
68      'def DoThat()',
69      '  delfunction DeleteMe4',
70      'enddef',
71      'DoThat()',
72      ], 'E1084:')
73
74  # Check that global :def function can be replaced and deleted
75  var lines =<< trim END
76      vim9script
77      def g:Global(): string
78        return "yes"
79      enddef
80      assert_equal("yes", g:Global())
81      def! g:Global(): string
82        return "no"
83      enddef
84      assert_equal("no", g:Global())
85      delfunc g:Global
86      assert_false(exists('*g:Global'))
87  END
88  CheckScriptSuccess(lines)
89
90  # Check that global function can be replaced by a :def function and deleted
91  lines =<< trim END
92      vim9script
93      func g:Global()
94        return "yes"
95      endfunc
96      assert_equal("yes", g:Global())
97      def! g:Global(): string
98        return "no"
99      enddef
100      assert_equal("no", g:Global())
101      delfunc g:Global
102      assert_false(exists('*g:Global'))
103  END
104  CheckScriptSuccess(lines)
105
106  # Check that global :def function can be replaced by a function and deleted
107  lines =<< trim END
108      vim9script
109      def g:Global(): string
110        return "yes"
111      enddef
112      assert_equal("yes", g:Global())
113      func! g:Global()
114        return "no"
115      endfunc
116      assert_equal("no", g:Global())
117      delfunc g:Global
118      assert_false(exists('*g:Global'))
119  END
120  CheckScriptSuccess(lines)
121enddef
122
123def Test_wrong_type()
124  CheckDefFailure(['var name: list<nothing>'], 'E1010:')
125  CheckDefFailure(['var name: list<list<nothing>>'], 'E1010:')
126  CheckDefFailure(['var name: dict<nothing>'], 'E1010:')
127  CheckDefFailure(['var name: dict<dict<nothing>>'], 'E1010:')
128
129  CheckDefFailure(['var name: dict<number'], 'E1009:')
130  CheckDefFailure(['var name: dict<list<number>'], 'E1009:')
131
132  CheckDefFailure(['var name: ally'], 'E1010:')
133  CheckDefFailure(['var name: bram'], 'E1010:')
134  CheckDefFailure(['var name: cathy'], 'E1010:')
135  CheckDefFailure(['var name: dom'], 'E1010:')
136  CheckDefFailure(['var name: freddy'], 'E1010:')
137  CheckDefFailure(['var name: john'], 'E1010:')
138  CheckDefFailure(['var name: larry'], 'E1010:')
139  CheckDefFailure(['var name: ned'], 'E1010:')
140  CheckDefFailure(['var name: pam'], 'E1010:')
141  CheckDefFailure(['var name: sam'], 'E1010:')
142  CheckDefFailure(['var name: vim'], 'E1010:')
143
144  CheckDefFailure(['var Ref: number', 'Ref()'], 'E1085:')
145  CheckDefFailure(['var Ref: string', 'var res = Ref()'], 'E1085:')
146enddef
147
148def Test_script_wrong_type()
149  var lines =<< trim END
150      vim9script
151      var s:dict: dict<string>
152      s:dict['a'] = ['x']
153  END
154  CheckScriptFailure(lines, 'E1012: Type mismatch; expected string but got list<string>', 3)
155enddef
156
157def Test_const()
158  CheckDefFailure(['final name = 234', 'name = 99'], 'E1018:')
159  CheckDefFailure(['final one = 234', 'var one = 99'], 'E1017:')
160  CheckDefFailure(['final list = [1, 2]', 'var list = [3, 4]'], 'E1017:')
161  CheckDefFailure(['final two'], 'E1125:')
162  CheckDefFailure(['final &option'], 'E996:')
163
164  var lines =<< trim END
165    final list = [1, 2, 3]
166    list[0] = 4
167    list->assert_equal([4, 2, 3])
168    const other = [5, 6, 7]
169    other->assert_equal([5, 6, 7])
170
171    var varlist = [7, 8]
172    const constlist = [1, varlist, 3]
173    varlist[0] = 77
174    # TODO: does not work yet
175    # constlist[1][1] = 88
176    var cl = constlist[1]
177    cl[1] = 88
178    constlist->assert_equal([1, [77, 88], 3])
179
180    var vardict = #{five: 5, six: 6}
181    const constdict = #{one: 1, two: vardict, three: 3}
182    vardict['five'] = 55
183    # TODO: does not work yet
184    # constdict['two']['six'] = 66
185    var cd = constdict['two']
186    cd['six'] = 66
187    constdict->assert_equal(#{one: 1, two: #{five: 55, six: 66}, three: 3})
188  END
189  CheckDefAndScriptSuccess(lines)
190enddef
191
192def Test_const_bang()
193  var lines =<< trim END
194      const var = 234
195      var = 99
196  END
197  CheckDefExecFailure(lines, 'E1018:', 2)
198  CheckScriptFailure(['vim9script'] + lines, 'E46:', 3)
199
200  lines =<< trim END
201      const ll = [2, 3, 4]
202      ll[0] = 99
203  END
204  CheckDefExecFailure(lines, 'E1119:', 2)
205  CheckScriptFailure(['vim9script'] + lines, 'E741:', 3)
206
207  lines =<< trim END
208      const ll = [2, 3, 4]
209      ll[3] = 99
210  END
211  CheckDefExecFailure(lines, 'E1118:', 2)
212  CheckScriptFailure(['vim9script'] + lines, 'E684:', 3)
213
214  lines =<< trim END
215      const dd = #{one: 1, two: 2}
216      dd["one"] = 99
217  END
218  CheckDefExecFailure(lines, 'E1121:', 2)
219  CheckScriptFailure(['vim9script'] + lines, 'E741:', 3)
220
221  lines =<< trim END
222      const dd = #{one: 1, two: 2}
223      dd["three"] = 99
224  END
225  CheckDefExecFailure(lines, 'E1120:')
226  CheckScriptFailure(['vim9script'] + lines, 'E741:', 3)
227enddef
228
229def Test_range_no_colon()
230  CheckDefFailure(['%s/a/b/'], 'E1050:')
231  CheckDefFailure(['+ s/a/b/'], 'E1050:')
232  CheckDefFailure(['- s/a/b/'], 'E1050:')
233  CheckDefFailure(['. s/a/b/'], 'E1050:')
234enddef
235
236
237def Test_block()
238  var outer = 1
239  {
240    var inner = 2
241    assert_equal(1, outer)
242    assert_equal(2, inner)
243  }
244  assert_equal(1, outer)
245enddef
246
247def Test_block_failure()
248  CheckDefFailure(['{', 'var inner = 1', '}', 'echo inner'], 'E1001:')
249  CheckDefFailure(['}'], 'E1025:')
250  CheckDefFailure(['{', 'echo 1'], 'E1026:')
251enddef
252
253func g:NoSuchFunc()
254  echo 'none'
255endfunc
256
257def Test_try_catch()
258  var l = []
259  try # comment
260    add(l, '1')
261    throw 'wrong'
262    add(l, '2')
263  catch # comment
264    add(l, v:exception)
265  finally # comment
266    add(l, '3')
267  endtry # comment
268  assert_equal(['1', 'wrong', '3'], l)
269
270  l = []
271  try
272    try
273      add(l, '1')
274      throw 'wrong'
275      add(l, '2')
276    catch /right/
277      add(l, v:exception)
278    endtry
279  catch /wrong/
280    add(l, 'caught')
281  fina
282    add(l, 'finally')
283  endtry
284  assert_equal(['1', 'caught', 'finally'], l)
285
286  var n: number
287  try
288    n = l[3]
289  catch /E684:/
290    n = 99
291  endtry
292  assert_equal(99, n)
293
294  try
295    # string slice returns a string, not a number
296    n = g:astring[3]
297  catch /E1012:/
298    n = 77
299  endtry
300  assert_equal(77, n)
301
302  try
303    n = l[g:astring]
304  catch /E1012:/
305    n = 88
306  endtry
307  assert_equal(88, n)
308
309  try
310    n = s:does_not_exist
311  catch /E121:/
312    n = 111
313  endtry
314  assert_equal(111, n)
315
316  try
317    n = g:does_not_exist
318  catch /E121:/
319    n = 121
320  endtry
321  assert_equal(121, n)
322
323  var d = #{one: 1}
324  try
325    n = d[g:astring]
326  catch /E716:/
327    n = 222
328  endtry
329  assert_equal(222, n)
330
331  try
332    n = -g:astring
333  catch /E39:/
334    n = 233
335  endtry
336  assert_equal(233, n)
337
338  try
339    n = +g:astring
340  catch /E1030:/
341    n = 244
342  endtry
343  assert_equal(244, n)
344
345  try
346    n = +g:alist
347  catch /E745:/
348    n = 255
349  endtry
350  assert_equal(255, n)
351
352  var nd: dict<any>
353  try
354    nd = {g:anumber: 1}
355  catch /E1012:/
356    n = 266
357  endtry
358  assert_equal(266, n)
359
360  try
361    [n] = [1, 2, 3]
362  catch /E1093:/
363    n = 277
364  endtry
365  assert_equal(277, n)
366
367  try
368    &ts = g:astring
369  catch /E1012:/
370    n = 288
371  endtry
372  assert_equal(288, n)
373
374  try
375    &backspace = 'asdf'
376  catch /E474:/
377    n = 299
378  endtry
379  assert_equal(299, n)
380
381  l = [1]
382  try
383    l[3] = 3
384  catch /E684:/
385    n = 300
386  endtry
387  assert_equal(300, n)
388
389  try
390    unlet g:does_not_exist
391  catch /E108:/
392    n = 322
393  endtry
394  assert_equal(322, n)
395
396  try
397    d = {'text': 1, g:astring: 2}
398  catch /E721:/
399    n = 333
400  endtry
401  assert_equal(333, n)
402
403  try
404    l = DeletedFunc()
405  catch /E933:/
406    n = 344
407  endtry
408  assert_equal(344, n)
409
410  try
411    echo len(v:true)
412  catch /E701:/
413    n = 355
414  endtry
415  assert_equal(355, n)
416
417  var P = function('g:NoSuchFunc')
418  delfunc g:NoSuchFunc
419  try
420    echo P()
421  catch /E117:/
422    n = 366
423  endtry
424  assert_equal(366, n)
425
426  try
427    echo g:NoSuchFunc()
428  catch /E117:/
429    n = 377
430  endtry
431  assert_equal(377, n)
432
433  try
434    echo g:alist + 4
435  catch /E745:/
436    n = 388
437  endtry
438  assert_equal(388, n)
439
440  try
441    echo 4 + g:alist
442  catch /E745:/
443    n = 399
444  endtry
445  assert_equal(399, n)
446
447  try
448    echo g:alist.member
449  catch /E715:/
450    n = 400
451  endtry
452  assert_equal(400, n)
453
454  try
455    echo d.member
456  catch /E716:/
457    n = 411
458  endtry
459  assert_equal(411, n)
460enddef
461
462def DeletedFunc(): list<any>
463  return ['delete me']
464enddef
465defcompile
466delfunc DeletedFunc
467
468def ThrowFromDef()
469  throw "getout" # comment
470enddef
471
472func CatchInFunc()
473  try
474    call ThrowFromDef()
475  catch
476    let g:thrown_func = v:exception
477  endtry
478endfunc
479
480def CatchInDef()
481  try
482    ThrowFromDef()
483  catch
484    g:thrown_def = v:exception
485  endtry
486enddef
487
488def ReturnFinally(): string
489  try
490    return 'intry'
491  finall
492    g:in_finally = 'finally'
493  endtry
494  return 'end'
495enddef
496
497def Test_try_catch_nested()
498  CatchInFunc()
499  assert_equal('getout', g:thrown_func)
500
501  CatchInDef()
502  assert_equal('getout', g:thrown_def)
503
504  assert_equal('intry', ReturnFinally())
505  assert_equal('finally', g:in_finally)
506enddef
507
508def TryOne(): number
509  try
510    return 0
511  catch
512  endtry
513  return 0
514enddef
515
516def TryTwo(n: number): string
517  try
518    var x = {}
519  catch
520  endtry
521  return 'text'
522enddef
523
524def Test_try_catch_twice()
525  assert_equal('text', TryOne()->TryTwo())
526enddef
527
528def Test_try_catch_match()
529  var seq = 'a'
530  try
531    throw 'something'
532  catch /nothing/
533    seq ..= 'x'
534  catch /some/
535    seq ..= 'b'
536  catch /asdf/
537    seq ..= 'x'
538  catch ?a\?sdf?
539    seq ..= 'y'
540  finally
541    seq ..= 'c'
542  endtry
543  assert_equal('abc', seq)
544enddef
545
546def Test_try_catch_fails()
547  CheckDefFailure(['catch'], 'E603:')
548  CheckDefFailure(['try', 'echo 0', 'catch', 'catch'], 'E1033:')
549  CheckDefFailure(['try', 'echo 0', 'catch /pat'], 'E1067:')
550  CheckDefFailure(['finally'], 'E606:')
551  CheckDefFailure(['try', 'echo 0', 'finally', 'echo 1', 'finally'], 'E607:')
552  CheckDefFailure(['endtry'], 'E602:')
553  CheckDefFailure(['while 1', 'endtry'], 'E170:')
554  CheckDefFailure(['for i in range(5)', 'endtry'], 'E170:')
555  CheckDefFailure(['if 1', 'endtry'], 'E171:')
556  CheckDefFailure(['try', 'echo 1', 'endtry'], 'E1032:')
557
558  CheckDefFailure(['throw'], 'E1015:')
559  CheckDefFailure(['throw xxx'], 'E1001:')
560enddef
561
562def Test_throw_vimscript()
563  # only checks line continuation
564  var lines =<< trim END
565      vim9script
566      try
567        throw 'one'
568              .. 'two'
569      catch
570        assert_equal('onetwo', v:exception)
571      endtry
572  END
573  CheckScriptSuccess(lines)
574enddef
575
576def Test_error_in_nested_function()
577  # an error in a nested :function aborts executin in the calling :def function
578  var lines =<< trim END
579      vim9script
580      def Func()
581        Error()
582        g:test_var = 1
583      enddef
584      func Error() abort
585        eval [][0]
586      endfunc
587      Func()
588  END
589  g:test_var = 0
590  CheckScriptFailure(lines, 'E684:')
591  assert_equal(0, g:test_var)
592enddef
593
594def Test_cexpr_vimscript()
595  # only checks line continuation
596  set errorformat=File\ %f\ line\ %l
597  var lines =<< trim END
598      vim9script
599      cexpr 'File'
600                .. ' someFile' ..
601                   ' line 19'
602      assert_equal(19, getqflist()[0].lnum)
603  END
604  CheckScriptSuccess(lines)
605  set errorformat&
606enddef
607
608def Test_statusline_syntax()
609  # legacy syntax is used for 'statusline'
610  var lines =<< trim END
611      vim9script
612      func g:Status()
613        return '%{"x" is# "x"}'
614      endfunc
615      set laststatus=2 statusline=%!Status()
616      redrawstatus
617      set laststatus statusline=
618  END
619  CheckScriptSuccess(lines)
620enddef
621
622def Test_list_vimscript()
623  # checks line continuation and comments
624  var lines =<< trim END
625      vim9script
626      var mylist = [
627            'one',
628            # comment
629            'two', # empty line follows
630
631            'three',
632            ]
633      assert_equal(['one', 'two', 'three'], mylist)
634  END
635  CheckScriptSuccess(lines)
636
637  # check all lines from heredoc are kept
638  lines =<< trim END
639      # comment 1
640      two
641      # comment 3
642
643      five
644      # comment 6
645  END
646  assert_equal(['# comment 1', 'two', '# comment 3', '', 'five', '# comment 6'], lines)
647enddef
648
649if has('channel')
650  let someJob = test_null_job()
651
652  def FuncWithError()
653    echomsg g:someJob
654  enddef
655
656  func Test_convert_emsg_to_exception()
657    try
658      call FuncWithError()
659    catch
660      call assert_match('Vim:E908:', v:exception)
661    endtry
662  endfunc
663endif
664
665let s:export_script_lines =<< trim END
666  vim9script
667  var name: string = 'bob'
668  def Concat(arg: string): string
669    return name .. arg
670  enddef
671  g:result = Concat('bie')
672  g:localname = name
673
674  export const CONST = 1234
675  export var exported = 9876
676  export var exp_name = 'John'
677  export def Exported(): string
678    return 'Exported'
679  enddef
680END
681
682def Undo_export_script_lines()
683  unlet g:result
684  unlet g:localname
685enddef
686
687def Test_vim9_import_export()
688  var import_script_lines =<< trim END
689    vim9script
690    import {exported, Exported} from './Xexport.vim'
691    g:imported = exported
692    exported += 3
693    g:imported_added = exported
694    g:imported_func = Exported()
695
696    def GetExported(): string
697      var local_dict = #{ref: Exported}
698      return local_dict.ref()
699    enddef
700    g:funcref_result = GetExported()
701
702    import {exp_name} from './Xexport.vim'
703    g:imported_name = exp_name
704    exp_name ..= ' Doe'
705    g:imported_name_appended = exp_name
706    g:imported_later = exported
707  END
708
709  writefile(import_script_lines, 'Ximport.vim')
710  writefile(s:export_script_lines, 'Xexport.vim')
711
712  source Ximport.vim
713
714  assert_equal('bobbie', g:result)
715  assert_equal('bob', g:localname)
716  assert_equal(9876, g:imported)
717  assert_equal(9879, g:imported_added)
718  assert_equal(9879, g:imported_later)
719  assert_equal('Exported', g:imported_func)
720  assert_equal('Exported', g:funcref_result)
721  assert_equal('John', g:imported_name)
722  assert_equal('John Doe', g:imported_name_appended)
723  assert_false(exists('g:name'))
724
725  Undo_export_script_lines()
726  unlet g:imported
727  unlet g:imported_added
728  unlet g:imported_later
729  unlet g:imported_func
730  unlet g:imported_name g:imported_name_appended
731  delete('Ximport.vim')
732
733  # similar, with line breaks
734  var import_line_break_script_lines =<< trim END
735    vim9script
736    import {
737        exported,
738        Exported,
739        }
740        from
741        './Xexport.vim'
742    g:imported = exported
743    exported += 5
744    g:imported_added = exported
745    g:imported_func = Exported()
746  END
747  writefile(import_line_break_script_lines, 'Ximport_lbr.vim')
748  source Ximport_lbr.vim
749
750  assert_equal(9876, g:imported)
751  assert_equal(9881, g:imported_added)
752  assert_equal('Exported', g:imported_func)
753
754  # exported script not sourced again
755  assert_false(exists('g:result'))
756  unlet g:imported
757  unlet g:imported_added
758  unlet g:imported_func
759  delete('Ximport_lbr.vim')
760
761  # import inside :def function
762  var import_in_def_lines =<< trim END
763    vim9script
764    def ImportInDef()
765      import exported from './Xexport.vim'
766      g:imported = exported
767      exported += 7
768      g:imported_added = exported
769    enddef
770    ImportInDef()
771  END
772  writefile(import_in_def_lines, 'Ximport2.vim')
773  source Ximport2.vim
774  # TODO: this should be 9879
775  assert_equal(9876, g:imported)
776  assert_equal(9883, g:imported_added)
777  unlet g:imported
778  unlet g:imported_added
779  delete('Ximport2.vim')
780
781  var import_star_as_lines =<< trim END
782    vim9script
783    import * as Export from './Xexport.vim'
784    def UseExport()
785      g:imported = Export.exported
786    enddef
787    UseExport()
788  END
789  writefile(import_star_as_lines, 'Ximport.vim')
790  source Ximport.vim
791  assert_equal(9883, g:imported)
792
793  var import_star_as_lines_no_dot =<< trim END
794    vim9script
795    import * as Export from './Xexport.vim'
796    def Func()
797      var dummy = 1
798      var imported = Export + dummy
799    enddef
800    defcompile
801  END
802  writefile(import_star_as_lines_no_dot, 'Ximport.vim')
803  assert_fails('source Ximport.vim', 'E1060:', '', 2, 'Func')
804
805  var import_star_as_lines_dot_space =<< trim END
806    vim9script
807    import * as Export from './Xexport.vim'
808    def Func()
809      var imported = Export . exported
810    enddef
811    defcompile
812  END
813  writefile(import_star_as_lines_dot_space, 'Ximport.vim')
814  assert_fails('source Ximport.vim', 'E1074:', '', 1, 'Func')
815
816  var import_star_as_lines_missing_name =<< trim END
817    vim9script
818    import * as Export from './Xexport.vim'
819    def Func()
820      var imported = Export.
821    enddef
822    defcompile
823  END
824  writefile(import_star_as_lines_missing_name, 'Ximport.vim')
825  assert_fails('source Ximport.vim', 'E1048:', '', 1, 'Func')
826
827  var import_star_as_lbr_lines =<< trim END
828    vim9script
829    import *
830        as Export
831        from
832        './Xexport.vim'
833    def UseExport()
834      g:imported = Export.exported
835    enddef
836    UseExport()
837  END
838  writefile(import_star_as_lbr_lines, 'Ximport.vim')
839  source Ximport.vim
840  assert_equal(9883, g:imported)
841
842  var import_star_lines =<< trim END
843    vim9script
844    import * from './Xexport.vim'
845  END
846  writefile(import_star_lines, 'Ximport.vim')
847  assert_fails('source Ximport.vim', 'E1045:', '', 2, 'Ximport.vim')
848
849  # try to import something that exists but is not exported
850  var import_not_exported_lines =<< trim END
851    vim9script
852    import name from './Xexport.vim'
853  END
854  writefile(import_not_exported_lines, 'Ximport.vim')
855  assert_fails('source Ximport.vim', 'E1049:', '', 2, 'Ximport.vim')
856
857  # try to import something that is already defined
858  var import_already_defined =<< trim END
859    vim9script
860    var exported = 'something'
861    import exported from './Xexport.vim'
862  END
863  writefile(import_already_defined, 'Ximport.vim')
864  assert_fails('source Ximport.vim', 'E1073:', '', 3, 'Ximport.vim')
865
866  # try to import something that is already defined
867  import_already_defined =<< trim END
868    vim9script
869    var exported = 'something'
870    import * as exported from './Xexport.vim'
871  END
872  writefile(import_already_defined, 'Ximport.vim')
873  assert_fails('source Ximport.vim', 'E1073:', '', 3, 'Ximport.vim')
874
875  # try to import something that is already defined
876  import_already_defined =<< trim END
877    vim9script
878    var exported = 'something'
879    import {exported} from './Xexport.vim'
880  END
881  writefile(import_already_defined, 'Ximport.vim')
882  assert_fails('source Ximport.vim', 'E1073:', '', 3, 'Ximport.vim')
883
884  # import a very long name, requires making a copy
885  var import_long_name_lines =<< trim END
886    vim9script
887    import name012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789 from './Xexport.vim'
888  END
889  writefile(import_long_name_lines, 'Ximport.vim')
890  assert_fails('source Ximport.vim', 'E1048:', '', 2, 'Ximport.vim')
891
892  var import_no_from_lines =<< trim END
893    vim9script
894    import name './Xexport.vim'
895  END
896  writefile(import_no_from_lines, 'Ximport.vim')
897  assert_fails('source Ximport.vim', 'E1070:', '', 2, 'Ximport.vim')
898
899  var import_invalid_string_lines =<< trim END
900    vim9script
901    import name from Xexport.vim
902  END
903  writefile(import_invalid_string_lines, 'Ximport.vim')
904  assert_fails('source Ximport.vim', 'E1071:', '', 2, 'Ximport.vim')
905
906  var import_wrong_name_lines =<< trim END
907    vim9script
908    import name from './XnoExport.vim'
909  END
910  writefile(import_wrong_name_lines, 'Ximport.vim')
911  assert_fails('source Ximport.vim', 'E1053:', '', 2, 'Ximport.vim')
912
913  var import_missing_comma_lines =<< trim END
914    vim9script
915    import {exported name} from './Xexport.vim'
916  END
917  writefile(import_missing_comma_lines, 'Ximport3.vim')
918  assert_fails('source Ximport3.vim', 'E1046:', '', 2, 'Ximport3.vim')
919
920  delete('Ximport.vim')
921  delete('Ximport3.vim')
922  delete('Xexport.vim')
923
924  # Check that in a Vim9 script 'cpo' is set to the Vim default.
925  set cpo&vi
926  var cpo_before = &cpo
927  var lines =<< trim END
928    vim9script
929    g:cpo_in_vim9script = &cpo
930  END
931  writefile(lines, 'Xvim9_script')
932  source Xvim9_script
933  assert_equal(cpo_before, &cpo)
934  set cpo&vim
935  assert_equal(&cpo, g:cpo_in_vim9script)
936  delete('Xvim9_script')
937enddef
938
939func g:Trigger()
940  source Ximport.vim
941  return "echo 'yes'\<CR>"
942endfunc
943
944def Test_import_export_expr_map()
945  # check that :import and :export work when buffer is locked
946  var export_lines =<< trim END
947    vim9script
948    export def That(): string
949      return 'yes'
950    enddef
951  END
952  writefile(export_lines, 'Xexport_that.vim')
953
954  var import_lines =<< trim END
955    vim9script
956    import That from './Xexport_that.vim'
957    assert_equal('yes', That())
958  END
959  writefile(import_lines, 'Ximport.vim')
960
961  nnoremap <expr> trigger g:Trigger()
962  feedkeys('trigger', "xt")
963
964  delete('Xexport_that.vim')
965  delete('Ximport.vim')
966  nunmap trigger
967enddef
968
969def Test_import_in_filetype()
970  # check that :import works when the buffer is locked
971  mkdir('ftplugin', 'p')
972  var export_lines =<< trim END
973    vim9script
974    export var That = 'yes'
975  END
976  writefile(export_lines, 'ftplugin/Xexport_ft.vim')
977
978  var import_lines =<< trim END
979    vim9script
980    import That from './Xexport_ft.vim'
981    assert_equal('yes', That)
982    g:did_load_mytpe = 1
983  END
984  writefile(import_lines, 'ftplugin/qf.vim')
985
986  var save_rtp = &rtp
987  &rtp = getcwd() .. ',' .. &rtp
988
989  filetype plugin on
990  copen
991  assert_equal(1, g:did_load_mytpe)
992
993  quit!
994  delete('Xexport_ft.vim')
995  delete('ftplugin', 'rf')
996  &rtp = save_rtp
997enddef
998
999def Test_use_import_in_mapping()
1000  var lines =<< trim END
1001      vim9script
1002      export def Funcx()
1003        g:result = 42
1004      enddef
1005  END
1006  writefile(lines, 'XsomeExport.vim')
1007  lines =<< trim END
1008      vim9script
1009      import Funcx from './XsomeExport.vim'
1010      nnoremap <F3> :call <sid>Funcx()<cr>
1011  END
1012  writefile(lines, 'Xmapscript.vim')
1013
1014  source Xmapscript.vim
1015  feedkeys("\<F3>", "xt")
1016  assert_equal(42, g:result)
1017
1018  unlet g:result
1019  delete('XsomeExport.vim')
1020  delete('Xmapscript.vim')
1021  nunmap <F3>
1022enddef
1023
1024def Test_vim9script_fails()
1025  CheckScriptFailure(['scriptversion 2', 'vim9script'], 'E1039:')
1026  CheckScriptFailure(['vim9script', 'scriptversion 2'], 'E1040:')
1027  CheckScriptFailure(['export var some = 123'], 'E1042:')
1028  CheckScriptFailure(['import some from "./Xexport.vim"'], 'E1048:')
1029  CheckScriptFailure(['vim9script', 'export var g:some'], 'E1022:')
1030  CheckScriptFailure(['vim9script', 'export echo 134'], 'E1043:')
1031
1032  CheckScriptFailure(['vim9script', 'var str: string', 'str = 1234'], 'E1012:')
1033  CheckScriptFailure(['vim9script', 'const str = "asdf"', 'str = "xxx"'], 'E46:')
1034
1035  assert_fails('vim9script', 'E1038:')
1036  assert_fails('export something', 'E1043:')
1037enddef
1038
1039func Test_import_fails_without_script()
1040  CheckRunVimInTerminal
1041
1042  " call indirectly to avoid compilation error for missing functions
1043  call Run_Test_import_fails_on_command_line()
1044endfunc
1045
1046def Run_Test_import_fails_on_command_line()
1047  var export =<< trim END
1048    vim9script
1049    export def Foo(): number
1050        return 0
1051    enddef
1052  END
1053  writefile(export, 'XexportCmd.vim')
1054
1055  var buf = RunVimInTerminal('-c "import Foo from ''./XexportCmd.vim''"', #{
1056                rows: 6, wait_for_ruler: 0})
1057  WaitForAssert({-> assert_match('^E1094:', term_getline(buf, 5))})
1058
1059  delete('XexportCmd.vim')
1060  StopVimInTerminal(buf)
1061enddef
1062
1063def Test_vim9script_reload_import()
1064  var lines =<< trim END
1065    vim9script
1066    const var = ''
1067    var valone = 1234
1068    def MyFunc(arg: string)
1069       valone = 5678
1070    enddef
1071  END
1072  var morelines =<< trim END
1073    var valtwo = 222
1074    export def GetValtwo(): number
1075      return valtwo
1076    enddef
1077  END
1078  writefile(lines + morelines, 'Xreload.vim')
1079  source Xreload.vim
1080  source Xreload.vim
1081  source Xreload.vim
1082
1083  var testlines =<< trim END
1084    vim9script
1085    def TheFunc()
1086      import GetValtwo from './Xreload.vim'
1087      assert_equal(222, GetValtwo())
1088    enddef
1089    TheFunc()
1090  END
1091  writefile(testlines, 'Ximport.vim')
1092  source Ximport.vim
1093
1094  # Test that when not using "morelines" GetValtwo() and valtwo are still
1095  # defined, because import doesn't reload a script.
1096  writefile(lines, 'Xreload.vim')
1097  source Ximport.vim
1098
1099  # cannot declare a var twice
1100  lines =<< trim END
1101    vim9script
1102    var valone = 1234
1103    var valone = 5678
1104  END
1105  writefile(lines, 'Xreload.vim')
1106  assert_fails('source Xreload.vim', 'E1041:', '', 3, 'Xreload.vim')
1107
1108  delete('Xreload.vim')
1109  delete('Ximport.vim')
1110enddef
1111
1112def s:RetSome(): string
1113  return 'some'
1114enddef
1115
1116" Not exported function that is referenced needs to be accessed by the
1117" script-local name.
1118def Test_vim9script_funcref()
1119  var sortlines =<< trim END
1120      vim9script
1121      def Compare(i1: number, i2: number): number
1122        return i2 - i1
1123      enddef
1124
1125      export def FastSort(): list<number>
1126        return range(5)->sort(Compare)
1127      enddef
1128  END
1129  writefile(sortlines, 'Xsort.vim')
1130
1131  var lines =<< trim END
1132    vim9script
1133    import FastSort from './Xsort.vim'
1134    def Test()
1135      g:result = FastSort()
1136    enddef
1137    Test()
1138  END
1139  writefile(lines, 'Xscript.vim')
1140
1141  source Xscript.vim
1142  assert_equal([4, 3, 2, 1, 0], g:result)
1143
1144  unlet g:result
1145  delete('Xsort.vim')
1146  delete('Xscript.vim')
1147
1148  var Funcref = function('s:RetSome')
1149  assert_equal('some', Funcref())
1150enddef
1151
1152" Check that when searching for "FilterFunc" it finds the import in the
1153" script where FastFilter() is called from, both as a string and as a direct
1154" function reference.
1155def Test_vim9script_funcref_other_script()
1156  var filterLines =<< trim END
1157    vim9script
1158    export def FilterFunc(idx: number, val: number): bool
1159      return idx % 2 == 1
1160    enddef
1161    export def FastFilter(): list<number>
1162      return range(10)->filter('FilterFunc')
1163    enddef
1164    export def FastFilterDirect(): list<number>
1165      return range(10)->filter(FilterFunc)
1166    enddef
1167  END
1168  writefile(filterLines, 'Xfilter.vim')
1169
1170  var lines =<< trim END
1171    vim9script
1172    import {FilterFunc, FastFilter, FastFilterDirect} from './Xfilter.vim'
1173    def Test()
1174      var x: list<number> = FastFilter()
1175    enddef
1176    Test()
1177    def TestDirect()
1178      var x: list<number> = FastFilterDirect()
1179    enddef
1180    TestDirect()
1181  END
1182  CheckScriptSuccess(lines)
1183  delete('Xfilter.vim')
1184enddef
1185
1186def Test_vim9script_reload_delfunc()
1187  var first_lines =<< trim END
1188    vim9script
1189    def FuncYes(): string
1190      return 'yes'
1191    enddef
1192  END
1193  var withno_lines =<< trim END
1194    def FuncNo(): string
1195      return 'no'
1196    enddef
1197    def g:DoCheck(no_exists: bool)
1198      assert_equal('yes', FuncYes())
1199      assert_equal('no', FuncNo())
1200    enddef
1201  END
1202  var nono_lines =<< trim END
1203    def g:DoCheck(no_exists: bool)
1204      assert_equal('yes', FuncYes())
1205      assert_fails('FuncNo()', 'E117:', '', 2, 'DoCheck')
1206    enddef
1207  END
1208
1209  # FuncNo() is defined
1210  writefile(first_lines + withno_lines, 'Xreloaded.vim')
1211  source Xreloaded.vim
1212  g:DoCheck(true)
1213
1214  # FuncNo() is not redefined
1215  writefile(first_lines + nono_lines, 'Xreloaded.vim')
1216  source Xreloaded.vim
1217  g:DoCheck()
1218
1219  # FuncNo() is back
1220  writefile(first_lines + withno_lines, 'Xreloaded.vim')
1221  source Xreloaded.vim
1222  g:DoCheck()
1223
1224  delete('Xreloaded.vim')
1225enddef
1226
1227def Test_vim9script_reload_delvar()
1228  # write the script with a script-local variable
1229  var lines =<< trim END
1230    vim9script
1231    var name = 'string'
1232  END
1233  writefile(lines, 'XreloadVar.vim')
1234  source XreloadVar.vim
1235
1236  # now write the script using the same variable locally - works
1237  lines =<< trim END
1238    vim9script
1239    def Func()
1240      var name = 'string'
1241    enddef
1242  END
1243  writefile(lines, 'XreloadVar.vim')
1244  source XreloadVar.vim
1245
1246  delete('XreloadVar.vim')
1247enddef
1248
1249def Test_import_absolute()
1250  var import_lines = [
1251        'vim9script',
1252        'import exported from "' .. escape(getcwd(), '\') .. '/Xexport_abs.vim"',
1253        'def UseExported()',
1254        '  g:imported_abs = exported',
1255        '  exported = 8888',
1256        '  g:imported_after = exported',
1257        'enddef',
1258        'UseExported()',
1259        'g:import_disassembled = execute("disass UseExported")',
1260        ]
1261  writefile(import_lines, 'Ximport_abs.vim')
1262  writefile(s:export_script_lines, 'Xexport_abs.vim')
1263
1264  source Ximport_abs.vim
1265
1266  assert_equal(9876, g:imported_abs)
1267  assert_equal(8888, g:imported_after)
1268  assert_match('<SNR>\d\+_UseExported.*' ..
1269          'g:imported_abs = exported.*' ..
1270          '0 LOADSCRIPT exported from .*Xexport_abs.vim.*' ..
1271          '1 STOREG g:imported_abs.*' ..
1272          'exported = 8888.*' ..
1273          '3 STORESCRIPT exported in .*Xexport_abs.vim.*' ..
1274          'g:imported_after = exported.*' ..
1275          '4 LOADSCRIPT exported from .*Xexport_abs.vim.*' ..
1276          '5 STOREG g:imported_after.*',
1277        g:import_disassembled)
1278
1279  Undo_export_script_lines()
1280  unlet g:imported_abs
1281  unlet g:import_disassembled
1282
1283  delete('Ximport_abs.vim')
1284  delete('Xexport_abs.vim')
1285enddef
1286
1287def Test_import_rtp()
1288  var import_lines = [
1289        'vim9script',
1290        'import exported from "Xexport_rtp.vim"',
1291        'g:imported_rtp = exported',
1292        ]
1293  writefile(import_lines, 'Ximport_rtp.vim')
1294  mkdir('import')
1295  writefile(s:export_script_lines, 'import/Xexport_rtp.vim')
1296
1297  var save_rtp = &rtp
1298  &rtp = getcwd()
1299  source Ximport_rtp.vim
1300  &rtp = save_rtp
1301
1302  assert_equal(9876, g:imported_rtp)
1303
1304  Undo_export_script_lines()
1305  unlet g:imported_rtp
1306  delete('Ximport_rtp.vim')
1307  delete('import', 'rf')
1308enddef
1309
1310def Test_import_compile_error()
1311  var export_lines = [
1312        'vim9script',
1313        'export def ExpFunc(): string',
1314        '  return notDefined',
1315        'enddef',
1316        ]
1317  writefile(export_lines, 'Xexported.vim')
1318
1319  var import_lines = [
1320        'vim9script',
1321        'import ExpFunc from "./Xexported.vim"',
1322        'def ImpFunc()',
1323        '  echo ExpFunc()',
1324        'enddef',
1325        'defcompile',
1326        ]
1327  writefile(import_lines, 'Ximport.vim')
1328
1329  try
1330    source Ximport.vim
1331  catch /E1001/
1332    # Error should be fore the Xexported.vim file.
1333    assert_match('E1001: Variable not found: notDefined', v:exception)
1334    assert_match('function <SNR>\d\+_ImpFunc\[1\]..<SNR>\d\+_ExpFunc, line 1', v:throwpoint)
1335  endtry
1336
1337  delete('Xexported.vim')
1338  delete('Ximport.vim')
1339enddef
1340
1341def Test_func_redefine_error()
1342  var lines = [
1343        'vim9script',
1344        'def Func()',
1345        '  eval [][0]',
1346        'enddef',
1347        'Func()',
1348        ]
1349  writefile(lines, 'Xtestscript.vim')
1350
1351  for count in range(3)
1352    try
1353      source Xtestscript.vim
1354    catch /E684/
1355      # function name should contain <SNR> every time
1356      assert_match('E684: list index out of range', v:exception)
1357      assert_match('function <SNR>\d\+_Func, line 1', v:throwpoint)
1358    endtry
1359  endfor
1360
1361  delete('Xtestscript.vim')
1362enddef
1363
1364def Test_func_overrules_import_fails()
1365  var export_lines =<< trim END
1366      vim9script
1367      export def Func()
1368        echo 'imported'
1369      enddef
1370  END
1371  writefile(export_lines, 'XexportedFunc.vim')
1372
1373  var lines =<< trim END
1374    vim9script
1375    import Func from './XexportedFunc.vim'
1376    def Func()
1377      echo 'local to function'
1378    enddef
1379  END
1380  CheckScriptFailure(lines, 'E1073:')
1381
1382  lines =<< trim END
1383    vim9script
1384    import Func from './XexportedFunc.vim'
1385    def Outer()
1386      def Func()
1387        echo 'local to function'
1388      enddef
1389    enddef
1390    defcompile
1391  END
1392  CheckScriptFailure(lines, 'E1073:')
1393
1394  delete('XexportedFunc.vim')
1395enddef
1396
1397def Test_func_redefine_fails()
1398  var lines =<< trim END
1399    vim9script
1400    def Func()
1401      echo 'one'
1402    enddef
1403    def Func()
1404      echo 'two'
1405    enddef
1406  END
1407  CheckScriptFailure(lines, 'E1073:')
1408
1409  lines =<< trim END
1410    vim9script
1411    def Foo(): string
1412      return 'foo'
1413      enddef
1414    def Func()
1415      var  Foo = {-> 'lambda'}
1416    enddef
1417    defcompile
1418  END
1419  CheckScriptFailure(lines, 'E1073:')
1420enddef
1421
1422def Test_fixed_size_list()
1423  # will be allocated as one piece of memory, check that changes work
1424  var l = [1, 2, 3, 4]
1425  l->remove(0)
1426  l->add(5)
1427  l->insert(99, 1)
1428  assert_equal([2, 99, 3, 4, 5], l)
1429enddef
1430
1431def Test_no_insert_xit()
1432  CheckDefExecFailure(['a = 1'], 'E1100:')
1433  CheckDefExecFailure(['c = 1'], 'E1100:')
1434  CheckDefExecFailure(['i = 1'], 'E1100:')
1435  CheckDefExecFailure(['t = 1'], 'E1100:')
1436  CheckDefExecFailure(['x = 1'], 'E1100:')
1437
1438  CheckScriptFailure(['vim9script', 'a = 1'], 'E488:')
1439  CheckScriptFailure(['vim9script', 'a'], 'E1100:')
1440  CheckScriptFailure(['vim9script', 'c = 1'], 'E488:')
1441  CheckScriptFailure(['vim9script', 'c'], 'E1100:')
1442  CheckScriptFailure(['vim9script', 'i = 1'], 'E488:')
1443  CheckScriptFailure(['vim9script', 'i'], 'E1100:')
1444  CheckScriptFailure(['vim9script', 't'], 'E1100:')
1445  CheckScriptFailure(['vim9script', 't = 1'], 'E1100:')
1446  CheckScriptFailure(['vim9script', 'x = 1'], 'E1100:')
1447enddef
1448
1449def IfElse(what: number): string
1450  var res = ''
1451  if what == 1
1452    res = "one"
1453  elseif what == 2
1454    res = "two"
1455  else
1456    res = "three"
1457  endif
1458  return res
1459enddef
1460
1461def Test_if_elseif_else()
1462  assert_equal('one', IfElse(1))
1463  assert_equal('two', IfElse(2))
1464  assert_equal('three', IfElse(3))
1465enddef
1466
1467def Test_if_elseif_else_fails()
1468  CheckDefFailure(['elseif true'], 'E582:')
1469  CheckDefFailure(['else'], 'E581:')
1470  CheckDefFailure(['endif'], 'E580:')
1471  CheckDefFailure(['if true', 'elseif xxx'], 'E1001:')
1472  CheckDefFailure(['if true', 'echo 1'], 'E171:')
1473enddef
1474
1475let g:bool_true = v:true
1476let g:bool_false = v:false
1477
1478def Test_if_const_expr()
1479  var res = false
1480  if true ? true : false
1481    res = true
1482  endif
1483  assert_equal(true, res)
1484
1485  g:glob = 2
1486  if false
1487    execute('g:glob = 3')
1488  endif
1489  assert_equal(2, g:glob)
1490  if true
1491    execute('g:glob = 3')
1492  endif
1493  assert_equal(3, g:glob)
1494
1495  res = false
1496  if g:bool_true ? true : false
1497    res = true
1498  endif
1499  assert_equal(true, res)
1500
1501  res = false
1502  if true ? g:bool_true : false
1503    res = true
1504  endif
1505  assert_equal(true, res)
1506
1507  res = false
1508  if true ? true : g:bool_false
1509    res = true
1510  endif
1511  assert_equal(true, res)
1512
1513  res = false
1514  if true ? false : true
1515    res = true
1516  endif
1517  assert_equal(false, res)
1518
1519  res = false
1520  if false ? false : true
1521    res = true
1522  endif
1523  assert_equal(true, res)
1524
1525  res = false
1526  if false ? true : false
1527    res = true
1528  endif
1529  assert_equal(false, res)
1530
1531  res = false
1532  if has('xyz') ? true : false
1533    res = true
1534  endif
1535  assert_equal(false, res)
1536
1537  res = false
1538  if true && true
1539    res = true
1540  endif
1541  assert_equal(true, res)
1542
1543  res = false
1544  if true && false
1545    res = true
1546  endif
1547  assert_equal(false, res)
1548
1549  res = false
1550  if g:bool_true && false
1551    res = true
1552  endif
1553  assert_equal(false, res)
1554
1555  res = false
1556  if true && g:bool_false
1557    res = true
1558  endif
1559  assert_equal(false, res)
1560
1561  res = false
1562  if false && false
1563    res = true
1564  endif
1565  assert_equal(false, res)
1566
1567  res = false
1568  if true || false
1569    res = true
1570  endif
1571  assert_equal(true, res)
1572
1573  res = false
1574  if g:bool_true || false
1575    res = true
1576  endif
1577  assert_equal(true, res)
1578
1579  res = false
1580  if true || g:bool_false
1581    res = true
1582  endif
1583  assert_equal(true, res)
1584
1585  res = false
1586  if false || false
1587    res = true
1588  endif
1589  assert_equal(false, res)
1590
1591  # with constant "false" expression may be invalid so long as the syntax is OK
1592  if false | eval 0 | endif
1593  if false | eval burp + 234 | endif
1594  if false | echo burp 234 'asd' | endif
1595  if false
1596    burp
1597  endif
1598enddef
1599
1600def Test_if_const_expr_fails()
1601  CheckDefFailure(['if "aaa" == "bbb'], 'E114:')
1602  CheckDefFailure(["if 'aaa' == 'bbb"], 'E115:')
1603  CheckDefFailure(["if has('aaa'"], 'E110:')
1604  CheckDefFailure(["if has('aaa') ? true false"], 'E109:')
1605enddef
1606
1607def RunNested(i: number): number
1608  var x: number = 0
1609  if i % 2
1610    if 1
1611      # comment
1612    else
1613      # comment
1614    endif
1615    x += 1
1616  else
1617    x += 1000
1618  endif
1619  return x
1620enddef
1621
1622def Test_nested_if()
1623  assert_equal(1, RunNested(1))
1624  assert_equal(1000, RunNested(2))
1625enddef
1626
1627def Test_execute_cmd()
1628  new
1629  setline(1, 'default')
1630  execute 'setline(1, "execute-string")'
1631  assert_equal('execute-string', getline(1))
1632
1633  execute "setline(1, 'execute-string')"
1634  assert_equal('execute-string', getline(1))
1635
1636  var cmd1 = 'setline(1,'
1637  var cmd2 = '"execute-var")'
1638  execute cmd1 cmd2 # comment
1639  assert_equal('execute-var', getline(1))
1640
1641  execute cmd1 cmd2 '|setline(1, "execute-var-string")'
1642  assert_equal('execute-var-string', getline(1))
1643
1644  var cmd_first = 'call '
1645  var cmd_last = 'setline(1, "execute-var-var")'
1646  execute cmd_first .. cmd_last
1647  assert_equal('execute-var-var', getline(1))
1648  bwipe!
1649
1650  var n = true
1651  execute 'echomsg' (n ? '"true"' : '"no"')
1652  assert_match('^true$', Screenline(&lines))
1653
1654  echomsg [1, 2, 3] #{a: 1, b: 2}
1655  assert_match('^\[1, 2, 3\] {''a'': 1, ''b'': 2}$', Screenline(&lines))
1656
1657  CheckDefFailure(['execute xxx'], 'E1001:', 1)
1658  CheckDefExecFailure(['execute "tabnext " .. 8'], 'E475:', 1)
1659  CheckDefFailure(['execute "cmd"# comment'], 'E488:', 1)
1660enddef
1661
1662def Test_execute_cmd_vimscript()
1663  # only checks line continuation
1664  var lines =<< trim END
1665      vim9script
1666      execute 'g:someVar'
1667                .. ' = ' ..
1668                   '28'
1669      assert_equal(28, g:someVar)
1670      unlet g:someVar
1671  END
1672  CheckScriptSuccess(lines)
1673enddef
1674
1675def Test_echo_cmd()
1676  echo 'some' # comment
1677  echon 'thing'
1678  assert_match('^something$', Screenline(&lines))
1679
1680  echo "some" # comment
1681  echon "thing"
1682  assert_match('^something$', Screenline(&lines))
1683
1684  var str1 = 'some'
1685  var str2 = 'more'
1686  echo str1 str2
1687  assert_match('^some more$', Screenline(&lines))
1688
1689  CheckDefFailure(['echo "xxx"# comment'], 'E488:')
1690enddef
1691
1692def Test_echomsg_cmd()
1693  echomsg 'some' 'more' # comment
1694  assert_match('^some more$', Screenline(&lines))
1695  echo 'clear'
1696  :1messages
1697  assert_match('^some more$', Screenline(&lines))
1698
1699  CheckDefFailure(['echomsg "xxx"# comment'], 'E488:')
1700enddef
1701
1702def Test_echomsg_cmd_vimscript()
1703  # only checks line continuation
1704  var lines =<< trim END
1705      vim9script
1706      echomsg 'here'
1707                .. ' is ' ..
1708                   'a message'
1709      assert_match('^here is a message$', Screenline(&lines))
1710  END
1711  CheckScriptSuccess(lines)
1712enddef
1713
1714def Test_echoerr_cmd()
1715  try
1716    echoerr 'something' 'wrong' # comment
1717  catch
1718    assert_match('something wrong', v:exception)
1719  endtry
1720enddef
1721
1722def Test_echoerr_cmd_vimscript()
1723  # only checks line continuation
1724  var lines =<< trim END
1725      vim9script
1726      try
1727        echoerr 'this'
1728                .. ' is ' ..
1729                   'wrong'
1730      catch
1731        assert_match('this is wrong', v:exception)
1732      endtry
1733  END
1734  CheckScriptSuccess(lines)
1735enddef
1736
1737def Test_for_outside_of_function()
1738  var lines =<< trim END
1739    vim9script
1740    new
1741    for var in range(0, 3)
1742      append(line('$'), var)
1743    endfor
1744    assert_equal(['', '0', '1', '2', '3'], getline(1, '$'))
1745    bwipe!
1746  END
1747  writefile(lines, 'Xvim9for.vim')
1748  source Xvim9for.vim
1749  delete('Xvim9for.vim')
1750enddef
1751
1752def Test_for_loop()
1753  var result = ''
1754  for cnt in range(7)
1755    if cnt == 4
1756      break
1757    endif
1758    if cnt == 2
1759      continue
1760    endif
1761    result ..= cnt .. '_'
1762  endfor
1763  assert_equal('0_1_3_', result)
1764
1765  var concat = ''
1766  for str in eval('["one", "two"]')
1767    concat ..= str
1768  endfor
1769  assert_equal('onetwo', concat)
1770enddef
1771
1772def Test_for_loop_fails()
1773  CheckDefFailure(['for # in range(5)'], 'E690:')
1774  CheckDefFailure(['for i In range(5)'], 'E690:')
1775  CheckDefFailure(['var x = 5', 'for x in range(5)'], 'E1017:')
1776  CheckScriptFailure(['def Func(arg: any)', 'for arg in range(5)', 'enddef', 'defcompile'], 'E1006:')
1777  CheckDefFailure(['for i in "text"'], 'E1012:')
1778  CheckDefFailure(['for i in xxx'], 'E1001:')
1779  CheckDefFailure(['endfor'], 'E588:')
1780  CheckDefFailure(['for i in range(3)', 'echo 3'], 'E170:')
1781enddef
1782
1783def Test_while_loop()
1784  var result = ''
1785  var cnt = 0
1786  while cnt < 555
1787    if cnt == 3
1788      break
1789    endif
1790    cnt += 1
1791    if cnt == 2
1792      continue
1793    endif
1794    result ..= cnt .. '_'
1795  endwhile
1796  assert_equal('1_3_', result)
1797enddef
1798
1799def Test_while_loop_fails()
1800  CheckDefFailure(['while xxx'], 'E1001:')
1801  CheckDefFailure(['endwhile'], 'E588:')
1802  CheckDefFailure(['continue'], 'E586:')
1803  CheckDefFailure(['if true', 'continue'], 'E586:')
1804  CheckDefFailure(['break'], 'E587:')
1805  CheckDefFailure(['if true', 'break'], 'E587:')
1806  CheckDefFailure(['while 1', 'echo 3'], 'E170:')
1807enddef
1808
1809def Test_interrupt_loop()
1810  var caught = false
1811  var x = 0
1812  try
1813    while 1
1814      x += 1
1815      if x == 100
1816        feedkeys("\<C-C>", 'Lt')
1817      endif
1818    endwhile
1819  catch
1820    caught = true
1821    assert_equal(100, x)
1822  endtry
1823  assert_true(caught, 'should have caught an exception')
1824  # consume the CTRL-C
1825  getchar(0)
1826enddef
1827
1828def Test_automatic_line_continuation()
1829  var mylist = [
1830      'one',
1831      'two',
1832      'three',
1833      ] # comment
1834  assert_equal(['one', 'two', 'three'], mylist)
1835
1836  var mydict = {
1837      'one': 1,
1838      'two': 2,
1839      'three':
1840          3,
1841      } # comment
1842  assert_equal({'one': 1, 'two': 2, 'three': 3}, mydict)
1843  mydict = #{
1844      one: 1,  # comment
1845      two:     # comment
1846           2,  # comment
1847      three: 3 # comment
1848      }
1849  assert_equal(#{one: 1, two: 2, three: 3}, mydict)
1850  mydict = #{
1851      one: 1,
1852      two:
1853           2,
1854      three: 3
1855      }
1856  assert_equal(#{one: 1, two: 2, three: 3}, mydict)
1857
1858  assert_equal(
1859        ['one', 'two', 'three'],
1860        split('one two three')
1861        )
1862enddef
1863
1864def Test_vim9_comment()
1865  CheckScriptSuccess([
1866      'vim9script',
1867      '# something',
1868      ])
1869  CheckScriptFailure([
1870      'vim9script',
1871      ':# something',
1872      ], 'E488:')
1873  CheckScriptFailure([
1874      '# something',
1875      ], 'E488:')
1876  CheckScriptFailure([
1877      ':# something',
1878      ], 'E488:')
1879
1880  { # block start
1881  } # block end
1882  CheckDefFailure([
1883      '{# comment',
1884      ], 'E488:')
1885  CheckDefFailure([
1886      '{',
1887      '}# comment',
1888      ], 'E488:')
1889
1890  echo "yes" # comment
1891  CheckDefFailure([
1892      'echo "yes"# comment',
1893      ], 'E488:')
1894  CheckScriptSuccess([
1895      'vim9script',
1896      'echo "yes" # something',
1897      ])
1898  CheckScriptFailure([
1899      'vim9script',
1900      'echo "yes"# something',
1901      ], 'E121:')
1902  CheckScriptFailure([
1903      'vim9script',
1904      'echo# something',
1905      ], 'E121:')
1906  CheckScriptFailure([
1907      'echo "yes" # something',
1908      ], 'E121:')
1909
1910  exe "echo" # comment
1911  CheckDefFailure([
1912      'exe "echo"# comment',
1913      ], 'E488:')
1914  CheckScriptSuccess([
1915      'vim9script',
1916      'exe "echo" # something',
1917      ])
1918  CheckScriptFailure([
1919      'vim9script',
1920      'exe "echo"# something',
1921      ], 'E121:')
1922  CheckDefFailure([
1923      'exe # comment',
1924      ], 'E1015:')
1925  CheckScriptFailure([
1926      'vim9script',
1927      'exe# something',
1928      ], 'E121:')
1929  CheckScriptFailure([
1930      'exe "echo" # something',
1931      ], 'E121:')
1932
1933  CheckDefFailure([
1934      'try# comment',
1935      '  echo "yes"',
1936      'catch',
1937      'endtry',
1938      ], 'E488:')
1939  CheckScriptFailure([
1940      'vim9script',
1941      'try# comment',
1942      'echo "yes"',
1943      ], 'E488:')
1944  CheckDefFailure([
1945      'try',
1946      '  throw#comment',
1947      'catch',
1948      'endtry',
1949      ], 'E1015:')
1950  CheckDefFailure([
1951      'try',
1952      '  throw "yes"#comment',
1953      'catch',
1954      'endtry',
1955      ], 'E488:')
1956  CheckDefFailure([
1957      'try',
1958      '  echo "yes"',
1959      'catch# comment',
1960      'endtry',
1961      ], 'E488:')
1962  CheckScriptFailure([
1963      'vim9script',
1964      'try',
1965      '  echo "yes"',
1966      'catch# comment',
1967      'endtry',
1968      ], 'E654:')
1969  CheckDefFailure([
1970      'try',
1971      '  echo "yes"',
1972      'catch /pat/# comment',
1973      'endtry',
1974      ], 'E488:')
1975  CheckDefFailure([
1976      'try',
1977      'echo "yes"',
1978      'catch',
1979      'endtry# comment',
1980      ], 'E488:')
1981  CheckScriptFailure([
1982      'vim9script',
1983      'try',
1984      '  echo "yes"',
1985      'catch',
1986      'endtry# comment',
1987      ], 'E488:')
1988
1989  CheckScriptSuccess([
1990      'vim9script',
1991      'hi # comment',
1992      ])
1993  CheckScriptFailure([
1994      'vim9script',
1995      'hi# comment',
1996      ], 'E416:')
1997  CheckScriptSuccess([
1998      'vim9script',
1999      'hi Search # comment',
2000      ])
2001  CheckScriptFailure([
2002      'vim9script',
2003      'hi Search# comment',
2004      ], 'E416:')
2005  CheckScriptSuccess([
2006      'vim9script',
2007      'hi link This Search # comment',
2008      ])
2009  CheckScriptFailure([
2010      'vim9script',
2011      'hi link This That# comment',
2012      ], 'E413:')
2013  CheckScriptSuccess([
2014      'vim9script',
2015      'hi clear This # comment',
2016      'hi clear # comment',
2017      ])
2018  # not tested, because it doesn't give an error but a warning:
2019  # hi clear This# comment',
2020  CheckScriptFailure([
2021      'vim9script',
2022      'hi clear# comment',
2023      ], 'E416:')
2024
2025  CheckScriptSuccess([
2026      'vim9script',
2027      'hi Group term=bold',
2028      'match Group /todo/ # comment',
2029      ])
2030  CheckScriptFailure([
2031      'vim9script',
2032      'hi Group term=bold',
2033      'match Group /todo/# comment',
2034      ], 'E488:')
2035  CheckScriptSuccess([
2036      'vim9script',
2037      'match # comment',
2038      ])
2039  CheckScriptFailure([
2040      'vim9script',
2041      'match# comment',
2042      ], 'E475:')
2043  CheckScriptSuccess([
2044      'vim9script',
2045      'match none # comment',
2046      ])
2047  CheckScriptFailure([
2048      'vim9script',
2049      'match none# comment',
2050      ], 'E475:')
2051
2052  CheckScriptSuccess([
2053      'vim9script',
2054      'menutrans clear # comment',
2055      ])
2056  CheckScriptFailure([
2057      'vim9script',
2058      'menutrans clear# comment text',
2059      ], 'E474:')
2060
2061  CheckScriptSuccess([
2062      'vim9script',
2063      'syntax clear # comment',
2064      ])
2065  CheckScriptFailure([
2066      'vim9script',
2067      'syntax clear# comment text',
2068      ], 'E28:')
2069  CheckScriptSuccess([
2070      'vim9script',
2071      'syntax keyword Word some',
2072      'syntax clear Word # comment',
2073      ])
2074  CheckScriptFailure([
2075      'vim9script',
2076      'syntax keyword Word some',
2077      'syntax clear Word# comment text',
2078      ], 'E28:')
2079
2080  CheckScriptSuccess([
2081      'vim9script',
2082      'syntax list # comment',
2083      ])
2084  CheckScriptFailure([
2085      'vim9script',
2086      'syntax list# comment text',
2087      ], 'E28:')
2088
2089  CheckScriptSuccess([
2090      'vim9script',
2091      'syntax match Word /pat/ oneline # comment',
2092      ])
2093  CheckScriptFailure([
2094      'vim9script',
2095      'syntax match Word /pat/ oneline# comment',
2096      ], 'E475:')
2097
2098  CheckScriptSuccess([
2099      'vim9script',
2100      'syntax keyword Word word # comm[ent',
2101      ])
2102  CheckScriptFailure([
2103      'vim9script',
2104      'syntax keyword Word word# comm[ent',
2105      ], 'E789:')
2106
2107  CheckScriptSuccess([
2108      'vim9script',
2109      'syntax match Word /pat/ # comment',
2110      ])
2111  CheckScriptFailure([
2112      'vim9script',
2113      'syntax match Word /pat/# comment',
2114      ], 'E402:')
2115
2116  CheckScriptSuccess([
2117      'vim9script',
2118      'syntax match Word /pat/ contains=Something # comment',
2119      ])
2120  CheckScriptFailure([
2121      'vim9script',
2122      'syntax match Word /pat/ contains=Something# comment',
2123      ], 'E475:')
2124  CheckScriptFailure([
2125      'vim9script',
2126      'syntax match Word /pat/ contains= # comment',
2127      ], 'E406:')
2128  CheckScriptFailure([
2129      'vim9script',
2130      'syntax match Word /pat/ contains=# comment',
2131      ], 'E475:')
2132
2133  CheckScriptSuccess([
2134      'vim9script',
2135      'syntax region Word start=/pat/ end=/pat/ # comment',
2136      ])
2137  CheckScriptFailure([
2138      'vim9script',
2139      'syntax region Word start=/pat/ end=/pat/# comment',
2140      ], 'E402:')
2141
2142  CheckScriptSuccess([
2143      'vim9script',
2144      'syntax sync # comment',
2145      ])
2146  CheckScriptFailure([
2147      'vim9script',
2148      'syntax sync# comment',
2149      ], 'E404:')
2150  CheckScriptSuccess([
2151      'vim9script',
2152      'syntax sync ccomment # comment',
2153      ])
2154  CheckScriptFailure([
2155      'vim9script',
2156      'syntax sync ccomment# comment',
2157      ], 'E404:')
2158
2159  CheckScriptSuccess([
2160      'vim9script',
2161      'syntax cluster Some contains=Word # comment',
2162      ])
2163  CheckScriptFailure([
2164      'vim9script',
2165      'syntax cluster Some contains=Word# comment',
2166      ], 'E475:')
2167
2168  CheckScriptSuccess([
2169      'vim9script',
2170      'command Echo echo # comment',
2171      'command Echo # comment',
2172      ])
2173  CheckScriptFailure([
2174      'vim9script',
2175      'command Echo echo# comment',
2176      'Echo',
2177      ], 'E121:')
2178  CheckScriptFailure([
2179      'vim9script',
2180      'command Echo# comment',
2181      ], 'E182:')
2182  CheckScriptFailure([
2183      'vim9script',
2184      'command Echo echo',
2185      'command Echo# comment',
2186      ], 'E182:')
2187
2188  CheckScriptSuccess([
2189      'vim9script',
2190      'function # comment',
2191      ])
2192  CheckScriptFailure([
2193      'vim9script',
2194      'function " comment',
2195      ], 'E129:')
2196  CheckScriptFailure([
2197      'vim9script',
2198      'function# comment',
2199      ], 'E129:')
2200  CheckScriptSuccess([
2201      'vim9script',
2202      'function CheckScriptSuccess # comment',
2203      ])
2204  CheckScriptFailure([
2205      'vim9script',
2206      'function CheckScriptSuccess# comment',
2207      ], 'E488:')
2208
2209  CheckScriptSuccess([
2210      'vim9script',
2211      'func g:DeleteMeA()',
2212      'endfunc',
2213      'delfunction g:DeleteMeA # comment',
2214      ])
2215  CheckScriptFailure([
2216      'vim9script',
2217      'func g:DeleteMeB()',
2218      'endfunc',
2219      'delfunction g:DeleteMeB# comment',
2220      ], 'E488:')
2221
2222  CheckScriptSuccess([
2223      'vim9script',
2224      'call execute("ls") # comment',
2225      ])
2226  CheckScriptFailure([
2227      'vim9script',
2228      'call execute("ls")# comment',
2229      ], 'E488:')
2230
2231  CheckScriptFailure([
2232      'def Test() " comment',
2233      'enddef',
2234      ], 'E488:')
2235  CheckScriptFailure([
2236      'vim9script',
2237      'def Test() " comment',
2238      'enddef',
2239      ], 'E488:')
2240
2241  CheckScriptSuccess([
2242      'func Test() " comment',
2243      'endfunc',
2244      ])
2245  CheckScriptSuccess([
2246      'vim9script',
2247      'func Test() " comment',
2248      'endfunc',
2249      ])
2250
2251  CheckScriptSuccess([
2252      'def Test() # comment',
2253      'enddef',
2254      ])
2255  CheckScriptFailure([
2256      'func Test() # comment',
2257      'endfunc',
2258      ], 'E488:')
2259enddef
2260
2261def Test_vim9_comment_gui()
2262  CheckCanRunGui
2263
2264  CheckScriptFailure([
2265      'vim9script',
2266      'gui#comment'
2267      ], 'E499:')
2268  CheckScriptFailure([
2269      'vim9script',
2270      'gui -f#comment'
2271      ], 'E499:')
2272enddef
2273
2274def Test_vim9_comment_not_compiled()
2275  au TabEnter *.vim g:entered = 1
2276  au TabEnter *.x g:entered = 2
2277
2278  edit test.vim
2279  doautocmd TabEnter #comment
2280  assert_equal(1, g:entered)
2281
2282  doautocmd TabEnter f.x
2283  assert_equal(2, g:entered)
2284
2285  g:entered = 0
2286  doautocmd TabEnter f.x #comment
2287  assert_equal(2, g:entered)
2288
2289  assert_fails('doautocmd Syntax#comment', 'E216:')
2290
2291  au! TabEnter
2292  unlet g:entered
2293
2294  CheckScriptSuccess([
2295      'vim9script',
2296      'g:var = 123',
2297      'b:var = 456',
2298      'w:var = 777',
2299      't:var = 888',
2300      'unlet g:var w:var # something',
2301      ])
2302
2303  CheckScriptFailure([
2304      'vim9script',
2305      'let var = 123',
2306      ], 'E1126: Cannot use :let in Vim9 script')
2307
2308  CheckScriptFailure([
2309      'vim9script',
2310      'var g:var = 123',
2311      ], 'E1016: Cannot declare a global variable:')
2312
2313  CheckScriptFailure([
2314      'vim9script',
2315      'var b:var = 123',
2316      ], 'E1016: Cannot declare a buffer variable:')
2317
2318  CheckScriptFailure([
2319      'vim9script',
2320      'var w:var = 123',
2321      ], 'E1016: Cannot declare a window variable:')
2322
2323  CheckScriptFailure([
2324      'vim9script',
2325      'var t:var = 123',
2326      ], 'E1016: Cannot declare a tab variable:')
2327
2328  CheckScriptFailure([
2329      'vim9script',
2330      'var v:version = 123',
2331      ], 'E1016: Cannot declare a v: variable:')
2332
2333  CheckScriptFailure([
2334      'vim9script',
2335      'var $VARIABLE = "text"',
2336      ], 'E1016: Cannot declare an environment variable:')
2337
2338  CheckScriptFailure([
2339      'vim9script',
2340      'g:var = 123',
2341      'unlet g:var# comment1',
2342      ], 'E108:')
2343
2344  CheckScriptFailure([
2345      'let g:var = 123',
2346      'unlet g:var # something',
2347      ], 'E488:')
2348
2349  CheckScriptSuccess([
2350      'vim9script',
2351      'if 1 # comment2',
2352      '  echo "yes"',
2353      'elseif 2 #comment',
2354      '  echo "no"',
2355      'endif',
2356      ])
2357
2358  CheckScriptFailure([
2359      'vim9script',
2360      'if 1# comment3',
2361      '  echo "yes"',
2362      'endif',
2363      ], 'E15:')
2364
2365  CheckScriptFailure([
2366      'vim9script',
2367      'if 0 # comment4',
2368      '  echo "yes"',
2369      'elseif 2#comment',
2370      '  echo "no"',
2371      'endif',
2372      ], 'E15:')
2373
2374  CheckScriptSuccess([
2375      'vim9script',
2376      'var v = 1 # comment5',
2377      ])
2378
2379  CheckScriptFailure([
2380      'vim9script',
2381      'var v = 1# comment6',
2382      ], 'E15:')
2383
2384  CheckScriptSuccess([
2385      'vim9script',
2386      'new'
2387      'setline(1, ["# define pat", "last"])',
2388      ':$',
2389      'dsearch /pat/ #comment',
2390      'bwipe!',
2391      ])
2392
2393  CheckScriptFailure([
2394      'vim9script',
2395      'new'
2396      'setline(1, ["# define pat", "last"])',
2397      ':$',
2398      'dsearch /pat/#comment',
2399      'bwipe!',
2400      ], 'E488:')
2401
2402  CheckScriptFailure([
2403      'vim9script',
2404      'func! SomeFunc()',
2405      ], 'E477:')
2406enddef
2407
2408def Test_finish()
2409  var lines =<< trim END
2410    vim9script
2411    g:res = 'one'
2412    if v:false | finish | endif
2413    g:res = 'two'
2414    finish
2415    g:res = 'three'
2416  END
2417  writefile(lines, 'Xfinished')
2418  source Xfinished
2419  assert_equal('two', g:res)
2420
2421  unlet g:res
2422  delete('Xfinished')
2423enddef
2424
2425def Test_forward_declaration()
2426  var lines =<< trim END
2427    vim9script
2428    def GetValue(): string
2429      return theVal
2430    enddef
2431    var theVal = 'something'
2432    g:initVal = GetValue()
2433    theVal = 'else'
2434    g:laterVal = GetValue()
2435  END
2436  writefile(lines, 'Xforward')
2437  source Xforward
2438  assert_equal('something', g:initVal)
2439  assert_equal('else', g:laterVal)
2440
2441  unlet g:initVal
2442  unlet g:laterVal
2443  delete('Xforward')
2444enddef
2445
2446def Test_source_vim9_from_legacy()
2447  var legacy_lines =<< trim END
2448    source Xvim9_script.vim
2449
2450    call assert_false(exists('local'))
2451    call assert_false(exists('exported'))
2452    call assert_false(exists('s:exported'))
2453    call assert_equal('global', global)
2454    call assert_equal('global', g:global)
2455
2456    " imported variable becomes script-local
2457    import exported from './Xvim9_script.vim'
2458    call assert_equal('exported', s:exported)
2459    call assert_false(exists('exported'))
2460
2461    " imported function becomes script-local
2462    import GetText from './Xvim9_script.vim'
2463    call assert_equal('text', s:GetText())
2464    call assert_false(exists('*GetText'))
2465  END
2466  writefile(legacy_lines, 'Xlegacy_script.vim')
2467
2468  var vim9_lines =<< trim END
2469    vim9script
2470    var local = 'local'
2471    g:global = 'global'
2472    export var exported = 'exported'
2473    export def GetText(): string
2474       return 'text'
2475    enddef
2476  END
2477  writefile(vim9_lines, 'Xvim9_script.vim')
2478
2479  source Xlegacy_script.vim
2480
2481  assert_equal('global', g:global)
2482  unlet g:global
2483
2484  delete('Xlegacy_script.vim')
2485  delete('Xvim9_script.vim')
2486enddef
2487
2488func Test_vim9script_not_global()
2489  " check that items defined in Vim9 script are script-local, not global
2490  let vim9lines =<< trim END
2491    vim9script
2492    var name = 'local'
2493    func TheFunc()
2494      echo 'local'
2495    endfunc
2496    def DefFunc()
2497      echo 'local'
2498    enddef
2499  END
2500  call writefile(vim9lines, 'Xvim9script.vim')
2501  source Xvim9script.vim
2502  try
2503    echo g:var
2504    assert_report('did not fail')
2505  catch /E121:/
2506    " caught
2507  endtry
2508  try
2509    call TheFunc()
2510    assert_report('did not fail')
2511  catch /E117:/
2512    " caught
2513  endtry
2514  try
2515    call DefFunc()
2516    assert_report('did not fail')
2517  catch /E117:/
2518    " caught
2519  endtry
2520
2521  call delete('Xvim9script.vim')
2522endfunc
2523
2524def Test_vim9_copen()
2525  # this was giving an error for setting w:quickfix_title
2526  copen
2527  quit
2528enddef
2529
2530" test using a vim9script that is auto-loaded from an autocmd
2531def Test_vim9_autoload()
2532  var lines =<< trim END
2533     vim9script
2534     def foo#test()
2535         echomsg getreg('"')
2536     enddef
2537  END
2538
2539  mkdir('Xdir/autoload', 'p')
2540  writefile(lines, 'Xdir/autoload/foo.vim')
2541  var save_rtp = &rtp
2542  exe 'set rtp^=' .. getcwd() .. '/Xdir'
2543  augroup test
2544    autocmd TextYankPost * call foo#test()
2545  augroup END
2546
2547  normal Y
2548
2549  augroup test
2550    autocmd!
2551  augroup END
2552  delete('Xdir', 'rf')
2553  &rtp = save_rtp
2554enddef
2555
2556" This was causing a crash because suppress_errthrow wasn't reset.
2557def Test_vim9_autoload_error()
2558  var lines =<< trim END
2559      vim9script
2560      def crash#func()
2561          try
2562              for x in List()
2563              endfor
2564          catch
2565          endtry
2566          g:ok = true
2567      enddef
2568      fu List()
2569          invalid
2570      endfu
2571      try
2572          invalid
2573      catch /wontmatch/
2574      endtry
2575  END
2576  call mkdir('Xruntime/autoload', 'p')
2577  call writefile(lines, 'Xruntime/autoload/crash.vim')
2578
2579  # run in a separate Vim to avoid the side effects of assert_fails()
2580  lines =<< trim END
2581    exe 'set rtp^=' .. getcwd() .. '/Xruntime'
2582    call crash#func()
2583    call writefile(['ok'], 'Xdidit')
2584    qall!
2585  END
2586  writefile(lines, 'Xscript')
2587  RunVim([], [], '-S Xscript')
2588  assert_equal(['ok'], readfile('Xdidit'))
2589
2590  delete('Xdidit')
2591  delete('Xscript')
2592  delete('Xruntime', 'rf')
2593enddef
2594
2595def Test_script_var_in_autocmd()
2596  # using a script variable from an autocommand, defined in a :def function in a
2597  # legacy Vim script, cannot check the variable type.
2598  var lines =<< trim END
2599    let s:counter = 1
2600    def s:Func()
2601      au! CursorHold
2602      au CursorHold * s:counter += 1
2603    enddef
2604    call s:Func()
2605    doau CursorHold
2606    call assert_equal(2, s:counter)
2607    au! CursorHold
2608  END
2609  CheckScriptSuccess(lines)
2610enddef
2611
2612def Test_cmdline_win()
2613  # if the Vim syntax highlighting uses Vim9 constructs they can be used from
2614  # the command line window.
2615  mkdir('rtp/syntax', 'p')
2616  var export_lines =<< trim END
2617    vim9script
2618    export var That = 'yes'
2619  END
2620  writefile(export_lines, 'rtp/syntax/Xexport.vim')
2621  var import_lines =<< trim END
2622    vim9script
2623    import That from './Xexport.vim'
2624  END
2625  writefile(import_lines, 'rtp/syntax/vim.vim')
2626  var save_rtp = &rtp
2627  &rtp = getcwd() .. '/rtp' .. ',' .. &rtp
2628  syntax on
2629  augroup CmdWin
2630    autocmd CmdwinEnter * g:got_there = 'yes'
2631  augroup END
2632  # this will open and also close the cmdline window
2633  feedkeys('q:', 'xt')
2634  assert_equal('yes', g:got_there)
2635
2636  augroup CmdWin
2637    au!
2638  augroup END
2639  &rtp = save_rtp
2640  delete('rtp', 'rf')
2641enddef
2642
2643def Test_invalid_sid()
2644  assert_fails('func <SNR>1234_func', 'E123:')
2645
2646  if RunVim([], ['wq! Xdidit'], '+"func <SNR>1_func"')
2647    assert_equal([], readfile('Xdidit'))
2648  endif
2649  delete('Xdidit')
2650enddef
2651
2652def Test_unset_any_variable()
2653  var lines =<< trim END
2654    var name: any
2655    assert_equal(0, name)
2656  END
2657  CheckDefAndScriptSuccess(lines)
2658enddef
2659
2660func Test_define_func_at_command_line()
2661  CheckRunVimInTerminal
2662
2663  " call indirectly to avoid compilation error for missing functions
2664  call Run_Test_define_func_at_command_line()
2665endfunc
2666
2667def Run_Test_define_func_at_command_line()
2668  # run in a separate Vim instance to avoid the script context
2669  var lines =<< trim END
2670    func CheckAndQuit()
2671      call assert_fails('call Afunc()', 'E117: Unknown function: Bfunc')
2672      call writefile(['errors: ' .. string(v:errors)], 'Xdidcmd')
2673    endfunc
2674  END
2675  writefile([''], 'Xdidcmd')
2676  writefile(lines, 'XcallFunc')
2677  var buf = RunVimInTerminal('-S XcallFunc', #{rows: 6})
2678  # define Afunc() on the command line
2679  term_sendkeys(buf, ":def Afunc()\<CR>Bfunc()\<CR>enddef\<CR>")
2680  term_sendkeys(buf, ":call CheckAndQuit()\<CR>")
2681  WaitForAssert({-> assert_equal(['errors: []'], readfile('Xdidcmd'))})
2682
2683  call StopVimInTerminal(buf)
2684  delete('XcallFunc')
2685  delete('Xdidcmd')
2686enddef
2687
2688def Test_script_var_scope()
2689  var lines =<< trim END
2690      vim9script
2691      if true
2692        if true
2693          var one = 'one'
2694          echo one
2695        endif
2696        echo one
2697      endif
2698  END
2699  CheckScriptFailure(lines, 'E121:', 7)
2700
2701  lines =<< trim END
2702      vim9script
2703      if true
2704        if false
2705          var one = 'one'
2706          echo one
2707        else
2708          var one = 'one'
2709          echo one
2710        endif
2711        echo one
2712      endif
2713  END
2714  CheckScriptFailure(lines, 'E121:', 10)
2715
2716  lines =<< trim END
2717      vim9script
2718      while true
2719        var one = 'one'
2720        echo one
2721        break
2722      endwhile
2723      echo one
2724  END
2725  CheckScriptFailure(lines, 'E121:', 7)
2726
2727  lines =<< trim END
2728      vim9script
2729      for i in range(1)
2730        var one = 'one'
2731        echo one
2732      endfor
2733      echo one
2734  END
2735  CheckScriptFailure(lines, 'E121:', 6)
2736
2737  lines =<< trim END
2738      vim9script
2739      {
2740        var one = 'one'
2741        assert_equal('one', one)
2742      }
2743      assert_false(exists('one'))
2744      assert_false(exists('s:one'))
2745  END
2746  CheckScriptSuccess(lines)
2747
2748  lines =<< trim END
2749      vim9script
2750      {
2751        var one = 'one'
2752        echo one
2753      }
2754      echo one
2755  END
2756  CheckScriptFailure(lines, 'E121:', 6)
2757enddef
2758
2759" Keep this last, it messes up highlighting.
2760def Test_substitute_cmd()
2761  new
2762  setline(1, 'something')
2763  :substitute(some(other(
2764  assert_equal('otherthing', getline(1))
2765  bwipe!
2766
2767  # also when the context is Vim9 script
2768  var lines =<< trim END
2769    vim9script
2770    new
2771    setline(1, 'something')
2772    :substitute(some(other(
2773    assert_equal('otherthing', getline(1))
2774    bwipe!
2775  END
2776  writefile(lines, 'Xvim9lines')
2777  source Xvim9lines
2778
2779  delete('Xvim9lines')
2780enddef
2781
2782" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker
2783