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