blob: e6d97289609ff028dbac567e6172824f27295277 [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 Moolenaare70dd112022-01-21 16:31:11 +0000676def Test_use_autoload_import_in_fold_expression()
677 mkdir('Xdir/autoload', 'p')
678 var save_rtp = &rtp
679 exe 'set rtp^=' .. getcwd() .. '/Xdir'
680
681 var lines =<< trim END
682 vim9script
683 export def Expr(): string
684 return getline(v:lnum) =~ '^#' ? '>1' : '1'
685 enddef
Bram Moolenaar9530b582022-01-22 13:39:08 +0000686 export def Text(): string
687 return 'fold text'
688 enddef
Bram Moolenaare70dd112022-01-21 16:31:11 +0000689 g:fold_loaded = 'yes'
690 END
691 writefile(lines, 'Xdir/autoload/fold.vim')
692
693 lines =<< trim END
694 vim9script
695 import autoload 'fold.vim'
696 &foldexpr = 'fold.Expr()'
Bram Moolenaar9530b582022-01-22 13:39:08 +0000697 &foldtext = 'fold.Text()'
Bram Moolenaare70dd112022-01-21 16:31:11 +0000698 &foldmethod = 'expr'
699 &debug = 'throw'
700 END
701 new
702 setline(1, ['# one', 'text', '# two', 'text'])
703 g:fold_loaded = 'no'
704 CheckScriptSuccess(lines)
705 assert_equal('no', g:fold_loaded)
706 redraw
707 assert_equal('yes', g:fold_loaded)
708
709 # Check that script context of 'foldexpr' is copied to another buffer.
710 edit! otherfile
711 redraw
712
Bram Moolenaar9530b582022-01-22 13:39:08 +0000713 set foldexpr= foldtext& foldmethod& debug=
Bram Moolenaare70dd112022-01-21 16:31:11 +0000714 bwipe!
715 delete('Xdir', 'rf')
716 &rtp = save_rtp
717enddef
718
Bram Moolenaar7b29f6a2022-01-22 17:58:13 +0000719func Test_import_in_diffexpr()
720 CheckExecutable diff
721
722 call Run_Test_import_in_diffexpr()
723endfunc
724
725def Run_Test_import_in_diffexpr()
726 var lines =<< trim END
727 vim9script
728
729 export def DiffExpr()
730 # Prepend some text to check diff type detection
731 writefile(['warning', ' message'], v:fname_out)
732 silent exe '!diff ' .. v:fname_in .. ' '
733 .. v:fname_new .. '>>' .. v:fname_out
734 enddef
735 END
736 writefile(lines, 'Xdiffexpr')
737
738 lines =<< trim END
739 vim9script
740 import './Xdiffexpr' as diff
741
742 set diffexpr=diff.DiffExpr()
743 set diffopt=foldcolumn:0
744 END
745 CheckScriptSuccess(lines)
746
747 enew!
748 call setline(1, ['one', 'two', 'three'])
749 diffthis
750
751 botright vert new
752 call setline(1, ['one', 'two', 'three.'])
753 diffthis
754 # we only check if this does not cause errors
755 redraw
756
757 diffoff!
758 bwipe!
759 bwipe!
760enddef
761
Bram Moolenaard8448622022-01-07 21:39:52 +0000762def Test_export_fails()
763 CheckScriptFailure(['export var some = 123'], 'E1042:')
764 CheckScriptFailure(['vim9script', 'export var g:some'], 'E1022:')
765 CheckScriptFailure(['vim9script', 'export echo 134'], 'E1043:')
766
767 assert_fails('export something', 'E1043:')
768enddef
769
770func Test_import_fails_without_script()
771 CheckRunVimInTerminal
772
773 " call indirectly to avoid compilation error for missing functions
774 call Run_Test_import_fails_on_command_line()
775endfunc
776
777def Run_Test_import_fails_on_command_line()
778 var export =<< trim END
779 vim9script
780 export def Foo(): number
781 return 0
782 enddef
783 END
784 writefile(export, 'XexportCmd.vim')
785
786 var buf = RunVimInTerminal('-c "import Foo from ''./XexportCmd.vim''"', {
787 rows: 6, wait_for_ruler: 0})
788 WaitForAssert(() => assert_match('^E1094:', term_getline(buf, 5)))
789
790 delete('XexportCmd.vim')
791 StopVimInTerminal(buf)
792enddef
793
794def Test_vim9_reload_noclear()
795 var lines =<< trim END
796 vim9script
797 export var exported = 'thexport'
798
799 export def TheFunc(x = 0)
800 enddef
801 END
802 writefile(lines, 'XExportReload')
803 lines =<< trim END
804 vim9script noclear
805 g:loadCount += 1
806 var s:reloaded = 'init'
807 import './XExportReload' as exp
808
809 def Again(): string
810 return 'again'
811 enddef
812
813 exp.TheFunc()
814
815 if exists('s:loaded') | finish | endif
816 var s:loaded = true
817
818 var s:notReloaded = 'yes'
819 s:reloaded = 'first'
820 def g:Values(): list<string>
821 return [s:reloaded, s:notReloaded, Again(), Once(), exp.exported]
822 enddef
823
824 def Once(): string
825 return 'once'
826 enddef
827 END
828 writefile(lines, 'XReloaded')
829 g:loadCount = 0
830 source XReloaded
831 assert_equal(1, g:loadCount)
832 assert_equal(['first', 'yes', 'again', 'once', 'thexport'], g:Values())
833 source XReloaded
834 assert_equal(2, g:loadCount)
835 assert_equal(['init', 'yes', 'again', 'once', 'thexport'], g:Values())
836 source XReloaded
837 assert_equal(3, g:loadCount)
838 assert_equal(['init', 'yes', 'again', 'once', 'thexport'], g:Values())
839
840 delete('XReloaded')
841 delete('XExportReload')
842 delfunc g:Values
843 unlet g:loadCount
844
845 lines =<< trim END
846 vim9script
847 def Inner()
848 enddef
849 END
850 lines->writefile('XreloadScript.vim')
851 source XreloadScript.vim
852
853 lines =<< trim END
854 vim9script
855 def Outer()
856 def Inner()
857 enddef
858 enddef
859 defcompile
860 END
861 lines->writefile('XreloadScript.vim')
862 source XreloadScript.vim
863
864 delete('XreloadScript.vim')
865enddef
866
867def Test_vim9_reload_import()
868 var lines =<< trim END
869 vim9script
870 const var = ''
871 var valone = 1234
872 def MyFunc(arg: string)
873 valone = 5678
874 enddef
875 END
876 var morelines =<< trim END
877 var valtwo = 222
878 export def GetValtwo(): number
879 return valtwo
880 enddef
881 END
882 writefile(lines + morelines, 'Xreload.vim')
883 source Xreload.vim
884 source Xreload.vim
885 source Xreload.vim
886
887 # cannot declare a var twice
888 lines =<< trim END
889 vim9script
890 var valone = 1234
891 var valone = 5678
892 END
893 writefile(lines, 'Xreload.vim')
894 assert_fails('source Xreload.vim', 'E1041:', '', 3, 'Xreload.vim')
895
896 delete('Xreload.vim')
897 delete('Ximport.vim')
898enddef
899
900" if a script is reloaded with a script-local variable that changed its type, a
901" compiled function using that variable must fail.
902def Test_script_reload_change_type()
903 var lines =<< trim END
904 vim9script noclear
905 var str = 'string'
906 def g:GetStr(): string
907 return str .. 'xxx'
908 enddef
909 END
910 writefile(lines, 'Xreload.vim')
911 source Xreload.vim
912 echo g:GetStr()
913
914 lines =<< trim END
915 vim9script noclear
916 var str = 1234
917 END
918 writefile(lines, 'Xreload.vim')
919 source Xreload.vim
920 assert_fails('echo g:GetStr()', 'E1150:')
921
922 delfunc g:GetStr
923 delete('Xreload.vim')
924enddef
925
926" Define CallFunc so that the test can be compiled
927command CallFunc echo 'nop'
928
929def Test_script_reload_from_function()
930 var lines =<< trim END
931 vim9script
932
933 if exists('g:loaded')
934 finish
935 endif
936 g:loaded = 1
937 delcommand CallFunc
938 command CallFunc Func()
939 def Func()
940 so XreloadFunc.vim
941 g:didTheFunc = 1
942 enddef
943 END
944 writefile(lines, 'XreloadFunc.vim')
945 source XreloadFunc.vim
946 CallFunc
947 assert_equal(1, g:didTheFunc)
948
949 delete('XreloadFunc.vim')
950 delcommand CallFunc
951 unlet g:loaded
952 unlet g:didTheFunc
953enddef
954
955def s:RetSome(): string
956 return 'some'
957enddef
958
959" Not exported function that is referenced needs to be accessed by the
960" script-local name.
961def Test_vim9_funcref()
962 var sortlines =<< trim END
963 vim9script
964 def Compare(i1: number, i2: number): number
965 return i2 - i1
966 enddef
967
968 export def FastSort(): list<number>
969 return range(5)->sort(Compare)
970 enddef
971
972 export def GetString(arg: string): string
973 return arg
974 enddef
975 END
976 writefile(sortlines, 'Xsort.vim')
977
978 var lines =<< trim END
979 vim9script
980 import './Xsort.vim'
981 def Test()
982 g:result = Xsort.FastSort()
983 enddef
984 Test()
Bram Moolenaar7c24dfd2022-01-08 17:03:55 +0000985 END
986 writefile(lines, 'Xscript.vim')
987 source Xscript.vim
988 assert_equal([4, 3, 2, 1, 0], g:result)
989 unlet g:result
Bram Moolenaard8448622022-01-07 21:39:52 +0000990
Bram Moolenaar7c24dfd2022-01-08 17:03:55 +0000991 lines =<< trim END
992 vim9script
Bram Moolenaard8448622022-01-07 21:39:52 +0000993 # using a function imported with "as"
994 import './Xsort.vim' as anAlias
995 assert_equal('yes', anAlias.GetString('yes'))
996
997 # using the function from a compiled function
998 def TestMore(): string
999 var s = s:anAlias.GetString('foo')
1000 return s .. anAlias.GetString('bar')
1001 enddef
1002 assert_equal('foobar', TestMore())
1003
1004 # error when using a function that isn't exported
1005 assert_fails('anAlias.Compare(1, 2)', 'E1049:')
1006 END
1007 writefile(lines, 'Xscript.vim')
1008
Bram Moolenaard8448622022-01-07 21:39:52 +00001009 delete('Xsort.vim')
1010 delete('Xscript.vim')
1011
1012 var Funcref = function('s:RetSome')
1013 assert_equal('some', Funcref())
1014enddef
1015
1016" Check that when searching for "FilterFunc" it finds the import in the
1017" script where FastFilter() is called from, both as a string and as a direct
1018" function reference.
1019def Test_vim9_funcref_other_script()
1020 var filterLines =<< trim END
1021 vim9script
1022 export def FilterFunc(idx: number, val: number): bool
1023 return idx % 2 == 1
1024 enddef
1025 export def FastFilter(): list<number>
1026 return range(10)->filter('FilterFunc(v:key, v:val)')
1027 enddef
1028 export def FastFilterDirect(): list<number>
1029 return range(10)->filter(FilterFunc)
1030 enddef
1031 END
1032 writefile(filterLines, 'Xfilter.vim')
1033
1034 var lines =<< trim END
1035 vim9script
1036 import './Xfilter.vim' as filter
1037 def Test()
1038 var x: list<number> = filter.FastFilter()
1039 enddef
1040 Test()
1041 def TestDirect()
1042 var x: list<number> = filter.FastFilterDirect()
1043 enddef
1044 TestDirect()
1045 END
1046 CheckScriptSuccess(lines)
1047 delete('Xfilter.vim')
1048enddef
1049
1050def Test_import_absolute()
1051 var import_lines = [
1052 'vim9script',
1053 'import "' .. escape(getcwd(), '\') .. '/Xexport_abs.vim" as abs',
1054 'def UseExported()',
1055 ' g:imported_abs = abs.exported',
1056 ' abs.exported = 8888',
1057 ' g:imported_after = abs.exported',
1058 'enddef',
1059 'UseExported()',
1060 'g:import_disassembled = execute("disass UseExported")',
1061 ]
1062 writefile(import_lines, 'Ximport_abs.vim')
1063 writefile(s:export_script_lines, 'Xexport_abs.vim')
1064
1065 source Ximport_abs.vim
1066
1067 assert_equal(9876, g:imported_abs)
1068 assert_equal(8888, g:imported_after)
1069 assert_match('<SNR>\d\+_UseExported\_s*' ..
1070 'g:imported_abs = abs.exported\_s*' ..
1071 '0 LOADSCRIPT exported-2 from .*Xexport_abs.vim\_s*' ..
1072 '1 STOREG g:imported_abs\_s*' ..
1073 'abs.exported = 8888\_s*' ..
1074 '2 PUSHNR 8888\_s*' ..
1075 '3 STORESCRIPT exported-2 in .*Xexport_abs.vim\_s*' ..
1076 'g:imported_after = abs.exported\_s*' ..
1077 '4 LOADSCRIPT exported-2 from .*Xexport_abs.vim\_s*' ..
1078 '5 STOREG g:imported_after',
1079 g:import_disassembled)
1080
1081 Undo_export_script_lines()
1082 unlet g:imported_abs
1083 unlet g:import_disassembled
1084
1085 delete('Ximport_abs.vim')
1086 delete('Xexport_abs.vim')
1087enddef
1088
1089def Test_import_rtp()
1090 var import_lines = [
1091 'vim9script',
1092 'import "Xexport_rtp.vim" as rtp',
1093 'g:imported_rtp = rtp.exported',
1094 ]
1095 writefile(import_lines, 'Ximport_rtp.vim')
1096 mkdir('import', 'p')
1097 writefile(s:export_script_lines, 'import/Xexport_rtp.vim')
1098
1099 var save_rtp = &rtp
1100 &rtp = getcwd()
1101 source Ximport_rtp.vim
1102 &rtp = save_rtp
1103
1104 assert_equal(9876, g:imported_rtp)
1105
1106 Undo_export_script_lines()
1107 unlet g:imported_rtp
1108 delete('Ximport_rtp.vim')
1109 delete('import', 'rf')
1110enddef
1111
1112def Test_import_compile_error()
1113 var export_lines = [
1114 'vim9script',
1115 'export def ExpFunc(): string',
1116 ' return notDefined',
1117 'enddef',
1118 ]
1119 writefile(export_lines, 'Xexported.vim')
1120
1121 var import_lines = [
1122 'vim9script',
1123 'import "./Xexported.vim" as expo',
1124 'def ImpFunc()',
1125 ' echo expo.ExpFunc()',
1126 'enddef',
1127 'defcompile',
1128 ]
1129 writefile(import_lines, 'Ximport.vim')
1130
1131 try
1132 source Ximport.vim
1133 catch /E1001/
1134 # Error should be before the Xexported.vim file.
1135 assert_match('E1001: Variable not found: notDefined', v:exception)
1136 assert_match('function <SNR>\d\+_ImpFunc\[1\]..<SNR>\d\+_ExpFunc, line 1', v:throwpoint)
1137 endtry
1138
1139 delete('Xexported.vim')
1140 delete('Ximport.vim')
1141enddef
1142
1143def Test_func_overrules_import_fails()
1144 var export_lines =<< trim END
1145 vim9script
1146 export def Func()
1147 echo 'imported'
1148 enddef
1149 END
1150 writefile(export_lines, 'XexportedFunc.vim')
1151
1152 var lines =<< trim END
1153 vim9script
1154 import './XexportedFunc.vim' as Func
1155 def Func()
1156 echo 'local to function'
1157 enddef
1158 END
Bram Moolenaar937610b2022-01-19 17:21:29 +00001159 CheckScriptFailure(lines, 'E1213: Redefining imported item "Func"')
Bram Moolenaard8448622022-01-07 21:39:52 +00001160
1161 lines =<< trim END
1162 vim9script
1163 import './XexportedFunc.vim' as Func
1164 def Outer()
1165 def Func()
1166 echo 'local to function'
1167 enddef
1168 enddef
1169 defcompile
1170 END
1171 CheckScriptFailure(lines, 'E1236:')
1172
1173 delete('XexportedFunc.vim')
1174enddef
1175
1176def Test_source_vim9_from_legacy()
1177 var vim9_lines =<< trim END
1178 vim9script
1179 var local = 'local'
1180 g:global = 'global'
1181 export var exported = 'exported'
1182 export def GetText(): string
1183 return 'text'
1184 enddef
1185 END
1186 writefile(vim9_lines, 'Xvim9_script.vim')
1187
1188 var legacy_lines =<< trim END
1189 source Xvim9_script.vim
1190
1191 call assert_false(exists('local'))
1192 call assert_false(exists('exported'))
1193 call assert_false(exists('s:exported'))
1194 call assert_equal('global', global)
1195 call assert_equal('global', g:global)
Bram Moolenaard8448622022-01-07 21:39:52 +00001196 END
1197 writefile(legacy_lines, 'Xlegacy_script.vim')
1198
1199 source Xlegacy_script.vim
1200 assert_equal('global', g:global)
1201 unlet g:global
1202
1203 delete('Xlegacy_script.vim')
1204 delete('Xvim9_script.vim')
1205enddef
1206
Bram Moolenaarc43e6232022-01-13 20:51:56 +00001207def Test_import_vim9_from_legacy()
1208 var vim9_lines =<< trim END
1209 vim9script
1210 var local = 'local'
1211 g:global = 'global'
1212 export var exported = 'exported'
1213 export def GetText(): string
1214 return 'text'
1215 enddef
1216 END
1217 writefile(vim9_lines, 'Xvim9_export.vim')
1218
1219 var legacy_lines =<< trim END
1220 import './Xvim9_export.vim' as vim9
1221
1222 call assert_false(exists('vim9'))
1223 call assert_false(exists('local'))
1224 call assert_false(exists('s:vim9.local'))
1225 call assert_equal('global', global)
1226 call assert_equal('global', g:global)
1227 call assert_false(exists('exported'))
1228 call assert_false(exists('s:exported'))
1229 call assert_false(exists('*GetText'))
1230
1231 " imported symbol is script-local
1232 call assert_equal('exported', s:vim9.exported)
1233 call assert_equal('text', s:vim9.GetText())
1234 END
1235 writefile(legacy_lines, 'Xlegacy_script.vim')
1236
1237 source Xlegacy_script.vim
1238 assert_equal('global', g:global)
1239 unlet g:global
1240
1241 delete('Xlegacy_script.vim')
1242 delete('Xvim9_export.vim')
1243enddef
1244
Bram Moolenaard8448622022-01-07 21:39:52 +00001245def Test_cmdline_win()
1246 # if the Vim syntax highlighting uses Vim9 constructs they can be used from
1247 # the command line window.
1248 mkdir('rtp/syntax', 'p')
1249 var export_lines =<< trim END
1250 vim9script
1251 export var That = 'yes'
1252 END
1253 writefile(export_lines, 'rtp/syntax/Xexport.vim')
1254 var import_lines =<< trim END
1255 vim9script
1256 import './Xexport.vim' as exp
1257 echo exp.That
1258 END
1259 writefile(import_lines, 'rtp/syntax/vim.vim')
1260 var save_rtp = &rtp
1261 &rtp = getcwd() .. '/rtp' .. ',' .. &rtp
1262 syntax on
1263 augroup CmdWin
1264 autocmd CmdwinEnter * g:got_there = 'yes'
1265 augroup END
1266 # this will open and also close the cmdline window
1267 feedkeys('q:', 'xt')
1268 assert_equal('yes', g:got_there)
1269
1270 augroup CmdWin
1271 au!
1272 augroup END
1273 &rtp = save_rtp
1274 delete('rtp', 'rf')
1275enddef
1276
1277def Test_import_gone_when_sourced_twice()
1278 var exportlines =<< trim END
1279 vim9script
1280 if exists('g:guard')
1281 finish
1282 endif
1283 g:guard = 1
1284 export var name = 'someName'
1285 END
1286 writefile(exportlines, 'XexportScript.vim')
1287
1288 var lines =<< trim END
1289 vim9script
1290 import './XexportScript.vim' as expo
1291 def g:GetName(): string
1292 return expo.name
1293 enddef
1294 END
1295 writefile(lines, 'XscriptImport.vim')
1296 so XscriptImport.vim
1297 assert_equal('someName', g:GetName())
1298
1299 so XexportScript.vim
1300 assert_fails('call g:GetName()', 'E1149:')
1301
1302 delfunc g:GetName
1303 delete('XexportScript.vim')
1304 delete('XscriptImport.vim')
1305 unlet g:guard
1306enddef
1307
Bram Moolenaar160aa862022-01-10 21:29:57 +00001308" test using an auto-loaded function and variable
Bram Moolenaar0e3e7ba2022-01-13 20:18:56 +00001309def Test_vim9_autoload_full_name()
Bram Moolenaar160aa862022-01-10 21:29:57 +00001310 var lines =<< trim END
1311 vim9script
1312 def some#gettest(): string
1313 return 'test'
1314 enddef
1315 g:some#name = 'name'
1316 g:some#dict = {key: 'value'}
1317
1318 def some#varargs(a1: string, ...l: list<string>): string
1319 return a1 .. l[0] .. l[1]
1320 enddef
1321 END
1322
1323 mkdir('Xdir/autoload', 'p')
1324 writefile(lines, 'Xdir/autoload/some.vim')
1325 var save_rtp = &rtp
1326 exe 'set rtp^=' .. getcwd() .. '/Xdir'
1327
1328 assert_equal('test', g:some#gettest())
1329 assert_equal('name', g:some#name)
1330 assert_equal('value', g:some#dict.key)
1331 g:some#other = 'other'
1332 assert_equal('other', g:some#other)
1333
1334 assert_equal('abc', some#varargs('a', 'b', 'c'))
1335
1336 # upper case script name works
1337 lines =<< trim END
1338 vim9script
1339 def Other#getOther(): string
1340 return 'other'
1341 enddef
1342 END
1343 writefile(lines, 'Xdir/autoload/Other.vim')
1344 assert_equal('other', g:Other#getOther())
1345
1346 delete('Xdir', 'rf')
1347 &rtp = save_rtp
1348enddef
1349
1350def Test_vim9script_autoload()
1351 mkdir('Xdir/autoload', 'p')
1352 var save_rtp = &rtp
1353 exe 'set rtp^=' .. getcwd() .. '/Xdir'
1354
Bram Moolenaarfd218c82022-01-18 16:26:24 +00001355 # when the path has "/autoload/" prefix is not needed
Bram Moolenaar160aa862022-01-10 21:29:57 +00001356 var lines =<< trim END
Bram Moolenaarfd218c82022-01-18 16:26:24 +00001357 vim9script
Bram Moolenaar17d36cb2022-01-12 11:46:40 +00001358 g:prefixed_loaded += 1
Bram Moolenaar160aa862022-01-10 21:29:57 +00001359
1360 export def Gettest(): string
1361 return 'test'
1362 enddef
1363
Bram Moolenaar0e3e7ba2022-01-13 20:18:56 +00001364 export var name = 'name'
1365
1366 export func GetFunc()
1367 return Gettest() .. 'more' .. s:name
Bram Moolenaar160aa862022-01-10 21:29:57 +00001368 endfunc
1369
Bram Moolenaar0e3e7ba2022-01-13 20:18:56 +00001370 export def GetDef(): string
1371 return Gettest() .. 'more' .. name
1372 enddef
1373
Bram Moolenaar160aa862022-01-10 21:29:57 +00001374 export final fname = 'final'
1375 export const cname = 'const'
1376 END
1377 writefile(lines, 'Xdir/autoload/prefixed.vim')
1378
Bram Moolenaar17d36cb2022-01-12 11:46:40 +00001379 g:prefixed_loaded = 0
1380 g:expected_loaded = 0
Bram Moolenaar160aa862022-01-10 21:29:57 +00001381 lines =<< trim END
1382 vim9script
1383 import autoload 'prefixed.vim'
Bram Moolenaar17d36cb2022-01-12 11:46:40 +00001384 assert_equal(g:expected_loaded, g:prefixed_loaded)
Bram Moolenaar160aa862022-01-10 21:29:57 +00001385 assert_equal('test', prefixed.Gettest())
Bram Moolenaar17d36cb2022-01-12 11:46:40 +00001386 assert_equal(1, g:prefixed_loaded)
Bram Moolenaar160aa862022-01-10 21:29:57 +00001387
Bram Moolenaar0e3e7ba2022-01-13 20:18:56 +00001388 assert_equal('testmorename', prefixed.GetFunc())
1389 assert_equal('testmorename', prefixed.GetDef())
Bram Moolenaar160aa862022-01-10 21:29:57 +00001390 assert_equal('name', prefixed.name)
1391 assert_equal('final', prefixed.fname)
1392 assert_equal('const', prefixed.cname)
1393 END
1394 CheckScriptSuccess(lines)
Bram Moolenaar17d36cb2022-01-12 11:46:40 +00001395 # can source it again, autoload script not loaded again
1396 g:expected_loaded = 1
1397 CheckScriptSuccess(lines)
Bram Moolenaar160aa862022-01-10 21:29:57 +00001398
1399 # can also get the items by autoload name
1400 lines =<< trim END
1401 call assert_equal('test', prefixed#Gettest())
Bram Moolenaar0e3e7ba2022-01-13 20:18:56 +00001402 call assert_equal('testmorename', prefixed#GetFunc())
Bram Moolenaar160aa862022-01-10 21:29:57 +00001403 call assert_equal('name', prefixed#name)
1404 call assert_equal('final', prefixed#fname)
1405 call assert_equal('const', prefixed#cname)
1406 END
1407 CheckScriptSuccess(lines)
1408
Bram Moolenaarf111cdf2022-01-12 12:48:17 +00001409 unlet g:prefixed_loaded
1410 unlet g:expected_loaded
1411 delete('Xdir', 'rf')
1412 &rtp = save_rtp
1413enddef
1414
Bram Moolenaard02dce22022-01-18 17:43:04 +00001415def Test_import_autoload_not_exported()
1416 mkdir('Xdir/autoload', 'p')
1417 var save_rtp = &rtp
1418 exe 'set rtp^=' .. getcwd() .. '/Xdir'
1419
1420 # error when using an item that is not exported from an autoload script
1421 var exportLines =<< trim END
1422 vim9script
1423 var notExported = 123
1424 def NotExport()
1425 echo 'nop'
1426 enddef
1427 END
1428 writefile(exportLines, 'Xdir/autoload/notExport1.vim')
1429
1430 var lines =<< trim END
1431 vim9script
1432 import autoload 'notExport1.vim'
1433 echo notExport1.notFound
1434 END
1435 CheckScriptFailure(lines, 'E1048: Item not found in script: notFound')
1436
1437 lines =<< trim END
1438 vim9script
1439 import autoload 'notExport1.vim'
1440 echo notExport1.notExported
1441 END
1442 CheckScriptFailure(lines, 'E1049: Item not exported in script: notExported')
1443
1444 lines =<< trim END
1445 vim9script
1446 import autoload 'notExport1.vim'
1447 echo notExport1.NotFunc()
1448 END
1449 CheckScriptFailure(lines, 'E1048: Item not found in script: NotFunc')
1450
1451 lines =<< trim END
1452 vim9script
1453 import autoload 'notExport1.vim'
1454 echo notExport1.NotExport()
1455 END
1456 CheckScriptFailure(lines, 'E1049: Item not exported in script: NotExport')
1457
1458 lines =<< trim END
1459 vim9script
1460 import autoload 'notExport1.vim'
1461 echo 'text'->notExport1.NotFunc()
1462 END
1463 CheckScriptFailure(lines, 'E1048: Item not found in script: NotFunc')
1464
1465 lines =<< trim END
1466 vim9script
1467 import autoload 'notExport1.vim'
1468 echo 'text'->notExport1.NotExport()
1469 END
1470 CheckScriptFailure(lines, 'E1049: Item not exported in script: NotExport')
1471
1472 # using a :def function we use a different autoload script every time so that
1473 # the function is compiled without the script loaded
1474 writefile(exportLines, 'Xdir/autoload/notExport2.vim')
1475 lines =<< trim END
1476 vim9script
1477 import autoload 'notExport2.vim'
1478 def Testit()
1479 echo notExport2.notFound
1480 enddef
1481 Testit()
1482 END
1483 CheckScriptFailure(lines, 'E1048: Item not found in script: notExport2#notFound')
1484
1485 writefile(exportLines, 'Xdir/autoload/notExport3.vim')
1486 lines =<< trim END
1487 vim9script
1488 import autoload 'notExport3.vim'
1489 def Testit()
1490 echo notExport3.notExported
1491 enddef
1492 Testit()
1493 END
1494 # don't get E1049 because it is too complicated to figure out
1495 CheckScriptFailure(lines, 'E1048: Item not found in script: notExport3#notExported')
1496
1497 writefile(exportLines, 'Xdir/autoload/notExport4.vim')
1498 lines =<< trim END
1499 vim9script
1500 import autoload 'notExport4.vim'
1501 def Testit()
1502 echo notExport4.NotFunc()
1503 enddef
1504 Testit()
1505 END
1506 CheckScriptFailure(lines, 'E117: Unknown function: notExport4#NotFunc')
1507
1508 writefile(exportLines, 'Xdir/autoload/notExport5.vim')
1509 lines =<< trim END
1510 vim9script
1511 import autoload 'notExport5.vim'
1512 def Testit()
1513 echo notExport5.NotExport()
1514 enddef
1515 Testit()
1516 END
1517 CheckScriptFailure(lines, 'E117: Unknown function: notExport5#NotExport')
1518
1519 writefile(exportLines, 'Xdir/autoload/notExport6.vim')
1520 lines =<< trim END
1521 vim9script
1522 import autoload 'notExport6.vim'
1523 def Testit()
1524 echo 'text'->notExport6.NotFunc()
1525 enddef
1526 Testit()
1527 END
1528 CheckScriptFailure(lines, 'E117: Unknown function: notExport6#NotFunc')
1529
1530 writefile(exportLines, 'Xdir/autoload/notExport7.vim')
1531 lines =<< trim END
1532 vim9script
1533 import autoload 'notExport7.vim'
1534 def Testit()
1535 echo 'text'->notExport7.NotExport()
1536 enddef
1537 Testit()
1538 END
1539 CheckScriptFailure(lines, 'E117: Unknown function: notExport7#NotExport')
1540
1541 delete('Xdir', 'rf')
1542 &rtp = save_rtp
1543enddef
1544
Bram Moolenaarf111cdf2022-01-12 12:48:17 +00001545def Test_vim9script_autoload_call()
1546 mkdir('Xdir/autoload', 'p')
1547 var save_rtp = &rtp
1548 exe 'set rtp^=' .. getcwd() .. '/Xdir'
1549
1550 var lines =<< trim END
Bram Moolenaarfd218c82022-01-18 16:26:24 +00001551 vim9script
Bram Moolenaarf111cdf2022-01-12 12:48:17 +00001552
Bram Moolenaarcbbc48f2022-01-18 12:58:28 +00001553 export def RetArg(arg: string): string
1554 return arg
1555 enddef
1556
Bram Moolenaarf111cdf2022-01-12 12:48:17 +00001557 export def Getother()
1558 g:result = 'other'
1559 enddef
1560 END
Bram Moolenaar5d982692022-01-12 15:15:27 +00001561 writefile(lines, 'Xdir/autoload/another.vim')
Bram Moolenaarf111cdf2022-01-12 12:48:17 +00001562
1563 lines =<< trim END
1564 vim9script
Bram Moolenaar5d982692022-01-12 15:15:27 +00001565 import autoload 'another.vim'
Bram Moolenaarcbbc48f2022-01-18 12:58:28 +00001566
1567 # compile this before 'another.vim' is loaded
1568 def CallAnother()
1569 assert_equal('foo', 'foo'->another.RetArg())
1570 enddef
1571 CallAnother()
1572
Bram Moolenaar5d982692022-01-12 15:15:27 +00001573 call another.Getother()
Bram Moolenaarf111cdf2022-01-12 12:48:17 +00001574 assert_equal('other', g:result)
Bram Moolenaar3d8e25a2022-01-22 11:00:02 +00001575
1576 assert_equal('arg', call('another.RetArg', ['arg']))
Bram Moolenaarf111cdf2022-01-12 12:48:17 +00001577 END
1578 CheckScriptSuccess(lines)
1579
1580 unlet g:result
Bram Moolenaar160aa862022-01-10 21:29:57 +00001581 delete('Xdir', 'rf')
1582 &rtp = save_rtp
1583enddef
1584
Bram Moolenaarb697dc22022-01-22 11:27:29 +00001585def Test_vim9script_noclear_autoload()
1586 mkdir('Xdir/autoload', 'p')
1587 var save_rtp = &rtp
1588 exe 'set rtp^=' .. getcwd() .. '/Xdir'
1589
1590 var lines =<< trim END
1591 vim9script
1592 export def Func(): string
1593 return 'called'
1594 enddef
1595 g:double_loaded = 'yes'
1596 END
1597 writefile(lines, 'Xdir/autoload/double.vim')
1598
1599 lines =<< trim END
1600 vim9script noclear
1601 if exists('g:script_loaded')
1602 finish
1603 endif
1604 g:script_loaded = true
1605
1606 import autoload 'double.vim'
1607 nnoremap <F3> <ScriptCmd>g:result = double.Func()<CR>
1608 END
1609 g:double_loaded = 'no'
1610 writefile(lines, 'Xloaddouble')
1611 source Xloaddouble
1612 assert_equal('no', g:double_loaded)
1613 assert_equal(true, g:script_loaded)
1614 source Xloaddouble
1615 feedkeys("\<F3>", 'xt')
1616 assert_equal('called', g:result)
1617 assert_equal('yes', g:double_loaded)
1618
1619 delete('Xloaddouble')
1620 unlet g:double_loaded
1621 unlet g:script_loaded
1622 unlet g:result
1623 delete('Xdir', 'rf')
1624 &rtp = save_rtp
1625enddef
1626
Bram Moolenaar9c7cae62022-01-20 19:10:25 +00001627def Test_vim9script_autoload_duplicate()
1628 mkdir('Xdir/autoload', 'p')
1629
1630 var lines =<< trim END
1631 vim9script
1632
1633 export def Func()
1634 enddef
1635
1636 def Func()
1637 enddef
1638 END
1639 writefile(lines, 'Xdir/autoload/dupfunc.vim')
1640 assert_fails('source Xdir/autoload/dupfunc.vim', 'E1073:')
1641
1642 lines =<< trim END
1643 vim9script
1644
1645 def Func()
1646 enddef
1647
1648 export def Func()
1649 enddef
1650 END
1651 writefile(lines, 'Xdir/autoload/dup2func.vim')
1652 assert_fails('source Xdir/autoload/dup2func.vim', 'E1073:')
1653
1654 lines =<< trim END
1655 vim9script
1656
1657 def Func()
1658 enddef
1659
1660 export var Func = 'asdf'
1661 END
1662 writefile(lines, 'Xdir/autoload/dup3func.vim')
1663 assert_fails('source Xdir/autoload/dup3func.vim', 'E1041: Redefining script item Func')
1664
1665 lines =<< trim END
1666 vim9script
1667
1668 export var Func = 'asdf'
1669
1670 def Func()
1671 enddef
1672 END
1673 writefile(lines, 'Xdir/autoload/dup4func.vim')
1674 assert_fails('source Xdir/autoload/dup4func.vim', 'E707:')
1675
1676 lines =<< trim END
1677 vim9script
1678
1679 var Func = 'asdf'
1680
1681 export def Func()
1682 enddef
1683 END
1684 writefile(lines, 'Xdir/autoload/dup5func.vim')
1685 assert_fails('source Xdir/autoload/dup5func.vim', 'E707:')
1686
1687 lines =<< trim END
1688 vim9script
1689
1690 export def Func()
1691 enddef
1692
1693 var Func = 'asdf'
1694 END
1695 writefile(lines, 'Xdir/autoload/dup6func.vim')
1696 assert_fails('source Xdir/autoload/dup6func.vim', 'E1041: Redefining script item Func')
1697
1698 delete('Xdir', 'rf')
1699enddef
1700
Bram Moolenaar2017d6f2022-01-20 19:38:46 +00001701def Test_autoload_missing_function_name()
1702 mkdir('Xdir/autoload', 'p')
1703
1704 var lines =<< trim END
1705 vim9script
1706
1707 def loadme#()
1708 enddef
1709 END
1710 writefile(lines, 'Xdir/autoload/loadme.vim')
1711 assert_fails('source Xdir/autoload/loadme.vim', 'E129:')
1712
1713 delete('Xdir', 'rf')
1714enddef
1715
Bram Moolenaar19e69a62022-01-21 20:37:05 +00001716def Test_autoload_name_wring()
1717 var lines =<< trim END
1718 vim9script
1719 def Xscriptname#Func()
1720 enddef
1721 END
1722 writefile(lines, 'Xscriptname.vim')
1723 CheckScriptFailure(lines, 'E1263:')
1724
1725 delete('Xscriptname')
1726enddef
1727
Bram Moolenaard041f422022-01-12 19:54:00 +00001728def Test_import_autoload_postponed()
1729 mkdir('Xdir/autoload', 'p')
1730 var save_rtp = &rtp
1731 exe 'set rtp^=' .. getcwd() .. '/Xdir'
1732
1733 var lines =<< trim END
Bram Moolenaarfd218c82022-01-18 16:26:24 +00001734 vim9script
Bram Moolenaard041f422022-01-12 19:54:00 +00001735
1736 g:loaded_postponed = 'true'
1737 export var variable = 'bla'
1738 export def Function(): string
1739 return 'bla'
1740 enddef
1741 END
1742 writefile(lines, 'Xdir/autoload/postponed.vim')
1743
1744 lines =<< trim END
1745 vim9script
1746
1747 import autoload 'postponed.vim'
1748 def Tryit()
1749 echo postponed.variable
1750 echo postponed.Function()
1751 enddef
1752 defcompile
1753 END
1754 CheckScriptSuccess(lines)
1755 assert_false(exists('g:loaded_postponed'))
1756 CheckScriptSuccess(lines + ['Tryit()'])
1757 assert_equal('true', g:loaded_postponed)
1758
1759 unlet g:loaded_postponed
1760 delete('Xdir', 'rf')
1761 &rtp = save_rtp
1762enddef
1763
Bram Moolenaar3e4fa3d2022-01-13 22:05:09 +00001764def Test_import_autoload_override()
1765 mkdir('Xdir/autoload', 'p')
1766 var save_rtp = &rtp
1767 exe 'set rtp^=' .. getcwd() .. '/Xdir'
1768 test_override('autoload', 1)
1769
1770 var lines =<< trim END
Bram Moolenaarfd218c82022-01-18 16:26:24 +00001771 vim9script
Bram Moolenaar3e4fa3d2022-01-13 22:05:09 +00001772
1773 g:loaded_override = 'true'
1774 export var variable = 'bla'
1775 export def Function(): string
1776 return 'bla'
1777 enddef
1778 END
1779 writefile(lines, 'Xdir/autoload/override.vim')
1780
1781 lines =<< trim END
1782 vim9script
1783
1784 import autoload 'override.vim'
1785 assert_equal('true', g:loaded_override)
1786
1787 def Tryit()
1788 echo override.doesNotExist
1789 enddef
1790 defcompile
1791 END
1792 CheckScriptFailure(lines, 'E1048: Item not found in script: doesNotExist', 1)
1793
1794 test_override('autoload', 0)
1795 unlet g:loaded_override
1796 delete('Xdir', 'rf')
1797 &rtp = save_rtp
1798enddef
1799
Bram Moolenaar19db9e62022-01-11 11:58:19 +00001800def Test_autoload_mapping()
1801 mkdir('Xdir/autoload', 'p')
1802 var save_rtp = &rtp
1803 exe 'set rtp^=' .. getcwd() .. '/Xdir'
1804
1805 var lines =<< trim END
Bram Moolenaarfd218c82022-01-18 16:26:24 +00001806 vim9script
Bram Moolenaar19db9e62022-01-11 11:58:19 +00001807
1808 g:toggle_loaded = 'yes'
1809
1810 export def Toggle(): string
1811 return ":g:toggle_called = 'yes'\<CR>"
1812 enddef
Bram Moolenaare32c3c42022-01-15 18:26:04 +00001813 export def Doit()
1814 g:doit_called = 'yes'
1815 enddef
Bram Moolenaar19db9e62022-01-11 11:58:19 +00001816 END
1817 writefile(lines, 'Xdir/autoload/toggle.vim')
1818
1819 lines =<< trim END
1820 vim9script
1821
1822 import autoload 'toggle.vim'
1823
1824 nnoremap <silent> <expr> tt toggle.Toggle()
Bram Moolenaare32c3c42022-01-15 18:26:04 +00001825 nnoremap <silent> xx <ScriptCmd>toggle.Doit()<CR>
1826 nnoremap <silent> yy <Cmd>toggle.Doit()<CR>
Bram Moolenaar19db9e62022-01-11 11:58:19 +00001827 END
1828 CheckScriptSuccess(lines)
1829 assert_false(exists("g:toggle_loaded"))
1830 assert_false(exists("g:toggle_called"))
Bram Moolenaar6079da72022-01-18 14:16:59 +00001831 assert_match('\d A: \f*[/\\]toggle.vim', execute('scriptnames'))
Bram Moolenaar19db9e62022-01-11 11:58:19 +00001832
1833 feedkeys("tt", 'xt')
1834 assert_equal('yes', g:toggle_loaded)
1835 assert_equal('yes', g:toggle_called)
Bram Moolenaar6079da72022-01-18 14:16:59 +00001836 assert_match('\d: \f*[/\\]toggle.vim', execute('scriptnames'))
Bram Moolenaar19db9e62022-01-11 11:58:19 +00001837
Bram Moolenaare32c3c42022-01-15 18:26:04 +00001838 feedkeys("xx", 'xt')
1839 assert_equal('yes', g:doit_called)
1840
1841 assert_fails('call feedkeys("yy", "xt")', 'E121: Undefined variable: toggle')
1842
Bram Moolenaar19db9e62022-01-11 11:58:19 +00001843 nunmap tt
Bram Moolenaare32c3c42022-01-15 18:26:04 +00001844 nunmap xx
1845 nunmap yy
Bram Moolenaar19db9e62022-01-11 11:58:19 +00001846 unlet g:toggle_loaded
1847 unlet g:toggle_called
1848 delete('Xdir', 'rf')
1849 &rtp = save_rtp
1850enddef
1851
Bram Moolenaar160aa862022-01-10 21:29:57 +00001852def Test_vim9script_autoload_fails()
1853 var lines =<< trim END
1854 vim9script autoload
1855 var n = 0
1856 END
Bram Moolenaarfd218c82022-01-18 16:26:24 +00001857 CheckScriptFailure(lines, 'E475: Invalid argument: autoload')
1858
1859 lines =<< trim END
1860 vim9script noclear noclear
1861 var n = 0
1862 END
1863 CheckScriptFailure(lines, 'E983: Duplicate argument: noclear')
Bram Moolenaar160aa862022-01-10 21:29:57 +00001864enddef
1865
1866def Test_import_autoload_fails()
1867 var lines =<< trim END
1868 vim9script
1869 import autoload autoload 'prefixed.vim'
1870 END
1871 CheckScriptFailure(lines, 'E121: Undefined variable: autoload')
1872
1873 lines =<< trim END
1874 vim9script
Bram Moolenaar1836d612022-01-18 13:14:47 +00001875 import autoload './doesNotExist.vim'
Bram Moolenaar160aa862022-01-10 21:29:57 +00001876 END
1877 CheckScriptFailure(lines, 'E1264:')
Bram Moolenaar1836d612022-01-18 13:14:47 +00001878
1879 lines =<< trim END
1880 vim9script
1881 import autoload '/dir/doesNotExist.vim'
1882 END
1883 CheckScriptFailure(lines, 'E1264:')
1884
1885 lines =<< trim END
1886 vim9script
1887 import autoload 'doesNotExist.vim'
1888 END
1889 CheckScriptFailure(lines, 'E1053: Could not import "doesNotExist.vim"')
Bram Moolenaar160aa862022-01-10 21:29:57 +00001890enddef
1891
1892" test disassembling an auto-loaded function starting with "debug"
1893def Test_vim9_autoload_disass()
1894 mkdir('Xdir/autoload', 'p')
1895 var save_rtp = &rtp
1896 exe 'set rtp^=' .. getcwd() .. '/Xdir'
1897
1898 var lines =<< trim END
1899 vim9script
1900 def debugit#test(): string
1901 return 'debug'
1902 enddef
1903 END
1904 writefile(lines, 'Xdir/autoload/debugit.vim')
1905
1906 lines =<< trim END
1907 vim9script
1908 def profileit#test(): string
1909 return 'profile'
1910 enddef
1911 END
1912 writefile(lines, 'Xdir/autoload/profileit.vim')
1913
1914 lines =<< trim END
1915 vim9script
1916 assert_equal('debug', debugit#test())
1917 disass debugit#test
1918 assert_equal('profile', profileit#test())
1919 disass profileit#test
1920 END
1921 CheckScriptSuccess(lines)
1922
1923 delete('Xdir', 'rf')
1924 &rtp = save_rtp
1925enddef
1926
1927" test using a vim9script that is auto-loaded from an autocmd
1928def Test_vim9_aucmd_autoload()
1929 var lines =<< trim END
1930 vim9script
1931 def foo#test()
1932 echomsg getreg('"')
1933 enddef
1934 END
1935
1936 mkdir('Xdir/autoload', 'p')
1937 writefile(lines, 'Xdir/autoload/foo.vim')
1938 var save_rtp = &rtp
1939 exe 'set rtp^=' .. getcwd() .. '/Xdir'
1940 augroup test
1941 autocmd TextYankPost * call foo#test()
1942 augroup END
1943
1944 normal Y
1945
1946 augroup test
1947 autocmd!
1948 augroup END
1949 delete('Xdir', 'rf')
1950 &rtp = save_rtp
1951enddef
1952
Bram Moolenaar3049fcf2022-01-13 19:25:50 +00001953" test using a autoloaded file that is case sensitive
1954def Test_vim9_autoload_case_sensitive()
1955 var lines =<< trim END
Bram Moolenaarfd218c82022-01-18 16:26:24 +00001956 vim9script
Bram Moolenaar3049fcf2022-01-13 19:25:50 +00001957 export def CaseSensitive(): string
1958 return 'done'
1959 enddef
1960 END
1961
1962 mkdir('Xdir/autoload', 'p')
1963 writefile(lines, 'Xdir/autoload/CaseSensitive.vim')
1964 var save_rtp = &rtp
1965 exe 'set rtp^=' .. getcwd() .. '/Xdir'
1966
1967 lines =<< trim END
1968 vim9script
1969 import autoload 'CaseSensitive.vim'
1970 assert_equal('done', CaseSensitive.CaseSensitive())
1971 END
1972 CheckScriptSuccess(lines)
1973
Bram Moolenaarbfac4092022-01-16 11:12:12 +00001974 if !has('fname_case')
1975 lines =<< trim END
1976 vim9script
1977 import autoload 'CaseSensitive.vim'
1978 import autoload 'casesensitive.vim'
1979 END
1980 CheckScriptFailure(lines, 'E1262:')
1981 endif
1982
Bram Moolenaar3049fcf2022-01-13 19:25:50 +00001983 delete('Xdir', 'rf')
1984 &rtp = save_rtp
1985enddef
1986
Bram Moolenaar160aa862022-01-10 21:29:57 +00001987" This was causing a crash because suppress_errthrow wasn't reset.
1988def Test_vim9_autoload_error()
1989 var lines =<< trim END
1990 vim9script
1991 def crash#func()
1992 try
1993 for x in List()
1994 endfor
1995 catch
1996 endtry
1997 g:ok = true
1998 enddef
1999 fu List()
2000 invalid
2001 endfu
2002 try
2003 alsoinvalid
2004 catch /wontmatch/
2005 endtry
2006 END
2007 call mkdir('Xruntime/autoload', 'p')
2008 call writefile(lines, 'Xruntime/autoload/crash.vim')
2009
2010 # run in a separate Vim to avoid the side effects of assert_fails()
2011 lines =<< trim END
2012 exe 'set rtp^=' .. getcwd() .. '/Xruntime'
2013 call crash#func()
2014 call writefile(['ok'], 'Xdidit')
2015 qall!
2016 END
2017 writefile(lines, 'Xscript')
2018 RunVim([], [], '-S Xscript')
2019 assert_equal(['ok'], readfile('Xdidit'))
2020
2021 delete('Xdidit')
2022 delete('Xscript')
2023 delete('Xruntime', 'rf')
2024
2025 lines =<< trim END
2026 vim9script
2027 var foo#bar = 'asdf'
2028 END
2029 CheckScriptFailure(lines, 'E461: Illegal variable name: foo#bar', 2)
2030enddef
2031
Bram Moolenaard8448622022-01-07 21:39:52 +00002032
2033" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker