blob: 6e61d071895ce629c605a1c76e94409fbfee6ea7 [file] [log] [blame]
Bram Moolenaard8448622022-01-07 21:39:52 +00001" Test import/export of the Vim9 script language.
Bram Moolenaar160aa862022-01-10 21:29:57 +00002" Also the autoload mechanism.
Bram Moolenaard8448622022-01-07 21:39:52 +00003
4source check.vim
5source term_util.vim
6source vim9.vim
7
8let s:export_script_lines =<< trim END
9 vim9script
10 var name: string = 'bob'
11 def Concat(arg: string): string
12 return name .. arg
13 enddef
14 g:result = Concat('bie')
15 g:localname = name
16
17 export const CONST = 1234
18 export var exported = 9876
19 export var exp_name = 'John'
20 export def Exported(): string
21 return 'Exported'
22 enddef
23 export def ExportedValue(): number
24 return exported
25 enddef
26 export def ExportedInc()
27 exported += 5
28 enddef
29 export final theList = [1]
Bram Moolenaar857c8bb2022-01-15 21:08:19 +000030 export def AddSome(s: string): string
31 return s .. 'some'
32 enddef
33 export var AddRef = AddSome
Bram Moolenaard8448622022-01-07 21:39:52 +000034END
35
36def Undo_export_script_lines()
37 unlet g:result
38 unlet g:localname
39enddef
40
41def Test_vim9_import_export()
42 writefile(s:export_script_lines, 'Xexport.vim')
43 var import_script_lines =<< trim END
44 vim9script
45 var dir = './'
46 var ext = ".vim"
47 import dir .. 'Xexport' .. ext as expo
48
49 g:exported1 = expo.exported
50 expo.exported += 3
51 g:exported2 = expo.exported
52 g:exported3 = expo.ExportedValue()
53
54 expo.ExportedInc()
55 g:exported_i1 = expo.exported
56 g:exported_i2 = expo.ExportedValue()
57
58 expo.exported = 11
59 g:exported_s1 = expo.exported
60 g:exported_s2 = expo.ExportedValue()
61
62 g:imported_func = expo.Exported()
63
64 def GetExported(): string
65 var local_dict = {ref: expo.Exported}
66 return local_dict.ref()
67 enddef
68 g:funcref_result = GetExported()
69
Bram Moolenaar21f0d6c2022-01-20 17:35:49 +000070 def GetName(): string
71 return expo.exp_name .. 'son'
72 enddef
73 g:long_name = GetName()
74
Bram Moolenaard8448622022-01-07 21:39:52 +000075 g:imported_name = expo.exp_name
76 expo.exp_name ..= ' Doe'
Bram Moolenaar47036b62022-01-16 21:18:53 +000077 expo.exp_name = expo.exp_name .. ' Maar'
Bram Moolenaard8448622022-01-07 21:39:52 +000078 g:imported_name_appended = expo.exp_name
79 g:exported_later = expo.exported
80
81 expo.theList->add(2)
82 assert_equal([1, 2], expo.theList)
Bram Moolenaar857c8bb2022-01-15 21:08:19 +000083
84 assert_equal('andthensome', 'andthen'->expo.AddSome())
85 assert_equal('awesome', 'awe'->expo.AddRef())
Bram Moolenaard8448622022-01-07 21:39:52 +000086 END
87 writefile(import_script_lines, 'Ximport.vim')
88 source Ximport.vim
89
90 assert_equal('bobbie', g:result)
91 assert_equal('bob', g:localname)
92 assert_equal(9876, g:exported1)
93 assert_equal(9879, g:exported2)
94 assert_equal(9879, g:exported3)
95
96 assert_equal(9884, g:exported_i1)
97 assert_equal(9884, g:exported_i2)
98
99 assert_equal(11, g:exported_s1)
100 assert_equal(11, g:exported_s2)
101 assert_equal(11, g:exported_later)
102
103 assert_equal('Exported', g:imported_func)
104 assert_equal('Exported', g:funcref_result)
105 assert_equal('John', g:imported_name)
Bram Moolenaar21f0d6c2022-01-20 17:35:49 +0000106 assert_equal('Johnson', g:long_name)
Bram Moolenaar47036b62022-01-16 21:18:53 +0000107 assert_equal('John Doe Maar', g:imported_name_appended)
Bram Moolenaard8448622022-01-07 21:39:52 +0000108 assert_false(exists('g:name'))
109
110 Undo_export_script_lines()
111 unlet g:exported1
112 unlet g:exported2
113 unlet g:exported3
114 unlet g:exported_i1
115 unlet g:exported_i2
116 unlet g:exported_later
117 unlet g:imported_func
Bram Moolenaar21f0d6c2022-01-20 17:35:49 +0000118 unlet g:imported_name g:long_name g:imported_name_appended
Bram Moolenaard8448622022-01-07 21:39:52 +0000119 delete('Ximport.vim')
120
121 # similar, with line breaks
122 var import_line_break_script_lines =<< trim END
123 vim9script
124 import './Xexport.vim'
125 as expo
126 g:exported = expo.exported
127 expo.exported += 7
128 g:exported_added = expo.exported
129 g:imported_func = expo.Exported()
130 END
131 writefile(import_line_break_script_lines, 'Ximport_lbr.vim')
132 source Ximport_lbr.vim
133
134 assert_equal(11, g:exported)
135 assert_equal(18, g:exported_added)
136 assert_equal('Exported', g:imported_func)
137
138 # exported script not sourced again
139 assert_false(exists('g:result'))
140 unlet g:exported
141 unlet g:exported_added
142 unlet g:imported_func
143 delete('Ximport_lbr.vim')
144
145 var line_break_before_dot =<< trim END
146 vim9script
147 import './Xexport.vim' as expo
148 g:exported = expo
149 .exported
150 END
151 writefile(line_break_before_dot, 'Ximport_lbr_before_dot.vim')
152 assert_fails('source Ximport_lbr_before_dot.vim', 'E1060:', '', 3)
153 delete('Ximport_lbr_before_dot.vim')
154
155 var line_break_after_dot =<< trim END
156 vim9script
157 import './Xexport.vim' as expo
158 g:exported = expo.
159 exported
160 END
161 writefile(line_break_after_dot, 'Ximport_lbr_after_dot.vim')
162 assert_fails('source Ximport_lbr_after_dot.vim', 'E1074:', '', 3)
163 delete('Ximport_lbr_after_dot.vim')
164
165 var import_star_as_lines =<< trim END
166 vim9script
167 import './Xexport.vim' as Export
168 def UseExport()
169 g:exported_def = Export.exported
170 enddef
171 g:exported_script = Export.exported
172 assert_equal(1, exists('Export.exported'))
173 assert_equal(0, exists('Export.notexported'))
174 UseExport()
175 END
176 writefile(import_star_as_lines, 'Ximport.vim')
177 source Ximport.vim
178
179 assert_equal(18, g:exported_def)
180 assert_equal(18, g:exported_script)
181 unlet g:exported_def
182 unlet g:exported_script
183
184 var import_star_as_lines_no_dot =<< trim END
185 vim9script
186 import './Xexport.vim' as Export
187 def Func()
188 var dummy = 1
189 var imported = Export + dummy
190 enddef
191 defcompile
192 END
193 writefile(import_star_as_lines_no_dot, 'Ximport.vim')
194 assert_fails('source Ximport.vim', 'E1060:', '', 2, 'Func')
195
196 var import_star_as_lines_dot_space =<< trim END
197 vim9script
198 import './Xexport.vim' as Export
199 def Func()
200 var imported = Export . exported
201 enddef
202 defcompile
203 END
204 writefile(import_star_as_lines_dot_space, 'Ximport.vim')
205 assert_fails('source Ximport.vim', 'E1074:', '', 1, 'Func')
206
Bram Moolenaar7c24dfd2022-01-08 17:03:55 +0000207 writefile(s:export_script_lines, 'Xexport2.vim')
208 var import_as_duplicated =<< trim END
Bram Moolenaard8448622022-01-07 21:39:52 +0000209 vim9script
210 import './Xexport.vim' as expo
Bram Moolenaar7c24dfd2022-01-08 17:03:55 +0000211 import './Xexport2.vim' as expo
Bram Moolenaard8448622022-01-07 21:39:52 +0000212 END
Bram Moolenaar7c24dfd2022-01-08 17:03:55 +0000213 writefile(import_as_duplicated, 'Ximport.vim')
Bram Moolenaard8448622022-01-07 21:39:52 +0000214 assert_fails('source Ximport.vim', 'E1073:', '', 3, 'Ximport.vim')
Bram Moolenaar7c24dfd2022-01-08 17:03:55 +0000215 delete('Xexport2.vim')
Bram Moolenaard8448622022-01-07 21:39:52 +0000216
217 var import_star_as_lines_script_no_dot =<< trim END
218 vim9script
219 import './Xexport.vim' as Export
220 g:imported_script = Export exported
221 END
222 writefile(import_star_as_lines_script_no_dot, 'Ximport.vim')
223 assert_fails('source Ximport.vim', 'E1060: Expected dot after name: Export exported')
224
225 var import_star_as_lines_script_space_after_dot =<< trim END
226 vim9script
227 import './Xexport.vim' as Export
228 g:imported_script = Export. exported
229 END
230 writefile(import_star_as_lines_script_space_after_dot, 'Ximport.vim')
231 assert_fails('source Ximport.vim', 'E1074:')
232
233 var import_star_as_lines_missing_name =<< trim END
234 vim9script
235 import './Xexport.vim' as Export
236 def Func()
237 var imported = Export.
238 enddef
239 defcompile
240 END
241 writefile(import_star_as_lines_missing_name, 'Ximport.vim')
242 assert_fails('source Ximport.vim', 'E1048:', '', 1, 'Func')
243
244 var import_star_as_lbr_lines =<< trim END
245 vim9script
246 import './Xexport.vim'
247 as Export
248 def UseExport()
249 g:exported = Export.exported
250 enddef
251 UseExport()
252 END
253 writefile(import_star_as_lbr_lines, 'Ximport.vim')
254 source Ximport.vim
255 assert_equal(18, g:exported)
256 unlet g:exported
257
258 # try to use something that exists but is not exported
259 var import_not_exported_lines =<< trim END
260 vim9script
261 import './Xexport.vim' as expo
262 echo expo.name
263 END
264 writefile(import_not_exported_lines, 'Ximport.vim')
265 assert_fails('source Ximport.vim', 'E1049:', '', 3, 'Ximport.vim')
266
267 # try to import something that is already defined
268 var import_already_defined =<< trim END
269 vim9script
270 var exported = 'something'
271 import './Xexport.vim' as exported
272 END
273 writefile(import_already_defined, 'Ximport.vim')
274 assert_fails('source Ximport.vim', 'E1054:', '', 3, 'Ximport.vim')
275
276 # try changing an imported const
277 var import_assign_to_const =<< trim END
278 vim9script
279 import './Xexport.vim' as expo
280 def Assign()
281 expo.CONST = 987
282 enddef
283 defcompile
284 END
285 writefile(import_assign_to_const, 'Ximport.vim')
286 assert_fails('source Ximport.vim', 'E46:', '', 1, '_Assign')
287
288 # try changing an imported final
289 var import_assign_to_final =<< trim END
290 vim9script
291 import './Xexport.vim' as expo
292 def Assign()
293 expo.theList = [2]
294 enddef
295 defcompile
296 END
297 writefile(import_assign_to_final, 'Ximport.vim')
298 assert_fails('source Ximport.vim', 'E46:', '', 1, '_Assign')
299
300 var import_no_as_lines =<< trim END
301 vim9script
302 import './Xexport.vim' name
303 END
304 writefile(import_no_as_lines, 'Ximport.vim')
305 assert_fails('source Ximport.vim', 'E488:', '', 2, 'Ximport.vim')
306
307 var import_invalid_string_lines =<< trim END
308 vim9script
309 import Xexport.vim
310 END
311 writefile(import_invalid_string_lines, 'Ximport.vim')
312 assert_fails('source Ximport.vim', 'E121:', '', 2, 'Ximport.vim')
313
314 var import_wrong_name_lines =<< trim END
315 vim9script
316 import './XnoExport.vim'
317 END
318 writefile(import_wrong_name_lines, 'Ximport.vim')
319 assert_fails('source Ximport.vim', 'E1053:', '', 2, 'Ximport.vim')
320
321 var import_redefining_lines =<< trim END
322 vim9script
323 import './Xexport.vim' as exported
324 var exported = 5
325 END
326 writefile(import_redefining_lines, 'Ximport.vim')
327 assert_fails('source Ximport.vim', 'E1213: Redefining imported item "exported"', '', 3)
328
Bram Moolenaar160aa862022-01-10 21:29:57 +0000329 var import_missing_dot_lines =<< trim END
330 vim9script
331 import './Xexport.vim' as expo
332 def Test()
333 expo = 9
334 enddef
335 defcompile
336 END
337 writefile(import_missing_dot_lines, 'Ximport.vim')
338 assert_fails('source Ximport.vim', 'E1258:', '', 1)
339
340 var import_missing_name_lines =<< trim END
341 vim9script
342 import './Xexport.vim' as expo
343 def Test()
344 expo.99 = 9
345 enddef
346 defcompile
347 END
348 writefile(import_missing_name_lines, 'Ximport.vim')
Bram Moolenaar76283822022-01-10 21:39:03 +0000349 assert_fails('source Ximport.vim', 'E1259:', '', 1)
Bram Moolenaar160aa862022-01-10 21:29:57 +0000350
Bram Moolenaard8448622022-01-07 21:39:52 +0000351 var import_assign_wrong_type_lines =<< trim END
352 vim9script
353 import './Xexport.vim' as expo
354 expo.exported = 'xxx'
355 END
356 writefile(import_assign_wrong_type_lines, 'Ximport.vim')
357 assert_fails('source Ximport.vim', 'E1012: Type mismatch; expected number but got string', '', 3)
358
359 var import_assign_const_lines =<< trim END
360 vim9script
361 import './Xexport.vim' as expo
362 expo.CONST = 4321
363 END
364 writefile(import_assign_const_lines, 'Ximport.vim')
365 assert_fails('source Ximport.vim', 'E46: Cannot change read-only variable "CONST"', '', 3)
366
367 delete('Ximport.vim')
368 delete('Ximport3.vim')
369 delete('Xexport.vim')
370
371 # Check that in a Vim9 script 'cpo' is set to the Vim default.
372 # Flags added or removed are also applied to the restored value.
373 set cpo=abcd
374 var lines =<< trim END
375 vim9script
376 g:cpo_in_vim9script = &cpo
377 set cpo+=f
378 set cpo-=c
379 g:cpo_after_vim9script = &cpo
380 END
381 writefile(lines, 'Xvim9_script')
382 source Xvim9_script
383 assert_equal('fabd', &cpo)
384 set cpo&vim
385 assert_equal(&cpo, g:cpo_in_vim9script)
386 var newcpo = substitute(&cpo, 'c', '', '') .. 'f'
387 assert_equal(newcpo, g:cpo_after_vim9script)
388
389 delete('Xvim9_script')
390enddef
391
392def Test_import_funcref()
393 var lines =<< trim END
394 vim9script
395 export def F(): number
396 return 42
397 enddef
398 export const G = F
399 END
400 writefile(lines, 'Xlib.vim')
401
402 lines =<< trim END
403 vim9script
404 import './Xlib.vim' as lib
405 const Foo = lib.G()
406 assert_equal(42, Foo)
407
408 def DoTest()
409 const Goo = lib.G()
410 assert_equal(42, Goo)
411 enddef
412 DoTest()
413 END
414 CheckScriptSuccess(lines)
415
416 delete('Xlib.vim')
417enddef
418
419def Test_import_fails()
420 writefile([], 'Xfoo.vim')
421 var lines =<< trim END
422 import './Xfoo.vim' as foo
423 foo = 'bar'
424 END
425 CheckDefAndScriptFailure(lines, ['E1094:', 'E1236: Cannot use foo itself'])
426 lines =<< trim END
427 vim9script
428 import './Xfoo.vim' as foo
429 var that = foo
430 END
431 CheckScriptFailure(lines, 'E1060: Expected dot after name: foo')
Bram Moolenaardd5893b2022-01-20 21:32:54 +0000432 lines =<< trim END
433 vim9script
434 import './Xfoo.vim' as foo
435 var that: any
436 that += foo
437 END
438 CheckScriptFailure(lines, 'E1060: Expected dot after name: foo')
439 lines =<< trim END
440 vim9script
441 import './Xfoo.vim' as foo
442 foo += 9
443 END
444 CheckScriptFailure(lines, 'E1060: Expected dot after name: foo')
Bram Moolenaard8448622022-01-07 21:39:52 +0000445
446 lines =<< trim END
447 vim9script
448 import './Xfoo.vim' as 9foo
449 END
450 CheckScriptFailure(lines, 'E1047:')
451 lines =<< trim END
452 vim9script
453 import './Xfoo.vim' as the#foo
454 END
455 CheckScriptFailure(lines, 'E1047:')
456 lines =<< trim END
457 vim9script
458 import './Xfoo.vim' as g:foo
459 END
460 CheckScriptFailure(lines, 'E1047:')
461
462 delete('Xfoo.vim')
463
464 lines =<< trim END
465 vim9script
466 def TheFunc()
467 echo 'the func'
468 enddef
469 export var Ref = TheFunc
470 END
471 writefile([], 'Xthat.vim')
Bram Moolenaar7c24dfd2022-01-08 17:03:55 +0000472
Bram Moolenaard8448622022-01-07 21:39:52 +0000473 lines =<< trim END
474 import './Xthat.vim' as That
475 That()
476 END
477 CheckDefAndScriptFailure(lines, ['E1094:', 'E1236: Cannot use That itself'])
Bram Moolenaar7c24dfd2022-01-08 17:03:55 +0000478
479 lines =<< trim END
Bram Moolenaar937610b2022-01-19 17:21:29 +0000480 vim9script
481 import './Xthat.vim' as That
482 def Func()
483 echo That()
484 enddef
485 Func()
486 END
487 CheckScriptFailure(lines, 'E1236: Cannot use That itself')
488
489 lines =<< trim END
Bram Moolenaar7c24dfd2022-01-08 17:03:55 +0000490 import './Xthat.vim' as one
491 import './Xthat.vim' as two
492 END
493 CheckScriptFailure(lines, 'E1262:')
494
495 delete('Xthat.vim')
Bram Moolenaard8448622022-01-07 21:39:52 +0000496
497 mkdir('Ximport')
498
499 writefile(['vim9script'], 'Ximport/.vim')
500 lines =<< trim END
501 vim9script
502 import './Ximport/.vim'
503 END
504 CheckScriptFailure(lines, 'E1261: Cannot import .vim without using "as"')
505 lines =<< trim END
506 vim9script
507 import './Ximport/.vim' as vim
508 END
509 CheckScriptSuccess(lines)
510
511 writefile(['vim9script'], 'Ximport/.vimrc')
512 lines =<< trim END
513 vim9script
514 import './Ximport/.vimrc'
515 END
516 CheckScriptFailure(lines, 'E1257: Imported script must use "as" or end in .vim')
517 lines =<< trim END
518 vim9script
519 import './Ximport/.vimrc' as vimrc
520 END
521 CheckScriptSuccess(lines)
522
523 delete('Ximport', 'rf')
524enddef
525
526func g:Trigger()
527 source Ximport.vim
528 return "echo 'yes'\<CR>"
529endfunc
530
531def Test_import_export_expr_map()
532 # check that :import and :export work when buffer is locked
533 var export_lines =<< trim END
534 vim9script
535 export def That(): string
536 return 'yes'
537 enddef
538 END
539 writefile(export_lines, 'Xexport_that.vim')
540
541 var import_lines =<< trim END
542 vim9script
543 import './Xexport_that.vim' as that
544 assert_equal('yes', that.That())
545 END
546 writefile(import_lines, 'Ximport.vim')
547
548 nnoremap <expr> trigger g:Trigger()
549 feedkeys('trigger', "xt")
550
551 delete('Xexport_that.vim')
552 delete('Ximport.vim')
553 nunmap trigger
554enddef
555
556def Test_import_in_filetype()
557 # check that :import works when the buffer is locked
558 mkdir('ftplugin', 'p')
559 var export_lines =<< trim END
560 vim9script
561 export var That = 'yes'
562 END
563 writefile(export_lines, 'ftplugin/Xexport_ft.vim')
564
565 var import_lines =<< trim END
566 vim9script
567 import './Xexport_ft.vim' as ft
568 assert_equal('yes', ft.That)
569 g:did_load_mytpe = 1
570 END
571 writefile(import_lines, 'ftplugin/qf.vim')
572
573 var save_rtp = &rtp
574 &rtp = getcwd() .. ',' .. &rtp
575
576 filetype plugin on
577 copen
578 assert_equal(1, g:did_load_mytpe)
579
580 quit!
581 delete('Xexport_ft.vim')
582 delete('ftplugin', 'rf')
583 &rtp = save_rtp
584enddef
585
586def Test_use_import_in_mapping()
587 var lines =<< trim END
588 vim9script
589 export def Funcx()
590 g:result = 42
591 enddef
592 END
593 writefile(lines, 'XsomeExport.vim')
594 lines =<< trim END
595 vim9script
596 import './XsomeExport.vim' as some
597 var Funcy = some.Funcx
598 nnoremap <F3> :call <sid>Funcy()<cr>
599 END
600 writefile(lines, 'Xmapscript.vim')
601
602 source Xmapscript.vim
603 feedkeys("\<F3>", "xt")
604 assert_equal(42, g:result)
605
606 unlet g:result
607 delete('XsomeExport.vim')
608 delete('Xmapscript.vim')
609 nunmap <F3>
610enddef
611
Bram Moolenaarf0e7e632022-01-21 13:29:56 +0000612def Test_use_import_in_command_completion()
Bram Moolenaar15d16352022-01-17 20:09:08 +0000613 var lines =<< trim END
614 vim9script
615 export def Complete(..._): list<string>
616 return ['abcd']
617 enddef
618 END
619 writefile(lines, 'Xscript.vim')
620
621 lines =<< trim END
622 vim9script
623 import './Xscript.vim'
624
625 command -nargs=1 -complete=customlist,Xscript.Complete Cmd echo 'ok'
626 feedkeys(":Cmd ab\<Tab>\<C-B>#\<CR>", 'xnt')
627 assert_equal('#Cmd abcd', @:)
628 END
629 CheckScriptSuccess(lines)
630
631 delcommand Cmd
632 delete('Xscript.vim')
633enddef
634
Bram Moolenaarf0e7e632022-01-21 13:29:56 +0000635def Test_use_autoload_import_in_insert_completion()
636 mkdir('Xdir/autoload', 'p')
637 var save_rtp = &rtp
638 exe 'set rtp^=' .. getcwd() .. '/Xdir'
639
640 var lines =<< trim END
641 vim9script
642 export def ThesaurusFunc(findbase: bool, _): any
643 if findbase
644 return 1
645 endif
646 return [
647 'check',
648 'experiment',
649 'test',
650 'verification'
651 ]
652 enddef
653 g:completion_loaded = 'yes'
654 END
655 writefile(lines, 'Xdir/autoload/completion.vim')
656
657 new
658 lines =<< trim END
659 vim9script
660 g:completion_loaded = 'no'
661 import autoload 'completion.vim'
662 set thesaurusfunc=completion.ThesaurusFunc
663 assert_equal('no', g:completion_loaded)
664 feedkeys("i\<C-X>\<C-T>\<C-N>\<Esc>", 'xt')
665 assert_equal('experiment', getline(1))
666 assert_equal('yes', g:completion_loaded)
667 END
668 CheckScriptSuccess(lines)
669
670 set thesaurusfunc=
671 bwipe!
672 delete('Xdir', 'rf')
673 &rtp = save_rtp
674enddef
675
Bram Moolenaard8448622022-01-07 21:39:52 +0000676def Test_export_fails()
677 CheckScriptFailure(['export var some = 123'], 'E1042:')
678 CheckScriptFailure(['vim9script', 'export var g:some'], 'E1022:')
679 CheckScriptFailure(['vim9script', 'export echo 134'], 'E1043:')
680
681 assert_fails('export something', 'E1043:')
682enddef
683
684func Test_import_fails_without_script()
685 CheckRunVimInTerminal
686
687 " call indirectly to avoid compilation error for missing functions
688 call Run_Test_import_fails_on_command_line()
689endfunc
690
691def Run_Test_import_fails_on_command_line()
692 var export =<< trim END
693 vim9script
694 export def Foo(): number
695 return 0
696 enddef
697 END
698 writefile(export, 'XexportCmd.vim')
699
700 var buf = RunVimInTerminal('-c "import Foo from ''./XexportCmd.vim''"', {
701 rows: 6, wait_for_ruler: 0})
702 WaitForAssert(() => assert_match('^E1094:', term_getline(buf, 5)))
703
704 delete('XexportCmd.vim')
705 StopVimInTerminal(buf)
706enddef
707
708def Test_vim9_reload_noclear()
709 var lines =<< trim END
710 vim9script
711 export var exported = 'thexport'
712
713 export def TheFunc(x = 0)
714 enddef
715 END
716 writefile(lines, 'XExportReload')
717 lines =<< trim END
718 vim9script noclear
719 g:loadCount += 1
720 var s:reloaded = 'init'
721 import './XExportReload' as exp
722
723 def Again(): string
724 return 'again'
725 enddef
726
727 exp.TheFunc()
728
729 if exists('s:loaded') | finish | endif
730 var s:loaded = true
731
732 var s:notReloaded = 'yes'
733 s:reloaded = 'first'
734 def g:Values(): list<string>
735 return [s:reloaded, s:notReloaded, Again(), Once(), exp.exported]
736 enddef
737
738 def Once(): string
739 return 'once'
740 enddef
741 END
742 writefile(lines, 'XReloaded')
743 g:loadCount = 0
744 source XReloaded
745 assert_equal(1, g:loadCount)
746 assert_equal(['first', 'yes', 'again', 'once', 'thexport'], g:Values())
747 source XReloaded
748 assert_equal(2, g:loadCount)
749 assert_equal(['init', 'yes', 'again', 'once', 'thexport'], g:Values())
750 source XReloaded
751 assert_equal(3, g:loadCount)
752 assert_equal(['init', 'yes', 'again', 'once', 'thexport'], g:Values())
753
754 delete('XReloaded')
755 delete('XExportReload')
756 delfunc g:Values
757 unlet g:loadCount
758
759 lines =<< trim END
760 vim9script
761 def Inner()
762 enddef
763 END
764 lines->writefile('XreloadScript.vim')
765 source XreloadScript.vim
766
767 lines =<< trim END
768 vim9script
769 def Outer()
770 def Inner()
771 enddef
772 enddef
773 defcompile
774 END
775 lines->writefile('XreloadScript.vim')
776 source XreloadScript.vim
777
778 delete('XreloadScript.vim')
779enddef
780
781def Test_vim9_reload_import()
782 var lines =<< trim END
783 vim9script
784 const var = ''
785 var valone = 1234
786 def MyFunc(arg: string)
787 valone = 5678
788 enddef
789 END
790 var morelines =<< trim END
791 var valtwo = 222
792 export def GetValtwo(): number
793 return valtwo
794 enddef
795 END
796 writefile(lines + morelines, 'Xreload.vim')
797 source Xreload.vim
798 source Xreload.vim
799 source Xreload.vim
800
801 # cannot declare a var twice
802 lines =<< trim END
803 vim9script
804 var valone = 1234
805 var valone = 5678
806 END
807 writefile(lines, 'Xreload.vim')
808 assert_fails('source Xreload.vim', 'E1041:', '', 3, 'Xreload.vim')
809
810 delete('Xreload.vim')
811 delete('Ximport.vim')
812enddef
813
814" if a script is reloaded with a script-local variable that changed its type, a
815" compiled function using that variable must fail.
816def Test_script_reload_change_type()
817 var lines =<< trim END
818 vim9script noclear
819 var str = 'string'
820 def g:GetStr(): string
821 return str .. 'xxx'
822 enddef
823 END
824 writefile(lines, 'Xreload.vim')
825 source Xreload.vim
826 echo g:GetStr()
827
828 lines =<< trim END
829 vim9script noclear
830 var str = 1234
831 END
832 writefile(lines, 'Xreload.vim')
833 source Xreload.vim
834 assert_fails('echo g:GetStr()', 'E1150:')
835
836 delfunc g:GetStr
837 delete('Xreload.vim')
838enddef
839
840" Define CallFunc so that the test can be compiled
841command CallFunc echo 'nop'
842
843def Test_script_reload_from_function()
844 var lines =<< trim END
845 vim9script
846
847 if exists('g:loaded')
848 finish
849 endif
850 g:loaded = 1
851 delcommand CallFunc
852 command CallFunc Func()
853 def Func()
854 so XreloadFunc.vim
855 g:didTheFunc = 1
856 enddef
857 END
858 writefile(lines, 'XreloadFunc.vim')
859 source XreloadFunc.vim
860 CallFunc
861 assert_equal(1, g:didTheFunc)
862
863 delete('XreloadFunc.vim')
864 delcommand CallFunc
865 unlet g:loaded
866 unlet g:didTheFunc
867enddef
868
869def s:RetSome(): string
870 return 'some'
871enddef
872
873" Not exported function that is referenced needs to be accessed by the
874" script-local name.
875def Test_vim9_funcref()
876 var sortlines =<< trim END
877 vim9script
878 def Compare(i1: number, i2: number): number
879 return i2 - i1
880 enddef
881
882 export def FastSort(): list<number>
883 return range(5)->sort(Compare)
884 enddef
885
886 export def GetString(arg: string): string
887 return arg
888 enddef
889 END
890 writefile(sortlines, 'Xsort.vim')
891
892 var lines =<< trim END
893 vim9script
894 import './Xsort.vim'
895 def Test()
896 g:result = Xsort.FastSort()
897 enddef
898 Test()
Bram Moolenaar7c24dfd2022-01-08 17:03:55 +0000899 END
900 writefile(lines, 'Xscript.vim')
901 source Xscript.vim
902 assert_equal([4, 3, 2, 1, 0], g:result)
903 unlet g:result
Bram Moolenaard8448622022-01-07 21:39:52 +0000904
Bram Moolenaar7c24dfd2022-01-08 17:03:55 +0000905 lines =<< trim END
906 vim9script
Bram Moolenaard8448622022-01-07 21:39:52 +0000907 # using a function imported with "as"
908 import './Xsort.vim' as anAlias
909 assert_equal('yes', anAlias.GetString('yes'))
910
911 # using the function from a compiled function
912 def TestMore(): string
913 var s = s:anAlias.GetString('foo')
914 return s .. anAlias.GetString('bar')
915 enddef
916 assert_equal('foobar', TestMore())
917
918 # error when using a function that isn't exported
919 assert_fails('anAlias.Compare(1, 2)', 'E1049:')
920 END
921 writefile(lines, 'Xscript.vim')
922
Bram Moolenaard8448622022-01-07 21:39:52 +0000923 delete('Xsort.vim')
924 delete('Xscript.vim')
925
926 var Funcref = function('s:RetSome')
927 assert_equal('some', Funcref())
928enddef
929
930" Check that when searching for "FilterFunc" it finds the import in the
931" script where FastFilter() is called from, both as a string and as a direct
932" function reference.
933def Test_vim9_funcref_other_script()
934 var filterLines =<< trim END
935 vim9script
936 export def FilterFunc(idx: number, val: number): bool
937 return idx % 2 == 1
938 enddef
939 export def FastFilter(): list<number>
940 return range(10)->filter('FilterFunc(v:key, v:val)')
941 enddef
942 export def FastFilterDirect(): list<number>
943 return range(10)->filter(FilterFunc)
944 enddef
945 END
946 writefile(filterLines, 'Xfilter.vim')
947
948 var lines =<< trim END
949 vim9script
950 import './Xfilter.vim' as filter
951 def Test()
952 var x: list<number> = filter.FastFilter()
953 enddef
954 Test()
955 def TestDirect()
956 var x: list<number> = filter.FastFilterDirect()
957 enddef
958 TestDirect()
959 END
960 CheckScriptSuccess(lines)
961 delete('Xfilter.vim')
962enddef
963
964def Test_import_absolute()
965 var import_lines = [
966 'vim9script',
967 'import "' .. escape(getcwd(), '\') .. '/Xexport_abs.vim" as abs',
968 'def UseExported()',
969 ' g:imported_abs = abs.exported',
970 ' abs.exported = 8888',
971 ' g:imported_after = abs.exported',
972 'enddef',
973 'UseExported()',
974 'g:import_disassembled = execute("disass UseExported")',
975 ]
976 writefile(import_lines, 'Ximport_abs.vim')
977 writefile(s:export_script_lines, 'Xexport_abs.vim')
978
979 source Ximport_abs.vim
980
981 assert_equal(9876, g:imported_abs)
982 assert_equal(8888, g:imported_after)
983 assert_match('<SNR>\d\+_UseExported\_s*' ..
984 'g:imported_abs = abs.exported\_s*' ..
985 '0 LOADSCRIPT exported-2 from .*Xexport_abs.vim\_s*' ..
986 '1 STOREG g:imported_abs\_s*' ..
987 'abs.exported = 8888\_s*' ..
988 '2 PUSHNR 8888\_s*' ..
989 '3 STORESCRIPT exported-2 in .*Xexport_abs.vim\_s*' ..
990 'g:imported_after = abs.exported\_s*' ..
991 '4 LOADSCRIPT exported-2 from .*Xexport_abs.vim\_s*' ..
992 '5 STOREG g:imported_after',
993 g:import_disassembled)
994
995 Undo_export_script_lines()
996 unlet g:imported_abs
997 unlet g:import_disassembled
998
999 delete('Ximport_abs.vim')
1000 delete('Xexport_abs.vim')
1001enddef
1002
1003def Test_import_rtp()
1004 var import_lines = [
1005 'vim9script',
1006 'import "Xexport_rtp.vim" as rtp',
1007 'g:imported_rtp = rtp.exported',
1008 ]
1009 writefile(import_lines, 'Ximport_rtp.vim')
1010 mkdir('import', 'p')
1011 writefile(s:export_script_lines, 'import/Xexport_rtp.vim')
1012
1013 var save_rtp = &rtp
1014 &rtp = getcwd()
1015 source Ximport_rtp.vim
1016 &rtp = save_rtp
1017
1018 assert_equal(9876, g:imported_rtp)
1019
1020 Undo_export_script_lines()
1021 unlet g:imported_rtp
1022 delete('Ximport_rtp.vim')
1023 delete('import', 'rf')
1024enddef
1025
1026def Test_import_compile_error()
1027 var export_lines = [
1028 'vim9script',
1029 'export def ExpFunc(): string',
1030 ' return notDefined',
1031 'enddef',
1032 ]
1033 writefile(export_lines, 'Xexported.vim')
1034
1035 var import_lines = [
1036 'vim9script',
1037 'import "./Xexported.vim" as expo',
1038 'def ImpFunc()',
1039 ' echo expo.ExpFunc()',
1040 'enddef',
1041 'defcompile',
1042 ]
1043 writefile(import_lines, 'Ximport.vim')
1044
1045 try
1046 source Ximport.vim
1047 catch /E1001/
1048 # Error should be before the Xexported.vim file.
1049 assert_match('E1001: Variable not found: notDefined', v:exception)
1050 assert_match('function <SNR>\d\+_ImpFunc\[1\]..<SNR>\d\+_ExpFunc, line 1', v:throwpoint)
1051 endtry
1052
1053 delete('Xexported.vim')
1054 delete('Ximport.vim')
1055enddef
1056
1057def Test_func_overrules_import_fails()
1058 var export_lines =<< trim END
1059 vim9script
1060 export def Func()
1061 echo 'imported'
1062 enddef
1063 END
1064 writefile(export_lines, 'XexportedFunc.vim')
1065
1066 var lines =<< trim END
1067 vim9script
1068 import './XexportedFunc.vim' as Func
1069 def Func()
1070 echo 'local to function'
1071 enddef
1072 END
Bram Moolenaar937610b2022-01-19 17:21:29 +00001073 CheckScriptFailure(lines, 'E1213: Redefining imported item "Func"')
Bram Moolenaard8448622022-01-07 21:39:52 +00001074
1075 lines =<< trim END
1076 vim9script
1077 import './XexportedFunc.vim' as Func
1078 def Outer()
1079 def Func()
1080 echo 'local to function'
1081 enddef
1082 enddef
1083 defcompile
1084 END
1085 CheckScriptFailure(lines, 'E1236:')
1086
1087 delete('XexportedFunc.vim')
1088enddef
1089
1090def Test_source_vim9_from_legacy()
1091 var vim9_lines =<< trim END
1092 vim9script
1093 var local = 'local'
1094 g:global = 'global'
1095 export var exported = 'exported'
1096 export def GetText(): string
1097 return 'text'
1098 enddef
1099 END
1100 writefile(vim9_lines, 'Xvim9_script.vim')
1101
1102 var legacy_lines =<< trim END
1103 source Xvim9_script.vim
1104
1105 call assert_false(exists('local'))
1106 call assert_false(exists('exported'))
1107 call assert_false(exists('s:exported'))
1108 call assert_equal('global', global)
1109 call assert_equal('global', g:global)
Bram Moolenaard8448622022-01-07 21:39:52 +00001110 END
1111 writefile(legacy_lines, 'Xlegacy_script.vim')
1112
1113 source Xlegacy_script.vim
1114 assert_equal('global', g:global)
1115 unlet g:global
1116
1117 delete('Xlegacy_script.vim')
1118 delete('Xvim9_script.vim')
1119enddef
1120
Bram Moolenaarc43e6232022-01-13 20:51:56 +00001121def Test_import_vim9_from_legacy()
1122 var vim9_lines =<< trim END
1123 vim9script
1124 var local = 'local'
1125 g:global = 'global'
1126 export var exported = 'exported'
1127 export def GetText(): string
1128 return 'text'
1129 enddef
1130 END
1131 writefile(vim9_lines, 'Xvim9_export.vim')
1132
1133 var legacy_lines =<< trim END
1134 import './Xvim9_export.vim' as vim9
1135
1136 call assert_false(exists('vim9'))
1137 call assert_false(exists('local'))
1138 call assert_false(exists('s:vim9.local'))
1139 call assert_equal('global', global)
1140 call assert_equal('global', g:global)
1141 call assert_false(exists('exported'))
1142 call assert_false(exists('s:exported'))
1143 call assert_false(exists('*GetText'))
1144
1145 " imported symbol is script-local
1146 call assert_equal('exported', s:vim9.exported)
1147 call assert_equal('text', s:vim9.GetText())
1148 END
1149 writefile(legacy_lines, 'Xlegacy_script.vim')
1150
1151 source Xlegacy_script.vim
1152 assert_equal('global', g:global)
1153 unlet g:global
1154
1155 delete('Xlegacy_script.vim')
1156 delete('Xvim9_export.vim')
1157enddef
1158
Bram Moolenaard8448622022-01-07 21:39:52 +00001159def Test_cmdline_win()
1160 # if the Vim syntax highlighting uses Vim9 constructs they can be used from
1161 # the command line window.
1162 mkdir('rtp/syntax', 'p')
1163 var export_lines =<< trim END
1164 vim9script
1165 export var That = 'yes'
1166 END
1167 writefile(export_lines, 'rtp/syntax/Xexport.vim')
1168 var import_lines =<< trim END
1169 vim9script
1170 import './Xexport.vim' as exp
1171 echo exp.That
1172 END
1173 writefile(import_lines, 'rtp/syntax/vim.vim')
1174 var save_rtp = &rtp
1175 &rtp = getcwd() .. '/rtp' .. ',' .. &rtp
1176 syntax on
1177 augroup CmdWin
1178 autocmd CmdwinEnter * g:got_there = 'yes'
1179 augroup END
1180 # this will open and also close the cmdline window
1181 feedkeys('q:', 'xt')
1182 assert_equal('yes', g:got_there)
1183
1184 augroup CmdWin
1185 au!
1186 augroup END
1187 &rtp = save_rtp
1188 delete('rtp', 'rf')
1189enddef
1190
1191def Test_import_gone_when_sourced_twice()
1192 var exportlines =<< trim END
1193 vim9script
1194 if exists('g:guard')
1195 finish
1196 endif
1197 g:guard = 1
1198 export var name = 'someName'
1199 END
1200 writefile(exportlines, 'XexportScript.vim')
1201
1202 var lines =<< trim END
1203 vim9script
1204 import './XexportScript.vim' as expo
1205 def g:GetName(): string
1206 return expo.name
1207 enddef
1208 END
1209 writefile(lines, 'XscriptImport.vim')
1210 so XscriptImport.vim
1211 assert_equal('someName', g:GetName())
1212
1213 so XexportScript.vim
1214 assert_fails('call g:GetName()', 'E1149:')
1215
1216 delfunc g:GetName
1217 delete('XexportScript.vim')
1218 delete('XscriptImport.vim')
1219 unlet g:guard
1220enddef
1221
Bram Moolenaar160aa862022-01-10 21:29:57 +00001222" test using an auto-loaded function and variable
Bram Moolenaar0e3e7ba2022-01-13 20:18:56 +00001223def Test_vim9_autoload_full_name()
Bram Moolenaar160aa862022-01-10 21:29:57 +00001224 var lines =<< trim END
1225 vim9script
1226 def some#gettest(): string
1227 return 'test'
1228 enddef
1229 g:some#name = 'name'
1230 g:some#dict = {key: 'value'}
1231
1232 def some#varargs(a1: string, ...l: list<string>): string
1233 return a1 .. l[0] .. l[1]
1234 enddef
1235 END
1236
1237 mkdir('Xdir/autoload', 'p')
1238 writefile(lines, 'Xdir/autoload/some.vim')
1239 var save_rtp = &rtp
1240 exe 'set rtp^=' .. getcwd() .. '/Xdir'
1241
1242 assert_equal('test', g:some#gettest())
1243 assert_equal('name', g:some#name)
1244 assert_equal('value', g:some#dict.key)
1245 g:some#other = 'other'
1246 assert_equal('other', g:some#other)
1247
1248 assert_equal('abc', some#varargs('a', 'b', 'c'))
1249
1250 # upper case script name works
1251 lines =<< trim END
1252 vim9script
1253 def Other#getOther(): string
1254 return 'other'
1255 enddef
1256 END
1257 writefile(lines, 'Xdir/autoload/Other.vim')
1258 assert_equal('other', g:Other#getOther())
1259
1260 delete('Xdir', 'rf')
1261 &rtp = save_rtp
1262enddef
1263
1264def Test_vim9script_autoload()
1265 mkdir('Xdir/autoload', 'p')
1266 var save_rtp = &rtp
1267 exe 'set rtp^=' .. getcwd() .. '/Xdir'
1268
Bram Moolenaarfd218c82022-01-18 16:26:24 +00001269 # when the path has "/autoload/" prefix is not needed
Bram Moolenaar160aa862022-01-10 21:29:57 +00001270 var lines =<< trim END
Bram Moolenaarfd218c82022-01-18 16:26:24 +00001271 vim9script
Bram Moolenaar17d36cb2022-01-12 11:46:40 +00001272 g:prefixed_loaded += 1
Bram Moolenaar160aa862022-01-10 21:29:57 +00001273
1274 export def Gettest(): string
1275 return 'test'
1276 enddef
1277
Bram Moolenaar0e3e7ba2022-01-13 20:18:56 +00001278 export var name = 'name'
1279
1280 export func GetFunc()
1281 return Gettest() .. 'more' .. s:name
Bram Moolenaar160aa862022-01-10 21:29:57 +00001282 endfunc
1283
Bram Moolenaar0e3e7ba2022-01-13 20:18:56 +00001284 export def GetDef(): string
1285 return Gettest() .. 'more' .. name
1286 enddef
1287
Bram Moolenaar160aa862022-01-10 21:29:57 +00001288 export final fname = 'final'
1289 export const cname = 'const'
1290 END
1291 writefile(lines, 'Xdir/autoload/prefixed.vim')
1292
Bram Moolenaar17d36cb2022-01-12 11:46:40 +00001293 g:prefixed_loaded = 0
1294 g:expected_loaded = 0
Bram Moolenaar160aa862022-01-10 21:29:57 +00001295 lines =<< trim END
1296 vim9script
1297 import autoload 'prefixed.vim'
Bram Moolenaar17d36cb2022-01-12 11:46:40 +00001298 assert_equal(g:expected_loaded, g:prefixed_loaded)
Bram Moolenaar160aa862022-01-10 21:29:57 +00001299 assert_equal('test', prefixed.Gettest())
Bram Moolenaar17d36cb2022-01-12 11:46:40 +00001300 assert_equal(1, g:prefixed_loaded)
Bram Moolenaar160aa862022-01-10 21:29:57 +00001301
Bram Moolenaar0e3e7ba2022-01-13 20:18:56 +00001302 assert_equal('testmorename', prefixed.GetFunc())
1303 assert_equal('testmorename', prefixed.GetDef())
Bram Moolenaar160aa862022-01-10 21:29:57 +00001304 assert_equal('name', prefixed.name)
1305 assert_equal('final', prefixed.fname)
1306 assert_equal('const', prefixed.cname)
1307 END
1308 CheckScriptSuccess(lines)
Bram Moolenaar17d36cb2022-01-12 11:46:40 +00001309 # can source it again, autoload script not loaded again
1310 g:expected_loaded = 1
1311 CheckScriptSuccess(lines)
Bram Moolenaar160aa862022-01-10 21:29:57 +00001312
1313 # can also get the items by autoload name
1314 lines =<< trim END
1315 call assert_equal('test', prefixed#Gettest())
Bram Moolenaar0e3e7ba2022-01-13 20:18:56 +00001316 call assert_equal('testmorename', prefixed#GetFunc())
Bram Moolenaar160aa862022-01-10 21:29:57 +00001317 call assert_equal('name', prefixed#name)
1318 call assert_equal('final', prefixed#fname)
1319 call assert_equal('const', prefixed#cname)
1320 END
1321 CheckScriptSuccess(lines)
1322
Bram Moolenaarf111cdf2022-01-12 12:48:17 +00001323 unlet g:prefixed_loaded
1324 unlet g:expected_loaded
1325 delete('Xdir', 'rf')
1326 &rtp = save_rtp
1327enddef
1328
Bram Moolenaard02dce22022-01-18 17:43:04 +00001329def Test_import_autoload_not_exported()
1330 mkdir('Xdir/autoload', 'p')
1331 var save_rtp = &rtp
1332 exe 'set rtp^=' .. getcwd() .. '/Xdir'
1333
1334 # error when using an item that is not exported from an autoload script
1335 var exportLines =<< trim END
1336 vim9script
1337 var notExported = 123
1338 def NotExport()
1339 echo 'nop'
1340 enddef
1341 END
1342 writefile(exportLines, 'Xdir/autoload/notExport1.vim')
1343
1344 var lines =<< trim END
1345 vim9script
1346 import autoload 'notExport1.vim'
1347 echo notExport1.notFound
1348 END
1349 CheckScriptFailure(lines, 'E1048: Item not found in script: notFound')
1350
1351 lines =<< trim END
1352 vim9script
1353 import autoload 'notExport1.vim'
1354 echo notExport1.notExported
1355 END
1356 CheckScriptFailure(lines, 'E1049: Item not exported in script: notExported')
1357
1358 lines =<< trim END
1359 vim9script
1360 import autoload 'notExport1.vim'
1361 echo notExport1.NotFunc()
1362 END
1363 CheckScriptFailure(lines, 'E1048: Item not found in script: NotFunc')
1364
1365 lines =<< trim END
1366 vim9script
1367 import autoload 'notExport1.vim'
1368 echo notExport1.NotExport()
1369 END
1370 CheckScriptFailure(lines, 'E1049: Item not exported in script: NotExport')
1371
1372 lines =<< trim END
1373 vim9script
1374 import autoload 'notExport1.vim'
1375 echo 'text'->notExport1.NotFunc()
1376 END
1377 CheckScriptFailure(lines, 'E1048: Item not found in script: NotFunc')
1378
1379 lines =<< trim END
1380 vim9script
1381 import autoload 'notExport1.vim'
1382 echo 'text'->notExport1.NotExport()
1383 END
1384 CheckScriptFailure(lines, 'E1049: Item not exported in script: NotExport')
1385
1386 # using a :def function we use a different autoload script every time so that
1387 # the function is compiled without the script loaded
1388 writefile(exportLines, 'Xdir/autoload/notExport2.vim')
1389 lines =<< trim END
1390 vim9script
1391 import autoload 'notExport2.vim'
1392 def Testit()
1393 echo notExport2.notFound
1394 enddef
1395 Testit()
1396 END
1397 CheckScriptFailure(lines, 'E1048: Item not found in script: notExport2#notFound')
1398
1399 writefile(exportLines, 'Xdir/autoload/notExport3.vim')
1400 lines =<< trim END
1401 vim9script
1402 import autoload 'notExport3.vim'
1403 def Testit()
1404 echo notExport3.notExported
1405 enddef
1406 Testit()
1407 END
1408 # don't get E1049 because it is too complicated to figure out
1409 CheckScriptFailure(lines, 'E1048: Item not found in script: notExport3#notExported')
1410
1411 writefile(exportLines, 'Xdir/autoload/notExport4.vim')
1412 lines =<< trim END
1413 vim9script
1414 import autoload 'notExport4.vim'
1415 def Testit()
1416 echo notExport4.NotFunc()
1417 enddef
1418 Testit()
1419 END
1420 CheckScriptFailure(lines, 'E117: Unknown function: notExport4#NotFunc')
1421
1422 writefile(exportLines, 'Xdir/autoload/notExport5.vim')
1423 lines =<< trim END
1424 vim9script
1425 import autoload 'notExport5.vim'
1426 def Testit()
1427 echo notExport5.NotExport()
1428 enddef
1429 Testit()
1430 END
1431 CheckScriptFailure(lines, 'E117: Unknown function: notExport5#NotExport')
1432
1433 writefile(exportLines, 'Xdir/autoload/notExport6.vim')
1434 lines =<< trim END
1435 vim9script
1436 import autoload 'notExport6.vim'
1437 def Testit()
1438 echo 'text'->notExport6.NotFunc()
1439 enddef
1440 Testit()
1441 END
1442 CheckScriptFailure(lines, 'E117: Unknown function: notExport6#NotFunc')
1443
1444 writefile(exportLines, 'Xdir/autoload/notExport7.vim')
1445 lines =<< trim END
1446 vim9script
1447 import autoload 'notExport7.vim'
1448 def Testit()
1449 echo 'text'->notExport7.NotExport()
1450 enddef
1451 Testit()
1452 END
1453 CheckScriptFailure(lines, 'E117: Unknown function: notExport7#NotExport')
1454
1455 delete('Xdir', 'rf')
1456 &rtp = save_rtp
1457enddef
1458
Bram Moolenaarf111cdf2022-01-12 12:48:17 +00001459def Test_vim9script_autoload_call()
1460 mkdir('Xdir/autoload', 'p')
1461 var save_rtp = &rtp
1462 exe 'set rtp^=' .. getcwd() .. '/Xdir'
1463
1464 var lines =<< trim END
Bram Moolenaarfd218c82022-01-18 16:26:24 +00001465 vim9script
Bram Moolenaarf111cdf2022-01-12 12:48:17 +00001466
Bram Moolenaarcbbc48f2022-01-18 12:58:28 +00001467 export def RetArg(arg: string): string
1468 return arg
1469 enddef
1470
Bram Moolenaarf111cdf2022-01-12 12:48:17 +00001471 export def Getother()
1472 g:result = 'other'
1473 enddef
1474 END
Bram Moolenaar5d982692022-01-12 15:15:27 +00001475 writefile(lines, 'Xdir/autoload/another.vim')
Bram Moolenaarf111cdf2022-01-12 12:48:17 +00001476
1477 lines =<< trim END
1478 vim9script
Bram Moolenaar5d982692022-01-12 15:15:27 +00001479 import autoload 'another.vim'
Bram Moolenaarcbbc48f2022-01-18 12:58:28 +00001480
1481 # compile this before 'another.vim' is loaded
1482 def CallAnother()
1483 assert_equal('foo', 'foo'->another.RetArg())
1484 enddef
1485 CallAnother()
1486
Bram Moolenaar5d982692022-01-12 15:15:27 +00001487 call another.Getother()
Bram Moolenaarf111cdf2022-01-12 12:48:17 +00001488 assert_equal('other', g:result)
1489 END
1490 CheckScriptSuccess(lines)
1491
1492 unlet g:result
Bram Moolenaar160aa862022-01-10 21:29:57 +00001493 delete('Xdir', 'rf')
1494 &rtp = save_rtp
1495enddef
1496
Bram Moolenaar9c7cae62022-01-20 19:10:25 +00001497def Test_vim9script_autoload_duplicate()
1498 mkdir('Xdir/autoload', 'p')
1499
1500 var lines =<< trim END
1501 vim9script
1502
1503 export def Func()
1504 enddef
1505
1506 def Func()
1507 enddef
1508 END
1509 writefile(lines, 'Xdir/autoload/dupfunc.vim')
1510 assert_fails('source Xdir/autoload/dupfunc.vim', 'E1073:')
1511
1512 lines =<< trim END
1513 vim9script
1514
1515 def Func()
1516 enddef
1517
1518 export def Func()
1519 enddef
1520 END
1521 writefile(lines, 'Xdir/autoload/dup2func.vim')
1522 assert_fails('source Xdir/autoload/dup2func.vim', 'E1073:')
1523
1524 lines =<< trim END
1525 vim9script
1526
1527 def Func()
1528 enddef
1529
1530 export var Func = 'asdf'
1531 END
1532 writefile(lines, 'Xdir/autoload/dup3func.vim')
1533 assert_fails('source Xdir/autoload/dup3func.vim', 'E1041: Redefining script item Func')
1534
1535 lines =<< trim END
1536 vim9script
1537
1538 export var Func = 'asdf'
1539
1540 def Func()
1541 enddef
1542 END
1543 writefile(lines, 'Xdir/autoload/dup4func.vim')
1544 assert_fails('source Xdir/autoload/dup4func.vim', 'E707:')
1545
1546 lines =<< trim END
1547 vim9script
1548
1549 var Func = 'asdf'
1550
1551 export def Func()
1552 enddef
1553 END
1554 writefile(lines, 'Xdir/autoload/dup5func.vim')
1555 assert_fails('source Xdir/autoload/dup5func.vim', 'E707:')
1556
1557 lines =<< trim END
1558 vim9script
1559
1560 export def Func()
1561 enddef
1562
1563 var Func = 'asdf'
1564 END
1565 writefile(lines, 'Xdir/autoload/dup6func.vim')
1566 assert_fails('source Xdir/autoload/dup6func.vim', 'E1041: Redefining script item Func')
1567
1568 delete('Xdir', 'rf')
1569enddef
1570
Bram Moolenaar2017d6f2022-01-20 19:38:46 +00001571def Test_autoload_missing_function_name()
1572 mkdir('Xdir/autoload', 'p')
1573
1574 var lines =<< trim END
1575 vim9script
1576
1577 def loadme#()
1578 enddef
1579 END
1580 writefile(lines, 'Xdir/autoload/loadme.vim')
1581 assert_fails('source Xdir/autoload/loadme.vim', 'E129:')
1582
1583 delete('Xdir', 'rf')
1584enddef
1585
Bram Moolenaard041f422022-01-12 19:54:00 +00001586def Test_import_autoload_postponed()
1587 mkdir('Xdir/autoload', 'p')
1588 var save_rtp = &rtp
1589 exe 'set rtp^=' .. getcwd() .. '/Xdir'
1590
1591 var lines =<< trim END
Bram Moolenaarfd218c82022-01-18 16:26:24 +00001592 vim9script
Bram Moolenaard041f422022-01-12 19:54:00 +00001593
1594 g:loaded_postponed = 'true'
1595 export var variable = 'bla'
1596 export def Function(): string
1597 return 'bla'
1598 enddef
1599 END
1600 writefile(lines, 'Xdir/autoload/postponed.vim')
1601
1602 lines =<< trim END
1603 vim9script
1604
1605 import autoload 'postponed.vim'
1606 def Tryit()
1607 echo postponed.variable
1608 echo postponed.Function()
1609 enddef
1610 defcompile
1611 END
1612 CheckScriptSuccess(lines)
1613 assert_false(exists('g:loaded_postponed'))
1614 CheckScriptSuccess(lines + ['Tryit()'])
1615 assert_equal('true', g:loaded_postponed)
1616
1617 unlet g:loaded_postponed
1618 delete('Xdir', 'rf')
1619 &rtp = save_rtp
1620enddef
1621
Bram Moolenaar3e4fa3d2022-01-13 22:05:09 +00001622def Test_import_autoload_override()
1623 mkdir('Xdir/autoload', 'p')
1624 var save_rtp = &rtp
1625 exe 'set rtp^=' .. getcwd() .. '/Xdir'
1626 test_override('autoload', 1)
1627
1628 var lines =<< trim END
Bram Moolenaarfd218c82022-01-18 16:26:24 +00001629 vim9script
Bram Moolenaar3e4fa3d2022-01-13 22:05:09 +00001630
1631 g:loaded_override = 'true'
1632 export var variable = 'bla'
1633 export def Function(): string
1634 return 'bla'
1635 enddef
1636 END
1637 writefile(lines, 'Xdir/autoload/override.vim')
1638
1639 lines =<< trim END
1640 vim9script
1641
1642 import autoload 'override.vim'
1643 assert_equal('true', g:loaded_override)
1644
1645 def Tryit()
1646 echo override.doesNotExist
1647 enddef
1648 defcompile
1649 END
1650 CheckScriptFailure(lines, 'E1048: Item not found in script: doesNotExist', 1)
1651
1652 test_override('autoload', 0)
1653 unlet g:loaded_override
1654 delete('Xdir', 'rf')
1655 &rtp = save_rtp
1656enddef
1657
Bram Moolenaar19db9e62022-01-11 11:58:19 +00001658def Test_autoload_mapping()
1659 mkdir('Xdir/autoload', 'p')
1660 var save_rtp = &rtp
1661 exe 'set rtp^=' .. getcwd() .. '/Xdir'
1662
1663 var lines =<< trim END
Bram Moolenaarfd218c82022-01-18 16:26:24 +00001664 vim9script
Bram Moolenaar19db9e62022-01-11 11:58:19 +00001665
1666 g:toggle_loaded = 'yes'
1667
1668 export def Toggle(): string
1669 return ":g:toggle_called = 'yes'\<CR>"
1670 enddef
Bram Moolenaare32c3c42022-01-15 18:26:04 +00001671 export def Doit()
1672 g:doit_called = 'yes'
1673 enddef
Bram Moolenaar19db9e62022-01-11 11:58:19 +00001674 END
1675 writefile(lines, 'Xdir/autoload/toggle.vim')
1676
1677 lines =<< trim END
1678 vim9script
1679
1680 import autoload 'toggle.vim'
1681
1682 nnoremap <silent> <expr> tt toggle.Toggle()
Bram Moolenaare32c3c42022-01-15 18:26:04 +00001683 nnoremap <silent> xx <ScriptCmd>toggle.Doit()<CR>
1684 nnoremap <silent> yy <Cmd>toggle.Doit()<CR>
Bram Moolenaar19db9e62022-01-11 11:58:19 +00001685 END
1686 CheckScriptSuccess(lines)
1687 assert_false(exists("g:toggle_loaded"))
1688 assert_false(exists("g:toggle_called"))
Bram Moolenaar6079da72022-01-18 14:16:59 +00001689 assert_match('\d A: \f*[/\\]toggle.vim', execute('scriptnames'))
Bram Moolenaar19db9e62022-01-11 11:58:19 +00001690
1691 feedkeys("tt", 'xt')
1692 assert_equal('yes', g:toggle_loaded)
1693 assert_equal('yes', g:toggle_called)
Bram Moolenaar6079da72022-01-18 14:16:59 +00001694 assert_match('\d: \f*[/\\]toggle.vim', execute('scriptnames'))
Bram Moolenaar19db9e62022-01-11 11:58:19 +00001695
Bram Moolenaare32c3c42022-01-15 18:26:04 +00001696 feedkeys("xx", 'xt')
1697 assert_equal('yes', g:doit_called)
1698
1699 assert_fails('call feedkeys("yy", "xt")', 'E121: Undefined variable: toggle')
1700
Bram Moolenaar19db9e62022-01-11 11:58:19 +00001701 nunmap tt
Bram Moolenaare32c3c42022-01-15 18:26:04 +00001702 nunmap xx
1703 nunmap yy
Bram Moolenaar19db9e62022-01-11 11:58:19 +00001704 unlet g:toggle_loaded
1705 unlet g:toggle_called
1706 delete('Xdir', 'rf')
1707 &rtp = save_rtp
1708enddef
1709
Bram Moolenaar160aa862022-01-10 21:29:57 +00001710def Test_vim9script_autoload_fails()
1711 var lines =<< trim END
1712 vim9script autoload
1713 var n = 0
1714 END
Bram Moolenaarfd218c82022-01-18 16:26:24 +00001715 CheckScriptFailure(lines, 'E475: Invalid argument: autoload')
1716
1717 lines =<< trim END
1718 vim9script noclear noclear
1719 var n = 0
1720 END
1721 CheckScriptFailure(lines, 'E983: Duplicate argument: noclear')
Bram Moolenaar160aa862022-01-10 21:29:57 +00001722enddef
1723
1724def Test_import_autoload_fails()
1725 var lines =<< trim END
1726 vim9script
1727 import autoload autoload 'prefixed.vim'
1728 END
1729 CheckScriptFailure(lines, 'E121: Undefined variable: autoload')
1730
1731 lines =<< trim END
1732 vim9script
Bram Moolenaar1836d612022-01-18 13:14:47 +00001733 import autoload './doesNotExist.vim'
Bram Moolenaar160aa862022-01-10 21:29:57 +00001734 END
1735 CheckScriptFailure(lines, 'E1264:')
Bram Moolenaar1836d612022-01-18 13:14:47 +00001736
1737 lines =<< trim END
1738 vim9script
1739 import autoload '/dir/doesNotExist.vim'
1740 END
1741 CheckScriptFailure(lines, 'E1264:')
1742
1743 lines =<< trim END
1744 vim9script
1745 import autoload 'doesNotExist.vim'
1746 END
1747 CheckScriptFailure(lines, 'E1053: Could not import "doesNotExist.vim"')
Bram Moolenaar160aa862022-01-10 21:29:57 +00001748enddef
1749
1750" test disassembling an auto-loaded function starting with "debug"
1751def Test_vim9_autoload_disass()
1752 mkdir('Xdir/autoload', 'p')
1753 var save_rtp = &rtp
1754 exe 'set rtp^=' .. getcwd() .. '/Xdir'
1755
1756 var lines =<< trim END
1757 vim9script
1758 def debugit#test(): string
1759 return 'debug'
1760 enddef
1761 END
1762 writefile(lines, 'Xdir/autoload/debugit.vim')
1763
1764 lines =<< trim END
1765 vim9script
1766 def profileit#test(): string
1767 return 'profile'
1768 enddef
1769 END
1770 writefile(lines, 'Xdir/autoload/profileit.vim')
1771
1772 lines =<< trim END
1773 vim9script
1774 assert_equal('debug', debugit#test())
1775 disass debugit#test
1776 assert_equal('profile', profileit#test())
1777 disass profileit#test
1778 END
1779 CheckScriptSuccess(lines)
1780
1781 delete('Xdir', 'rf')
1782 &rtp = save_rtp
1783enddef
1784
1785" test using a vim9script that is auto-loaded from an autocmd
1786def Test_vim9_aucmd_autoload()
1787 var lines =<< trim END
1788 vim9script
1789 def foo#test()
1790 echomsg getreg('"')
1791 enddef
1792 END
1793
1794 mkdir('Xdir/autoload', 'p')
1795 writefile(lines, 'Xdir/autoload/foo.vim')
1796 var save_rtp = &rtp
1797 exe 'set rtp^=' .. getcwd() .. '/Xdir'
1798 augroup test
1799 autocmd TextYankPost * call foo#test()
1800 augroup END
1801
1802 normal Y
1803
1804 augroup test
1805 autocmd!
1806 augroup END
1807 delete('Xdir', 'rf')
1808 &rtp = save_rtp
1809enddef
1810
Bram Moolenaar3049fcf2022-01-13 19:25:50 +00001811" test using a autoloaded file that is case sensitive
1812def Test_vim9_autoload_case_sensitive()
1813 var lines =<< trim END
Bram Moolenaarfd218c82022-01-18 16:26:24 +00001814 vim9script
Bram Moolenaar3049fcf2022-01-13 19:25:50 +00001815 export def CaseSensitive(): string
1816 return 'done'
1817 enddef
1818 END
1819
1820 mkdir('Xdir/autoload', 'p')
1821 writefile(lines, 'Xdir/autoload/CaseSensitive.vim')
1822 var save_rtp = &rtp
1823 exe 'set rtp^=' .. getcwd() .. '/Xdir'
1824
1825 lines =<< trim END
1826 vim9script
1827 import autoload 'CaseSensitive.vim'
1828 assert_equal('done', CaseSensitive.CaseSensitive())
1829 END
1830 CheckScriptSuccess(lines)
1831
Bram Moolenaarbfac4092022-01-16 11:12:12 +00001832 if !has('fname_case')
1833 lines =<< trim END
1834 vim9script
1835 import autoload 'CaseSensitive.vim'
1836 import autoload 'casesensitive.vim'
1837 END
1838 CheckScriptFailure(lines, 'E1262:')
1839 endif
1840
Bram Moolenaar3049fcf2022-01-13 19:25:50 +00001841 delete('Xdir', 'rf')
1842 &rtp = save_rtp
1843enddef
1844
Bram Moolenaar160aa862022-01-10 21:29:57 +00001845" This was causing a crash because suppress_errthrow wasn't reset.
1846def Test_vim9_autoload_error()
1847 var lines =<< trim END
1848 vim9script
1849 def crash#func()
1850 try
1851 for x in List()
1852 endfor
1853 catch
1854 endtry
1855 g:ok = true
1856 enddef
1857 fu List()
1858 invalid
1859 endfu
1860 try
1861 alsoinvalid
1862 catch /wontmatch/
1863 endtry
1864 END
1865 call mkdir('Xruntime/autoload', 'p')
1866 call writefile(lines, 'Xruntime/autoload/crash.vim')
1867
1868 # run in a separate Vim to avoid the side effects of assert_fails()
1869 lines =<< trim END
1870 exe 'set rtp^=' .. getcwd() .. '/Xruntime'
1871 call crash#func()
1872 call writefile(['ok'], 'Xdidit')
1873 qall!
1874 END
1875 writefile(lines, 'Xscript')
1876 RunVim([], [], '-S Xscript')
1877 assert_equal(['ok'], readfile('Xdidit'))
1878
1879 delete('Xdidit')
1880 delete('Xscript')
1881 delete('Xruntime', 'rf')
1882
1883 lines =<< trim END
1884 vim9script
1885 var foo#bar = 'asdf'
1886 END
1887 CheckScriptFailure(lines, 'E461: Illegal variable name: foo#bar', 2)
1888enddef
1889
Bram Moolenaard8448622022-01-07 21:39:52 +00001890
1891" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker