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
8source screendump.vim
9
10def Test_range_only()
11  new
12  setline(1, ['blah', 'Blah'])
13  :/Blah/
14  assert_equal(2, getcurpos()[1])
15  bwipe!
16
17  # without range commands use current line
18  new
19  setline(1, ['one', 'two', 'three'])
20  :2
21  print
22  assert_equal('two', Screenline(&lines))
23  :3
24  list
25  assert_equal('three$', Screenline(&lines))
26
27  # missing command does not print the line
28  var lines =<< trim END
29    vim9script
30    :1|
31    assert_equal('three$', Screenline(&lines))
32    :|
33    assert_equal('three$', Screenline(&lines))
34  END
35  CheckScriptSuccess(lines)
36
37  bwipe!
38
39  # won't generate anything
40  if false
41    :123
42  endif
43enddef
44
45let g:alist = [7]
46let g:astring = 'text'
47let g:anumber = 123
48
49def Test_delfunction()
50  # Check function is defined in script namespace
51  CheckScriptSuccess([
52      'vim9script',
53      'func CheckMe()',
54      '  return 123',
55      'endfunc',
56      'assert_equal(123, s:CheckMe())',
57      ])
58
59  # Check function in script namespace cannot be deleted
60  CheckScriptFailure([
61      'vim9script',
62      'func DeleteMe1()',
63      'endfunc',
64      'delfunction DeleteMe1',
65      ], 'E1084:')
66  CheckScriptFailure([
67      'vim9script',
68      'func DeleteMe2()',
69      'endfunc',
70      'def DoThat()',
71      '  delfunction DeleteMe2',
72      'enddef',
73      'DoThat()',
74      ], 'E1084:')
75  CheckScriptFailure([
76      'vim9script',
77      'def DeleteMe3()',
78      'enddef',
79      'delfunction DeleteMe3',
80      ], 'E1084:')
81  CheckScriptFailure([
82      'vim9script',
83      'def DeleteMe4()',
84      'enddef',
85      'def DoThat()',
86      '  delfunction DeleteMe4',
87      'enddef',
88      'DoThat()',
89      ], 'E1084:')
90
91  # Check that global :def function can be replaced and deleted
92  var lines =<< trim END
93      vim9script
94      def g:Global(): string
95        return "yes"
96      enddef
97      assert_equal("yes", g:Global())
98      def! g:Global(): string
99        return "no"
100      enddef
101      assert_equal("no", g:Global())
102      delfunc g:Global
103      assert_false(exists('*g:Global'))
104  END
105  CheckScriptSuccess(lines)
106
107  # Check that global function can be replaced by a :def function and deleted
108  lines =<< trim END
109      vim9script
110      func g:Global()
111        return "yes"
112      endfunc
113      assert_equal("yes", g:Global())
114      def! g:Global(): string
115        return "no"
116      enddef
117      assert_equal("no", g:Global())
118      delfunc g:Global
119      assert_false(exists('*g:Global'))
120  END
121  CheckScriptSuccess(lines)
122
123  # Check that global :def function can be replaced by a function and deleted
124  lines =<< trim END
125      vim9script
126      def g:Global(): string
127        return "yes"
128      enddef
129      assert_equal("yes", g:Global())
130      func! g:Global()
131        return "no"
132      endfunc
133      assert_equal("no", g:Global())
134      delfunc g:Global
135      assert_false(exists('*g:Global'))
136  END
137  CheckScriptSuccess(lines)
138enddef
139
140def Test_wrong_type()
141  CheckDefFailure(['var name: list<nothing>'], 'E1010:')
142  CheckDefFailure(['var name: list<list<nothing>>'], 'E1010:')
143  CheckDefFailure(['var name: dict<nothing>'], 'E1010:')
144  CheckDefFailure(['var name: dict<dict<nothing>>'], 'E1010:')
145
146  CheckDefFailure(['var name: dict<number'], 'E1009:')
147  CheckDefFailure(['var name: dict<list<number>'], 'E1009:')
148
149  CheckDefFailure(['var name: ally'], 'E1010:')
150  CheckDefFailure(['var name: bram'], 'E1010:')
151  CheckDefFailure(['var name: cathy'], 'E1010:')
152  CheckDefFailure(['var name: dom'], 'E1010:')
153  CheckDefFailure(['var name: freddy'], 'E1010:')
154  CheckDefFailure(['var name: john'], 'E1010:')
155  CheckDefFailure(['var name: larry'], 'E1010:')
156  CheckDefFailure(['var name: ned'], 'E1010:')
157  CheckDefFailure(['var name: pam'], 'E1010:')
158  CheckDefFailure(['var name: sam'], 'E1010:')
159  CheckDefFailure(['var name: vim'], 'E1010:')
160
161  CheckDefFailure(['var Ref: number', 'Ref()'], 'E1085:')
162  CheckDefFailure(['var Ref: string', 'var res = Ref()'], 'E1085:')
163enddef
164
165def Test_script_wrong_type()
166  var lines =<< trim END
167      vim9script
168      var s:dict: dict<string>
169      s:dict['a'] = ['x']
170  END
171  CheckScriptFailure(lines, 'E1012: Type mismatch; expected string but got list<string>', 3)
172enddef
173
174def Test_const()
175  CheckDefFailure(['final name = 234', 'name = 99'], 'E1018:')
176  CheckDefFailure(['final one = 234', 'var one = 99'], 'E1017:')
177  CheckDefFailure(['final list = [1, 2]', 'var list = [3, 4]'], 'E1017:')
178  CheckDefFailure(['final two'], 'E1125:')
179  CheckDefFailure(['final &option'], 'E996:')
180
181  var lines =<< trim END
182    final list = [1, 2, 3]
183    list[0] = 4
184    list->assert_equal([4, 2, 3])
185    const other = [5, 6, 7]
186    other->assert_equal([5, 6, 7])
187
188    var varlist = [7, 8]
189    const constlist = [1, varlist, 3]
190    varlist[0] = 77
191    # TODO: does not work yet
192    # constlist[1][1] = 88
193    var cl = constlist[1]
194    cl[1] = 88
195    constlist->assert_equal([1, [77, 88], 3])
196
197    var vardict = {five: 5, six: 6}
198    const constdict = {one: 1, two: vardict, three: 3}
199    vardict['five'] = 55
200    # TODO: does not work yet
201    # constdict['two']['six'] = 66
202    var cd = constdict['two']
203    cd['six'] = 66
204    constdict->assert_equal({one: 1, two: {five: 55, six: 66}, three: 3})
205  END
206  CheckDefAndScriptSuccess(lines)
207enddef
208
209def Test_const_bang()
210  var lines =<< trim END
211      const var = 234
212      var = 99
213  END
214  CheckDefExecFailure(lines, 'E1018:', 2)
215  CheckScriptFailure(['vim9script'] + lines, 'E46:', 3)
216
217  lines =<< trim END
218      const ll = [2, 3, 4]
219      ll[0] = 99
220  END
221  CheckDefExecFailure(lines, 'E1119:', 2)
222  CheckScriptFailure(['vim9script'] + lines, 'E741:', 3)
223
224  lines =<< trim END
225      const ll = [2, 3, 4]
226      ll[3] = 99
227  END
228  CheckDefExecFailure(lines, 'E1118:', 2)
229  CheckScriptFailure(['vim9script'] + lines, 'E684:', 3)
230
231  lines =<< trim END
232      const dd = {one: 1, two: 2}
233      dd["one"] = 99
234  END
235  CheckDefExecFailure(lines, 'E1121:', 2)
236  CheckScriptFailure(['vim9script'] + lines, 'E741:', 3)
237
238  lines =<< trim END
239      const dd = {one: 1, two: 2}
240      dd["three"] = 99
241  END
242  CheckDefExecFailure(lines, 'E1120:')
243  CheckScriptFailure(['vim9script'] + lines, 'E741:', 3)
244enddef
245
246def Test_range_no_colon()
247  CheckDefFailure(['%s/a/b/'], 'E1050:')
248  CheckDefFailure(['+ s/a/b/'], 'E1050:')
249  CheckDefFailure(['- s/a/b/'], 'E1050:')
250  CheckDefFailure(['. s/a/b/'], 'E1050:')
251enddef
252
253
254def Test_block()
255  var outer = 1
256  {
257    var inner = 2
258    assert_equal(1, outer)
259    assert_equal(2, inner)
260  }
261  assert_equal(1, outer)
262
263  {|echo 'yes'|}
264enddef
265
266def Test_block_failure()
267  CheckDefFailure(['{', 'var inner = 1', '}', 'echo inner'], 'E1001:')
268  CheckDefFailure(['}'], 'E1025:')
269  CheckDefFailure(['{', 'echo 1'], 'E1026:')
270enddef
271
272def Test_block_local_vars()
273  var lines =<< trim END
274      vim9script
275      v:testing = 1
276      if true
277        var text = ['hello']
278        def SayHello(): list<string>
279          return text
280        enddef
281        def SetText(v: string)
282          text = [v]
283        enddef
284      endif
285
286      if true
287        var text = ['again']
288        def SayAgain(): list<string>
289          return text
290        enddef
291      endif
292
293      # test that the "text" variables are not cleaned up
294      test_garbagecollect_now()
295
296      defcompile
297
298      assert_equal(['hello'], SayHello())
299      assert_equal(['again'], SayAgain())
300
301      SetText('foobar')
302      assert_equal(['foobar'], SayHello())
303
304      call writefile(['ok'], 'Xdidit')
305      qall!
306  END
307
308  # need to execute this with a separate Vim instance to avoid the current
309  # context gets garbage collected.
310  writefile(lines, 'Xscript')
311  RunVim([], [], '-S Xscript')
312  assert_equal(['ok'], readfile('Xdidit'))
313
314  delete('Xscript')
315  delete('Xdidit')
316enddef
317
318def Test_block_local_vars_with_func()
319  var lines =<< trim END
320      vim9script
321      if true
322        var foo = 'foo'
323        if true
324          var bar = 'bar'
325          def Func(): list<string>
326            return [foo, bar]
327          enddef
328        endif
329      endif
330      # function is compiled here, after blocks have finished, can still access
331      # "foo" and "bar"
332      assert_equal(['foo', 'bar'], Func())
333  END
334  CheckScriptSuccess(lines)
335enddef
336
337func g:NoSuchFunc()
338  echo 'none'
339endfunc
340
341def Test_try_catch_throw()
342  var l = []
343  try # comment
344    add(l, '1')
345    throw 'wrong'
346    add(l, '2')
347  catch # comment
348    add(l, v:exception)
349  finally # comment
350    add(l, '3')
351  endtry # comment
352  assert_equal(['1', 'wrong', '3'], l)
353
354  l = []
355  try
356    try
357      add(l, '1')
358      throw 'wrong'
359      add(l, '2')
360    catch /right/
361      add(l, v:exception)
362    endtry
363  catch /wrong/
364    add(l, 'caught')
365  fina
366    add(l, 'finally')
367  endtry
368  assert_equal(['1', 'caught', 'finally'], l)
369
370  var n: number
371  try
372    n = l[3]
373  catch /E684:/
374    n = 99
375  endtry
376  assert_equal(99, n)
377
378  var done = 'no'
379  if 0
380    try | catch | endtry
381  else
382    done = 'yes'
383  endif
384  assert_equal('yes', done)
385
386  done = 'no'
387  if 1
388    done = 'yes'
389  else
390    try | catch | endtry
391    done = 'never'
392  endif
393  assert_equal('yes', done)
394
395  if 1
396  else
397    try | catch /pat/ | endtry
398    try | catch /pat/
399    endtry
400    try
401    catch /pat/ | endtry
402    try
403    catch /pat/
404    endtry
405  endif
406
407  try
408    # string slice returns a string, not a number
409    n = g:astring[3]
410  catch /E1012:/
411    n = 77
412  endtry
413  assert_equal(77, n)
414
415  try
416    n = l[g:astring]
417  catch /E1012:/
418    n = 88
419  endtry
420  assert_equal(88, n)
421
422  try
423    n = s:does_not_exist
424  catch /E121:/
425    n = 111
426  endtry
427  assert_equal(111, n)
428
429  try
430    n = g:does_not_exist
431  catch /E121:/
432    n = 121
433  endtry
434  assert_equal(121, n)
435
436  var d = {one: 1}
437  try
438    n = d[g:astring]
439  catch /E716:/
440    n = 222
441  endtry
442  assert_equal(222, n)
443
444  try
445    n = -g:astring
446  catch /E39:/
447    n = 233
448  endtry
449  assert_equal(233, n)
450
451  try
452    n = +g:astring
453  catch /E1030:/
454    n = 244
455  endtry
456  assert_equal(244, n)
457
458  try
459    n = +g:alist
460  catch /E745:/
461    n = 255
462  endtry
463  assert_equal(255, n)
464
465  var nd: dict<any>
466  try
467    nd = {[g:alist]: 1}
468  catch /E1105:/
469    n = 266
470  endtry
471  assert_equal(266, n)
472
473  try
474    [n] = [1, 2, 3]
475  catch /E1093:/
476    n = 277
477  endtry
478  assert_equal(277, n)
479
480  try
481    &ts = g:astring
482  catch /E1012:/
483    n = 288
484  endtry
485  assert_equal(288, n)
486
487  try
488    &backspace = 'asdf'
489  catch /E474:/
490    n = 299
491  endtry
492  assert_equal(299, n)
493
494  l = [1]
495  try
496    l[3] = 3
497  catch /E684:/
498    n = 300
499  endtry
500  assert_equal(300, n)
501
502  try
503    unlet g:does_not_exist
504  catch /E108:/
505    n = 322
506  endtry
507  assert_equal(322, n)
508
509  try
510    d = {text: 1, [g:astring]: 2}
511  catch /E721:/
512    n = 333
513  endtry
514  assert_equal(333, n)
515
516  try
517    l = DeletedFunc()
518  catch /E933:/
519    n = 344
520  endtry
521  assert_equal(344, n)
522
523  try
524    echo len(v:true)
525  catch /E701:/
526    n = 355
527  endtry
528  assert_equal(355, n)
529
530  var P = function('g:NoSuchFunc')
531  delfunc g:NoSuchFunc
532  try
533    echo P()
534  catch /E117:/
535    n = 366
536  endtry
537  assert_equal(366, n)
538
539  try
540    echo g:NoSuchFunc()
541  catch /E117:/
542    n = 377
543  endtry
544  assert_equal(377, n)
545
546  try
547    echo g:alist + 4
548  catch /E745:/
549    n = 388
550  endtry
551  assert_equal(388, n)
552
553  try
554    echo 4 + g:alist
555  catch /E745:/
556    n = 399
557  endtry
558  assert_equal(399, n)
559
560  try
561    echo g:alist.member
562  catch /E715:/
563    n = 400
564  endtry
565  assert_equal(400, n)
566
567  try
568    echo d.member
569  catch /E716:/
570    n = 411
571  endtry
572  assert_equal(411, n)
573
574  var counter = 0
575  for i in range(4)
576    try
577      eval [][0]
578    catch
579    endtry
580    counter += 1
581  endfor
582  assert_equal(4, counter)
583
584  # return in finally after empty catch
585  def ReturnInFinally(): number
586    try
587    finally
588      return 4
589    endtry
590    return 2
591  enddef
592  assert_equal(4, ReturnInFinally())
593enddef
594
595" :while at the very start of a function that :continue jumps to
596def TryContinueFunc()
597 while g:Count < 2
598   g:sequence ..= 't'
599    try
600      echoerr 'Test'
601    catch
602      g:Count += 1
603      g:sequence ..= 'c'
604      continue
605    endtry
606    g:sequence ..= 'e'
607    g:Count += 1
608  endwhile
609enddef
610
611def Test_continue_in_try_in_while()
612  g:Count = 0
613  g:sequence = ''
614  TryContinueFunc()
615  assert_equal('tctc', g:sequence)
616  unlet g:Count
617  unlet g:sequence
618enddef
619
620def Test_nocatch_return_in_try()
621  # return in try block returns normally
622  def ReturnInTry(): string
623    try
624      return '"some message"'
625    catch
626    endtry
627    return 'not reached'
628  enddef
629  exe 'echoerr ' .. ReturnInTry()
630enddef
631
632def Test_cnext_works_in_catch()
633  var lines =<< trim END
634      vim9script
635      au BufEnter * eval 0
636      writefile(['text'], 'Xfile1')
637      writefile(['text'], 'Xfile2')
638      var items = [
639          {lnum: 1, filename: 'Xfile1', valid: true},
640          {lnum: 1, filename: 'Xfile2', valid: true}
641        ]
642      setqflist([], ' ', {items: items})
643      cwindow
644
645      def CnextOrCfirst()
646        # if cnext fails, cfirst is used
647        try
648          cnext
649        catch
650          cfirst
651        endtry
652      enddef
653
654      CnextOrCfirst()
655      CnextOrCfirst()
656      writefile([getqflist({idx: 0}).idx], 'Xresult')
657      qall
658  END
659  writefile(lines, 'XCatchCnext')
660  RunVim([], [], '--clean -S XCatchCnext')
661  assert_equal(['1'], readfile('Xresult'))
662
663  delete('Xfile1')
664  delete('Xfile2')
665  delete('XCatchCnext')
666  delete('Xresult')
667enddef
668
669def Test_throw_skipped()
670  if 0
671    throw dontgethere
672  endif
673enddef
674
675def Test_nocatch_throw_silenced()
676  var lines =<< trim END
677    vim9script
678    def Func()
679      throw 'error'
680    enddef
681    silent! Func()
682  END
683  writefile(lines, 'XthrowSilenced')
684  source XthrowSilenced
685  delete('XthrowSilenced')
686enddef
687
688def DeletedFunc(): list<any>
689  return ['delete me']
690enddef
691defcompile
692delfunc DeletedFunc
693
694def ThrowFromDef()
695  throw "getout" # comment
696enddef
697
698func CatchInFunc()
699  try
700    call ThrowFromDef()
701  catch
702    let g:thrown_func = v:exception
703  endtry
704endfunc
705
706def CatchInDef()
707  try
708    ThrowFromDef()
709  catch
710    g:thrown_def = v:exception
711  endtry
712enddef
713
714def ReturnFinally(): string
715  try
716    return 'intry'
717  finall
718    g:in_finally = 'finally'
719  endtry
720  return 'end'
721enddef
722
723def Test_try_catch_nested()
724  CatchInFunc()
725  assert_equal('getout', g:thrown_func)
726
727  CatchInDef()
728  assert_equal('getout', g:thrown_def)
729
730  assert_equal('intry', ReturnFinally())
731  assert_equal('finally', g:in_finally)
732enddef
733
734def TryOne(): number
735  try
736    return 0
737  catch
738  endtry
739  return 0
740enddef
741
742def TryTwo(n: number): string
743  try
744    var x = {}
745  catch
746  endtry
747  return 'text'
748enddef
749
750def Test_try_catch_twice()
751  assert_equal('text', TryOne()->TryTwo())
752enddef
753
754def Test_try_catch_match()
755  var seq = 'a'
756  try
757    throw 'something'
758  catch /nothing/
759    seq ..= 'x'
760  catch /some/
761    seq ..= 'b'
762  catch /asdf/
763    seq ..= 'x'
764  catch ?a\?sdf?
765    seq ..= 'y'
766  finally
767    seq ..= 'c'
768  endtry
769  assert_equal('abc', seq)
770enddef
771
772def Test_try_catch_fails()
773  CheckDefFailure(['catch'], 'E603:')
774  CheckDefFailure(['try', 'echo 0', 'catch', 'catch'], 'E1033:')
775  CheckDefFailure(['try', 'echo 0', 'catch /pat'], 'E1067:')
776  CheckDefFailure(['finally'], 'E606:')
777  CheckDefFailure(['try', 'echo 0', 'finally', 'echo 1', 'finally'], 'E607:')
778  CheckDefFailure(['endtry'], 'E602:')
779  CheckDefFailure(['while 1', 'endtry'], 'E170:')
780  CheckDefFailure(['for i in range(5)', 'endtry'], 'E170:')
781  CheckDefFailure(['if 1', 'endtry'], 'E171:')
782  CheckDefFailure(['try', 'echo 1', 'endtry'], 'E1032:')
783
784  CheckDefFailure(['throw'], 'E1143:')
785  CheckDefFailure(['throw xxx'], 'E1001:')
786enddef
787
788def Try_catch_skipped()
789  var l = []
790  try
791  finally
792  endtry
793
794  if 1
795  else
796    try
797    endtry
798  endif
799enddef
800
801" The skipped try/endtry was updating the wrong instruction.
802def Test_try_catch_skipped()
803  var instr = execute('disassemble Try_catch_skipped')
804  assert_match("NEWLIST size 0\n", instr)
805enddef
806
807
808
809def Test_throw_vimscript()
810  # only checks line continuation
811  var lines =<< trim END
812      vim9script
813      try
814        throw 'one'
815              .. 'two'
816      catch
817        assert_equal('onetwo', v:exception)
818      endtry
819  END
820  CheckScriptSuccess(lines)
821
822  lines =<< trim END
823    vim9script
824    @r = ''
825    def Func()
826      throw @r
827    enddef
828    var result = ''
829    try
830      Func()
831    catch /E1129:/
832      result = 'caught'
833    endtry
834    assert_equal('caught', result)
835  END
836  CheckScriptSuccess(lines)
837enddef
838
839def Test_error_in_nested_function()
840  # an error in a nested :function aborts executing in the calling :def function
841  var lines =<< trim END
842      vim9script
843      def Func()
844        Error()
845        g:test_var = 1
846      enddef
847      func Error() abort
848        eval [][0]
849      endfunc
850      Func()
851  END
852  g:test_var = 0
853  CheckScriptFailure(lines, 'E684:')
854  assert_equal(0, g:test_var)
855enddef
856
857def Test_cexpr_vimscript()
858  # only checks line continuation
859  set errorformat=File\ %f\ line\ %l
860  var lines =<< trim END
861      vim9script
862      cexpr 'File'
863                .. ' someFile' ..
864                   ' line 19'
865      assert_equal(19, getqflist()[0].lnum)
866  END
867  CheckScriptSuccess(lines)
868  set errorformat&
869enddef
870
871def Test_statusline_syntax()
872  # legacy syntax is used for 'statusline'
873  var lines =<< trim END
874      vim9script
875      func g:Status()
876        return '%{"x" is# "x"}'
877      endfunc
878      set laststatus=2 statusline=%!Status()
879      redrawstatus
880      set laststatus statusline=
881  END
882  CheckScriptSuccess(lines)
883enddef
884
885def Test_list_vimscript()
886  # checks line continuation and comments
887  var lines =<< trim END
888      vim9script
889      var mylist = [
890            'one',
891            # comment
892            'two', # empty line follows
893
894            'three',
895            ]
896      assert_equal(['one', 'two', 'three'], mylist)
897  END
898  CheckScriptSuccess(lines)
899
900  # check all lines from heredoc are kept
901  lines =<< trim END
902      # comment 1
903      two
904      # comment 3
905
906      five
907      # comment 6
908  END
909  assert_equal(['# comment 1', 'two', '# comment 3', '', 'five', '# comment 6'], lines)
910
911  lines =<< trim END
912    [{
913      a: 0}]->string()->assert_equal("[{'a': 0}]")
914  END
915  CheckDefAndScriptSuccess(lines)
916enddef
917
918if has('channel')
919  let someJob = test_null_job()
920
921  def FuncWithError()
922    echomsg g:someJob
923  enddef
924
925  func Test_convert_emsg_to_exception()
926    try
927      call FuncWithError()
928    catch
929      call assert_match('Vim:E908:', v:exception)
930    endtry
931  endfunc
932endif
933
934let s:export_script_lines =<< trim END
935  vim9script
936  var name: string = 'bob'
937  def Concat(arg: string): string
938    return name .. arg
939  enddef
940  g:result = Concat('bie')
941  g:localname = name
942
943  export const CONST = 1234
944  export var exported = 9876
945  export var exp_name = 'John'
946  export def Exported(): string
947    return 'Exported'
948  enddef
949  export final theList = [1]
950END
951
952def Undo_export_script_lines()
953  unlet g:result
954  unlet g:localname
955enddef
956
957def Test_vim9_import_export()
958  var import_script_lines =<< trim END
959    vim9script
960    import {exported, Exported} from './Xexport.vim'
961    g:imported = exported
962    exported += 3
963    g:imported_added = exported
964    g:imported_func = Exported()
965
966    def GetExported(): string
967      var local_dict = {ref: Exported}
968      return local_dict.ref()
969    enddef
970    g:funcref_result = GetExported()
971
972    import {exp_name} from './Xexport.vim'
973    g:imported_name = exp_name
974    exp_name ..= ' Doe'
975    g:imported_name_appended = exp_name
976    g:imported_later = exported
977
978    import theList from './Xexport.vim'
979    theList->add(2)
980    assert_equal([1, 2], theList)
981  END
982
983  writefile(import_script_lines, 'Ximport.vim')
984  writefile(s:export_script_lines, 'Xexport.vim')
985
986  source Ximport.vim
987
988  assert_equal('bobbie', g:result)
989  assert_equal('bob', g:localname)
990  assert_equal(9876, g:imported)
991  assert_equal(9879, g:imported_added)
992  assert_equal(9879, g:imported_later)
993  assert_equal('Exported', g:imported_func)
994  assert_equal('Exported', g:funcref_result)
995  assert_equal('John', g:imported_name)
996  assert_equal('John Doe', g:imported_name_appended)
997  assert_false(exists('g:name'))
998
999  Undo_export_script_lines()
1000  unlet g:imported
1001  unlet g:imported_added
1002  unlet g:imported_later
1003  unlet g:imported_func
1004  unlet g:imported_name g:imported_name_appended
1005  delete('Ximport.vim')
1006
1007  # similar, with line breaks
1008  var import_line_break_script_lines =<< trim END
1009    vim9script
1010    import {
1011        exported,
1012        Exported,
1013        }
1014        from
1015        './Xexport.vim'
1016    g:imported = exported
1017    exported += 5
1018    g:imported_added = exported
1019    g:imported_func = Exported()
1020  END
1021  writefile(import_line_break_script_lines, 'Ximport_lbr.vim')
1022  source Ximport_lbr.vim
1023
1024  assert_equal(9876, g:imported)
1025  assert_equal(9881, g:imported_added)
1026  assert_equal('Exported', g:imported_func)
1027
1028  # exported script not sourced again
1029  assert_false(exists('g:result'))
1030  unlet g:imported
1031  unlet g:imported_added
1032  unlet g:imported_func
1033  delete('Ximport_lbr.vim')
1034
1035  # import inside :def function
1036  var import_in_def_lines =<< trim END
1037    vim9script
1038    def ImportInDef()
1039      import exported from './Xexport.vim'
1040      g:imported = exported
1041      exported += 7
1042      g:imported_added = exported
1043    enddef
1044    ImportInDef()
1045  END
1046  writefile(import_in_def_lines, 'Ximport2.vim')
1047  source Ximport2.vim
1048  # TODO: this should be 9879
1049  assert_equal(9876, g:imported)
1050  assert_equal(9883, g:imported_added)
1051  unlet g:imported
1052  unlet g:imported_added
1053  delete('Ximport2.vim')
1054
1055  var import_star_as_lines =<< trim END
1056    vim9script
1057    import * as Export from './Xexport.vim'
1058    def UseExport()
1059      g:imported_def = Export.exported
1060    enddef
1061    g:imported_script = Export.exported
1062    assert_equal(1, exists('Export.exported'))
1063    assert_equal(0, exists('Export.notexported'))
1064    UseExport()
1065  END
1066  writefile(import_star_as_lines, 'Ximport.vim')
1067  source Ximport.vim
1068  assert_equal(9883, g:imported_def)
1069  assert_equal(9883, g:imported_script)
1070
1071  var import_star_as_lines_no_dot =<< trim END
1072    vim9script
1073    import * as Export from './Xexport.vim'
1074    def Func()
1075      var dummy = 1
1076      var imported = Export + dummy
1077    enddef
1078    defcompile
1079  END
1080  writefile(import_star_as_lines_no_dot, 'Ximport.vim')
1081  assert_fails('source Ximport.vim', 'E1060:', '', 2, 'Func')
1082
1083  var import_star_as_lines_dot_space =<< trim END
1084    vim9script
1085    import * as Export from './Xexport.vim'
1086    def Func()
1087      var imported = Export . exported
1088    enddef
1089    defcompile
1090  END
1091  writefile(import_star_as_lines_dot_space, 'Ximport.vim')
1092  assert_fails('source Ximport.vim', 'E1074:', '', 1, 'Func')
1093
1094  var import_star_as_duplicated =<< trim END
1095    vim9script
1096    import * as Export from './Xexport.vim'
1097    var some = 'other'
1098    import * as Export from './Xexport.vim'
1099    defcompile
1100  END
1101  writefile(import_star_as_duplicated, 'Ximport.vim')
1102  assert_fails('source Ximport.vim', 'E1073:', '', 4, 'Ximport.vim')
1103
1104  var import_star_as_lines_script_no_dot =<< trim END
1105    vim9script
1106    import * as Export from './Xexport.vim'
1107    g:imported_script = Export exported
1108  END
1109  writefile(import_star_as_lines_script_no_dot, 'Ximport.vim')
1110  assert_fails('source Ximport.vim', 'E1029:')
1111
1112  var import_star_as_lines_script_space_after_dot =<< trim END
1113    vim9script
1114    import * as Export from './Xexport.vim'
1115    g:imported_script = Export. exported
1116  END
1117  writefile(import_star_as_lines_script_space_after_dot, 'Ximport.vim')
1118  assert_fails('source Ximport.vim', 'E1074:')
1119
1120  var import_star_as_lines_missing_name =<< trim END
1121    vim9script
1122    import * as Export from './Xexport.vim'
1123    def Func()
1124      var imported = Export.
1125    enddef
1126    defcompile
1127  END
1128  writefile(import_star_as_lines_missing_name, 'Ximport.vim')
1129  assert_fails('source Ximport.vim', 'E1048:', '', 1, 'Func')
1130
1131  var import_star_as_lbr_lines =<< trim END
1132    vim9script
1133    import *
1134        as Export
1135        from
1136        './Xexport.vim'
1137    def UseExport()
1138      g:imported = Export.exported
1139    enddef
1140    UseExport()
1141  END
1142  writefile(import_star_as_lbr_lines, 'Ximport.vim')
1143  source Ximport.vim
1144  assert_equal(9883, g:imported)
1145
1146  var import_star_lines =<< trim END
1147    vim9script
1148    import * from './Xexport.vim'
1149  END
1150  writefile(import_star_lines, 'Ximport.vim')
1151  assert_fails('source Ximport.vim', 'E1045:', '', 2, 'Ximport.vim')
1152
1153  # try to import something that exists but is not exported
1154  var import_not_exported_lines =<< trim END
1155    vim9script
1156    import name from './Xexport.vim'
1157  END
1158  writefile(import_not_exported_lines, 'Ximport.vim')
1159  assert_fails('source Ximport.vim', 'E1049:', '', 2, 'Ximport.vim')
1160
1161  # try to import something that is already defined
1162  var import_already_defined =<< trim END
1163    vim9script
1164    var exported = 'something'
1165    import exported from './Xexport.vim'
1166  END
1167  writefile(import_already_defined, 'Ximport.vim')
1168  assert_fails('source Ximport.vim', 'E1054:', '', 3, 'Ximport.vim')
1169
1170  # try to import something that is already defined
1171  import_already_defined =<< trim END
1172    vim9script
1173    var exported = 'something'
1174    import * as exported from './Xexport.vim'
1175  END
1176  writefile(import_already_defined, 'Ximport.vim')
1177  assert_fails('source Ximport.vim', 'E1054:', '', 3, 'Ximport.vim')
1178
1179  # try to import something that is already defined
1180  import_already_defined =<< trim END
1181    vim9script
1182    var exported = 'something'
1183    import {exported} from './Xexport.vim'
1184  END
1185  writefile(import_already_defined, 'Ximport.vim')
1186  assert_fails('source Ximport.vim', 'E1054:', '', 3, 'Ximport.vim')
1187
1188  # try changing an imported const
1189  var import_assign_to_const =<< trim END
1190    vim9script
1191    import CONST from './Xexport.vim'
1192    def Assign()
1193      CONST = 987
1194    enddef
1195    defcompile
1196  END
1197  writefile(import_assign_to_const, 'Ximport.vim')
1198  assert_fails('source Ximport.vim', 'E46:', '', 1, '_Assign')
1199
1200  # try changing an imported final
1201  var import_assign_to_final =<< trim END
1202    vim9script
1203    import theList from './Xexport.vim'
1204    def Assign()
1205      theList = [2]
1206    enddef
1207    defcompile
1208  END
1209  writefile(import_assign_to_final, 'Ximport.vim')
1210  assert_fails('source Ximport.vim', 'E46:', '', 1, '_Assign')
1211
1212  # import a very long name, requires making a copy
1213  var import_long_name_lines =<< trim END
1214    vim9script
1215    import name012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789 from './Xexport.vim'
1216  END
1217  writefile(import_long_name_lines, 'Ximport.vim')
1218  assert_fails('source Ximport.vim', 'E1048:', '', 2, 'Ximport.vim')
1219
1220  var import_no_from_lines =<< trim END
1221    vim9script
1222    import name './Xexport.vim'
1223  END
1224  writefile(import_no_from_lines, 'Ximport.vim')
1225  assert_fails('source Ximport.vim', 'E1070:', '', 2, 'Ximport.vim')
1226
1227  var import_invalid_string_lines =<< trim END
1228    vim9script
1229    import name from Xexport.vim
1230  END
1231  writefile(import_invalid_string_lines, 'Ximport.vim')
1232  assert_fails('source Ximport.vim', 'E1071:', '', 2, 'Ximport.vim')
1233
1234  var import_wrong_name_lines =<< trim END
1235    vim9script
1236    import name from './XnoExport.vim'
1237  END
1238  writefile(import_wrong_name_lines, 'Ximport.vim')
1239  assert_fails('source Ximport.vim', 'E1053:', '', 2, 'Ximport.vim')
1240
1241  var import_missing_comma_lines =<< trim END
1242    vim9script
1243    import {exported name} from './Xexport.vim'
1244  END
1245  writefile(import_missing_comma_lines, 'Ximport3.vim')
1246  assert_fails('source Ximport3.vim', 'E1046:', '', 2, 'Ximport3.vim')
1247
1248  delete('Ximport.vim')
1249  delete('Ximport3.vim')
1250  delete('Xexport.vim')
1251
1252  # Check that in a Vim9 script 'cpo' is set to the Vim default.
1253  # Flags added or removed are also applied to the restored value.
1254  set cpo=abcd
1255  var lines =<< trim END
1256    vim9script
1257    g:cpo_in_vim9script = &cpo
1258    set cpo+=f
1259    set cpo-=c
1260    g:cpo_after_vim9script = &cpo
1261  END
1262  writefile(lines, 'Xvim9_script')
1263  source Xvim9_script
1264  assert_equal('fabd', &cpo)
1265  set cpo&vim
1266  assert_equal(&cpo, g:cpo_in_vim9script)
1267  var newcpo = substitute(&cpo, 'c', '', '') .. 'f'
1268  assert_equal(newcpo, g:cpo_after_vim9script)
1269
1270  delete('Xvim9_script')
1271enddef
1272
1273def Test_import_as()
1274  var export_lines =<< trim END
1275    vim9script
1276    export var one = 1
1277    export var yes = 'yes'
1278  END
1279  writefile(export_lines, 'XexportAs')
1280
1281  var import_lines =<< trim END
1282    vim9script
1283    import one as thatOne from './XexportAs'
1284    assert_equal(1, thatOne)
1285    import yes as yesYes from './XexportAs'
1286    assert_equal('yes', yesYes)
1287  END
1288  CheckScriptSuccess(import_lines)
1289
1290  import_lines =<< trim END
1291    vim9script
1292    import {one as thatOne, yes as yesYes} from './XexportAs'
1293    assert_equal(1, thatOne)
1294    assert_equal('yes', yesYes)
1295    assert_fails('echo one', 'E121:')
1296    assert_fails('echo yes', 'E121:')
1297  END
1298  CheckScriptSuccess(import_lines)
1299
1300  delete('XexportAs')
1301enddef
1302
1303func g:Trigger()
1304  source Ximport.vim
1305  return "echo 'yes'\<CR>"
1306endfunc
1307
1308def Test_import_export_expr_map()
1309  # check that :import and :export work when buffer is locked
1310  var export_lines =<< trim END
1311    vim9script
1312    export def That(): string
1313      return 'yes'
1314    enddef
1315  END
1316  writefile(export_lines, 'Xexport_that.vim')
1317
1318  var import_lines =<< trim END
1319    vim9script
1320    import That from './Xexport_that.vim'
1321    assert_equal('yes', That())
1322  END
1323  writefile(import_lines, 'Ximport.vim')
1324
1325  nnoremap <expr> trigger g:Trigger()
1326  feedkeys('trigger', "xt")
1327
1328  delete('Xexport_that.vim')
1329  delete('Ximport.vim')
1330  nunmap trigger
1331enddef
1332
1333def Test_import_in_filetype()
1334  # check that :import works when the buffer is locked
1335  mkdir('ftplugin', 'p')
1336  var export_lines =<< trim END
1337    vim9script
1338    export var That = 'yes'
1339  END
1340  writefile(export_lines, 'ftplugin/Xexport_ft.vim')
1341
1342  var import_lines =<< trim END
1343    vim9script
1344    import That from './Xexport_ft.vim'
1345    assert_equal('yes', That)
1346    g:did_load_mytpe = 1
1347  END
1348  writefile(import_lines, 'ftplugin/qf.vim')
1349
1350  var save_rtp = &rtp
1351  &rtp = getcwd() .. ',' .. &rtp
1352
1353  filetype plugin on
1354  copen
1355  assert_equal(1, g:did_load_mytpe)
1356
1357  quit!
1358  delete('Xexport_ft.vim')
1359  delete('ftplugin', 'rf')
1360  &rtp = save_rtp
1361enddef
1362
1363def Test_use_import_in_mapping()
1364  var lines =<< trim END
1365      vim9script
1366      export def Funcx()
1367        g:result = 42
1368      enddef
1369  END
1370  writefile(lines, 'XsomeExport.vim')
1371  lines =<< trim END
1372      vim9script
1373      import Funcx from './XsomeExport.vim'
1374      nnoremap <F3> :call <sid>Funcx()<cr>
1375  END
1376  writefile(lines, 'Xmapscript.vim')
1377
1378  source Xmapscript.vim
1379  feedkeys("\<F3>", "xt")
1380  assert_equal(42, g:result)
1381
1382  unlet g:result
1383  delete('XsomeExport.vim')
1384  delete('Xmapscript.vim')
1385  nunmap <F3>
1386enddef
1387
1388def Test_vim9script_mix()
1389  var lines =<< trim END
1390    if has(g:feature)
1391      " legacy script
1392      let g:legacy = 1
1393      finish
1394    endif
1395    vim9script
1396    g:legacy = 0
1397  END
1398  g:feature = 'eval'
1399  g:legacy = -1
1400  CheckScriptSuccess(lines)
1401  assert_equal(1, g:legacy)
1402
1403  g:feature = 'noteval'
1404  g:legacy = -1
1405  CheckScriptSuccess(lines)
1406  assert_equal(0, g:legacy)
1407enddef
1408
1409def Test_vim9script_fails()
1410  CheckScriptFailure(['scriptversion 2', 'vim9script'], 'E1039:')
1411  CheckScriptFailure(['vim9script', 'scriptversion 2'], 'E1040:')
1412  CheckScriptFailure(['export var some = 123'], 'E1042:')
1413  CheckScriptFailure(['import some from "./Xexport.vim"'], 'E1048:')
1414  CheckScriptFailure(['vim9script', 'export var g:some'], 'E1022:')
1415  CheckScriptFailure(['vim9script', 'export echo 134'], 'E1043:')
1416
1417  CheckScriptFailure(['vim9script', 'var str: string', 'str = 1234'], 'E1012:')
1418  CheckScriptFailure(['vim9script', 'const str = "asdf"', 'str = "xxx"'], 'E46:')
1419
1420  assert_fails('vim9script', 'E1038:')
1421  assert_fails('export something', 'E1043:')
1422enddef
1423
1424func Test_import_fails_without_script()
1425  CheckRunVimInTerminal
1426
1427  " call indirectly to avoid compilation error for missing functions
1428  call Run_Test_import_fails_on_command_line()
1429endfunc
1430
1431def Run_Test_import_fails_on_command_line()
1432  var export =<< trim END
1433    vim9script
1434    export def Foo(): number
1435        return 0
1436    enddef
1437  END
1438  writefile(export, 'XexportCmd.vim')
1439
1440  var buf = RunVimInTerminal('-c "import Foo from ''./XexportCmd.vim''"', {
1441                rows: 6, wait_for_ruler: 0})
1442  WaitForAssert(() => assert_match('^E1094:', term_getline(buf, 5)))
1443
1444  delete('XexportCmd.vim')
1445  StopVimInTerminal(buf)
1446enddef
1447
1448def Test_vim9script_reload_noclear()
1449  var lines =<< trim END
1450    vim9script
1451    export var exported = 'thexport'
1452  END
1453  writefile(lines, 'XExportReload')
1454  lines =<< trim END
1455    vim9script noclear
1456    g:loadCount += 1
1457    var s:reloaded = 'init'
1458    import exported from './XExportReload'
1459
1460    def Again(): string
1461      return 'again'
1462    enddef
1463
1464    if exists('s:loaded') | finish | endif
1465    var s:loaded = true
1466
1467    var s:notReloaded = 'yes'
1468    s:reloaded = 'first'
1469    def g:Values(): list<string>
1470      return [s:reloaded, s:notReloaded, Again(), Once(), exported]
1471    enddef
1472
1473    def Once(): string
1474      return 'once'
1475    enddef
1476  END
1477  writefile(lines, 'XReloaded')
1478  g:loadCount = 0
1479  source XReloaded
1480  assert_equal(1, g:loadCount)
1481  assert_equal(['first', 'yes', 'again', 'once', 'thexport'], g:Values())
1482  source XReloaded
1483  assert_equal(2, g:loadCount)
1484  assert_equal(['init', 'yes', 'again', 'once', 'thexport'], g:Values())
1485  source XReloaded
1486  assert_equal(3, g:loadCount)
1487  assert_equal(['init', 'yes', 'again', 'once', 'thexport'], g:Values())
1488
1489  delete('XReloaded')
1490  delete('XExportReload')
1491  delfunc g:Values
1492  unlet g:loadCount
1493enddef
1494
1495def Test_vim9script_reload_import()
1496  var lines =<< trim END
1497    vim9script
1498    const var = ''
1499    var valone = 1234
1500    def MyFunc(arg: string)
1501       valone = 5678
1502    enddef
1503  END
1504  var morelines =<< trim END
1505    var valtwo = 222
1506    export def GetValtwo(): number
1507      return valtwo
1508    enddef
1509  END
1510  writefile(lines + morelines, 'Xreload.vim')
1511  source Xreload.vim
1512  source Xreload.vim
1513  source Xreload.vim
1514
1515  var testlines =<< trim END
1516    vim9script
1517    def TheFunc()
1518      import GetValtwo from './Xreload.vim'
1519      assert_equal(222, GetValtwo())
1520    enddef
1521    TheFunc()
1522  END
1523  writefile(testlines, 'Ximport.vim')
1524  source Ximport.vim
1525
1526  # Test that when not using "morelines" GetValtwo() and valtwo are still
1527  # defined, because import doesn't reload a script.
1528  writefile(lines, 'Xreload.vim')
1529  source Ximport.vim
1530
1531  # cannot declare a var twice
1532  lines =<< trim END
1533    vim9script
1534    var valone = 1234
1535    var valone = 5678
1536  END
1537  writefile(lines, 'Xreload.vim')
1538  assert_fails('source Xreload.vim', 'E1041:', '', 3, 'Xreload.vim')
1539
1540  delete('Xreload.vim')
1541  delete('Ximport.vim')
1542enddef
1543
1544" if a script is reloaded with a script-local variable that changed its type, a
1545" compiled function using that variable must fail.
1546def Test_script_reload_change_type()
1547  var lines =<< trim END
1548    vim9script noclear
1549    var str = 'string'
1550    def g:GetStr(): string
1551      return str .. 'xxx'
1552    enddef
1553  END
1554  writefile(lines, 'Xreload.vim')
1555  source Xreload.vim
1556  echo g:GetStr()
1557
1558  lines =<< trim END
1559    vim9script noclear
1560    var str = 1234
1561  END
1562  writefile(lines, 'Xreload.vim')
1563  source Xreload.vim
1564  assert_fails('echo g:GetStr()', 'E1150:')
1565
1566  delfunc g:GetStr
1567  delete('Xreload.vim')
1568enddef
1569
1570" Define CallFunc so that the test can be compiled
1571command CallFunc echo 'nop'
1572
1573def Test_script_reload_from_function()
1574  var lines =<< trim END
1575      vim9script
1576
1577      if exists('g:loaded')
1578        finish
1579      endif
1580      g:loaded = 1
1581      delcommand CallFunc
1582      command CallFunc Func()
1583      def Func()
1584        so XreloadFunc.vim
1585        g:didTheFunc = 1
1586      enddef
1587  END
1588  writefile(lines, 'XreloadFunc.vim')
1589  source XreloadFunc.vim
1590  CallFunc
1591  assert_equal(1, g:didTheFunc)
1592
1593  delete('XreloadFunc.vim')
1594  delcommand CallFunc
1595  unlet g:loaded
1596  unlet g:didTheFunc
1597enddef
1598
1599def Test_script_var_shadows_function()
1600  var lines =<< trim END
1601      vim9script
1602      def Func(): number
1603        return 123
1604      enddef
1605      var Func = 1
1606  END
1607  CheckScriptFailure(lines, 'E1041:', 5)
1608enddef
1609
1610def s:RetSome(): string
1611  return 'some'
1612enddef
1613
1614" Not exported function that is referenced needs to be accessed by the
1615" script-local name.
1616def Test_vim9script_funcref()
1617  var sortlines =<< trim END
1618      vim9script
1619      def Compare(i1: number, i2: number): number
1620        return i2 - i1
1621      enddef
1622
1623      export def FastSort(): list<number>
1624        return range(5)->sort(Compare)
1625      enddef
1626
1627      export def GetString(arg: string): string
1628        return arg
1629      enddef
1630  END
1631  writefile(sortlines, 'Xsort.vim')
1632
1633  var lines =<< trim END
1634    vim9script
1635    import FastSort from './Xsort.vim'
1636    def Test()
1637      g:result = FastSort()
1638    enddef
1639    Test()
1640
1641    # using a function imported with "as"
1642    import * as anAlias from './Xsort.vim'
1643    assert_equal('yes', anAlias.GetString('yes'))
1644
1645    # using the function from a compiled function
1646    def TestMore(): string
1647      var s = s:anAlias.GetString('foo')
1648      return s .. anAlias.GetString('bar')
1649    enddef
1650    assert_equal('foobar', TestMore())
1651
1652    # error when using a function that isn't exported
1653    assert_fails('anAlias.Compare(1, 2)', 'E1049:')
1654  END
1655  writefile(lines, 'Xscript.vim')
1656
1657  source Xscript.vim
1658  assert_equal([4, 3, 2, 1, 0], g:result)
1659
1660  unlet g:result
1661  delete('Xsort.vim')
1662  delete('Xscript.vim')
1663
1664  var Funcref = function('s:RetSome')
1665  assert_equal('some', Funcref())
1666enddef
1667
1668" Check that when searching for "FilterFunc" it finds the import in the
1669" script where FastFilter() is called from, both as a string and as a direct
1670" function reference.
1671def Test_vim9script_funcref_other_script()
1672  var filterLines =<< trim END
1673    vim9script
1674    export def FilterFunc(idx: number, val: number): bool
1675      return idx % 2 == 1
1676    enddef
1677    export def FastFilter(): list<number>
1678      return range(10)->filter('FilterFunc')
1679    enddef
1680    export def FastFilterDirect(): list<number>
1681      return range(10)->filter(FilterFunc)
1682    enddef
1683  END
1684  writefile(filterLines, 'Xfilter.vim')
1685
1686  var lines =<< trim END
1687    vim9script
1688    import {FilterFunc, FastFilter, FastFilterDirect} from './Xfilter.vim'
1689    def Test()
1690      var x: list<number> = FastFilter()
1691    enddef
1692    Test()
1693    def TestDirect()
1694      var x: list<number> = FastFilterDirect()
1695    enddef
1696    TestDirect()
1697  END
1698  CheckScriptSuccess(lines)
1699  delete('Xfilter.vim')
1700enddef
1701
1702def Test_vim9script_reload_delfunc()
1703  var first_lines =<< trim END
1704    vim9script
1705    def FuncYes(): string
1706      return 'yes'
1707    enddef
1708  END
1709  var withno_lines =<< trim END
1710    def FuncNo(): string
1711      return 'no'
1712    enddef
1713    def g:DoCheck(no_exists: bool)
1714      assert_equal('yes', FuncYes())
1715      assert_equal('no', FuncNo())
1716    enddef
1717  END
1718  var nono_lines =<< trim END
1719    def g:DoCheck(no_exists: bool)
1720      assert_equal('yes', FuncYes())
1721      assert_fails('FuncNo()', 'E117:', '', 2, 'DoCheck')
1722    enddef
1723  END
1724
1725  # FuncNo() is defined
1726  writefile(first_lines + withno_lines, 'Xreloaded.vim')
1727  source Xreloaded.vim
1728  g:DoCheck(true)
1729
1730  # FuncNo() is not redefined
1731  writefile(first_lines + nono_lines, 'Xreloaded.vim')
1732  source Xreloaded.vim
1733  g:DoCheck(false)
1734
1735  # FuncNo() is back
1736  writefile(first_lines + withno_lines, 'Xreloaded.vim')
1737  source Xreloaded.vim
1738  g:DoCheck(false)
1739
1740  delete('Xreloaded.vim')
1741enddef
1742
1743def Test_vim9script_reload_delvar()
1744  # write the script with a script-local variable
1745  var lines =<< trim END
1746    vim9script
1747    var name = 'string'
1748  END
1749  writefile(lines, 'XreloadVar.vim')
1750  source XreloadVar.vim
1751
1752  # now write the script using the same variable locally - works
1753  lines =<< trim END
1754    vim9script
1755    def Func()
1756      var name = 'string'
1757    enddef
1758  END
1759  writefile(lines, 'XreloadVar.vim')
1760  source XreloadVar.vim
1761
1762  delete('XreloadVar.vim')
1763enddef
1764
1765def Test_import_absolute()
1766  var import_lines = [
1767        'vim9script',
1768        'import exported from "' .. escape(getcwd(), '\') .. '/Xexport_abs.vim"',
1769        'def UseExported()',
1770        '  g:imported_abs = exported',
1771        '  exported = 8888',
1772        '  g:imported_after = exported',
1773        'enddef',
1774        'UseExported()',
1775        'g:import_disassembled = execute("disass UseExported")',
1776        ]
1777  writefile(import_lines, 'Ximport_abs.vim')
1778  writefile(s:export_script_lines, 'Xexport_abs.vim')
1779
1780  source Ximport_abs.vim
1781
1782  assert_equal(9876, g:imported_abs)
1783  assert_equal(8888, g:imported_after)
1784  assert_match('<SNR>\d\+_UseExported\_s*' ..
1785          'g:imported_abs = exported\_s*' ..
1786          '0 LOADSCRIPT exported-2 from .*Xexport_abs.vim\_s*' ..
1787          '1 STOREG g:imported_abs\_s*' ..
1788          'exported = 8888\_s*' ..
1789          '2 PUSHNR 8888\_s*' ..
1790          '3 STORESCRIPT exported-2 in .*Xexport_abs.vim\_s*' ..
1791          'g:imported_after = exported\_s*' ..
1792          '4 LOADSCRIPT exported-2 from .*Xexport_abs.vim\_s*' ..
1793          '5 STOREG g:imported_after',
1794        g:import_disassembled)
1795
1796  Undo_export_script_lines()
1797  unlet g:imported_abs
1798  unlet g:import_disassembled
1799
1800  delete('Ximport_abs.vim')
1801  delete('Xexport_abs.vim')
1802enddef
1803
1804def Test_import_rtp()
1805  var import_lines = [
1806        'vim9script',
1807        'import exported from "Xexport_rtp.vim"',
1808        'g:imported_rtp = exported',
1809        ]
1810  writefile(import_lines, 'Ximport_rtp.vim')
1811  mkdir('import')
1812  writefile(s:export_script_lines, 'import/Xexport_rtp.vim')
1813
1814  var save_rtp = &rtp
1815  &rtp = getcwd()
1816  source Ximport_rtp.vim
1817  &rtp = save_rtp
1818
1819  assert_equal(9876, g:imported_rtp)
1820
1821  Undo_export_script_lines()
1822  unlet g:imported_rtp
1823  delete('Ximport_rtp.vim')
1824  delete('import', 'rf')
1825enddef
1826
1827def Test_import_compile_error()
1828  var export_lines = [
1829        'vim9script',
1830        'export def ExpFunc(): string',
1831        '  return notDefined',
1832        'enddef',
1833        ]
1834  writefile(export_lines, 'Xexported.vim')
1835
1836  var import_lines = [
1837        'vim9script',
1838        'import ExpFunc from "./Xexported.vim"',
1839        'def ImpFunc()',
1840        '  echo ExpFunc()',
1841        'enddef',
1842        'defcompile',
1843        ]
1844  writefile(import_lines, 'Ximport.vim')
1845
1846  try
1847    source Ximport.vim
1848  catch /E1001/
1849    # Error should be fore the Xexported.vim file.
1850    assert_match('E1001: Variable not found: notDefined', v:exception)
1851    assert_match('function <SNR>\d\+_ImpFunc\[1\]..<SNR>\d\+_ExpFunc, line 1', v:throwpoint)
1852  endtry
1853
1854  delete('Xexported.vim')
1855  delete('Ximport.vim')
1856enddef
1857
1858def Test_func_redefine_error()
1859  var lines = [
1860        'vim9script',
1861        'def Func()',
1862        '  eval [][0]',
1863        'enddef',
1864        'Func()',
1865        ]
1866  writefile(lines, 'Xtestscript.vim')
1867
1868  for count in range(3)
1869    try
1870      source Xtestscript.vim
1871    catch /E684/
1872      # function name should contain <SNR> every time
1873      assert_match('E684: list index out of range', v:exception)
1874      assert_match('function <SNR>\d\+_Func, line 1', v:throwpoint)
1875    endtry
1876  endfor
1877
1878  delete('Xtestscript.vim')
1879enddef
1880
1881def Test_func_overrules_import_fails()
1882  var export_lines =<< trim END
1883      vim9script
1884      export def Func()
1885        echo 'imported'
1886      enddef
1887  END
1888  writefile(export_lines, 'XexportedFunc.vim')
1889
1890  var lines =<< trim END
1891    vim9script
1892    import Func from './XexportedFunc.vim'
1893    def Func()
1894      echo 'local to function'
1895    enddef
1896  END
1897  CheckScriptFailure(lines, 'E1073:')
1898
1899  lines =<< trim END
1900    vim9script
1901    import Func from './XexportedFunc.vim'
1902    def Outer()
1903      def Func()
1904        echo 'local to function'
1905      enddef
1906    enddef
1907    defcompile
1908  END
1909  CheckScriptFailure(lines, 'E1073:')
1910
1911  delete('XexportedFunc.vim')
1912enddef
1913
1914def Test_func_redefine_fails()
1915  var lines =<< trim END
1916    vim9script
1917    def Func()
1918      echo 'one'
1919    enddef
1920    def Func()
1921      echo 'two'
1922    enddef
1923  END
1924  CheckScriptFailure(lines, 'E1073:')
1925
1926  lines =<< trim END
1927    vim9script
1928    def Foo(): string
1929      return 'foo'
1930      enddef
1931    def Func()
1932      var  Foo = {-> 'lambda'}
1933    enddef
1934    defcompile
1935  END
1936  CheckScriptFailure(lines, 'E1073:')
1937enddef
1938
1939def Test_fixed_size_list()
1940  # will be allocated as one piece of memory, check that changes work
1941  var l = [1, 2, 3, 4]
1942  l->remove(0)
1943  l->add(5)
1944  l->insert(99, 1)
1945  assert_equal([2, 99, 3, 4, 5], l)
1946enddef
1947
1948def Test_no_insert_xit()
1949  CheckDefExecFailure(['a = 1'], 'E1100:')
1950  CheckDefExecFailure(['c = 1'], 'E1100:')
1951  CheckDefExecFailure(['i = 1'], 'E1100:')
1952  CheckDefExecFailure(['t = 1'], 'E1100:')
1953  CheckDefExecFailure(['x = 1'], 'E1100:')
1954
1955  CheckScriptFailure(['vim9script', 'a = 1'], 'E488:')
1956  CheckScriptFailure(['vim9script', 'a'], 'E1100:')
1957  CheckScriptFailure(['vim9script', 'c = 1'], 'E488:')
1958  CheckScriptFailure(['vim9script', 'c'], 'E1100:')
1959  CheckScriptFailure(['vim9script', 'i = 1'], 'E488:')
1960  CheckScriptFailure(['vim9script', 'i'], 'E1100:')
1961  CheckScriptFailure(['vim9script', 'o = 1'], 'E1100:')
1962  CheckScriptFailure(['vim9script', 'o'], 'E1100:')
1963  CheckScriptFailure(['vim9script', 't'], 'E1100:')
1964  CheckScriptFailure(['vim9script', 't = 1'], 'E1100:')
1965  CheckScriptFailure(['vim9script', 'x = 1'], 'E1100:')
1966enddef
1967
1968def IfElse(what: number): string
1969  var res = ''
1970  if what == 1
1971    res = "one"
1972  elseif what == 2
1973    res = "two"
1974  else
1975    res = "three"
1976  endif
1977  return res
1978enddef
1979
1980def Test_if_elseif_else()
1981  assert_equal('one', IfElse(1))
1982  assert_equal('two', IfElse(2))
1983  assert_equal('three', IfElse(3))
1984enddef
1985
1986def Test_if_elseif_else_fails()
1987  CheckDefFailure(['elseif true'], 'E582:')
1988  CheckDefFailure(['else'], 'E581:')
1989  CheckDefFailure(['endif'], 'E580:')
1990  CheckDefFailure(['if g:abool', 'elseif xxx'], 'E1001:')
1991  CheckDefFailure(['if true', 'echo 1'], 'E171:')
1992
1993  var lines =<< trim END
1994      var s = ''
1995      if s = ''
1996      endif
1997  END
1998  CheckDefFailure(lines, 'E488:')
1999
2000  lines =<< trim END
2001      var s = ''
2002      if s == ''
2003      elseif s = ''
2004      endif
2005  END
2006  CheckDefFailure(lines, 'E488:')
2007enddef
2008
2009let g:bool_true = v:true
2010let g:bool_false = v:false
2011
2012def Test_if_const_expr()
2013  var res = false
2014  if true ? true : false
2015    res = true
2016  endif
2017  assert_equal(true, res)
2018
2019  g:glob = 2
2020  if false
2021    execute('g:glob = 3')
2022  endif
2023  assert_equal(2, g:glob)
2024  if true
2025    execute('g:glob = 3')
2026  endif
2027  assert_equal(3, g:glob)
2028
2029  res = false
2030  if g:bool_true ? true : false
2031    res = true
2032  endif
2033  assert_equal(true, res)
2034
2035  res = false
2036  if true ? g:bool_true : false
2037    res = true
2038  endif
2039  assert_equal(true, res)
2040
2041  res = false
2042  if true ? true : g:bool_false
2043    res = true
2044  endif
2045  assert_equal(true, res)
2046
2047  res = false
2048  if true ? false : true
2049    res = true
2050  endif
2051  assert_equal(false, res)
2052
2053  res = false
2054  if false ? false : true
2055    res = true
2056  endif
2057  assert_equal(true, res)
2058
2059  res = false
2060  if false ? true : false
2061    res = true
2062  endif
2063  assert_equal(false, res)
2064
2065  res = false
2066  if has('xyz') ? true : false
2067    res = true
2068  endif
2069  assert_equal(false, res)
2070
2071  res = false
2072  if true && true
2073    res = true
2074  endif
2075  assert_equal(true, res)
2076
2077  res = false
2078  if true && false
2079    res = true
2080  endif
2081  assert_equal(false, res)
2082
2083  res = false
2084  if g:bool_true && false
2085    res = true
2086  endif
2087  assert_equal(false, res)
2088
2089  res = false
2090  if true && g:bool_false
2091    res = true
2092  endif
2093  assert_equal(false, res)
2094
2095  res = false
2096  if false && false
2097    res = true
2098  endif
2099  assert_equal(false, res)
2100
2101  res = false
2102  if true || false
2103    res = true
2104  endif
2105  assert_equal(true, res)
2106
2107  res = false
2108  if g:bool_true || false
2109    res = true
2110  endif
2111  assert_equal(true, res)
2112
2113  res = false
2114  if true || g:bool_false
2115    res = true
2116  endif
2117  assert_equal(true, res)
2118
2119  res = false
2120  if false || false
2121    res = true
2122  endif
2123  assert_equal(false, res)
2124
2125  # with constant "false" expression may be invalid so long as the syntax is OK
2126  if false | eval 0 | endif
2127  if false | eval burp + 234 | endif
2128  if false | echo burp 234 'asd' | endif
2129  if false
2130    burp
2131  endif
2132enddef
2133
2134def Test_if_const_expr_fails()
2135  CheckDefFailure(['if "aaa" == "bbb'], 'E114:')
2136  CheckDefFailure(["if 'aaa' == 'bbb"], 'E115:')
2137  CheckDefFailure(["if has('aaa'"], 'E110:')
2138  CheckDefFailure(["if has('aaa') ? true false"], 'E109:')
2139enddef
2140
2141def RunNested(i: number): number
2142  var x: number = 0
2143  if i % 2
2144    if 1
2145      # comment
2146    else
2147      # comment
2148    endif
2149    x += 1
2150  else
2151    x += 1000
2152  endif
2153  return x
2154enddef
2155
2156def Test_nested_if()
2157  assert_equal(1, RunNested(1))
2158  assert_equal(1000, RunNested(2))
2159enddef
2160
2161def Test_execute_cmd()
2162  # missing argument is ignored
2163  execute
2164  execute # comment
2165
2166  new
2167  setline(1, 'default')
2168  execute 'setline(1, "execute-string")'
2169  assert_equal('execute-string', getline(1))
2170
2171  execute "setline(1, 'execute-string')"
2172  assert_equal('execute-string', getline(1))
2173
2174  var cmd1 = 'setline(1,'
2175  var cmd2 = '"execute-var")'
2176  execute cmd1 cmd2 # comment
2177  assert_equal('execute-var', getline(1))
2178
2179  execute cmd1 cmd2 '|setline(1, "execute-var-string")'
2180  assert_equal('execute-var-string', getline(1))
2181
2182  var cmd_first = 'call '
2183  var cmd_last = 'setline(1, "execute-var-var")'
2184  execute cmd_first .. cmd_last
2185  assert_equal('execute-var-var', getline(1))
2186  bwipe!
2187
2188  var n = true
2189  execute 'echomsg' (n ? '"true"' : '"no"')
2190  assert_match('^true$', Screenline(&lines))
2191
2192  echomsg [1, 2, 3] {a: 1, b: 2}
2193  assert_match('^\[1, 2, 3\] {''a'': 1, ''b'': 2}$', Screenline(&lines))
2194
2195  CheckDefFailure(['execute xxx'], 'E1001:', 1)
2196  CheckDefExecFailure(['execute "tabnext " .. 8'], 'E475:', 1)
2197  CheckDefFailure(['execute "cmd"# comment'], 'E488:', 1)
2198enddef
2199
2200def Test_execute_cmd_vimscript()
2201  # only checks line continuation
2202  var lines =<< trim END
2203      vim9script
2204      execute 'g:someVar'
2205                .. ' = ' ..
2206                   '28'
2207      assert_equal(28, g:someVar)
2208      unlet g:someVar
2209  END
2210  CheckScriptSuccess(lines)
2211enddef
2212
2213def Test_echo_cmd()
2214  echo 'some' # comment
2215  echon 'thing'
2216  assert_match('^something$', Screenline(&lines))
2217
2218  echo "some" # comment
2219  echon "thing"
2220  assert_match('^something$', Screenline(&lines))
2221
2222  var str1 = 'some'
2223  var str2 = 'more'
2224  echo str1 str2
2225  assert_match('^some more$', Screenline(&lines))
2226
2227  CheckDefFailure(['echo "xxx"# comment'], 'E488:')
2228enddef
2229
2230def Test_echomsg_cmd()
2231  echomsg 'some' 'more' # comment
2232  assert_match('^some more$', Screenline(&lines))
2233  echo 'clear'
2234  :1messages
2235  assert_match('^some more$', Screenline(&lines))
2236
2237  CheckDefFailure(['echomsg "xxx"# comment'], 'E488:')
2238enddef
2239
2240def Test_echomsg_cmd_vimscript()
2241  # only checks line continuation
2242  var lines =<< trim END
2243      vim9script
2244      echomsg 'here'
2245                .. ' is ' ..
2246                   'a message'
2247      assert_match('^here is a message$', Screenline(&lines))
2248  END
2249  CheckScriptSuccess(lines)
2250enddef
2251
2252def Test_echoerr_cmd()
2253  try
2254    echoerr 'something' 'wrong' # comment
2255  catch
2256    assert_match('something wrong', v:exception)
2257  endtry
2258enddef
2259
2260def Test_echoerr_cmd_vimscript()
2261  # only checks line continuation
2262  var lines =<< trim END
2263      vim9script
2264      try
2265        echoerr 'this'
2266                .. ' is ' ..
2267                   'wrong'
2268      catch
2269        assert_match('this is wrong', v:exception)
2270      endtry
2271  END
2272  CheckScriptSuccess(lines)
2273enddef
2274
2275def Test_for_outside_of_function()
2276  var lines =<< trim END
2277    vim9script
2278    new
2279    for var in range(0, 3)
2280      append(line('$'), var)
2281    endfor
2282    assert_equal(['', '0', '1', '2', '3'], getline(1, '$'))
2283    bwipe!
2284
2285    var result = ''
2286    for i in [1, 2, 3]
2287      var loop = ' loop ' .. i
2288      result ..= loop
2289    endfor
2290    assert_equal(' loop 1 loop 2 loop 3', result)
2291  END
2292  writefile(lines, 'Xvim9for.vim')
2293  source Xvim9for.vim
2294  delete('Xvim9for.vim')
2295enddef
2296
2297def Test_for_loop()
2298  var lines =<< trim END
2299      var result = ''
2300      for cnt in range(7)
2301        if cnt == 4
2302          break
2303        endif
2304        if cnt == 2
2305          continue
2306        endif
2307        result ..= cnt .. '_'
2308      endfor
2309      assert_equal('0_1_3_', result)
2310
2311      var concat = ''
2312      for str in eval('["one", "two"]')
2313        concat ..= str
2314      endfor
2315      assert_equal('onetwo', concat)
2316
2317      var total = 0
2318      for nr in
2319          [1, 2, 3]
2320        total += nr
2321      endfor
2322      assert_equal(6, total)
2323
2324      total = 0
2325      for nr
2326        in [1, 2, 3]
2327        total += nr
2328      endfor
2329      assert_equal(6, total)
2330
2331      total = 0
2332      for nr
2333        in
2334        [1, 2, 3]
2335        total += nr
2336      endfor
2337      assert_equal(6, total)
2338
2339      # with type
2340      total = 0
2341      for n: number in [1, 2, 3]
2342        total += n
2343      endfor
2344      assert_equal(6, total)
2345
2346      var chars = ''
2347      for s: string in 'foobar'
2348        chars ..= s
2349      endfor
2350      assert_equal('foobar', chars)
2351
2352      # unpack with type
2353      var res = ''
2354      for [n: number, s: string] in [[1, 'a'], [2, 'b']]
2355        res ..= n .. s
2356      endfor
2357      assert_equal('1a2b', res)
2358
2359      # loop over string
2360      res = ''
2361      for c in 'aéc̀d'
2362        res ..= c .. '-'
2363      endfor
2364      assert_equal('a-é-c̀-d-', res)
2365
2366      res = ''
2367      for c in ''
2368        res ..= c .. '-'
2369      endfor
2370      assert_equal('', res)
2371
2372      res = ''
2373      for c in test_null_string()
2374        res ..= c .. '-'
2375      endfor
2376      assert_equal('', res)
2377
2378      var foo: list<dict<any>> = [
2379              {a: 'Cat'}
2380            ]
2381      for dd in foo
2382        dd.counter = 12
2383      endfor
2384      assert_equal([{a: 'Cat', counter: 12}], foo)
2385  END
2386  CheckDefAndScriptSuccess(lines)
2387enddef
2388
2389def Test_for_loop_fails()
2390  CheckDefFailure(['for '], 'E1097:')
2391  CheckDefFailure(['for x'], 'E1097:')
2392  CheckDefFailure(['for x in'], 'E1097:')
2393  CheckDefFailure(['for # in range(5)'], 'E690:')
2394  CheckDefFailure(['for i In range(5)'], 'E690:')
2395  CheckDefFailure(['var x = 5', 'for x in range(5)'], 'E1017:')
2396  CheckScriptFailure(['def Func(arg: any)', 'for arg in range(5)', 'enddef', 'defcompile'], 'E1006:')
2397  delfunc! g:Func
2398  CheckDefFailure(['for i in xxx'], 'E1001:')
2399  CheckDefFailure(['endfor'], 'E588:')
2400  CheckDefFailure(['for i in range(3)', 'echo 3'], 'E170:')
2401
2402  # wrong type detected at compile time
2403  CheckDefFailure(['for i in {a: 1}', 'echo 3', 'endfor'], 'E1177: For loop on dict not supported')
2404
2405  # wrong type detected at runtime
2406  g:adict = {a: 1}
2407  CheckDefExecFailure(['for i in g:adict', 'echo 3', 'endfor'], 'E1177: For loop on dict not supported')
2408  unlet g:adict
2409
2410  var lines =<< trim END
2411      var d: list<dict<any>> = [{a: 0}]
2412      for e in d
2413        e = {a: 0, b: ''}
2414      endfor
2415  END
2416  CheckDefAndScriptFailure2(lines, 'E1018:', 'E46:', 3)
2417
2418  lines =<< trim END
2419      for nr: number in ['foo']
2420      endfor
2421  END
2422  CheckDefAndScriptFailure(lines, 'E1012: Type mismatch; expected number but got string', 1)
2423enddef
2424
2425def Test_for_loop_script_var()
2426  # cannot use s:var in a :def function
2427  CheckDefFailure(['for s:var in range(3)', 'echo 3'], 'E1101:')
2428
2429  # can use s:var in Vim9 script, with or without s:
2430  var lines =<< trim END
2431    vim9script
2432    var total = 0
2433    for s:var in [1, 2, 3]
2434      total += s:var
2435    endfor
2436    assert_equal(6, total)
2437
2438    total = 0
2439    for var in [1, 2, 3]
2440      total += var
2441    endfor
2442    assert_equal(6, total)
2443  END
2444enddef
2445
2446def Test_for_loop_unpack()
2447  var lines =<< trim END
2448      var result = []
2449      for [v1, v2] in [[1, 2], [3, 4]]
2450        result->add(v1)
2451        result->add(v2)
2452      endfor
2453      assert_equal([1, 2, 3, 4], result)
2454
2455      result = []
2456      for [v1, v2; v3] in [[1, 2], [3, 4, 5, 6]]
2457        result->add(v1)
2458        result->add(v2)
2459        result->add(v3)
2460      endfor
2461      assert_equal([1, 2, [], 3, 4, [5, 6]], result)
2462
2463      result = []
2464      for [&ts, &sw] in [[1, 2], [3, 4]]
2465        result->add(&ts)
2466        result->add(&sw)
2467      endfor
2468      assert_equal([1, 2, 3, 4], result)
2469
2470      var slist: list<string>
2471      for [$LOOPVAR, @r, v:errmsg] in [['a', 'b', 'c'], ['d', 'e', 'f']]
2472        slist->add($LOOPVAR)
2473        slist->add(@r)
2474        slist->add(v:errmsg)
2475      endfor
2476      assert_equal(['a', 'b', 'c', 'd', 'e', 'f'], slist)
2477
2478      slist = []
2479      for [g:globalvar, b:bufvar, w:winvar, t:tabvar] in [['global', 'buf', 'win', 'tab'], ['1', '2', '3', '4']]
2480        slist->add(g:globalvar)
2481        slist->add(b:bufvar)
2482        slist->add(w:winvar)
2483        slist->add(t:tabvar)
2484      endfor
2485      assert_equal(['global', 'buf', 'win', 'tab', '1', '2', '3', '4'], slist)
2486      unlet! g:globalvar b:bufvar w:winvar t:tabvar
2487  END
2488  CheckDefAndScriptSuccess(lines)
2489
2490  lines =<< trim END
2491      for [v1, v2] in [[1, 2, 3], [3, 4]]
2492        echo v1 v2
2493      endfor
2494  END
2495  CheckDefExecFailure(lines, 'E710:', 1)
2496
2497  lines =<< trim END
2498      for [v1, v2] in [[1], [3, 4]]
2499        echo v1 v2
2500      endfor
2501  END
2502  CheckDefExecFailure(lines, 'E711:', 1)
2503
2504  lines =<< trim END
2505      for [v1, v1] in [[1, 2], [3, 4]]
2506        echo v1
2507      endfor
2508  END
2509  CheckDefExecFailure(lines, 'E1017:', 1)
2510enddef
2511
2512def Test_for_loop_with_try_continue()
2513  var lines =<< trim END
2514      var looped = 0
2515      var cleanup = 0
2516      for i in range(3)
2517        looped += 1
2518        try
2519          eval [][0]
2520        catch
2521          continue
2522        finally
2523          cleanup += 1
2524        endtry
2525      endfor
2526      assert_equal(3, looped)
2527      assert_equal(3, cleanup)
2528  END
2529  CheckDefAndScriptSuccess(lines)
2530enddef
2531
2532def Test_while_loop()
2533  var result = ''
2534  var cnt = 0
2535  while cnt < 555
2536    if cnt == 3
2537      break
2538    endif
2539    cnt += 1
2540    if cnt == 2
2541      continue
2542    endif
2543    result ..= cnt .. '_'
2544  endwhile
2545  assert_equal('1_3_', result)
2546
2547  var s = ''
2548  while s == 'x' # {comment}
2549  endwhile
2550enddef
2551
2552def Test_while_loop_fails()
2553  CheckDefFailure(['while xxx'], 'E1001:')
2554  CheckDefFailure(['endwhile'], 'E588:')
2555  CheckDefFailure(['continue'], 'E586:')
2556  CheckDefFailure(['if true', 'continue'], 'E586:')
2557  CheckDefFailure(['break'], 'E587:')
2558  CheckDefFailure(['if true', 'break'], 'E587:')
2559  CheckDefFailure(['while 1', 'echo 3'], 'E170:')
2560
2561  var lines =<< trim END
2562      var s = ''
2563      while s = ''
2564      endwhile
2565  END
2566  CheckDefFailure(lines, 'E488:')
2567enddef
2568
2569def Test_interrupt_loop()
2570  var caught = false
2571  var x = 0
2572  try
2573    while 1
2574      x += 1
2575      if x == 100
2576        feedkeys("\<C-C>", 'Lt')
2577      endif
2578    endwhile
2579  catch
2580    caught = true
2581    assert_equal(100, x)
2582  endtry
2583  assert_true(caught, 'should have caught an exception')
2584  # consume the CTRL-C
2585  getchar(0)
2586enddef
2587
2588def Test_automatic_line_continuation()
2589  var mylist = [
2590      'one',
2591      'two',
2592      'three',
2593      ] # comment
2594  assert_equal(['one', 'two', 'three'], mylist)
2595
2596  var mydict = {
2597      ['one']: 1,
2598      ['two']: 2,
2599      ['three']:
2600          3,
2601      } # comment
2602  assert_equal({one: 1, two: 2, three: 3}, mydict)
2603  mydict = {
2604      one: 1,  # comment
2605      two:     # comment
2606           2,  # comment
2607      three: 3 # comment
2608      }
2609  assert_equal({one: 1, two: 2, three: 3}, mydict)
2610  mydict = {
2611      one: 1,
2612      two:
2613           2,
2614      three: 3
2615      }
2616  assert_equal({one: 1, two: 2, three: 3}, mydict)
2617
2618  assert_equal(
2619        ['one', 'two', 'three'],
2620        split('one two three')
2621        )
2622enddef
2623
2624def Test_vim9_comment()
2625  CheckScriptSuccess([
2626      'vim9script',
2627      '# something',
2628      '#something',
2629      '#{something',
2630      ])
2631
2632  split Xfile
2633  CheckScriptSuccess([
2634      'vim9script',
2635      'edit #something',
2636      ])
2637  CheckScriptSuccess([
2638      'vim9script',
2639      'edit #{something',
2640      ])
2641  close
2642
2643  CheckScriptFailure([
2644      'vim9script',
2645      ':# something',
2646      ], 'E488:')
2647  CheckScriptFailure([
2648      '# something',
2649      ], 'E488:')
2650  CheckScriptFailure([
2651      ':# something',
2652      ], 'E488:')
2653
2654  { # block start
2655  } # block end
2656  CheckDefFailure([
2657      '{# comment',
2658      ], 'E488:')
2659  CheckDefFailure([
2660      '{',
2661      '}# comment',
2662      ], 'E488:')
2663
2664  echo "yes" # comment
2665  CheckDefFailure([
2666      'echo "yes"# comment',
2667      ], 'E488:')
2668  CheckScriptSuccess([
2669      'vim9script',
2670      'echo "yes" # something',
2671      ])
2672  CheckScriptFailure([
2673      'vim9script',
2674      'echo "yes"# something',
2675      ], 'E121:')
2676  CheckScriptFailure([
2677      'vim9script',
2678      'echo# something',
2679      ], 'E1144:')
2680  CheckScriptFailure([
2681      'echo "yes" # something',
2682      ], 'E121:')
2683
2684  exe "echo" # comment
2685  CheckDefFailure([
2686      'exe "echo"# comment',
2687      ], 'E488:')
2688  CheckScriptSuccess([
2689      'vim9script',
2690      'exe "echo" # something',
2691      ])
2692  CheckScriptFailure([
2693      'vim9script',
2694      'exe "echo"# something',
2695      ], 'E121:')
2696  CheckScriptFailure([
2697      'vim9script',
2698      'exe# something',
2699      ], 'E1144:')
2700  CheckScriptFailure([
2701      'exe "echo" # something',
2702      ], 'E121:')
2703
2704  CheckDefFailure([
2705      'try# comment',
2706      '  echo "yes"',
2707      'catch',
2708      'endtry',
2709      ], 'E1144:')
2710  CheckScriptFailure([
2711      'vim9script',
2712      'try# comment',
2713      'echo "yes"',
2714      ], 'E1144:')
2715  CheckDefFailure([
2716      'try',
2717      '  throw#comment',
2718      'catch',
2719      'endtry',
2720      ], 'E1144:')
2721  CheckDefFailure([
2722      'try',
2723      '  throw "yes"#comment',
2724      'catch',
2725      'endtry',
2726      ], 'E488:')
2727  CheckDefFailure([
2728      'try',
2729      '  echo "yes"',
2730      'catch# comment',
2731      'endtry',
2732      ], 'E1144:')
2733  CheckScriptFailure([
2734      'vim9script',
2735      'try',
2736      '  echo "yes"',
2737      'catch# comment',
2738      'endtry',
2739      ], 'E1144:')
2740  CheckDefFailure([
2741      'try',
2742      '  echo "yes"',
2743      'catch /pat/# comment',
2744      'endtry',
2745      ], 'E488:')
2746  CheckDefFailure([
2747      'try',
2748      'echo "yes"',
2749      'catch',
2750      'endtry# comment',
2751      ], 'E1144:')
2752  CheckScriptFailure([
2753      'vim9script',
2754      'try',
2755      '  echo "yes"',
2756      'catch',
2757      'endtry# comment',
2758      ], 'E1144:')
2759
2760  CheckScriptSuccess([
2761      'vim9script',
2762      'hi # comment',
2763      ])
2764  CheckScriptFailure([
2765      'vim9script',
2766      'hi# comment',
2767      ], 'E1144:')
2768  CheckScriptSuccess([
2769      'vim9script',
2770      'hi Search # comment',
2771      ])
2772  CheckScriptFailure([
2773      'vim9script',
2774      'hi Search# comment',
2775      ], 'E416:')
2776  CheckScriptSuccess([
2777      'vim9script',
2778      'hi link This Search # comment',
2779      ])
2780  CheckScriptFailure([
2781      'vim9script',
2782      'hi link This That# comment',
2783      ], 'E413:')
2784  CheckScriptSuccess([
2785      'vim9script',
2786      'hi clear This # comment',
2787      'hi clear # comment',
2788      ])
2789  # not tested, because it doesn't give an error but a warning:
2790  # hi clear This# comment',
2791  CheckScriptFailure([
2792      'vim9script',
2793      'hi clear# comment',
2794      ], 'E416:')
2795
2796  CheckScriptSuccess([
2797      'vim9script',
2798      'hi Group term=bold',
2799      'match Group /todo/ # comment',
2800      ])
2801  CheckScriptFailure([
2802      'vim9script',
2803      'hi Group term=bold',
2804      'match Group /todo/# comment',
2805      ], 'E488:')
2806  CheckScriptSuccess([
2807      'vim9script',
2808      'match # comment',
2809      ])
2810  CheckScriptFailure([
2811      'vim9script',
2812      'match# comment',
2813      ], 'E1144:')
2814  CheckScriptSuccess([
2815      'vim9script',
2816      'match none # comment',
2817      ])
2818  CheckScriptFailure([
2819      'vim9script',
2820      'match none# comment',
2821      ], 'E475:')
2822
2823  CheckScriptSuccess([
2824      'vim9script',
2825      'menutrans clear # comment',
2826      ])
2827  CheckScriptFailure([
2828      'vim9script',
2829      'menutrans clear# comment text',
2830      ], 'E474:')
2831
2832  CheckScriptSuccess([
2833      'vim9script',
2834      'syntax clear # comment',
2835      ])
2836  CheckScriptFailure([
2837      'vim9script',
2838      'syntax clear# comment text',
2839      ], 'E28:')
2840  CheckScriptSuccess([
2841      'vim9script',
2842      'syntax keyword Word some',
2843      'syntax clear Word # comment',
2844      ])
2845  CheckScriptFailure([
2846      'vim9script',
2847      'syntax keyword Word some',
2848      'syntax clear Word# comment text',
2849      ], 'E28:')
2850
2851  CheckScriptSuccess([
2852      'vim9script',
2853      'syntax list # comment',
2854      ])
2855  CheckScriptFailure([
2856      'vim9script',
2857      'syntax list# comment text',
2858      ], 'E28:')
2859
2860  CheckScriptSuccess([
2861      'vim9script',
2862      'syntax match Word /pat/ oneline # comment',
2863      ])
2864  CheckScriptFailure([
2865      'vim9script',
2866      'syntax match Word /pat/ oneline# comment',
2867      ], 'E475:')
2868
2869  CheckScriptSuccess([
2870      'vim9script',
2871      'syntax keyword Word word # comm[ent',
2872      ])
2873  CheckScriptFailure([
2874      'vim9script',
2875      'syntax keyword Word word# comm[ent',
2876      ], 'E789:')
2877
2878  CheckScriptSuccess([
2879      'vim9script',
2880      'syntax match Word /pat/ # comment',
2881      ])
2882  CheckScriptFailure([
2883      'vim9script',
2884      'syntax match Word /pat/# comment',
2885      ], 'E402:')
2886
2887  CheckScriptSuccess([
2888      'vim9script',
2889      'syntax match Word /pat/ contains=Something # comment',
2890      ])
2891  CheckScriptFailure([
2892      'vim9script',
2893      'syntax match Word /pat/ contains=Something# comment',
2894      ], 'E475:')
2895  CheckScriptFailure([
2896      'vim9script',
2897      'syntax match Word /pat/ contains= # comment',
2898      ], 'E406:')
2899  CheckScriptFailure([
2900      'vim9script',
2901      'syntax match Word /pat/ contains=# comment',
2902      ], 'E475:')
2903
2904  CheckScriptSuccess([
2905      'vim9script',
2906      'syntax region Word start=/pat/ end=/pat/ # comment',
2907      ])
2908  CheckScriptFailure([
2909      'vim9script',
2910      'syntax region Word start=/pat/ end=/pat/# comment',
2911      ], 'E402:')
2912
2913  CheckScriptSuccess([
2914      'vim9script',
2915      'syntax sync # comment',
2916      ])
2917  CheckScriptFailure([
2918      'vim9script',
2919      'syntax sync# comment',
2920      ], 'E404:')
2921  CheckScriptSuccess([
2922      'vim9script',
2923      'syntax sync ccomment # comment',
2924      ])
2925  CheckScriptFailure([
2926      'vim9script',
2927      'syntax sync ccomment# comment',
2928      ], 'E404:')
2929
2930  CheckScriptSuccess([
2931      'vim9script',
2932      'syntax cluster Some contains=Word # comment',
2933      ])
2934  CheckScriptFailure([
2935      'vim9script',
2936      'syntax cluster Some contains=Word# comment',
2937      ], 'E475:')
2938
2939  CheckScriptSuccess([
2940      'vim9script',
2941      'command Echo echo # comment',
2942      'command Echo # comment',
2943      'delcommand Echo',
2944      ])
2945  CheckScriptFailure([
2946      'vim9script',
2947      'command Echo echo# comment',
2948      'Echo',
2949      ], 'E1144:')
2950  delcommand Echo
2951
2952  var curdir = getcwd()
2953  CheckScriptSuccess([
2954      'command Echo cd " comment',
2955      'Echo',
2956      'delcommand Echo',
2957      ])
2958  CheckScriptSuccess([
2959      'vim9script',
2960      'command Echo cd # comment',
2961      'Echo',
2962      'delcommand Echo',
2963      ])
2964  CheckScriptFailure([
2965      'vim9script',
2966      'command Echo cd " comment',
2967      'Echo',
2968      ], 'E344:')
2969  delcommand Echo
2970  chdir(curdir)
2971
2972  CheckScriptFailure([
2973      'vim9script',
2974      'command Echo# comment',
2975      ], 'E182:')
2976  CheckScriptFailure([
2977      'vim9script',
2978      'command Echo echo',
2979      'command Echo# comment',
2980      ], 'E182:')
2981  delcommand Echo
2982
2983  CheckScriptSuccess([
2984      'vim9script',
2985      'function # comment',
2986      ])
2987  CheckScriptFailure([
2988      'vim9script',
2989      'function " comment',
2990      ], 'E129:')
2991  CheckScriptFailure([
2992      'vim9script',
2993      'function# comment',
2994      ], 'E1144:')
2995  CheckScriptSuccess([
2996      'vim9script',
2997      'function CheckScriptSuccess # comment',
2998      ])
2999  CheckScriptFailure([
3000      'vim9script',
3001      'function CheckScriptSuccess# comment',
3002      ], 'E488:')
3003
3004  CheckScriptSuccess([
3005      'vim9script',
3006      'func g:DeleteMeA()',
3007      'endfunc',
3008      'delfunction g:DeleteMeA # comment',
3009      ])
3010  CheckScriptFailure([
3011      'vim9script',
3012      'func g:DeleteMeB()',
3013      'endfunc',
3014      'delfunction g:DeleteMeB# comment',
3015      ], 'E488:')
3016
3017  CheckScriptSuccess([
3018      'vim9script',
3019      'call execute("ls") # comment',
3020      ])
3021  CheckScriptFailure([
3022      'vim9script',
3023      'call execute("ls")# comment',
3024      ], 'E488:')
3025
3026  CheckScriptFailure([
3027      'def Test() " comment',
3028      'enddef',
3029      ], 'E488:')
3030  CheckScriptFailure([
3031      'vim9script',
3032      'def Test() " comment',
3033      'enddef',
3034      ], 'E488:')
3035
3036  CheckScriptSuccess([
3037      'func Test() " comment',
3038      'endfunc',
3039      'delfunc Test',
3040      ])
3041  CheckScriptSuccess([
3042      'vim9script',
3043      'func Test() " comment',
3044      'endfunc',
3045      ])
3046
3047  CheckScriptSuccess([
3048      'def Test() # comment',
3049      'enddef',
3050      ])
3051  CheckScriptFailure([
3052      'func Test() # comment',
3053      'endfunc',
3054      ], 'E488:')
3055enddef
3056
3057def Test_vim9_comment_gui()
3058  CheckCanRunGui
3059
3060  CheckScriptFailure([
3061      'vim9script',
3062      'gui#comment'
3063      ], 'E1144:')
3064  CheckScriptFailure([
3065      'vim9script',
3066      'gui -f#comment'
3067      ], 'E499:')
3068enddef
3069
3070def Test_vim9_comment_not_compiled()
3071  au TabEnter *.vim g:entered = 1
3072  au TabEnter *.x g:entered = 2
3073
3074  edit test.vim
3075  doautocmd TabEnter #comment
3076  assert_equal(1, g:entered)
3077
3078  doautocmd TabEnter f.x
3079  assert_equal(2, g:entered)
3080
3081  g:entered = 0
3082  doautocmd TabEnter f.x #comment
3083  assert_equal(2, g:entered)
3084
3085  assert_fails('doautocmd Syntax#comment', 'E216:')
3086
3087  au! TabEnter
3088  unlet g:entered
3089
3090  CheckScriptSuccess([
3091      'vim9script',
3092      'g:var = 123',
3093      'b:var = 456',
3094      'w:var = 777',
3095      't:var = 888',
3096      'unlet g:var w:var # something',
3097      ])
3098
3099  CheckScriptFailure([
3100      'vim9script',
3101      'let var = 123',
3102      ], 'E1126: Cannot use :let in Vim9 script')
3103
3104  CheckScriptFailure([
3105      'vim9script',
3106      'var g:var = 123',
3107      ], 'E1016: Cannot declare a global variable:')
3108
3109  CheckScriptFailure([
3110      'vim9script',
3111      'var b:var = 123',
3112      ], 'E1016: Cannot declare a buffer variable:')
3113
3114  CheckScriptFailure([
3115      'vim9script',
3116      'var w:var = 123',
3117      ], 'E1016: Cannot declare a window variable:')
3118
3119  CheckScriptFailure([
3120      'vim9script',
3121      'var t:var = 123',
3122      ], 'E1016: Cannot declare a tab variable:')
3123
3124  CheckScriptFailure([
3125      'vim9script',
3126      'var v:version = 123',
3127      ], 'E1016: Cannot declare a v: variable:')
3128
3129  CheckScriptFailure([
3130      'vim9script',
3131      'var $VARIABLE = "text"',
3132      ], 'E1016: Cannot declare an environment variable:')
3133
3134  CheckScriptFailure([
3135      'vim9script',
3136      'g:var = 123',
3137      'unlet g:var# comment1',
3138      ], 'E108:')
3139
3140  CheckScriptFailure([
3141      'let g:var = 123',
3142      'unlet g:var # something',
3143      ], 'E488:')
3144
3145  CheckScriptSuccess([
3146      'vim9script',
3147      'if 1 # comment2',
3148      '  echo "yes"',
3149      'elseif 2 #comment',
3150      '  echo "no"',
3151      'endif',
3152      ])
3153
3154  CheckScriptFailure([
3155      'vim9script',
3156      'if 1# comment3',
3157      '  echo "yes"',
3158      'endif',
3159      ], 'E15:')
3160
3161  CheckScriptFailure([
3162      'vim9script',
3163      'if 0 # comment4',
3164      '  echo "yes"',
3165      'elseif 2#comment',
3166      '  echo "no"',
3167      'endif',
3168      ], 'E15:')
3169
3170  CheckScriptSuccess([
3171      'vim9script',
3172      'var v = 1 # comment5',
3173      ])
3174
3175  CheckScriptFailure([
3176      'vim9script',
3177      'var v = 1# comment6',
3178      ], 'E15:')
3179
3180  CheckScriptSuccess([
3181      'vim9script',
3182      'new'
3183      'setline(1, ["# define pat", "last"])',
3184      ':$',
3185      'dsearch /pat/ #comment',
3186      'bwipe!',
3187      ])
3188
3189  CheckScriptFailure([
3190      'vim9script',
3191      'new'
3192      'setline(1, ["# define pat", "last"])',
3193      ':$',
3194      'dsearch /pat/#comment',
3195      'bwipe!',
3196      ], 'E488:')
3197
3198  CheckScriptFailure([
3199      'vim9script',
3200      'func! SomeFunc()',
3201      ], 'E477:')
3202enddef
3203
3204def Test_finish()
3205  var lines =<< trim END
3206    vim9script
3207    g:res = 'one'
3208    if v:false | finish | endif
3209    g:res = 'two'
3210    finish
3211    g:res = 'three'
3212  END
3213  writefile(lines, 'Xfinished')
3214  source Xfinished
3215  assert_equal('two', g:res)
3216
3217  unlet g:res
3218  delete('Xfinished')
3219enddef
3220
3221def Test_forward_declaration()
3222  var lines =<< trim END
3223    vim9script
3224    def GetValue(): string
3225      return theVal
3226    enddef
3227    var theVal = 'something'
3228    g:initVal = GetValue()
3229    theVal = 'else'
3230    g:laterVal = GetValue()
3231  END
3232  writefile(lines, 'Xforward')
3233  source Xforward
3234  assert_equal('something', g:initVal)
3235  assert_equal('else', g:laterVal)
3236
3237  unlet g:initVal
3238  unlet g:laterVal
3239  delete('Xforward')
3240enddef
3241
3242def Test_source_vim9_from_legacy()
3243  var vim9_lines =<< trim END
3244    vim9script
3245    var local = 'local'
3246    g:global = 'global'
3247    export var exported = 'exported'
3248    export def GetText(): string
3249       return 'text'
3250    enddef
3251  END
3252  writefile(vim9_lines, 'Xvim9_script.vim')
3253
3254  var legacy_lines =<< trim END
3255    source Xvim9_script.vim
3256
3257    call assert_false(exists('local'))
3258    call assert_false(exists('exported'))
3259    call assert_false(exists('s:exported'))
3260    call assert_equal('global', global)
3261    call assert_equal('global', g:global)
3262
3263    " imported variable becomes script-local
3264    import exported from './Xvim9_script.vim'
3265    call assert_equal('exported', s:exported)
3266    call assert_false(exists('exported'))
3267
3268    " imported function becomes script-local
3269    import GetText from './Xvim9_script.vim'
3270    call assert_equal('text', s:GetText())
3271    call assert_false(exists('*GetText'))
3272  END
3273  writefile(legacy_lines, 'Xlegacy_script.vim')
3274
3275  source Xlegacy_script.vim
3276  assert_equal('global', g:global)
3277  unlet g:global
3278
3279  delete('Xlegacy_script.vim')
3280  delete('Xvim9_script.vim')
3281enddef
3282
3283def Test_declare_script_in_func()
3284  var lines =<< trim END
3285      vim9script
3286      func Declare()
3287        let s:local = 123
3288      endfunc
3289      Declare()
3290      assert_equal(123, local)
3291
3292      var error: string
3293      try
3294        local = 'asdf'
3295      catch
3296        error = v:exception
3297      endtry
3298      assert_match('E1012: Type mismatch; expected number but got string', error)
3299
3300      lockvar local
3301      try
3302        local = 999
3303      catch
3304        error = v:exception
3305      endtry
3306      assert_match('E741: Value is locked: local', error)
3307  END
3308  CheckScriptSuccess(lines)
3309enddef
3310
3311
3312func Test_vim9script_not_global()
3313  " check that items defined in Vim9 script are script-local, not global
3314  let vim9lines =<< trim END
3315    vim9script
3316    var name = 'local'
3317    func TheFunc()
3318      echo 'local'
3319    endfunc
3320    def DefFunc()
3321      echo 'local'
3322    enddef
3323  END
3324  call writefile(vim9lines, 'Xvim9script.vim')
3325  source Xvim9script.vim
3326  try
3327    echo g:var
3328    assert_report('did not fail')
3329  catch /E121:/
3330    " caught
3331  endtry
3332  try
3333    call TheFunc()
3334    assert_report('did not fail')
3335  catch /E117:/
3336    " caught
3337  endtry
3338  try
3339    call DefFunc()
3340    assert_report('did not fail')
3341  catch /E117:/
3342    " caught
3343  endtry
3344
3345  call delete('Xvim9script.vim')
3346endfunc
3347
3348def Test_vim9_copen()
3349  # this was giving an error for setting w:quickfix_title
3350  copen
3351  quit
3352enddef
3353
3354" test using an auto-loaded function and variable
3355def Test_vim9_autoload()
3356  var lines =<< trim END
3357     vim9script
3358     def some#gettest(): string
3359       return 'test'
3360     enddef
3361     g:some#name = 'name'
3362
3363     def some#varargs(a1: string, ...l: list<string>): string
3364       return a1 .. l[0] .. l[1]
3365     enddef
3366  END
3367
3368  mkdir('Xdir/autoload', 'p')
3369  writefile(lines, 'Xdir/autoload/some.vim')
3370  var save_rtp = &rtp
3371  exe 'set rtp^=' .. getcwd() .. '/Xdir'
3372
3373  assert_equal('test', g:some#gettest())
3374  assert_equal('name', g:some#name)
3375  g:some#other = 'other'
3376  assert_equal('other', g:some#other)
3377
3378  assert_equal('abc', some#varargs('a', 'b', 'c'))
3379
3380  # upper case script name works
3381  lines =<< trim END
3382     vim9script
3383     def Other#getOther(): string
3384       return 'other'
3385     enddef
3386  END
3387  writefile(lines, 'Xdir/autoload/Other.vim')
3388  assert_equal('other', g:Other#getOther())
3389
3390  delete('Xdir', 'rf')
3391  &rtp = save_rtp
3392enddef
3393
3394" test using a vim9script that is auto-loaded from an autocmd
3395def Test_vim9_aucmd_autoload()
3396  var lines =<< trim END
3397     vim9script
3398     def foo#test()
3399         echomsg getreg('"')
3400     enddef
3401  END
3402
3403  mkdir('Xdir/autoload', 'p')
3404  writefile(lines, 'Xdir/autoload/foo.vim')
3405  var save_rtp = &rtp
3406  exe 'set rtp^=' .. getcwd() .. '/Xdir'
3407  augroup test
3408    autocmd TextYankPost * call foo#test()
3409  augroup END
3410
3411  normal Y
3412
3413  augroup test
3414    autocmd!
3415  augroup END
3416  delete('Xdir', 'rf')
3417  &rtp = save_rtp
3418enddef
3419
3420" This was causing a crash because suppress_errthrow wasn't reset.
3421def Test_vim9_autoload_error()
3422  var lines =<< trim END
3423      vim9script
3424      def crash#func()
3425          try
3426              for x in List()
3427              endfor
3428          catch
3429          endtry
3430          g:ok = true
3431      enddef
3432      fu List()
3433          invalid
3434      endfu
3435      try
3436          alsoinvalid
3437      catch /wontmatch/
3438      endtry
3439  END
3440  call mkdir('Xruntime/autoload', 'p')
3441  call writefile(lines, 'Xruntime/autoload/crash.vim')
3442
3443  # run in a separate Vim to avoid the side effects of assert_fails()
3444  lines =<< trim END
3445    exe 'set rtp^=' .. getcwd() .. '/Xruntime'
3446    call crash#func()
3447    call writefile(['ok'], 'Xdidit')
3448    qall!
3449  END
3450  writefile(lines, 'Xscript')
3451  RunVim([], [], '-S Xscript')
3452  assert_equal(['ok'], readfile('Xdidit'))
3453
3454  delete('Xdidit')
3455  delete('Xscript')
3456  delete('Xruntime', 'rf')
3457
3458  lines =<< trim END
3459    vim9script
3460    var foo#bar = 'asdf'
3461  END
3462  CheckScriptFailure(lines, 'E461: Illegal variable name: foo#bar', 2)
3463enddef
3464
3465def Test_script_var_in_autocmd()
3466  # using a script variable from an autocommand, defined in a :def function in a
3467  # legacy Vim script, cannot check the variable type.
3468  var lines =<< trim END
3469    let s:counter = 1
3470    def s:Func()
3471      au! CursorHold
3472      au CursorHold * s:counter += 1
3473    enddef
3474    call s:Func()
3475    doau CursorHold
3476    call assert_equal(2, s:counter)
3477    au! CursorHold
3478  END
3479  CheckScriptSuccess(lines)
3480enddef
3481
3482def Test_cmdline_win()
3483  # if the Vim syntax highlighting uses Vim9 constructs they can be used from
3484  # the command line window.
3485  mkdir('rtp/syntax', 'p')
3486  var export_lines =<< trim END
3487    vim9script
3488    export var That = 'yes'
3489  END
3490  writefile(export_lines, 'rtp/syntax/Xexport.vim')
3491  var import_lines =<< trim END
3492    vim9script
3493    import That from './Xexport.vim'
3494  END
3495  writefile(import_lines, 'rtp/syntax/vim.vim')
3496  var save_rtp = &rtp
3497  &rtp = getcwd() .. '/rtp' .. ',' .. &rtp
3498  syntax on
3499  augroup CmdWin
3500    autocmd CmdwinEnter * g:got_there = 'yes'
3501  augroup END
3502  # this will open and also close the cmdline window
3503  feedkeys('q:', 'xt')
3504  assert_equal('yes', g:got_there)
3505
3506  augroup CmdWin
3507    au!
3508  augroup END
3509  &rtp = save_rtp
3510  delete('rtp', 'rf')
3511enddef
3512
3513def Test_invalid_sid()
3514  assert_fails('func <SNR>1234_func', 'E123:')
3515
3516  if RunVim([], ['wq! Xdidit'], '+"func <SNR>1_func"')
3517    assert_equal([], readfile('Xdidit'))
3518  endif
3519  delete('Xdidit')
3520enddef
3521
3522def Test_restoring_cpo()
3523  writefile(['vim9script', 'set nocp'], 'Xsourced')
3524  writefile(['call writefile(["done"], "Xdone")', 'quit!'], 'Xclose')
3525  if RunVim([], [], '-u NONE +"set cpo+=a" -S Xsourced -S Xclose')
3526    assert_equal(['done'], readfile('Xdone'))
3527  endif
3528  delete('Xsourced')
3529  delete('Xclose')
3530  delete('Xdone')
3531
3532  writefile(['vim9script'], 'XanotherScript')
3533  set cpo=aABceFsMny>
3534  edit XanotherScript
3535  so %
3536  assert_equal('aABceFsMny>', &cpo)
3537  :1del
3538  w
3539  so %
3540  assert_equal('aABceFsMny>', &cpo)
3541
3542  delete('XanotherScript')
3543  set cpo&vim
3544enddef
3545
3546" Use :function so we can use Check commands
3547func Test_no_redraw_when_restoring_cpo()
3548  CheckScreendump
3549  CheckFeature timers
3550
3551  let lines =<< trim END
3552    vim9script
3553    def script#func()
3554    enddef
3555  END
3556  call mkdir('Xdir/autoload', 'p')
3557  call writefile(lines, 'Xdir/autoload/script.vim')
3558
3559  let lines =<< trim END
3560      vim9script
3561      set cpo+=M
3562      exe 'set rtp^=' .. getcwd() .. '/Xdir'
3563      au CmdlineEnter : ++once timer_start(0, (_) => script#func())
3564      setline(1, 'some text')
3565  END
3566  call writefile(lines, 'XTest_redraw_cpo')
3567  let buf = RunVimInTerminal('-S XTest_redraw_cpo', {'rows': 6})
3568  call term_sendkeys(buf, "V:")
3569  call VerifyScreenDump(buf, 'Test_vim9_no_redraw', {})
3570
3571  " clean up
3572  call term_sendkeys(buf, "\<Esc>u")
3573  call StopVimInTerminal(buf)
3574  call delete('XTest_redraw_cpo')
3575  call delete('Xdir', 'rf')
3576endfunc
3577
3578
3579def Test_unset_any_variable()
3580  var lines =<< trim END
3581    var name: any
3582    assert_equal(0, name)
3583  END
3584  CheckDefAndScriptSuccess(lines)
3585enddef
3586
3587func Test_define_func_at_command_line()
3588  CheckRunVimInTerminal
3589
3590  " call indirectly to avoid compilation error for missing functions
3591  call Run_Test_define_func_at_command_line()
3592endfunc
3593
3594def Run_Test_define_func_at_command_line()
3595  # run in a separate Vim instance to avoid the script context
3596  var lines =<< trim END
3597    func CheckAndQuit()
3598      call assert_fails('call Afunc()', 'E117: Unknown function: Bfunc')
3599      call writefile(['errors: ' .. string(v:errors)], 'Xdidcmd')
3600    endfunc
3601  END
3602  writefile([''], 'Xdidcmd')
3603  writefile(lines, 'XcallFunc')
3604  var buf = RunVimInTerminal('-S XcallFunc', {rows: 6})
3605  # define Afunc() on the command line
3606  term_sendkeys(buf, ":def Afunc()\<CR>Bfunc()\<CR>enddef\<CR>")
3607  term_sendkeys(buf, ":call CheckAndQuit()\<CR>")
3608  WaitForAssert(() => assert_equal(['errors: []'], readfile('Xdidcmd')))
3609
3610  call StopVimInTerminal(buf)
3611  delete('XcallFunc')
3612  delete('Xdidcmd')
3613enddef
3614
3615def Test_script_var_scope()
3616  var lines =<< trim END
3617      vim9script
3618      if true
3619        if true
3620          var one = 'one'
3621          echo one
3622        endif
3623        echo one
3624      endif
3625  END
3626  CheckScriptFailure(lines, 'E121:', 7)
3627
3628  lines =<< trim END
3629      vim9script
3630      if true
3631        if false
3632          var one = 'one'
3633          echo one
3634        else
3635          var one = 'one'
3636          echo one
3637        endif
3638        echo one
3639      endif
3640  END
3641  CheckScriptFailure(lines, 'E121:', 10)
3642
3643  lines =<< trim END
3644      vim9script
3645      while true
3646        var one = 'one'
3647        echo one
3648        break
3649      endwhile
3650      echo one
3651  END
3652  CheckScriptFailure(lines, 'E121:', 7)
3653
3654  lines =<< trim END
3655      vim9script
3656      for i in range(1)
3657        var one = 'one'
3658        echo one
3659      endfor
3660      echo one
3661  END
3662  CheckScriptFailure(lines, 'E121:', 6)
3663
3664  lines =<< trim END
3665      vim9script
3666      {
3667        var one = 'one'
3668        assert_equal('one', one)
3669      }
3670      assert_false(exists('one'))
3671      assert_false(exists('s:one'))
3672  END
3673  CheckScriptSuccess(lines)
3674
3675  lines =<< trim END
3676      vim9script
3677      {
3678        var one = 'one'
3679        echo one
3680      }
3681      echo one
3682  END
3683  CheckScriptFailure(lines, 'E121:', 6)
3684enddef
3685
3686def Test_catch_exception_in_callback()
3687  var lines =<< trim END
3688    vim9script
3689    def Callback(...l: list<any>)
3690      try
3691        var x: string
3692        var y: string
3693        # this error should be caught with CHECKLEN
3694        [x, y] = ['']
3695      catch
3696        g:caught = 'yes'
3697      endtry
3698    enddef
3699    popup_menu('popup', {callback: Callback})
3700    feedkeys("\r", 'xt')
3701  END
3702  CheckScriptSuccess(lines)
3703
3704  unlet g:caught
3705enddef
3706
3707def Test_no_unknown_error_after_error()
3708  if !has('unix') || !has('job')
3709    throw 'Skipped: not unix of missing +job feature'
3710  endif
3711  var lines =<< trim END
3712      vim9script
3713      var source: list<number>
3714      def Out_cb(...l: list<any>)
3715          eval [][0]
3716      enddef
3717      def Exit_cb(...l: list<any>)
3718          sleep 1m
3719          source += l
3720      enddef
3721      var myjob = job_start('echo burp', {out_cb: Out_cb, exit_cb: Exit_cb, mode: 'raw'})
3722      while job_status(myjob) == 'run'
3723        sleep 10m
3724      endwhile
3725      # wait for Exit_cb() to be called
3726      sleep 200m
3727  END
3728  writefile(lines, 'Xdef')
3729  assert_fails('so Xdef', ['E684:', 'E1012:'])
3730  delete('Xdef')
3731enddef
3732
3733def InvokeNormal()
3734  exe "norm! :m+1\r"
3735enddef
3736
3737def Test_invoke_normal_in_visual_mode()
3738  xnoremap <F3> <Cmd>call <SID>InvokeNormal()<CR>
3739  new
3740  setline(1, ['aaa', 'bbb'])
3741  feedkeys("V\<F3>", 'xt')
3742  assert_equal(['bbb', 'aaa'], getline(1, 2))
3743  xunmap <F3>
3744enddef
3745
3746def Test_white_space_after_command()
3747  var lines =<< trim END
3748    exit_cb: Func})
3749  END
3750  CheckDefAndScriptFailure(lines, 'E1144:', 1)
3751
3752  lines =<< trim END
3753    e#
3754  END
3755  CheckDefAndScriptFailure(lines, 'E1144:', 1)
3756enddef
3757
3758def Test_script_var_gone_when_sourced_twice()
3759  var lines =<< trim END
3760      vim9script
3761      if exists('g:guard')
3762        finish
3763      endif
3764      g:guard = 1
3765      var name = 'thename'
3766      def g:GetName(): string
3767        return name
3768      enddef
3769      def g:SetName(arg: string)
3770        name = arg
3771      enddef
3772  END
3773  writefile(lines, 'XscriptTwice.vim')
3774  so XscriptTwice.vim
3775  assert_equal('thename', g:GetName())
3776  g:SetName('newname')
3777  assert_equal('newname', g:GetName())
3778  so XscriptTwice.vim
3779  assert_fails('call g:GetName()', 'E1149:')
3780  assert_fails('call g:SetName("x")', 'E1149:')
3781
3782  delfunc g:GetName
3783  delfunc g:SetName
3784  delete('XscriptTwice.vim')
3785  unlet g:guard
3786enddef
3787
3788def Test_import_gone_when_sourced_twice()
3789  var exportlines =<< trim END
3790      vim9script
3791      if exists('g:guard')
3792        finish
3793      endif
3794      g:guard = 1
3795      export var name = 'someName'
3796  END
3797  writefile(exportlines, 'XexportScript.vim')
3798
3799  var lines =<< trim END
3800      vim9script
3801      import name from './XexportScript.vim'
3802      def g:GetName(): string
3803        return name
3804      enddef
3805  END
3806  writefile(lines, 'XscriptImport.vim')
3807  so XscriptImport.vim
3808  assert_equal('someName', g:GetName())
3809
3810  so XexportScript.vim
3811  assert_fails('call g:GetName()', 'E1149:')
3812
3813  delfunc g:GetName
3814  delete('XexportScript.vim')
3815  delete('XscriptImport.vim')
3816  unlet g:guard
3817enddef
3818
3819def Test_unsupported_commands()
3820  var lines =<< trim END
3821      ka
3822  END
3823  CheckDefAndScriptFailure(lines, 'E1100:')
3824
3825  lines =<< trim END
3826      :1ka
3827  END
3828  CheckDefAndScriptFailure(lines, 'E481:')
3829
3830  lines =<< trim END
3831    t
3832  END
3833  CheckDefFailure(lines, 'E1100:')
3834  CheckScriptFailure(['vim9script'] + lines, 'E1100:')
3835
3836  lines =<< trim END
3837    x
3838  END
3839  CheckDefFailure(lines, 'E1100:')
3840  CheckScriptFailure(['vim9script'] + lines, 'E1100:')
3841
3842  lines =<< trim END
3843    xit
3844  END
3845  CheckDefFailure(lines, 'E1100:')
3846  CheckScriptFailure(['vim9script'] + lines, 'E1100:')
3847enddef
3848
3849" Keep this last, it messes up highlighting.
3850def Test_substitute_cmd()
3851  new
3852  setline(1, 'something')
3853  :substitute(some(other(
3854  assert_equal('otherthing', getline(1))
3855  bwipe!
3856
3857  # also when the context is Vim9 script
3858  var lines =<< trim END
3859    vim9script
3860    new
3861    setline(1, 'something')
3862    :substitute(some(other(
3863    assert_equal('otherthing', getline(1))
3864    bwipe!
3865  END
3866  writefile(lines, 'Xvim9lines')
3867  source Xvim9lines
3868
3869  delete('Xvim9lines')
3870enddef
3871
3872" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker
3873