blob: 968bce08b9a87fd0cedf6756b07ae6e9caa71637 [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
Bram Moolenaar62aec932022-01-29 21:45:34 +00006import './vim9.vim' as v9
Bram Moolenaard8448622022-01-07 21:39:52 +00007
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
Bram Moolenaar62aec932022-01-29 21:45:34 +000036def s:Undo_export_script_lines()
Bram Moolenaard8448622022-01-07 21:39:52 +000037 unlet g:result
38 unlet g:localname
39enddef
40
41def Test_vim9_import_export()
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +010042 writefile(s:export_script_lines, 'Xexport.vim', 'D')
Bram Moolenaard8448622022-01-07 21:39:52 +000043 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
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +010087 writefile(import_script_lines, 'Ximport.vim', 'D')
Bram Moolenaard8448622022-01-07 21:39:52 +000088 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
Bram Moolenaar68854a82022-01-31 18:59:13 +0000145 var import_shadows_cmdmod_lines =<< trim END
146 vim9script
147 import './Xexport.vim' as vim9
148 vim9.exp_name = 'Shadow'
149 assert_equal('Shadow', vim9.exp_name)
150 END
151 v9.CheckScriptSuccess(import_shadows_cmdmod_lines)
152
Bram Moolenaard8448622022-01-07 21:39:52 +0000153 var line_break_before_dot =<< trim END
154 vim9script
155 import './Xexport.vim' as expo
156 g:exported = expo
157 .exported
158 END
159 writefile(line_break_before_dot, 'Ximport_lbr_before_dot.vim')
160 assert_fails('source Ximport_lbr_before_dot.vim', 'E1060:', '', 3)
161 delete('Ximport_lbr_before_dot.vim')
162
163 var line_break_after_dot =<< trim END
164 vim9script
165 import './Xexport.vim' as expo
166 g:exported = expo.
167 exported
168 END
169 writefile(line_break_after_dot, 'Ximport_lbr_after_dot.vim')
170 assert_fails('source Ximport_lbr_after_dot.vim', 'E1074:', '', 3)
171 delete('Ximport_lbr_after_dot.vim')
172
173 var import_star_as_lines =<< trim END
174 vim9script
175 import './Xexport.vim' as Export
176 def UseExport()
177 g:exported_def = Export.exported
178 enddef
179 g:exported_script = Export.exported
180 assert_equal(1, exists('Export.exported'))
181 assert_equal(0, exists('Export.notexported'))
182 UseExport()
183 END
184 writefile(import_star_as_lines, 'Ximport.vim')
185 source Ximport.vim
186
187 assert_equal(18, g:exported_def)
188 assert_equal(18, g:exported_script)
189 unlet g:exported_def
190 unlet g:exported_script
191
192 var import_star_as_lines_no_dot =<< trim END
193 vim9script
194 import './Xexport.vim' as Export
195 def Func()
196 var dummy = 1
197 var imported = Export + dummy
198 enddef
199 defcompile
200 END
201 writefile(import_star_as_lines_no_dot, 'Ximport.vim')
202 assert_fails('source Ximport.vim', 'E1060:', '', 2, 'Func')
203
204 var import_star_as_lines_dot_space =<< trim END
205 vim9script
206 import './Xexport.vim' as Export
207 def Func()
208 var imported = Export . exported
209 enddef
210 defcompile
211 END
212 writefile(import_star_as_lines_dot_space, 'Ximport.vim')
213 assert_fails('source Ximport.vim', 'E1074:', '', 1, 'Func')
214
Bram Moolenaar7c24dfd2022-01-08 17:03:55 +0000215 writefile(s:export_script_lines, 'Xexport2.vim')
216 var import_as_duplicated =<< trim END
Bram Moolenaard8448622022-01-07 21:39:52 +0000217 vim9script
218 import './Xexport.vim' as expo
Bram Moolenaar7c24dfd2022-01-08 17:03:55 +0000219 import './Xexport2.vim' as expo
Bram Moolenaard8448622022-01-07 21:39:52 +0000220 END
Bram Moolenaar7c24dfd2022-01-08 17:03:55 +0000221 writefile(import_as_duplicated, 'Ximport.vim')
Bram Moolenaard8448622022-01-07 21:39:52 +0000222 assert_fails('source Ximport.vim', 'E1073:', '', 3, 'Ximport.vim')
Bram Moolenaar7c24dfd2022-01-08 17:03:55 +0000223 delete('Xexport2.vim')
Bram Moolenaard8448622022-01-07 21:39:52 +0000224
225 var import_star_as_lines_script_no_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_no_dot, 'Ximport.vim')
231 assert_fails('source Ximport.vim', 'E1060: Expected dot after name: Export exported')
232
233 var import_star_as_lines_script_space_after_dot =<< trim END
234 vim9script
235 import './Xexport.vim' as Export
236 g:imported_script = Export. exported
237 END
238 writefile(import_star_as_lines_script_space_after_dot, 'Ximport.vim')
239 assert_fails('source Ximport.vim', 'E1074:')
240
241 var import_star_as_lines_missing_name =<< trim END
242 vim9script
243 import './Xexport.vim' as Export
244 def Func()
245 var imported = Export.
246 enddef
247 defcompile
248 END
249 writefile(import_star_as_lines_missing_name, 'Ximport.vim')
250 assert_fails('source Ximport.vim', 'E1048:', '', 1, 'Func')
251
252 var import_star_as_lbr_lines =<< trim END
253 vim9script
254 import './Xexport.vim'
255 as Export
256 def UseExport()
257 g:exported = Export.exported
258 enddef
259 UseExport()
260 END
261 writefile(import_star_as_lbr_lines, 'Ximport.vim')
262 source Ximport.vim
263 assert_equal(18, g:exported)
264 unlet g:exported
265
266 # try to use something that exists but is not exported
267 var import_not_exported_lines =<< trim END
268 vim9script
269 import './Xexport.vim' as expo
270 echo expo.name
271 END
272 writefile(import_not_exported_lines, 'Ximport.vim')
273 assert_fails('source Ximport.vim', 'E1049:', '', 3, 'Ximport.vim')
274
275 # try to import something that is already defined
276 var import_already_defined =<< trim END
277 vim9script
278 var exported = 'something'
279 import './Xexport.vim' as exported
280 END
281 writefile(import_already_defined, 'Ximport.vim')
282 assert_fails('source Ximport.vim', 'E1054:', '', 3, 'Ximport.vim')
283
284 # try changing an imported const
285 var import_assign_to_const =<< trim END
286 vim9script
287 import './Xexport.vim' as expo
288 def Assign()
289 expo.CONST = 987
290 enddef
291 defcompile
292 END
293 writefile(import_assign_to_const, 'Ximport.vim')
294 assert_fails('source Ximport.vim', 'E46:', '', 1, '_Assign')
295
296 # try changing an imported final
297 var import_assign_to_final =<< trim END
298 vim9script
299 import './Xexport.vim' as expo
300 def Assign()
301 expo.theList = [2]
302 enddef
303 defcompile
304 END
305 writefile(import_assign_to_final, 'Ximport.vim')
306 assert_fails('source Ximport.vim', 'E46:', '', 1, '_Assign')
307
308 var import_no_as_lines =<< trim END
309 vim9script
310 import './Xexport.vim' name
311 END
312 writefile(import_no_as_lines, 'Ximport.vim')
313 assert_fails('source Ximport.vim', 'E488:', '', 2, 'Ximport.vim')
314
Bram Moolenaar5cb53b72022-05-26 19:54:05 +0100315 # trailing starts with "as"
316 var import_bad_as_lines =<< trim END
317 vim9script
318 import './Xexport.vim' asname
319 END
320 writefile(import_no_as_lines, 'Ximport.vim')
321 assert_fails('source Ximport.vim', 'E488:', '', 2, 'Ximport.vim')
322
Bram Moolenaard8448622022-01-07 21:39:52 +0000323 var import_invalid_string_lines =<< trim END
324 vim9script
325 import Xexport.vim
326 END
327 writefile(import_invalid_string_lines, 'Ximport.vim')
328 assert_fails('source Ximport.vim', 'E121:', '', 2, 'Ximport.vim')
329
330 var import_wrong_name_lines =<< trim END
331 vim9script
332 import './XnoExport.vim'
333 END
334 writefile(import_wrong_name_lines, 'Ximport.vim')
335 assert_fails('source Ximport.vim', 'E1053:', '', 2, 'Ximport.vim')
336
337 var import_redefining_lines =<< trim END
338 vim9script
339 import './Xexport.vim' as exported
340 var exported = 5
341 END
342 writefile(import_redefining_lines, 'Ximport.vim')
343 assert_fails('source Ximport.vim', 'E1213: Redefining imported item "exported"', '', 3)
344
Bram Moolenaar160aa862022-01-10 21:29:57 +0000345 var import_missing_dot_lines =<< trim END
346 vim9script
347 import './Xexport.vim' as expo
348 def Test()
349 expo = 9
350 enddef
351 defcompile
352 END
353 writefile(import_missing_dot_lines, 'Ximport.vim')
354 assert_fails('source Ximport.vim', 'E1258:', '', 1)
355
356 var import_missing_name_lines =<< trim END
357 vim9script
358 import './Xexport.vim' as expo
359 def Test()
360 expo.99 = 9
361 enddef
362 defcompile
363 END
364 writefile(import_missing_name_lines, 'Ximport.vim')
Bram Moolenaar76283822022-01-10 21:39:03 +0000365 assert_fails('source Ximport.vim', 'E1259:', '', 1)
Bram Moolenaar160aa862022-01-10 21:29:57 +0000366
Bram Moolenaard8448622022-01-07 21:39:52 +0000367 var import_assign_wrong_type_lines =<< trim END
368 vim9script
369 import './Xexport.vim' as expo
370 expo.exported = 'xxx'
371 END
372 writefile(import_assign_wrong_type_lines, 'Ximport.vim')
373 assert_fails('source Ximport.vim', 'E1012: Type mismatch; expected number but got string', '', 3)
374
375 var import_assign_const_lines =<< trim END
376 vim9script
377 import './Xexport.vim' as expo
378 expo.CONST = 4321
379 END
380 writefile(import_assign_const_lines, 'Ximport.vim')
381 assert_fails('source Ximport.vim', 'E46: Cannot change read-only variable "CONST"', '', 3)
382
Bram Moolenaard8448622022-01-07 21:39:52 +0000383 # Check that in a Vim9 script 'cpo' is set to the Vim default.
384 # Flags added or removed are also applied to the restored value.
385 set cpo=abcd
386 var lines =<< trim END
387 vim9script
388 g:cpo_in_vim9script = &cpo
389 set cpo+=f
390 set cpo-=c
391 g:cpo_after_vim9script = &cpo
392 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +0100393 writefile(lines, 'Xvim9_script', 'D')
Bram Moolenaard8448622022-01-07 21:39:52 +0000394 source Xvim9_script
395 assert_equal('fabd', &cpo)
396 set cpo&vim
397 assert_equal(&cpo, g:cpo_in_vim9script)
398 var newcpo = substitute(&cpo, 'c', '', '') .. 'f'
399 assert_equal(newcpo, g:cpo_after_vim9script)
400
401 delete('Xvim9_script')
402enddef
403
Bram Moolenaar5cb53b72022-05-26 19:54:05 +0100404def Test_import_very_long_name()
405 var lines =<< trim END
406 vim9script
407
408 export var verylongnameverylongnameverylongnameverylongnameverylongnameverylongnameverylongnameverylongnameverylongnameverylongnameverylongnameverylongnameverylongnameverylongnameverylongnameverylongname = 'asdf'
409 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +0100410 writefile(lines, 'Xverylong.vim', 'D')
Bram Moolenaar5cb53b72022-05-26 19:54:05 +0100411
412 lines =<< trim END
413 vim9script
414 import './Xverylong.vim'
415
416 g:result = Xverylong.verylongnameverylongnameverylongnameverylongnameverylongnameverylongnameverylongnameverylongnameverylongnameverylongnameverylongnameverylongnameverylongnameverylongnameverylongnameverylongname
417 END
418 v9.CheckScriptSuccess(lines)
419 assert_equal('asdf', g:result)
420
Bram Moolenaar5cb53b72022-05-26 19:54:05 +0100421 unlet g:result
422enddef
423
Bram Moolenaard8448622022-01-07 21:39:52 +0000424def Test_import_funcref()
425 var lines =<< trim END
426 vim9script
427 export def F(): number
428 return 42
429 enddef
430 export const G = F
431 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +0100432 writefile(lines, 'Xlib.vim', 'D')
Bram Moolenaard8448622022-01-07 21:39:52 +0000433
434 lines =<< trim END
435 vim9script
436 import './Xlib.vim' as lib
437 const Foo = lib.G()
438 assert_equal(42, Foo)
439
440 def DoTest()
441 const Goo = lib.G()
442 assert_equal(42, Goo)
443 enddef
444 DoTest()
445 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000446 v9.CheckScriptSuccess(lines)
Bram Moolenaard8448622022-01-07 21:39:52 +0000447enddef
448
Bram Moolenaar5ab30012022-10-07 17:26:22 +0100449def Test_export_closure()
450 # tests that the closure in block can be compiled, not the import part
451 var lines =<< trim END
452 vim9script
453 {
454 var foo = 42
455 export def Bar(): number
456 return foo
457 enddef
458 }
459 assert_equal(42, Bar())
460 END
461 v9.CheckScriptSuccess(lines)
462enddef
463
Bram Moolenaarc2f17f72022-02-21 13:13:50 +0000464def Test_import_duplicate_function()
465 # Function Hover() exists in both scripts, partial should refer to the right
466 # one.
467 var lines =<< trim END
468 vim9script
469
470 def Hover(d: dict<any>): string
471 return 'found it'
472 enddef
473
474 export def NewLspServer(): dict<any>
475 var d: dict<any> = {}
476 d->extend({hover: function('Hover', [d])})
477 return d
478 enddef
479
480 NewLspServer()
481 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +0100482 writefile(lines, 'Xserver.vim', 'D')
Bram Moolenaarc2f17f72022-02-21 13:13:50 +0000483
484 lines =<< trim END
485 vim9script
486
487 import './Xserver.vim' as server
488
489 export def Hover()
490 enddef
491
492 def AddServer()
493 var d: dict<any> = server.NewLspServer()
494 assert_equal('found it', d.hover())
495 enddef
496 AddServer()
497 END
498 v9.CheckScriptSuccess(lines)
Bram Moolenaarc2f17f72022-02-21 13:13:50 +0000499enddef
500
501
Bram Moolenaard8448622022-01-07 21:39:52 +0000502def Test_import_fails()
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +0100503 writefile([], 'Xfoo.vim', 'D')
Bram Moolenaard8448622022-01-07 21:39:52 +0000504 var lines =<< trim END
505 import './Xfoo.vim' as foo
506 foo = 'bar'
507 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000508 v9.CheckDefAndScriptFailure(lines, ['E1094:', 'E1236: Cannot use foo itself'])
Bram Moolenaard8448622022-01-07 21:39:52 +0000509 lines =<< trim END
510 vim9script
511 import './Xfoo.vim' as foo
512 var that = foo
513 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000514 v9.CheckScriptFailure(lines, 'E1060: Expected dot after name: foo')
Bram Moolenaardd5893b2022-01-20 21:32:54 +0000515 lines =<< trim END
516 vim9script
517 import './Xfoo.vim' as foo
518 var that: any
519 that += foo
520 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000521 v9.CheckScriptFailure(lines, 'E1060: Expected dot after name: foo')
Bram Moolenaardd5893b2022-01-20 21:32:54 +0000522 lines =<< trim END
523 vim9script
524 import './Xfoo.vim' as foo
525 foo += 9
526 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000527 v9.CheckScriptFailure(lines, 'E1060: Expected dot after name: foo')
Bram Moolenaard8448622022-01-07 21:39:52 +0000528
529 lines =<< trim END
530 vim9script
531 import './Xfoo.vim' as 9foo
532 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000533 v9.CheckScriptFailure(lines, 'E1047:')
Bram Moolenaard8448622022-01-07 21:39:52 +0000534 lines =<< trim END
535 vim9script
536 import './Xfoo.vim' as the#foo
537 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000538 v9.CheckScriptFailure(lines, 'E1047:')
Bram Moolenaard8448622022-01-07 21:39:52 +0000539 lines =<< trim END
540 vim9script
541 import './Xfoo.vim' as g:foo
542 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000543 v9.CheckScriptFailure(lines, 'E1047:')
Bram Moolenaard8448622022-01-07 21:39:52 +0000544
Bram Moolenaard8448622022-01-07 21:39:52 +0000545 lines =<< trim END
546 vim9script
547 def TheFunc()
548 echo 'the func'
549 enddef
550 export var Ref = TheFunc
551 END
552 writefile([], 'Xthat.vim')
Bram Moolenaar7c24dfd2022-01-08 17:03:55 +0000553
Bram Moolenaard8448622022-01-07 21:39:52 +0000554 lines =<< trim END
555 import './Xthat.vim' as That
556 That()
557 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000558 v9.CheckDefAndScriptFailure(lines, ['E1094:', 'E1236: Cannot use That itself'])
Bram Moolenaar7c24dfd2022-01-08 17:03:55 +0000559
560 lines =<< trim END
Bram Moolenaar937610b2022-01-19 17:21:29 +0000561 vim9script
562 import './Xthat.vim' as That
563 def Func()
564 echo That()
565 enddef
566 Func()
567 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000568 v9.CheckScriptFailure(lines, 'E1236: Cannot use That itself')
Bram Moolenaar937610b2022-01-19 17:21:29 +0000569
570 lines =<< trim END
Bram Moolenaar7c24dfd2022-01-08 17:03:55 +0000571 import './Xthat.vim' as one
572 import './Xthat.vim' as two
573 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000574 v9.CheckScriptFailure(lines, 'E1262:')
Bram Moolenaar7c24dfd2022-01-08 17:03:55 +0000575
576 delete('Xthat.vim')
Bram Moolenaar779aeff2022-02-08 19:12:19 +0000577
578 lines =<< trim END
579 vim9script
580 export var item = 'hello'
581 import './Xyourself.vim'
582 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +0100583 writefile(lines, 'Xyourself.vim', 'D')
Bram Moolenaar779aeff2022-02-08 19:12:19 +0000584 assert_fails('source Xyourself.vim', 'E1088:')
Bram Moolenaar779aeff2022-02-08 19:12:19 +0000585
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +0100586 mkdir('Ximport', 'R')
Bram Moolenaard8448622022-01-07 21:39:52 +0000587
588 writefile(['vim9script'], 'Ximport/.vim')
589 lines =<< trim END
590 vim9script
591 import './Ximport/.vim'
592 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000593 v9.CheckScriptFailure(lines, 'E1261: Cannot import .vim without using "as"')
Bram Moolenaard8448622022-01-07 21:39:52 +0000594 lines =<< trim END
595 vim9script
596 import './Ximport/.vim' as vim
597 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000598 v9.CheckScriptSuccess(lines)
Bram Moolenaard8448622022-01-07 21:39:52 +0000599
600 writefile(['vim9script'], 'Ximport/.vimrc')
601 lines =<< trim END
602 vim9script
603 import './Ximport/.vimrc'
604 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000605 v9.CheckScriptFailure(lines, 'E1257: Imported script must use "as" or end in .vim')
Bram Moolenaard8448622022-01-07 21:39:52 +0000606 lines =<< trim END
607 vim9script
608 import './Ximport/.vimrc' as vimrc
609 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000610 v9.CheckScriptSuccess(lines)
Bram Moolenaard8448622022-01-07 21:39:52 +0000611
Yegappan Lakshmanan885de442022-04-23 10:51:14 +0100612 new
613 setline(1, ['vim9script', 'import "" as abc'])
614 assert_fails('source', 'E1071: Invalid string for :import: "" as abc')
615 setline(2, 'import [] as abc')
616 assert_fails('source', 'E1071: Invalid string for :import: [] as abc')
617 setline(2, 'import test_null_string() as abc')
618 assert_fails('source', 'E1071: Invalid string for :import: test_null_string() as abc')
619 bw!
620 call writefile(['vim9script', "import './Xfoo.vim' ask expo"], 'Xbar.vim')
621 assert_fails('source Xbar.vim', 'E488: Trailing characters: ask expo')
622 writefile([], 'Xtemp')
623 call writefile(['vim9script', "import './Xtemp'"], 'Xbar.vim')
624 assert_fails('source Xbar.vim', 'E1257: Imported script must use "as" or end in .vim: Xtemp')
625 delete('Xtemp')
626 call writefile(['vim9script', "import './Xfoo.vim' as abc | foobar"], 'Xbar.vim')
627 assert_fails('source Xbar.vim', 'E492: Not an editor command: foobar')
628 call delete('Xbar.vim')
Bram Moolenaard8448622022-01-07 21:39:52 +0000629enddef
630
631func g:Trigger()
632 source Ximport.vim
633 return "echo 'yes'\<CR>"
634endfunc
635
636def Test_import_export_expr_map()
637 # check that :import and :export work when buffer is locked
638 var export_lines =<< trim END
639 vim9script
640 export def That(): string
641 return 'yes'
642 enddef
643 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +0100644 writefile(export_lines, 'Xexport_that.vim', 'D')
Bram Moolenaard8448622022-01-07 21:39:52 +0000645
646 var import_lines =<< trim END
647 vim9script
648 import './Xexport_that.vim' as that
649 assert_equal('yes', that.That())
650 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +0100651 writefile(import_lines, 'Ximport.vim', 'D')
Bram Moolenaard8448622022-01-07 21:39:52 +0000652
653 nnoremap <expr> trigger g:Trigger()
654 feedkeys('trigger', "xt")
655
Bram Moolenaard8448622022-01-07 21:39:52 +0000656 nunmap trigger
657enddef
658
659def Test_import_in_filetype()
660 # check that :import works when the buffer is locked
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +0100661 mkdir('ftplugin', 'pR')
Bram Moolenaard8448622022-01-07 21:39:52 +0000662 var export_lines =<< trim END
663 vim9script
664 export var That = 'yes'
665 END
666 writefile(export_lines, 'ftplugin/Xexport_ft.vim')
667
668 var import_lines =<< trim END
669 vim9script
670 import './Xexport_ft.vim' as ft
671 assert_equal('yes', ft.That)
672 g:did_load_mytpe = 1
673 END
674 writefile(import_lines, 'ftplugin/qf.vim')
675
676 var save_rtp = &rtp
677 &rtp = getcwd() .. ',' .. &rtp
678
679 filetype plugin on
680 copen
681 assert_equal(1, g:did_load_mytpe)
682
683 quit!
Bram Moolenaard8448622022-01-07 21:39:52 +0000684 &rtp = save_rtp
685enddef
686
687def Test_use_import_in_mapping()
688 var lines =<< trim END
689 vim9script
Bram Moolenaar89445512022-04-14 12:58:23 +0100690 export def Funcx(nr: number)
691 g:result = nr
Bram Moolenaard8448622022-01-07 21:39:52 +0000692 enddef
693 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +0100694 writefile(lines, 'XsomeExport.vim', 'D')
Bram Moolenaard8448622022-01-07 21:39:52 +0000695 lines =<< trim END
696 vim9script
697 import './XsomeExport.vim' as some
698 var Funcy = some.Funcx
Bram Moolenaar89445512022-04-14 12:58:23 +0100699 nnoremap <F3> :call <sid>Funcy(42)<cr>
700 nnoremap <F4> :call <sid>some.Funcx(44)<cr>
Bram Moolenaard8448622022-01-07 21:39:52 +0000701 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +0100702 writefile(lines, 'Xmapscript.vim', 'D')
Bram Moolenaard8448622022-01-07 21:39:52 +0000703
704 source Xmapscript.vim
705 feedkeys("\<F3>", "xt")
706 assert_equal(42, g:result)
Bram Moolenaar89445512022-04-14 12:58:23 +0100707 feedkeys("\<F4>", "xt")
708 assert_equal(44, g:result)
Bram Moolenaard8448622022-01-07 21:39:52 +0000709
710 unlet g:result
Bram Moolenaard8448622022-01-07 21:39:52 +0000711 nunmap <F3>
Bram Moolenaar89445512022-04-14 12:58:23 +0100712 nunmap <F4>
713enddef
714
Bram Moolenaar648dd882022-04-14 21:36:15 +0100715def Test_use_relative_autoload_import_in_mapping()
Bram Moolenaar89445512022-04-14 12:58:23 +0100716 var lines =<< trim END
717 vim9script
718 export def Func()
719 g:result = 42
720 enddef
721 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +0100722 writefile(lines, 'XrelautoloadExport.vim', 'D')
Bram Moolenaar89445512022-04-14 12:58:23 +0100723 lines =<< trim END
724 vim9script
Bram Moolenaar648dd882022-04-14 21:36:15 +0100725 import autoload './XrelautoloadExport.vim' as some
Bram Moolenaar89445512022-04-14 12:58:23 +0100726 nnoremap <F3> :call <SID>some.Func()<CR>
727 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +0100728 writefile(lines, 'Xmapscript.vim', 'D')
Bram Moolenaar89445512022-04-14 12:58:23 +0100729
730 source Xmapscript.vim
Bram Moolenaar648dd882022-04-14 21:36:15 +0100731 assert_match('\d\+ A: .*XrelautoloadExport.vim', execute('scriptnames')->split("\n")[-1])
Yegappan Lakshmanan520f6ef2022-08-25 17:40:40 +0100732 var l = getscriptinfo()
733 assert_match('XrelautoloadExport.vim$', l[-1].name)
734 assert_true(l[-1].autoload)
Bram Moolenaar89445512022-04-14 12:58:23 +0100735 feedkeys("\<F3>", "xt")
736 assert_equal(42, g:result)
Yegappan Lakshmanan520f6ef2022-08-25 17:40:40 +0100737 l = getscriptinfo({name: 'XrelautoloadExport'})
738 assert_true(len(l) == 1)
739 assert_match('XrelautoloadExport.vim$', l[0].name)
740 assert_false(l[0].autoload)
Yegappan Lakshmanan2f892d82022-08-28 18:52:10 +0100741 assert_equal(999999, l[0].version)
Bram Moolenaar89445512022-04-14 12:58:23 +0100742
743 unlet g:result
Bram Moolenaar89445512022-04-14 12:58:23 +0100744 nunmap <F3>
Bram Moolenaard8448622022-01-07 21:39:52 +0000745enddef
746
Bram Moolenaar5cb53b72022-05-26 19:54:05 +0100747def Test_autoload_import_var()
748 # variable name starts with "autoload"
749 var lines =<< trim END
750 vim9script
751 var autoloaded = "Xtest.vim"
752 import autoloaded
753 END
754 v9.CheckScriptFailure(lines, 'E1053: Could not import "Xtest.vim')
755enddef
756
Bram Moolenaar648dd882022-04-14 21:36:15 +0100757def Test_use_autoload_import_in_mapping()
758 var lines =<< trim END
759 vim9script
760 export def Func()
761 g:result = 49
762 enddef
763 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +0100764 mkdir('Ximpdir/autoload', 'pR')
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +0100765 writefile(lines, 'Ximpdir/autoload/XautoloadExport.vim')
Bram Moolenaar648dd882022-04-14 21:36:15 +0100766 var save_rtp = &rtp
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +0100767 exe 'set rtp^=' .. getcwd() .. '/Ximpdir'
Bram Moolenaar648dd882022-04-14 21:36:15 +0100768
769 lines =<< trim END
770 vim9script
771 import autoload 'XautoloadExport.vim' as some
772 nnoremap <F3> :call <SID>some.Func()<CR>
773 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +0100774 writefile(lines, 'Xmapscript.vim', 'D')
Bram Moolenaar648dd882022-04-14 21:36:15 +0100775
776 source Xmapscript.vim
777 assert_match('\d\+ A: .*autoload/XautoloadExport.vim', execute('scriptnames')->split("\n")[-1])
778 feedkeys("\<F3>", "xt")
779 assert_equal(49, g:result)
780
781 unlet g:result
Bram Moolenaar648dd882022-04-14 21:36:15 +0100782 nunmap <F3>
Bram Moolenaar648dd882022-04-14 21:36:15 +0100783 &rtp = save_rtp
784enddef
785
Bram Moolenaarf0e7e632022-01-21 13:29:56 +0000786def Test_use_import_in_command_completion()
Bram Moolenaar15d16352022-01-17 20:09:08 +0000787 var lines =<< trim END
788 vim9script
789 export def Complete(..._): list<string>
790 return ['abcd']
791 enddef
792 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +0100793 writefile(lines, 'Xscript.vim', 'D')
Bram Moolenaar15d16352022-01-17 20:09:08 +0000794
795 lines =<< trim END
796 vim9script
797 import './Xscript.vim'
798
799 command -nargs=1 -complete=customlist,Xscript.Complete Cmd echo 'ok'
800 feedkeys(":Cmd ab\<Tab>\<C-B>#\<CR>", 'xnt')
801 assert_equal('#Cmd abcd', @:)
802 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000803 v9.CheckScriptSuccess(lines)
Bram Moolenaar15d16352022-01-17 20:09:08 +0000804
805 delcommand Cmd
Bram Moolenaar15d16352022-01-17 20:09:08 +0000806enddef
807
Bram Moolenaar12eb2eb2022-04-15 22:57:09 +0100808def Test_use_import_with_funcref_in_command_completion()
809 var lines =<< trim END
810 vim9script
811 export def Complete(..._): list<string>
812 return ['abcd']
813 enddef
814 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +0100815 writefile(lines, 'Xscript.vim', 'D')
Bram Moolenaar12eb2eb2022-04-15 22:57:09 +0100816
817 lines =<< trim END
818 vim9script
819 import './Xscript.vim'
820
821 var Ref = Xscript.Complete
822 exe "command -nargs=1 -complete=customlist," .. expand('<SID>') .. "Ref Cmd echo 'ok'"
823 feedkeys(":Cmd ab\<Tab>\<C-B>#\<CR>", 'xnt')
824 assert_equal('#Cmd abcd', @:)
825 END
826 v9.CheckScriptSuccess(lines)
827
828 delcommand Cmd
Bram Moolenaar12eb2eb2022-04-15 22:57:09 +0100829enddef
830
Bram Moolenaarf0e7e632022-01-21 13:29:56 +0000831def Test_use_autoload_import_in_insert_completion()
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +0100832 mkdir('Xinsdir/autoload', 'pR')
Bram Moolenaarf0e7e632022-01-21 13:29:56 +0000833 var save_rtp = &rtp
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +0100834 exe 'set rtp^=' .. getcwd() .. '/Xinsdir'
Bram Moolenaarf0e7e632022-01-21 13:29:56 +0000835
836 var lines =<< trim END
837 vim9script
838 export def ThesaurusFunc(findbase: bool, _): any
839 if findbase
840 return 1
841 endif
842 return [
843 'check',
844 'experiment',
845 'test',
846 'verification'
847 ]
848 enddef
849 g:completion_loaded = 'yes'
850 END
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +0100851 writefile(lines, 'Xinsdir/autoload/completion.vim')
Bram Moolenaarf0e7e632022-01-21 13:29:56 +0000852
853 new
854 lines =<< trim END
855 vim9script
856 g:completion_loaded = 'no'
857 import autoload 'completion.vim'
858 set thesaurusfunc=completion.ThesaurusFunc
859 assert_equal('no', g:completion_loaded)
860 feedkeys("i\<C-X>\<C-T>\<C-N>\<Esc>", 'xt')
861 assert_equal('experiment', getline(1))
862 assert_equal('yes', g:completion_loaded)
863 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000864 v9.CheckScriptSuccess(lines)
Bram Moolenaarf0e7e632022-01-21 13:29:56 +0000865
866 set thesaurusfunc=
867 bwipe!
Bram Moolenaarf0e7e632022-01-21 13:29:56 +0000868 &rtp = save_rtp
869enddef
870
Bram Moolenaar3e93a2b2022-01-24 21:28:01 +0000871def Test_use_autoload_import_partial_in_opfunc()
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +0100872 mkdir('Xpartdir/autoload', 'pR')
Bram Moolenaar3e93a2b2022-01-24 21:28:01 +0000873 var save_rtp = &rtp
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +0100874 exe 'set rtp^=' .. getcwd() .. '/Xpartdir'
Bram Moolenaar3e93a2b2022-01-24 21:28:01 +0000875
876 var lines =<< trim END
877 vim9script
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +0100878 export def Opfunc1(..._)
Bram Moolenaar3e93a2b2022-01-24 21:28:01 +0000879 g:opfunc_called = 'yes'
880 enddef
881 END
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +0100882 writefile(lines, 'Xpartdir/autoload/opfunc.vim')
Bram Moolenaar3e93a2b2022-01-24 21:28:01 +0000883
884 new
885 lines =<< trim END
886 vim9script
887 import autoload 'opfunc.vim'
888 nnoremap <expr> <F3> TheFunc()
889 def TheFunc(): string
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +0100890 &operatorfunc = function('opfunc.Opfunc1', [0])
Bram Moolenaar3e93a2b2022-01-24 21:28:01 +0000891 return 'g@'
892 enddef
893 feedkeys("\<F3>l", 'xt')
894 assert_equal('yes', g:opfunc_called)
895 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000896 v9.CheckScriptSuccess(lines)
Bram Moolenaar3e93a2b2022-01-24 21:28:01 +0000897
898 set opfunc=
899 bwipe!
Bram Moolenaar06b77222022-01-25 15:51:56 +0000900 nunmap <F3>
901 &rtp = save_rtp
902enddef
903
904def Test_set_opfunc_to_autoload_func_directly()
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +0100905 mkdir('Xdirdir/autoload', 'pR')
Bram Moolenaar06b77222022-01-25 15:51:56 +0000906 var save_rtp = &rtp
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +0100907 exe 'set rtp^=' .. getcwd() .. '/Xdirdir'
Bram Moolenaar06b77222022-01-25 15:51:56 +0000908
909 var lines =<< trim END
910 vim9script
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +0100911 export def Opfunc2(..._)
Bram Moolenaar06b77222022-01-25 15:51:56 +0000912 g:opfunc_called = 'yes'
913 enddef
914 END
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +0100915 writefile(lines, 'Xdirdir/autoload/opfunc.vim')
Bram Moolenaar06b77222022-01-25 15:51:56 +0000916
917 new
918 lines =<< trim END
919 vim9script
920 import autoload 'opfunc.vim'
921 nnoremap <expr> <F3> TheFunc()
922 def TheFunc(): string
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +0100923 &operatorfunc = opfunc.Opfunc2
Bram Moolenaar06b77222022-01-25 15:51:56 +0000924 return 'g@'
925 enddef
926 feedkeys("\<F3>l", 'xt')
927 assert_equal('yes', g:opfunc_called)
928 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000929 v9.CheckScriptSuccess(lines)
Bram Moolenaar06b77222022-01-25 15:51:56 +0000930
931 set opfunc=
932 bwipe!
Bram Moolenaar06b77222022-01-25 15:51:56 +0000933 nunmap <F3>
Bram Moolenaar3e93a2b2022-01-24 21:28:01 +0000934 &rtp = save_rtp
935enddef
936
Bram Moolenaare70dd112022-01-21 16:31:11 +0000937def Test_use_autoload_import_in_fold_expression()
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +0100938 mkdir('Xfolddir/autoload', 'pR')
Bram Moolenaare70dd112022-01-21 16:31:11 +0000939 var save_rtp = &rtp
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +0100940 exe 'set rtp^=' .. getcwd() .. '/Xfolddir'
Bram Moolenaare70dd112022-01-21 16:31:11 +0000941
942 var lines =<< trim END
943 vim9script
944 export def Expr(): string
945 return getline(v:lnum) =~ '^#' ? '>1' : '1'
946 enddef
Bram Moolenaar9530b582022-01-22 13:39:08 +0000947 export def Text(): string
948 return 'fold text'
949 enddef
Bram Moolenaare70dd112022-01-21 16:31:11 +0000950 g:fold_loaded = 'yes'
951 END
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +0100952 writefile(lines, 'Xfolddir/autoload/fold.vim')
Bram Moolenaare70dd112022-01-21 16:31:11 +0000953
954 lines =<< trim END
955 vim9script
956 import autoload 'fold.vim'
957 &foldexpr = 'fold.Expr()'
Bram Moolenaar9530b582022-01-22 13:39:08 +0000958 &foldtext = 'fold.Text()'
Bram Moolenaare70dd112022-01-21 16:31:11 +0000959 &foldmethod = 'expr'
960 &debug = 'throw'
961 END
962 new
963 setline(1, ['# one', 'text', '# two', 'text'])
964 g:fold_loaded = 'no'
Bram Moolenaar62aec932022-01-29 21:45:34 +0000965 v9.CheckScriptSuccess(lines)
Bram Moolenaare70dd112022-01-21 16:31:11 +0000966 assert_equal('no', g:fold_loaded)
967 redraw
968 assert_equal('yes', g:fold_loaded)
969
970 # Check that script context of 'foldexpr' is copied to another buffer.
971 edit! otherfile
972 redraw
973
Bram Moolenaar9530b582022-01-22 13:39:08 +0000974 set foldexpr= foldtext& foldmethod& debug=
Bram Moolenaare70dd112022-01-21 16:31:11 +0000975 bwipe!
Bram Moolenaare70dd112022-01-21 16:31:11 +0000976 &rtp = save_rtp
977enddef
978
Bram Moolenaarc0ceeeb2022-03-30 21:12:27 +0100979def Test_autoload_import_relative()
980 var lines =<< trim END
981 vim9script
982
983 g:loaded = 'yes'
984 export def RelFunc(): string
985 return 'relfunc'
986 enddef
987 def NotExported()
988 echo 'not'
989 enddef
990
991 export var someText = 'some text'
992 var notexp = 'bad'
993 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +0100994 writefile(lines, 'XimportRel.vim', 'D')
995 writefile(lines, 'XimportRel2.vim', 'D')
996 writefile(lines, 'XimportRel3.vim', 'D')
997 writefile(lines, 'XimportRel4.vim', 'D')
998 writefile(lines, 'XimportRel5.vim', 'D')
Bram Moolenaarc0ceeeb2022-03-30 21:12:27 +0100999
1000 lines =<< trim END
1001 vim9script
1002 g:loaded = 'no'
1003 import autoload './XimportRel.vim'
1004 assert_equal('no', g:loaded)
1005
1006 def AFunc(): string
1007 var res = ''
1008 res ..= XimportRel.RelFunc()
1009 res ..= '/'
1010 res ..= XimportRel.someText
1011 XimportRel.someText = 'from AFunc'
1012 return res
1013 enddef
1014 # script not loaded when compiling
1015 defcompile
1016 assert_equal('no', g:loaded)
1017
1018 assert_equal('relfunc/some text', AFunc())
1019 assert_equal('yes', g:loaded)
1020 unlet g:loaded
1021
1022 assert_equal('from AFunc', XimportRel.someText)
1023 XimportRel.someText = 'from script'
1024 assert_equal('from script', XimportRel.someText)
1025 END
1026 v9.CheckScriptSuccess(lines)
1027
1028 lines =<< trim END
1029 vim9script
1030 import autoload './XimportRel.vim'
1031 echo XimportRel.NotExported()
1032 END
1033 v9.CheckScriptFailure(lines, 'E1049: Item not exported in script: NotExported', 3)
1034
1035 lines =<< trim END
1036 vim9script
1037 import autoload './XimportRel.vim'
1038 echo XimportRel.notexp
1039 END
1040 v9.CheckScriptFailure(lines, 'E1049: Item not exported in script: notexp', 3)
1041
1042 lines =<< trim END
1043 vim9script
1044 import autoload './XimportRel.vim'
1045 XimportRel.notexp = 'bad'
1046 END
1047 v9.CheckScriptFailure(lines, 'E1049: Item not exported in script: notexp', 3)
1048
1049 lines =<< trim END
1050 vim9script
1051 import autoload './XimportRel.vim'
1052 def Func()
1053 echo XimportRel.NotExported()
1054 enddef
1055 Func()
1056 END
1057 v9.CheckScriptFailure(lines, 'E1049: Item not exported in script: NotExported', 1)
1058
1059 lines =<< trim END
1060 vim9script
1061 import autoload './XimportRel.vim'
1062 def Func()
1063 echo XimportRel.notexp
1064 enddef
1065 Func()
1066 END
1067 v9.CheckScriptFailure(lines, 'E1049: Item not exported in script: notexp', 1)
1068
Bram Moolenaar10611952022-04-03 21:11:34 +01001069 # Same, script not imported before
Bram Moolenaarc0ceeeb2022-03-30 21:12:27 +01001070 lines =<< trim END
1071 vim9script
Bram Moolenaar10611952022-04-03 21:11:34 +01001072 import autoload './XimportRel4.vim'
Bram Moolenaarc0ceeeb2022-03-30 21:12:27 +01001073 def Func()
Bram Moolenaar10611952022-04-03 21:11:34 +01001074 echo XimportRel4.notexp
Bram Moolenaarc0ceeeb2022-03-30 21:12:27 +01001075 enddef
1076 Func()
1077 END
1078 v9.CheckScriptFailure(lines, 'E1049: Item not exported in script: notexp', 1)
1079
Bram Moolenaar10611952022-04-03 21:11:34 +01001080 # does not fail if the script wasn't loaded yet and only compiling
Bram Moolenaarc0ceeeb2022-03-30 21:12:27 +01001081 g:loaded = 'no'
1082 lines =<< trim END
1083 vim9script
1084 import autoload './XimportRel2.vim'
1085 def Func()
1086 echo XimportRel2.notexp
1087 enddef
1088 defcompile
1089 END
1090 v9.CheckScriptSuccess(lines)
1091 assert_equal('no', g:loaded)
1092
Bram Moolenaar10611952022-04-03 21:11:34 +01001093 lines =<< trim END
1094 vim9script
1095 import autoload './XimportRel.vim'
1096 def Func()
1097 XimportRel.notexp = 'bad'
1098 enddef
1099 Func()
1100 END
1101 v9.CheckScriptFailure(lines, 'E1049: Item not exported in script: notexp', 1)
1102
Bram Moolenaarc0ceeeb2022-03-30 21:12:27 +01001103 # fails with a not loaded import
1104 lines =<< trim END
1105 vim9script
1106 import autoload './XimportRel3.vim'
1107 def Func()
1108 XimportRel3.notexp = 'bad'
1109 enddef
1110 Func()
1111 END
1112 v9.CheckScriptFailure(lines, 'E1049: Item not exported in script: notexp', 1)
1113 assert_equal('yes', g:loaded)
1114 unlet g:loaded
1115
Bram Moolenaar10611952022-04-03 21:11:34 +01001116 lines =<< trim END
1117 vim9script
1118 import autoload './XimportRel5.vim'
1119 def Func()
1120 XimportRel5.nosuchvar = 'bad'
1121 enddef
1122 Func()
1123 END
1124 v9.CheckScriptFailure(lines, 'E121: Undefined variable: nosuchvar', 1)
1125 unlet g:loaded
1126
1127 # nasty: delete script after compiling function
1128 writefile(['vim9script'], 'XimportRelDel.vim')
1129 lines =<< trim END
1130 vim9script
1131
1132 import autoload './XimportRelDel.vim'
1133 def DoIt()
1134 echo XimportRelDel.var
1135 enddef
1136 defcompile
1137 delete('XimportRelDel.vim')
1138 DoIt()
1139 END
Bram Moolenaar242c1522022-04-03 21:52:51 +01001140 v9.CheckScriptFailure(lines, 'E484:')
Bram Moolenaarc0ceeeb2022-03-30 21:12:27 +01001141enddef
1142
Ernie Rael1433ac92024-04-17 22:36:32 +02001143def Test_autoload_import_relative_compiled()
1144 # autoload relative, access from compiled function. #14565
1145 var lines =<< trim END
1146 vim9script
1147
1148 export def F1(): string
1149 return 'InFile.vim'
1150 enddef
1151 END
1152 writefile(lines, 'xfile.vim', 'D')
1153 lines =<< trim END
1154 vim9script
1155
1156 import autoload './xfile.vim'
1157
1158 def F(): string
1159 return xfile.F1()
1160 enddef
1161 assert_equal('InFile.vim', F())
1162 END
1163 new
1164 setline(1, lines)
1165 :source
1166enddef
1167
Bram Moolenaarccbfd482022-03-31 16:18:23 +01001168def Test_autoload_import_relative_autoload_dir()
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01001169 mkdir('autoload', 'pR')
Bram Moolenaarccbfd482022-03-31 16:18:23 +01001170 var lines =<< trim END
1171 vim9script
1172 export def Bar()
1173 g:called_bar = 'yes'
1174 enddef
1175 END
1176 writefile(lines, 'autoload/script.vim')
1177
1178 lines =<< trim END
1179 vim9script
1180 import autoload './autoload/script.vim'
1181 def Foo()
1182 script.Bar()
1183 enddef
1184 Foo()
1185 assert_equal('yes', g:called_bar)
1186 END
1187 v9.CheckScriptSuccess(lines)
1188
1189 unlet g:called_bar
Bram Moolenaarccbfd482022-03-31 16:18:23 +01001190enddef
1191
Bram Moolenaaraac12da2022-04-24 21:33:20 +01001192def Test_autoload_import_deleted()
1193 var lines =<< trim END
1194 vim9script
1195 export const FOO = 1
1196 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01001197 writefile(lines, 'Xa.vim', 'D')
Bram Moolenaaraac12da2022-04-24 21:33:20 +01001198
1199 lines =<< trim END
1200 vim9script
1201 import autoload './Xa.vim'
1202
1203 delete('Xa.vim')
1204 var x = Xa.FOO
1205 END
1206 v9.CheckScriptFailure(lines, 'E484:')
Bram Moolenaaraac12da2022-04-24 21:33:20 +01001207enddef
1208
Bram Moolenaar6c4d4a62022-10-13 17:47:42 +01001209def Test_autoload_import_using_const()
1210 mkdir('Xdir/autoload', 'pR')
1211 var lines =<< trim END
1212 vim9script
1213 export const FOO = 42
1214 echomsg FOO
1215 END
1216 writefile(lines, 'Xdir/autoload/exp.vim')
1217
1218 var save_rtp = &rtp
1219 exe 'set rtp^=' .. getcwd() .. '/Xdir'
1220 lines =<< trim END
1221 vim9script
1222 import autoload 'exp.vim'
1223 assert_equal(42, exp.FOO)
1224 END
1225 v9.CheckScriptSuccess(lines)
1226 &rtp = save_rtp
1227enddef
1228
Bram Moolenaar7b29f6a2022-01-22 17:58:13 +00001229func Test_import_in_diffexpr()
1230 CheckExecutable diff
1231
1232 call Run_Test_import_in_diffexpr()
1233endfunc
1234
1235def Run_Test_import_in_diffexpr()
1236 var lines =<< trim END
1237 vim9script
1238
1239 export def DiffExpr()
1240 # Prepend some text to check diff type detection
1241 writefile(['warning', ' message'], v:fname_out)
1242 silent exe '!diff ' .. v:fname_in .. ' '
1243 .. v:fname_new .. '>>' .. v:fname_out
1244 enddef
1245 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01001246 writefile(lines, 'Xdiffexpr', 'D')
Bram Moolenaar7b29f6a2022-01-22 17:58:13 +00001247
1248 lines =<< trim END
1249 vim9script
1250 import './Xdiffexpr' as diff
1251
1252 set diffexpr=diff.DiffExpr()
1253 set diffopt=foldcolumn:0
1254 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001255 v9.CheckScriptSuccess(lines)
Bram Moolenaar7b29f6a2022-01-22 17:58:13 +00001256
1257 enew!
1258 call setline(1, ['one', 'two', 'three'])
1259 diffthis
1260
1261 botright vert new
1262 call setline(1, ['one', 'two', 'three.'])
1263 diffthis
1264 # we only check if this does not cause errors
1265 redraw
1266
1267 diffoff!
Bram Moolenaar50761872022-06-26 18:01:00 +01001268 set diffexpr=
1269 set diffopt&
Bram Moolenaar7b29f6a2022-01-22 17:58:13 +00001270 bwipe!
1271 bwipe!
1272enddef
1273
Bram Moolenaar36c2add2022-01-22 20:55:30 +00001274def Test_import_in_patchexpr()
1275 var lines =<< trim END
1276 vim9script
1277 export def TPatch()
1278 call writefile(['output file'], v:fname_out)
1279 enddef
1280 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01001281 writefile(lines, 'Xpatchexpr', 'D')
Bram Moolenaar36c2add2022-01-22 20:55:30 +00001282
1283 lines =<< trim END
1284 vim9script
1285 import './Xpatchexpr' as patch
1286 set patchexpr=patch.TPatch()
1287 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001288 v9.CheckScriptSuccess(lines)
Bram Moolenaar36c2add2022-01-22 20:55:30 +00001289
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01001290 call writefile(['input file'], 'Xinput', 'D')
1291 call writefile(['diff file'], 'Xdiff', 'D')
Bram Moolenaar36c2add2022-01-22 20:55:30 +00001292 :%bwipe!
1293 edit Xinput
1294 diffpatch Xdiff
1295 call assert_equal('output file', getline(1))
1296
Bram Moolenaar36c2add2022-01-22 20:55:30 +00001297 set patchexpr&
1298 :%bwipe!
1299enddef
1300
Bram Moolenaar3ba685e2022-01-22 19:17:31 +00001301def Test_import_in_formatexpr()
1302 var lines =<< trim END
1303 vim9script
1304 export def MyFormatExpr(): number
1305 g:did_format = 'yes'
1306 return 0
1307 enddef
1308 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01001309 writefile(lines, 'Xformatter', 'D')
Bram Moolenaar3ba685e2022-01-22 19:17:31 +00001310
1311 lines =<< trim END
1312 vim9script
1313 import './Xformatter' as format
1314 set formatexpr=format.MyFormatExpr()
1315 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001316 v9.CheckScriptSuccess(lines)
Bram Moolenaar3ba685e2022-01-22 19:17:31 +00001317
1318 new
1319 setline(1, ['a', 'b', 'c'])
1320 normal gqG
1321 assert_equal('yes', g:did_format)
1322
1323 bwipe!
Bram Moolenaar3ba685e2022-01-22 19:17:31 +00001324 unlet g:did_format
1325 set formatexpr=
1326enddef
1327
Bram Moolenaar47bcc5f2022-01-22 20:19:22 +00001328def Test_import_in_includeexpr()
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01001329 writefile(['found it'], 'Xthisfile', 'D')
Bram Moolenaar47bcc5f2022-01-22 20:19:22 +00001330 new
1331
1332 var lines =<< trim END
1333 vim9script
1334 export def DoSub(): string
1335 return substitute(v:fname, 'that', 'this', '')
1336 enddef
1337 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01001338 writefile(lines, 'Xinclude.vim', 'D')
Bram Moolenaar47bcc5f2022-01-22 20:19:22 +00001339
1340 lines =<< trim END
1341 vim9script
1342 import './Xinclude.vim'
1343 set includeexpr=Xinclude.DoSub()
1344 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001345 v9.CheckScriptSuccess(lines)
Bram Moolenaar47bcc5f2022-01-22 20:19:22 +00001346
1347 setline(1, ['Xthatfile'])
1348 exe "normal \<C-W>f"
1349 assert_equal('Xthisfile', expand('%'))
1350
1351 bwipe!
1352 bwipe!
1353 set includeexpr=
Bram Moolenaar47bcc5f2022-01-22 20:19:22 +00001354enddef
1355
Bram Moolenaar28e60cc2022-01-22 20:32:00 +00001356def Test_import_in_indentexpr()
1357 var lines =<< trim END
1358 vim9script
1359 export def GetIndent(): number
1360 return 5
1361 enddef
1362 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01001363 writefile(lines, 'Xindenter', 'D')
Bram Moolenaar28e60cc2022-01-22 20:32:00 +00001364
1365 lines =<< trim END
1366 vim9script
1367 import './Xindenter' as indent
1368 set indentexpr=indent.GetIndent()
1369 set debug=throw
1370 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001371 v9.CheckScriptSuccess(lines)
Bram Moolenaar28e60cc2022-01-22 20:32:00 +00001372
1373 new
1374 setline(1, 'hello')
1375 normal ==
1376 assert_equal(' hello', getline(1))
1377
1378 bwipe!
1379 set indentexpr= debug=
Bram Moolenaar28e60cc2022-01-22 20:32:00 +00001380enddef
1381
Bram Moolenaar7ef4a2f2022-01-23 13:44:35 +00001382func Test_import_in_printexpr()
1383 CheckFeature postscript
1384 call Run_Test_import_in_printexpr()
1385endfunc
1386
1387def Run_Test_import_in_printexpr()
1388 var lines =<< trim END
1389 vim9script
1390 export def PrintFile(): bool
1391 g:printed = 'yes'
1392 delete('v:fname_in')
1393 return false
1394 enddef
1395 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01001396 writefile(lines, 'Xprint.vim', 'D')
Bram Moolenaar7ef4a2f2022-01-23 13:44:35 +00001397
1398 lines =<< trim END
1399 vim9script
1400 import './Xprint.vim'
1401 set printexpr=Xprint.PrintFile()
1402 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001403 v9.CheckScriptSuccess(lines)
Bram Moolenaar7ef4a2f2022-01-23 13:44:35 +00001404
1405 help
1406 hardcopy dummy args
1407 assert_equal('yes', g:printed)
1408
Bram Moolenaar7ef4a2f2022-01-23 13:44:35 +00001409 set printexpr=
1410enddef
1411
Bram Moolenaarf4e88f22022-01-23 14:17:28 +00001412def Test_import_in_charconvert()
1413 var lines =<< trim END
1414 vim9script
1415 export def MakeUpper(): bool
1416 var data = readfile(v:fname_in)
1417 map(data, 'toupper(v:val)')
1418 writefile(data, v:fname_out)
1419 return false # success
1420 enddef
1421 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01001422 writefile(lines, 'Xconvert.vim', 'D')
Bram Moolenaarf4e88f22022-01-23 14:17:28 +00001423
1424 lines =<< trim END
1425 vim9script
1426 import './Xconvert.vim' as conv
1427 set charconvert=conv.MakeUpper()
1428 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001429 v9.CheckScriptSuccess(lines)
Bram Moolenaarf4e88f22022-01-23 14:17:28 +00001430
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01001431 writefile(['one', 'two'], 'Xiicfile', 'D')
Bram Moolenaarb18b4962022-09-02 21:55:50 +01001432 new Xiicfile
1433 write ++enc=ucase Xiicfile1
1434 assert_equal(['ONE', 'TWO'], readfile('Xiicfile1'))
Bram Moolenaarf4e88f22022-01-23 14:17:28 +00001435
Bram Moolenaarb18b4962022-09-02 21:55:50 +01001436 delete('Xiicfile1')
Bram Moolenaarf4e88f22022-01-23 14:17:28 +00001437 bwipe!
1438 set charconvert&
1439enddef
1440
Bram Moolenaar2a7aa832022-01-23 17:59:06 +00001441func Test_import_in_spellsuggest_expr()
1442 CheckFeature spell
1443 call Run_Test_import_in_spellsuggest_expr()
1444endfunc
1445
1446def Run_Test_import_in_spellsuggest_expr()
1447 var lines =<< trim END
1448 vim9script
1449 export def MySuggest(): list<any>
1450 return [['Fox', 8], ['Fop', 9]]
1451 enddef
1452 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01001453 writefile(lines, 'Xsuggest.vim', 'D')
Bram Moolenaar2a7aa832022-01-23 17:59:06 +00001454
1455 lines =<< trim END
1456 vim9script
1457 import './Xsuggest.vim' as sugg
1458 set spell spellsuggest=expr:sugg.MySuggest()
1459 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001460 v9.CheckScriptSuccess(lines)
Bram Moolenaar2a7aa832022-01-23 17:59:06 +00001461
1462 set verbose=1 # report errors
1463 call assert_equal(['Fox', 'Fop'], spellsuggest('Fo', 2))
1464
Bram Moolenaar2a7aa832022-01-23 17:59:06 +00001465 set nospell spellsuggest& verbose=0
1466enddef
1467
Bram Moolenaar6ac69ed2022-09-03 12:09:07 +01001468def Test_import_in_lambda_method()
1469 var lines =<< trim END
1470 vim9script
1471 export def Retarg(e: any): any
1472 return e
1473 enddef
1474 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01001475 writefile(lines, 'XexportRetarg.vim', 'D')
Bram Moolenaar6ac69ed2022-09-03 12:09:07 +01001476 lines =<< trim END
1477 vim9script
1478 import './XexportRetarg.vim'
1479 def Lambda(): string
1480 var F = (x) => x->XexportRetarg.Retarg()
1481 return F('arg')
1482 enddef
1483 assert_equal('arg', Lambda())
1484 END
1485 v9.CheckScriptSuccess(lines)
Bram Moolenaar6ac69ed2022-09-03 12:09:07 +01001486enddef
1487
Bram Moolenaaracc4b562022-01-24 13:54:45 +00001488def Test_export_shadows_global_function()
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01001489 mkdir('Xglobdir/autoload', 'pR')
Bram Moolenaaracc4b562022-01-24 13:54:45 +00001490 var save_rtp = &rtp
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01001491 exe 'set rtp^=' .. getcwd() .. '/Xglobdir'
Bram Moolenaaracc4b562022-01-24 13:54:45 +00001492
1493 var lines =<< trim END
1494 vim9script
1495 export def Shadow(): string
1496 return 'Shadow()'
1497 enddef
1498 END
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01001499 writefile(lines, 'Xglobdir/autoload/shadow.vim')
Bram Moolenaaracc4b562022-01-24 13:54:45 +00001500
1501 lines =<< trim END
1502 vim9script
1503
1504 def g:Shadow(): string
1505 return 'global'
1506 enddef
1507
1508 import autoload 'shadow.vim'
1509 assert_equal('Shadow()', shadow.Shadow())
1510 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001511 v9.CheckScriptSuccess(lines)
Bram Moolenaaracc4b562022-01-24 13:54:45 +00001512
1513 delfunc g:Shadow
1514 bwipe!
Bram Moolenaaracc4b562022-01-24 13:54:45 +00001515 &rtp = save_rtp
1516enddef
1517
Bram Moolenaard8448622022-01-07 21:39:52 +00001518def Test_export_fails()
Bram Moolenaar62aec932022-01-29 21:45:34 +00001519 v9.CheckScriptFailure(['export var some = 123'], 'E1042:')
1520 v9.CheckScriptFailure(['vim9script', 'export var g:some'], 'E1022:')
1521 v9.CheckScriptFailure(['vim9script', 'export echo 134'], 'E1043:')
Yegappan Lakshmanan885de442022-04-23 10:51:14 +01001522 v9.CheckScriptFailure(['vim9script', 'export function /a1b2c3'], 'E1044:')
Bram Moolenaard8448622022-01-07 21:39:52 +00001523
Bram Moolenaar5ab30012022-10-07 17:26:22 +01001524 assert_fails('export echo 1', 'E1043:')
Bram Moolenaard8448622022-01-07 21:39:52 +00001525enddef
1526
1527func Test_import_fails_without_script()
1528 CheckRunVimInTerminal
1529
1530 " call indirectly to avoid compilation error for missing functions
1531 call Run_Test_import_fails_on_command_line()
1532endfunc
1533
1534def Run_Test_import_fails_on_command_line()
1535 var export =<< trim END
1536 vim9script
1537 export def Foo(): number
1538 return 0
1539 enddef
1540 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01001541 writefile(export, 'XexportCmd.vim', 'D')
Bram Moolenaard8448622022-01-07 21:39:52 +00001542
Bram Moolenaar62aec932022-01-29 21:45:34 +00001543 var buf = g:RunVimInTerminal('-c "import Foo from ''./XexportCmd.vim''"', {
Bram Moolenaard8448622022-01-07 21:39:52 +00001544 rows: 6, wait_for_ruler: 0})
Bram Moolenaar62aec932022-01-29 21:45:34 +00001545 g:WaitForAssert(() => assert_match('^E1094:', term_getline(buf, 5)))
Bram Moolenaard8448622022-01-07 21:39:52 +00001546
Bram Moolenaar62aec932022-01-29 21:45:34 +00001547 g:StopVimInTerminal(buf)
Bram Moolenaard8448622022-01-07 21:39:52 +00001548enddef
1549
1550def Test_vim9_reload_noclear()
1551 var lines =<< trim END
1552 vim9script
1553 export var exported = 'thexport'
1554
1555 export def TheFunc(x = 0)
1556 enddef
1557 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01001558 writefile(lines, 'XExportReload', 'D')
Bram Moolenaard8448622022-01-07 21:39:52 +00001559 lines =<< trim END
1560 vim9script noclear
1561 g:loadCount += 1
Bram Moolenaara749a422022-02-12 19:52:25 +00001562 var reloaded = 'init'
Bram Moolenaard8448622022-01-07 21:39:52 +00001563 import './XExportReload' as exp
1564
1565 def Again(): string
1566 return 'again'
1567 enddef
1568
1569 exp.TheFunc()
1570
Bram Moolenaara749a422022-02-12 19:52:25 +00001571 if exists('loaded') | finish | endif
1572 var loaded = true
Bram Moolenaard8448622022-01-07 21:39:52 +00001573
Bram Moolenaara749a422022-02-12 19:52:25 +00001574 var notReloaded = 'yes'
1575 reloaded = 'first'
Bram Moolenaard8448622022-01-07 21:39:52 +00001576 def g:Values(): list<string>
Bram Moolenaara749a422022-02-12 19:52:25 +00001577 return [reloaded, notReloaded, Again(), Once(), exp.exported]
Bram Moolenaard8448622022-01-07 21:39:52 +00001578 enddef
1579
1580 def Once(): string
1581 return 'once'
1582 enddef
1583 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01001584 writefile(lines, 'XReloaded', 'D')
Bram Moolenaard8448622022-01-07 21:39:52 +00001585 g:loadCount = 0
1586 source XReloaded
1587 assert_equal(1, g:loadCount)
1588 assert_equal(['first', 'yes', 'again', 'once', 'thexport'], g:Values())
1589 source XReloaded
1590 assert_equal(2, g:loadCount)
1591 assert_equal(['init', 'yes', 'again', 'once', 'thexport'], g:Values())
1592 source XReloaded
1593 assert_equal(3, g:loadCount)
1594 assert_equal(['init', 'yes', 'again', 'once', 'thexport'], g:Values())
1595
Bram Moolenaard8448622022-01-07 21:39:52 +00001596 delfunc g:Values
1597 unlet g:loadCount
1598
1599 lines =<< trim END
1600 vim9script
1601 def Inner()
1602 enddef
1603 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01001604 lines->writefile('XreloadScript.vim', 'D')
Bram Moolenaard8448622022-01-07 21:39:52 +00001605 source XreloadScript.vim
1606
1607 lines =<< trim END
1608 vim9script
1609 def Outer()
1610 def Inner()
1611 enddef
1612 enddef
1613 defcompile
1614 END
1615 lines->writefile('XreloadScript.vim')
1616 source XreloadScript.vim
Bram Moolenaard8448622022-01-07 21:39:52 +00001617enddef
1618
Bram Moolenaarcd1cda22022-02-16 21:48:25 +00001619def Test_vim_reload_noclear_arg_count()
1620 var lines =<< trim END
1621 vim9script noclear
1622
1623 if !exists('g:didload')
1624 def Test(a: string, b: string)
1625 echo a b
1626 enddef
1627 def Call()
1628 Test('a', 'b')
1629 enddef
1630 else
1631 # redefine with one argument less
1632 def Test(a: string)
1633 echo a
1634 enddef
1635 endif
1636 Call()
1637 g:didload = 1
1638 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01001639 lines->writefile('XreloadScript_1.vim', 'D')
Bram Moolenaarcd1cda22022-02-16 21:48:25 +00001640 source XreloadScript_1.vim
1641 assert_fails('source XreloadScript_1.vim', 'E1106: One argument too many')
1642 unlet g:didload
1643
1644 lines =<< trim END
1645 vim9script noclear
1646
1647 if !exists('g:didload')
1648 def Test(a: string, b: string, c: string)
1649 echo a b
1650 enddef
1651 def Call()
1652 Test('a', 'b', 'c')
1653 enddef
1654 else
1655 # redefine with one argument less
1656 def Test(a: string)
1657 echo a
1658 enddef
1659 endif
1660 Call()
1661 g:didload = 1
1662 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01001663 lines->writefile('XreloadScript_2.vim', 'D')
Bram Moolenaarcd1cda22022-02-16 21:48:25 +00001664 source XreloadScript_2.vim
1665 assert_fails('source XreloadScript_2.vim', 'E1106: 2 arguments too many')
1666 unlet g:didload
1667
1668 lines =<< trim END
1669 vim9script noclear
1670
1671 if !exists('g:didload')
1672 def Test(a: string)
1673 echo a
1674 enddef
1675 def Call()
1676 Test('a')
1677 enddef
1678 else
1679 # redefine with one argument extra
1680 def Test(a: string, b: string)
1681 echo a b
1682 enddef
1683 endif
1684 Call()
1685 g:didload = 1
1686 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01001687 lines->writefile('XreloadScript_3.vim', 'D')
Bram Moolenaarcd1cda22022-02-16 21:48:25 +00001688 source XreloadScript_3.vim
1689 assert_fails('source XreloadScript_3.vim', 'E1190: One argument too few')
1690 unlet g:didload
1691
1692 lines =<< trim END
1693 vim9script noclear
1694
1695 if !exists('g:didload')
1696 def Test(a: string)
1697 echo a
1698 enddef
1699 def Call()
1700 Test('a')
1701 enddef
1702 else
1703 # redefine with two arguments extra
1704 def Test(a: string, b: string, c: string)
1705 echo a b
1706 enddef
1707 endif
1708 Call()
1709 g:didload = 1
1710 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01001711 lines->writefile('XreloadScript_4.vim', 'D')
Bram Moolenaarcd1cda22022-02-16 21:48:25 +00001712 source XreloadScript_4.vim
1713 assert_fails('source XreloadScript_4.vim', 'E1190: 2 arguments too few')
1714 unlet g:didload
Bram Moolenaarcd1cda22022-02-16 21:48:25 +00001715enddef
1716
1717def Test_vim9_reload_noclear_error()
1718 var lines =<< trim END
1719 vim9script noclear
1720
1721 if !exists('g:didload')
1722 def Test(a: string)
1723 echo a
1724 enddef
1725 def Call()
1726 Test('a')
1727 enddef
1728 else
1729 # redefine with a compile error
1730 def Test(a: string)
1731 echo ax
1732 enddef
1733 endif
1734 Call()
1735 g:didload = 1
1736 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01001737 lines->writefile('XreloadScriptErr.vim', 'D')
Bram Moolenaarcd1cda22022-02-16 21:48:25 +00001738 source XreloadScriptErr.vim
1739 assert_fails('source XreloadScriptErr.vim', 'E1001: Variable not found: ax')
1740
1741 unlet g:didload
Bram Moolenaarcd1cda22022-02-16 21:48:25 +00001742enddef
1743
Bram Moolenaard8448622022-01-07 21:39:52 +00001744def Test_vim9_reload_import()
1745 var lines =<< trim END
1746 vim9script
1747 const var = ''
1748 var valone = 1234
1749 def MyFunc(arg: string)
1750 valone = 5678
1751 enddef
1752 END
1753 var morelines =<< trim END
1754 var valtwo = 222
1755 export def GetValtwo(): number
1756 return valtwo
1757 enddef
1758 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01001759 writefile(lines + morelines, 'Xreload.vim', 'D')
Bram Moolenaard8448622022-01-07 21:39:52 +00001760 source Xreload.vim
1761 source Xreload.vim
1762 source Xreload.vim
1763
1764 # cannot declare a var twice
1765 lines =<< trim END
1766 vim9script
1767 var valone = 1234
1768 var valone = 5678
1769 END
1770 writefile(lines, 'Xreload.vim')
1771 assert_fails('source Xreload.vim', 'E1041:', '', 3, 'Xreload.vim')
1772
Bram Moolenaard8448622022-01-07 21:39:52 +00001773 delete('Ximport.vim')
1774enddef
1775
1776" if a script is reloaded with a script-local variable that changed its type, a
1777" compiled function using that variable must fail.
1778def Test_script_reload_change_type()
1779 var lines =<< trim END
1780 vim9script noclear
1781 var str = 'string'
1782 def g:GetStr(): string
1783 return str .. 'xxx'
1784 enddef
1785 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01001786 writefile(lines, 'Xreload.vim', 'D')
Bram Moolenaard8448622022-01-07 21:39:52 +00001787 source Xreload.vim
1788 echo g:GetStr()
1789
1790 lines =<< trim END
1791 vim9script noclear
1792 var str = 1234
1793 END
1794 writefile(lines, 'Xreload.vim')
1795 source Xreload.vim
1796 assert_fails('echo g:GetStr()', 'E1150:')
1797
1798 delfunc g:GetStr
Bram Moolenaard8448622022-01-07 21:39:52 +00001799enddef
1800
1801" Define CallFunc so that the test can be compiled
1802command CallFunc echo 'nop'
1803
1804def Test_script_reload_from_function()
1805 var lines =<< trim END
1806 vim9script
1807
Bram Moolenaar10611952022-04-03 21:11:34 +01001808 if exists('g:loadedThis')
Bram Moolenaard8448622022-01-07 21:39:52 +00001809 finish
1810 endif
Bram Moolenaar10611952022-04-03 21:11:34 +01001811 g:loadedThis = 1
Bram Moolenaard8448622022-01-07 21:39:52 +00001812 delcommand CallFunc
1813 command CallFunc Func()
1814 def Func()
1815 so XreloadFunc.vim
1816 g:didTheFunc = 1
1817 enddef
1818 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01001819 writefile(lines, 'XreloadFunc.vim', 'D')
Bram Moolenaard8448622022-01-07 21:39:52 +00001820 source XreloadFunc.vim
1821 CallFunc
1822 assert_equal(1, g:didTheFunc)
1823
Bram Moolenaard8448622022-01-07 21:39:52 +00001824 delcommand CallFunc
Bram Moolenaar10611952022-04-03 21:11:34 +01001825 unlet g:loadedThis
Bram Moolenaard8448622022-01-07 21:39:52 +00001826 unlet g:didTheFunc
1827enddef
1828
1829def s:RetSome(): string
1830 return 'some'
1831enddef
1832
1833" Not exported function that is referenced needs to be accessed by the
1834" script-local name.
1835def Test_vim9_funcref()
1836 var sortlines =<< trim END
1837 vim9script
1838 def Compare(i1: number, i2: number): number
1839 return i2 - i1
1840 enddef
1841
1842 export def FastSort(): list<number>
1843 return range(5)->sort(Compare)
1844 enddef
1845
1846 export def GetString(arg: string): string
1847 return arg
1848 enddef
1849 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01001850 writefile(sortlines, 'Xsort.vim', 'D')
Bram Moolenaard8448622022-01-07 21:39:52 +00001851
1852 var lines =<< trim END
1853 vim9script
1854 import './Xsort.vim'
1855 def Test()
1856 g:result = Xsort.FastSort()
1857 enddef
1858 Test()
Bram Moolenaar7c24dfd2022-01-08 17:03:55 +00001859 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01001860 writefile(lines, 'Xscript.vim', 'D')
Bram Moolenaar7c24dfd2022-01-08 17:03:55 +00001861 source Xscript.vim
1862 assert_equal([4, 3, 2, 1, 0], g:result)
1863 unlet g:result
Bram Moolenaard8448622022-01-07 21:39:52 +00001864
Bram Moolenaar7c24dfd2022-01-08 17:03:55 +00001865 lines =<< trim END
1866 vim9script
Bram Moolenaard8448622022-01-07 21:39:52 +00001867 # using a function imported with "as"
1868 import './Xsort.vim' as anAlias
1869 assert_equal('yes', anAlias.GetString('yes'))
1870
1871 # using the function from a compiled function
1872 def TestMore(): string
1873 var s = s:anAlias.GetString('foo')
1874 return s .. anAlias.GetString('bar')
1875 enddef
1876 assert_equal('foobar', TestMore())
1877
1878 # error when using a function that isn't exported
1879 assert_fails('anAlias.Compare(1, 2)', 'E1049:')
1880 END
1881 writefile(lines, 'Xscript.vim')
1882
Bram Moolenaard8448622022-01-07 21:39:52 +00001883 var Funcref = function('s:RetSome')
1884 assert_equal('some', Funcref())
1885enddef
1886
1887" Check that when searching for "FilterFunc" it finds the import in the
1888" script where FastFilter() is called from, both as a string and as a direct
1889" function reference.
1890def Test_vim9_funcref_other_script()
1891 var filterLines =<< trim END
1892 vim9script
1893 export def FilterFunc(idx: number, val: number): bool
1894 return idx % 2 == 1
1895 enddef
1896 export def FastFilter(): list<number>
1897 return range(10)->filter('FilterFunc(v:key, v:val)')
1898 enddef
1899 export def FastFilterDirect(): list<number>
1900 return range(10)->filter(FilterFunc)
1901 enddef
1902 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01001903 writefile(filterLines, 'Xfilter.vim', 'D')
Bram Moolenaard8448622022-01-07 21:39:52 +00001904
1905 var lines =<< trim END
1906 vim9script
1907 import './Xfilter.vim' as filter
1908 def Test()
1909 var x: list<number> = filter.FastFilter()
1910 enddef
1911 Test()
1912 def TestDirect()
1913 var x: list<number> = filter.FastFilterDirect()
1914 enddef
1915 TestDirect()
1916 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001917 v9.CheckScriptSuccess(lines)
Bram Moolenaard8448622022-01-07 21:39:52 +00001918enddef
1919
1920def Test_import_absolute()
1921 var import_lines = [
1922 'vim9script',
1923 'import "' .. escape(getcwd(), '\') .. '/Xexport_abs.vim" as abs',
1924 'def UseExported()',
1925 ' g:imported_abs = abs.exported',
1926 ' abs.exported = 8888',
1927 ' g:imported_after = abs.exported',
1928 'enddef',
1929 'UseExported()',
1930 'g:import_disassembled = execute("disass UseExported")',
1931 ]
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01001932 writefile(import_lines, 'Ximport_abs.vim', 'D')
1933 writefile(s:export_script_lines, 'Xexport_abs.vim', 'D')
Bram Moolenaard8448622022-01-07 21:39:52 +00001934
1935 source Ximport_abs.vim
1936
1937 assert_equal(9876, g:imported_abs)
1938 assert_equal(8888, g:imported_after)
1939 assert_match('<SNR>\d\+_UseExported\_s*' ..
1940 'g:imported_abs = abs.exported\_s*' ..
1941 '0 LOADSCRIPT exported-2 from .*Xexport_abs.vim\_s*' ..
1942 '1 STOREG g:imported_abs\_s*' ..
1943 'abs.exported = 8888\_s*' ..
1944 '2 PUSHNR 8888\_s*' ..
1945 '3 STORESCRIPT exported-2 in .*Xexport_abs.vim\_s*' ..
1946 'g:imported_after = abs.exported\_s*' ..
1947 '4 LOADSCRIPT exported-2 from .*Xexport_abs.vim\_s*' ..
1948 '5 STOREG g:imported_after',
1949 g:import_disassembled)
1950
1951 Undo_export_script_lines()
1952 unlet g:imported_abs
1953 unlet g:import_disassembled
Bram Moolenaard8448622022-01-07 21:39:52 +00001954enddef
1955
1956def Test_import_rtp()
1957 var import_lines = [
1958 'vim9script',
1959 'import "Xexport_rtp.vim" as rtp',
1960 'g:imported_rtp = rtp.exported',
1961 ]
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01001962 writefile(import_lines, 'Ximport_rtp.vim', 'D')
1963 mkdir('import', 'pR')
Bram Moolenaard8448622022-01-07 21:39:52 +00001964 writefile(s:export_script_lines, 'import/Xexport_rtp.vim')
1965
1966 var save_rtp = &rtp
1967 &rtp = getcwd()
1968 source Ximport_rtp.vim
1969 &rtp = save_rtp
1970
1971 assert_equal(9876, g:imported_rtp)
1972
1973 Undo_export_script_lines()
1974 unlet g:imported_rtp
Bram Moolenaard8448622022-01-07 21:39:52 +00001975enddef
1976
1977def Test_import_compile_error()
1978 var export_lines = [
1979 'vim9script',
1980 'export def ExpFunc(): string',
1981 ' return notDefined',
1982 'enddef',
1983 ]
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01001984 writefile(export_lines, 'Xexported.vim', 'D')
Bram Moolenaard8448622022-01-07 21:39:52 +00001985
1986 var import_lines = [
1987 'vim9script',
1988 'import "./Xexported.vim" as expo',
1989 'def ImpFunc()',
1990 ' echo expo.ExpFunc()',
1991 'enddef',
1992 'defcompile',
1993 ]
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01001994 writefile(import_lines, 'Ximport.vim', 'D')
Bram Moolenaard8448622022-01-07 21:39:52 +00001995
1996 try
1997 source Ximport.vim
1998 catch /E1001/
1999 # Error should be before the Xexported.vim file.
2000 assert_match('E1001: Variable not found: notDefined', v:exception)
2001 assert_match('function <SNR>\d\+_ImpFunc\[1\]..<SNR>\d\+_ExpFunc, line 1', v:throwpoint)
2002 endtry
Bram Moolenaard8448622022-01-07 21:39:52 +00002003enddef
2004
2005def Test_func_overrules_import_fails()
2006 var export_lines =<< trim END
2007 vim9script
2008 export def Func()
2009 echo 'imported'
2010 enddef
2011 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01002012 writefile(export_lines, 'XexportedFunc.vim', 'D')
Bram Moolenaard8448622022-01-07 21:39:52 +00002013
2014 var lines =<< trim END
2015 vim9script
2016 import './XexportedFunc.vim' as Func
2017 def Func()
2018 echo 'local to function'
2019 enddef
2020 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002021 v9.CheckScriptFailure(lines, 'E1213: Redefining imported item "Func"')
Bram Moolenaard8448622022-01-07 21:39:52 +00002022
2023 lines =<< trim END
2024 vim9script
2025 import './XexportedFunc.vim' as Func
2026 def Outer()
2027 def Func()
2028 echo 'local to function'
2029 enddef
2030 enddef
2031 defcompile
2032 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002033 v9.CheckScriptFailure(lines, 'E1236:')
Bram Moolenaard8448622022-01-07 21:39:52 +00002034enddef
2035
2036def Test_source_vim9_from_legacy()
2037 var vim9_lines =<< trim END
2038 vim9script
2039 var local = 'local'
2040 g:global = 'global'
2041 export var exported = 'exported'
2042 export def GetText(): string
2043 return 'text'
2044 enddef
2045 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01002046 writefile(vim9_lines, 'Xvim9_script.vim', 'D')
Bram Moolenaard8448622022-01-07 21:39:52 +00002047
2048 var legacy_lines =<< trim END
2049 source Xvim9_script.vim
2050
2051 call assert_false(exists('local'))
2052 call assert_false(exists('exported'))
2053 call assert_false(exists('s:exported'))
2054 call assert_equal('global', global)
2055 call assert_equal('global', g:global)
Bram Moolenaard8448622022-01-07 21:39:52 +00002056 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01002057 writefile(legacy_lines, 'Xlegacy_script.vim', 'D')
Bram Moolenaard8448622022-01-07 21:39:52 +00002058
2059 source Xlegacy_script.vim
2060 assert_equal('global', g:global)
2061 unlet g:global
Bram Moolenaarb775e722022-11-22 18:12:44 +00002062
2063 legacy_lines =<< trim END
2064 import './Xvim9_script.vim'
2065 let g:global = s:Xvim9_script.GetText()
2066 END
2067 writefile(legacy_lines, 'Xlegacyimport.vim', 'D')
2068 source Xlegacyimport.vim
2069 assert_equal('text', g:global)
2070 unlet g:global
Bram Moolenaard8448622022-01-07 21:39:52 +00002071enddef
2072
Bram Moolenaarc43e6232022-01-13 20:51:56 +00002073def Test_import_vim9_from_legacy()
2074 var vim9_lines =<< trim END
2075 vim9script
2076 var local = 'local'
2077 g:global = 'global'
2078 export var exported = 'exported'
2079 export def GetText(): string
2080 return 'text'
2081 enddef
Yegappan Lakshmananf1750ca2024-04-02 20:41:04 +02002082 export var exported_nr: number = 22
2083 def AddNum(n: number)
2084 exported_nr += n
2085 enddef
2086 export var exportedDict: dict<func> = {Fn: AddNum}
2087 export const CONST = 10
2088 export final finalVar = 'abc'
Bram Moolenaarc43e6232022-01-13 20:51:56 +00002089 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01002090 writefile(vim9_lines, 'Xvim9_export.vim', 'D')
Bram Moolenaarc43e6232022-01-13 20:51:56 +00002091
2092 var legacy_lines =<< trim END
2093 import './Xvim9_export.vim' as vim9
2094
2095 call assert_false(exists('vim9'))
2096 call assert_false(exists('local'))
2097 call assert_false(exists('s:vim9.local'))
2098 call assert_equal('global', global)
2099 call assert_equal('global', g:global)
2100 call assert_false(exists('exported'))
2101 call assert_false(exists('s:exported'))
2102 call assert_false(exists('*GetText'))
2103
2104 " imported symbol is script-local
2105 call assert_equal('exported', s:vim9.exported)
2106 call assert_equal('text', s:vim9.GetText())
Yegappan Lakshmananf1750ca2024-04-02 20:41:04 +02002107 call s:vim9.exportedDict.Fn(5)
2108 call assert_equal(27, s:vim9.exported_nr)
2109 call call(s:vim9.exportedDict.Fn, [3])
2110 call assert_equal(30, s:vim9.exported_nr)
2111 call assert_fails('let s:vim9.CONST = 20', 'E46: Cannot change read-only variable "CONST"')
2112 call assert_fails('let s:vim9.finalVar = ""', 'E46: Cannot change read-only variable "finalVar"')
2113 call assert_fails('let s:vim9.non_existing_var = 20', 'E1048: Item not found in script: non_existing_var')
Bram Moolenaarc43e6232022-01-13 20:51:56 +00002114 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01002115 writefile(legacy_lines, 'Xlegacy_script.vim', 'D')
Bram Moolenaarc43e6232022-01-13 20:51:56 +00002116
2117 source Xlegacy_script.vim
2118 assert_equal('global', g:global)
2119 unlet g:global
Bram Moolenaarc43e6232022-01-13 20:51:56 +00002120enddef
2121
Bram Moolenaard8448622022-01-07 21:39:52 +00002122def Test_cmdline_win()
2123 # if the Vim syntax highlighting uses Vim9 constructs they can be used from
2124 # the command line window.
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01002125 mkdir('rtp/syntax', 'pR')
Bram Moolenaard8448622022-01-07 21:39:52 +00002126 var export_lines =<< trim END
2127 vim9script
2128 export var That = 'yes'
2129 END
2130 writefile(export_lines, 'rtp/syntax/Xexport.vim')
2131 var import_lines =<< trim END
2132 vim9script
2133 import './Xexport.vim' as exp
2134 echo exp.That
2135 END
2136 writefile(import_lines, 'rtp/syntax/vim.vim')
2137 var save_rtp = &rtp
2138 &rtp = getcwd() .. '/rtp' .. ',' .. &rtp
2139 syntax on
2140 augroup CmdWin
2141 autocmd CmdwinEnter * g:got_there = 'yes'
2142 augroup END
2143 # this will open and also close the cmdline window
2144 feedkeys('q:', 'xt')
2145 assert_equal('yes', g:got_there)
2146
2147 augroup CmdWin
2148 au!
2149 augroup END
2150 &rtp = save_rtp
Bram Moolenaard8448622022-01-07 21:39:52 +00002151enddef
2152
2153def Test_import_gone_when_sourced_twice()
2154 var exportlines =<< trim END
2155 vim9script
2156 if exists('g:guard')
2157 finish
2158 endif
2159 g:guard = 1
2160 export var name = 'someName'
2161 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01002162 writefile(exportlines, 'XexportScript.vim', 'D')
Bram Moolenaard8448622022-01-07 21:39:52 +00002163
2164 var lines =<< trim END
2165 vim9script
2166 import './XexportScript.vim' as expo
2167 def g:GetName(): string
2168 return expo.name
2169 enddef
2170 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01002171 writefile(lines, 'XscriptImport.vim', 'D')
Bram Moolenaard8448622022-01-07 21:39:52 +00002172 so XscriptImport.vim
2173 assert_equal('someName', g:GetName())
2174
2175 so XexportScript.vim
2176 assert_fails('call g:GetName()', 'E1149:')
2177
2178 delfunc g:GetName
Bram Moolenaard8448622022-01-07 21:39:52 +00002179 unlet g:guard
2180enddef
2181
Bram Moolenaar160aa862022-01-10 21:29:57 +00002182" test using an auto-loaded function and variable
Bram Moolenaar0e3e7ba2022-01-13 20:18:56 +00002183def Test_vim9_autoload_full_name()
Bram Moolenaar160aa862022-01-10 21:29:57 +00002184 var lines =<< trim END
2185 vim9script
Bram Moolenaard8fe6d32022-01-30 18:40:44 +00002186 export def Gettest(): string
Bram Moolenaar160aa862022-01-10 21:29:57 +00002187 return 'test'
2188 enddef
2189 g:some#name = 'name'
2190 g:some#dict = {key: 'value'}
2191
Bram Moolenaard8fe6d32022-01-30 18:40:44 +00002192 export def Varargs(a1: string, ...l: list<string>): string
Bram Moolenaar160aa862022-01-10 21:29:57 +00002193 return a1 .. l[0] .. l[1]
2194 enddef
2195 END
2196
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01002197 mkdir('Xfulldir/autoload', 'pR')
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002198 writefile(lines, 'Xfulldir/autoload/some.vim')
Bram Moolenaar160aa862022-01-10 21:29:57 +00002199 var save_rtp = &rtp
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002200 exe 'set rtp^=' .. getcwd() .. '/Xfulldir'
Bram Moolenaar160aa862022-01-10 21:29:57 +00002201
Bram Moolenaard8fe6d32022-01-30 18:40:44 +00002202 assert_equal('test', g:some#Gettest())
Bram Moolenaar160aa862022-01-10 21:29:57 +00002203 assert_equal('name', g:some#name)
2204 assert_equal('value', g:some#dict.key)
2205 g:some#other = 'other'
2206 assert_equal('other', g:some#other)
2207
Bram Moolenaard8fe6d32022-01-30 18:40:44 +00002208 assert_equal('abc', some#Varargs('a', 'b', 'c'))
Bram Moolenaar160aa862022-01-10 21:29:57 +00002209
2210 # upper case script name works
2211 lines =<< trim END
2212 vim9script
Bram Moolenaard8fe6d32022-01-30 18:40:44 +00002213 export def GetOther(): string
Bram Moolenaar160aa862022-01-10 21:29:57 +00002214 return 'other'
2215 enddef
2216 END
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002217 writefile(lines, 'Xfulldir/autoload/Other.vim')
Bram Moolenaard8fe6d32022-01-30 18:40:44 +00002218 assert_equal('other', g:Other#GetOther())
Bram Moolenaar160aa862022-01-10 21:29:57 +00002219
Bram Moolenaar160aa862022-01-10 21:29:57 +00002220 &rtp = save_rtp
2221enddef
2222
2223def Test_vim9script_autoload()
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01002224 mkdir('Xaldir/autoload', 'pR')
Bram Moolenaar160aa862022-01-10 21:29:57 +00002225 var save_rtp = &rtp
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002226 exe 'set rtp^=' .. getcwd() .. '/Xaldir'
Bram Moolenaar160aa862022-01-10 21:29:57 +00002227
Bram Moolenaarfd218c82022-01-18 16:26:24 +00002228 # when the path has "/autoload/" prefix is not needed
Bram Moolenaar160aa862022-01-10 21:29:57 +00002229 var lines =<< trim END
Bram Moolenaarfd218c82022-01-18 16:26:24 +00002230 vim9script
Bram Moolenaar17d36cb2022-01-12 11:46:40 +00002231 g:prefixed_loaded += 1
Bram Moolenaar160aa862022-01-10 21:29:57 +00002232
2233 export def Gettest(): string
2234 return 'test'
2235 enddef
2236
Bram Moolenaar0e3e7ba2022-01-13 20:18:56 +00002237 export var name = 'name'
2238
2239 export func GetFunc()
2240 return Gettest() .. 'more' .. s:name
Bram Moolenaar160aa862022-01-10 21:29:57 +00002241 endfunc
2242
Bram Moolenaar0e3e7ba2022-01-13 20:18:56 +00002243 export def GetDef(): string
2244 return Gettest() .. 'more' .. name
2245 enddef
2246
Bram Moolenaar160aa862022-01-10 21:29:57 +00002247 export final fname = 'final'
2248 export const cname = 'const'
2249 END
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002250 writefile(lines, 'Xaldir/autoload/prefixed.vim')
Bram Moolenaar160aa862022-01-10 21:29:57 +00002251
Bram Moolenaar17d36cb2022-01-12 11:46:40 +00002252 g:prefixed_loaded = 0
2253 g:expected_loaded = 0
Bram Moolenaar160aa862022-01-10 21:29:57 +00002254 lines =<< trim END
2255 vim9script
2256 import autoload 'prefixed.vim'
Bram Moolenaar17d36cb2022-01-12 11:46:40 +00002257 assert_equal(g:expected_loaded, g:prefixed_loaded)
Bram Moolenaar160aa862022-01-10 21:29:57 +00002258 assert_equal('test', prefixed.Gettest())
Bram Moolenaar17d36cb2022-01-12 11:46:40 +00002259 assert_equal(1, g:prefixed_loaded)
Bram Moolenaar160aa862022-01-10 21:29:57 +00002260
Bram Moolenaar0e3e7ba2022-01-13 20:18:56 +00002261 assert_equal('testmorename', prefixed.GetFunc())
2262 assert_equal('testmorename', prefixed.GetDef())
Bram Moolenaar160aa862022-01-10 21:29:57 +00002263 assert_equal('name', prefixed.name)
2264 assert_equal('final', prefixed.fname)
2265 assert_equal('const', prefixed.cname)
2266 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002267 v9.CheckScriptSuccess(lines)
Bram Moolenaar17d36cb2022-01-12 11:46:40 +00002268 # can source it again, autoload script not loaded again
2269 g:expected_loaded = 1
Bram Moolenaar62aec932022-01-29 21:45:34 +00002270 v9.CheckScriptSuccess(lines)
Bram Moolenaar160aa862022-01-10 21:29:57 +00002271
2272 # can also get the items by autoload name
2273 lines =<< trim END
2274 call assert_equal('test', prefixed#Gettest())
Bram Moolenaar0e3e7ba2022-01-13 20:18:56 +00002275 call assert_equal('testmorename', prefixed#GetFunc())
Bram Moolenaar160aa862022-01-10 21:29:57 +00002276 call assert_equal('name', prefixed#name)
2277 call assert_equal('final', prefixed#fname)
2278 call assert_equal('const', prefixed#cname)
2279 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002280 v9.CheckScriptSuccess(lines)
Bram Moolenaar160aa862022-01-10 21:29:57 +00002281
Bram Moolenaarf111cdf2022-01-12 12:48:17 +00002282 unlet g:prefixed_loaded
2283 unlet g:expected_loaded
Bram Moolenaarf111cdf2022-01-12 12:48:17 +00002284 &rtp = save_rtp
2285enddef
2286
Bram Moolenaard02dce22022-01-18 17:43:04 +00002287def Test_import_autoload_not_exported()
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01002288 mkdir('Xnimdir/autoload', 'pR')
Bram Moolenaard02dce22022-01-18 17:43:04 +00002289 var save_rtp = &rtp
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002290 exe 'set rtp^=' .. getcwd() .. '/Xnimdir'
Bram Moolenaard02dce22022-01-18 17:43:04 +00002291
2292 # error when using an item that is not exported from an autoload script
2293 var exportLines =<< trim END
2294 vim9script
2295 var notExported = 123
2296 def NotExport()
2297 echo 'nop'
2298 enddef
2299 END
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002300 writefile(exportLines, 'Xnimdir/autoload/notExport1.vim')
Bram Moolenaard02dce22022-01-18 17:43:04 +00002301
2302 var lines =<< trim END
2303 vim9script
2304 import autoload 'notExport1.vim'
2305 echo notExport1.notFound
2306 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002307 v9.CheckScriptFailure(lines, 'E1048: Item not found in script: notFound')
Bram Moolenaard02dce22022-01-18 17:43:04 +00002308
2309 lines =<< trim END
2310 vim9script
2311 import autoload 'notExport1.vim'
2312 echo notExport1.notExported
2313 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002314 v9.CheckScriptFailure(lines, 'E1049: Item not exported in script: notExported')
Bram Moolenaard02dce22022-01-18 17:43:04 +00002315
2316 lines =<< trim END
2317 vim9script
2318 import autoload 'notExport1.vim'
2319 echo notExport1.NotFunc()
2320 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002321 v9.CheckScriptFailure(lines, 'E1048: Item not found in script: NotFunc')
Bram Moolenaard02dce22022-01-18 17:43:04 +00002322
2323 lines =<< trim END
2324 vim9script
2325 import autoload 'notExport1.vim'
2326 echo notExport1.NotExport()
2327 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002328 v9.CheckScriptFailure(lines, 'E1049: Item not exported in script: NotExport')
Bram Moolenaard02dce22022-01-18 17:43:04 +00002329
2330 lines =<< trim END
2331 vim9script
2332 import autoload 'notExport1.vim'
2333 echo 'text'->notExport1.NotFunc()
2334 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002335 v9.CheckScriptFailure(lines, 'E1048: Item not found in script: NotFunc')
Bram Moolenaard02dce22022-01-18 17:43:04 +00002336
2337 lines =<< trim END
2338 vim9script
2339 import autoload 'notExport1.vim'
2340 echo 'text'->notExport1.NotExport()
2341 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002342 v9.CheckScriptFailure(lines, 'E1049: Item not exported in script: NotExport')
Bram Moolenaard02dce22022-01-18 17:43:04 +00002343
2344 # using a :def function we use a different autoload script every time so that
2345 # the function is compiled without the script loaded
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002346 writefile(exportLines, 'Xnimdir/autoload/notExport2.vim')
Bram Moolenaard02dce22022-01-18 17:43:04 +00002347 lines =<< trim END
2348 vim9script
2349 import autoload 'notExport2.vim'
2350 def Testit()
2351 echo notExport2.notFound
2352 enddef
2353 Testit()
2354 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002355 v9.CheckScriptFailure(lines, 'E1048: Item not found in script: notExport2#notFound')
Bram Moolenaard02dce22022-01-18 17:43:04 +00002356
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002357 writefile(exportLines, 'Xnimdir/autoload/notExport3.vim')
Bram Moolenaard02dce22022-01-18 17:43:04 +00002358 lines =<< trim END
2359 vim9script
2360 import autoload 'notExport3.vim'
2361 def Testit()
2362 echo notExport3.notExported
2363 enddef
2364 Testit()
2365 END
2366 # don't get E1049 because it is too complicated to figure out
Bram Moolenaar62aec932022-01-29 21:45:34 +00002367 v9.CheckScriptFailure(lines, 'E1048: Item not found in script: notExport3#notExported')
Bram Moolenaard02dce22022-01-18 17:43:04 +00002368
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002369 writefile(exportLines, 'Xnimdir/autoload/notExport4.vim')
Bram Moolenaard02dce22022-01-18 17:43:04 +00002370 lines =<< trim END
2371 vim9script
2372 import autoload 'notExport4.vim'
2373 def Testit()
2374 echo notExport4.NotFunc()
2375 enddef
2376 Testit()
2377 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002378 v9.CheckScriptFailure(lines, 'E117: Unknown function: notExport4#NotFunc')
Bram Moolenaard02dce22022-01-18 17:43:04 +00002379
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002380 writefile(exportLines, 'Xnimdir/autoload/notExport5.vim')
Bram Moolenaard02dce22022-01-18 17:43:04 +00002381 lines =<< trim END
2382 vim9script
2383 import autoload 'notExport5.vim'
2384 def Testit()
2385 echo notExport5.NotExport()
2386 enddef
2387 Testit()
2388 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002389 v9.CheckScriptFailure(lines, 'E117: Unknown function: notExport5#NotExport')
Bram Moolenaard02dce22022-01-18 17:43:04 +00002390
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002391 writefile(exportLines, 'Xnimdir/autoload/notExport6.vim')
Bram Moolenaard02dce22022-01-18 17:43:04 +00002392 lines =<< trim END
2393 vim9script
2394 import autoload 'notExport6.vim'
2395 def Testit()
2396 echo 'text'->notExport6.NotFunc()
2397 enddef
2398 Testit()
2399 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002400 v9.CheckScriptFailure(lines, 'E117: Unknown function: notExport6#NotFunc')
Bram Moolenaard02dce22022-01-18 17:43:04 +00002401
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002402 writefile(exportLines, 'Xnimdir/autoload/notExport7.vim')
Bram Moolenaard02dce22022-01-18 17:43:04 +00002403 lines =<< trim END
2404 vim9script
2405 import autoload 'notExport7.vim'
2406 def Testit()
2407 echo 'text'->notExport7.NotExport()
2408 enddef
2409 Testit()
2410 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002411 v9.CheckScriptFailure(lines, 'E117: Unknown function: notExport7#NotExport')
Bram Moolenaard02dce22022-01-18 17:43:04 +00002412
Bram Moolenaard02dce22022-01-18 17:43:04 +00002413 &rtp = save_rtp
2414enddef
2415
Bram Moolenaarf111cdf2022-01-12 12:48:17 +00002416def Test_vim9script_autoload_call()
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01002417 mkdir('Xcalldir/autoload', 'pR')
Bram Moolenaarf111cdf2022-01-12 12:48:17 +00002418 var save_rtp = &rtp
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002419 exe 'set rtp^=' .. getcwd() .. '/Xcalldir'
Bram Moolenaarf111cdf2022-01-12 12:48:17 +00002420
2421 var lines =<< trim END
Bram Moolenaarfd218c82022-01-18 16:26:24 +00002422 vim9script
Bram Moolenaarf111cdf2022-01-12 12:48:17 +00002423
Bram Moolenaarcbbc48f2022-01-18 12:58:28 +00002424 export def RetArg(arg: string): string
2425 return arg
2426 enddef
2427
Bram Moolenaarf111cdf2022-01-12 12:48:17 +00002428 export def Getother()
2429 g:result = 'other'
2430 enddef
2431 END
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002432 writefile(lines, 'Xcalldir/autoload/another.vim')
Bram Moolenaarf111cdf2022-01-12 12:48:17 +00002433
2434 lines =<< trim END
2435 vim9script
Bram Moolenaar5d982692022-01-12 15:15:27 +00002436 import autoload 'another.vim'
Bram Moolenaarcbbc48f2022-01-18 12:58:28 +00002437
2438 # compile this before 'another.vim' is loaded
2439 def CallAnother()
2440 assert_equal('foo', 'foo'->another.RetArg())
2441 enddef
2442 CallAnother()
2443
Bram Moolenaar5d982692022-01-12 15:15:27 +00002444 call another.Getother()
Bram Moolenaarf111cdf2022-01-12 12:48:17 +00002445 assert_equal('other', g:result)
Bram Moolenaar3d8e25a2022-01-22 11:00:02 +00002446
2447 assert_equal('arg', call('another.RetArg', ['arg']))
Bram Moolenaar8164f6e2022-02-06 13:08:41 +00002448
2449 verbose function another.Getother
2450 # should we disallow this?
2451 verbose function another#Getother
Bram Moolenaarf111cdf2022-01-12 12:48:17 +00002452 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002453 v9.CheckScriptSuccess(lines)
Bram Moolenaarf111cdf2022-01-12 12:48:17 +00002454
2455 unlet g:result
Bram Moolenaar160aa862022-01-10 21:29:57 +00002456 &rtp = save_rtp
2457enddef
2458
Bram Moolenaarb697dc22022-01-22 11:27:29 +00002459def Test_vim9script_noclear_autoload()
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01002460 mkdir('Xnocdir/autoload', 'pR')
Bram Moolenaarb697dc22022-01-22 11:27:29 +00002461 var save_rtp = &rtp
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002462 exe 'set rtp^=' .. getcwd() .. '/Xnocdir'
Bram Moolenaarb697dc22022-01-22 11:27:29 +00002463
2464 var lines =<< trim END
2465 vim9script
2466 export def Func(): string
2467 return 'called'
2468 enddef
2469 g:double_loaded = 'yes'
2470 END
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002471 writefile(lines, 'Xnocdir/autoload/double.vim')
Bram Moolenaarb697dc22022-01-22 11:27:29 +00002472
2473 lines =<< trim END
2474 vim9script noclear
2475 if exists('g:script_loaded')
2476 finish
2477 endif
2478 g:script_loaded = true
2479
2480 import autoload 'double.vim'
2481 nnoremap <F3> <ScriptCmd>g:result = double.Func()<CR>
2482 END
2483 g:double_loaded = 'no'
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01002484 writefile(lines, 'Xloaddouble', 'D')
Bram Moolenaarb697dc22022-01-22 11:27:29 +00002485 source Xloaddouble
2486 assert_equal('no', g:double_loaded)
2487 assert_equal(true, g:script_loaded)
2488 source Xloaddouble
2489 feedkeys("\<F3>", 'xt')
2490 assert_equal('called', g:result)
2491 assert_equal('yes', g:double_loaded)
2492
Bram Moolenaarb697dc22022-01-22 11:27:29 +00002493 unlet g:double_loaded
2494 unlet g:script_loaded
2495 unlet g:result
Bram Moolenaarb697dc22022-01-22 11:27:29 +00002496 &rtp = save_rtp
2497enddef
2498
Bram Moolenaar9c7cae62022-01-20 19:10:25 +00002499def Test_vim9script_autoload_duplicate()
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01002500 mkdir('Xdupdir/autoload', 'pR')
Bram Moolenaar9c7cae62022-01-20 19:10:25 +00002501
2502 var lines =<< trim END
2503 vim9script
2504
2505 export def Func()
2506 enddef
2507
2508 def Func()
2509 enddef
2510 END
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002511 writefile(lines, 'Xdupdir/autoload/dupfunc.vim')
2512 assert_fails('source Xdupdir/autoload/dupfunc.vim', 'E1073:')
Bram Moolenaar9c7cae62022-01-20 19:10:25 +00002513
2514 lines =<< trim END
2515 vim9script
2516
2517 def Func()
2518 enddef
2519
2520 export def Func()
2521 enddef
2522 END
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002523 writefile(lines, 'Xdupdir/autoload/dup2func.vim')
2524 assert_fails('source Xdupdir/autoload/dup2func.vim', 'E1073:')
Bram Moolenaar9c7cae62022-01-20 19:10:25 +00002525
2526 lines =<< trim END
2527 vim9script
2528
2529 def Func()
2530 enddef
2531
2532 export var Func = 'asdf'
2533 END
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002534 writefile(lines, 'Xdupdir/autoload/dup3func.vim')
2535 assert_fails('source Xdupdir/autoload/dup3func.vim', 'E1041: Redefining script item: "Func"')
Bram Moolenaar9c7cae62022-01-20 19:10:25 +00002536
2537 lines =<< trim END
2538 vim9script
2539
2540 export var Func = 'asdf'
2541
2542 def Func()
2543 enddef
2544 END
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002545 writefile(lines, 'Xdupdir/autoload/dup4func.vim')
Bram Moolenaar6c4d4a62022-10-13 17:47:42 +01002546 assert_fails('source Xdupdir/autoload/dup4func.vim', 'E1041:')
Bram Moolenaar9c7cae62022-01-20 19:10:25 +00002547
2548 lines =<< trim END
2549 vim9script
2550
2551 var Func = 'asdf'
2552
2553 export def Func()
2554 enddef
2555 END
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002556 writefile(lines, 'Xdupdir/autoload/dup5func.vim')
2557 assert_fails('source Xdupdir/autoload/dup5func.vim', 'E707:')
Bram Moolenaar9c7cae62022-01-20 19:10:25 +00002558
2559 lines =<< trim END
2560 vim9script
2561
2562 export def Func()
2563 enddef
2564
2565 var Func = 'asdf'
2566 END
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002567 writefile(lines, 'Xdupdir/autoload/dup6func.vim')
2568 assert_fails('source Xdupdir/autoload/dup6func.vim', 'E1041: Redefining script item: "Func"')
Bram Moolenaar9c7cae62022-01-20 19:10:25 +00002569enddef
2570
Bram Moolenaar2017d6f2022-01-20 19:38:46 +00002571def Test_autoload_missing_function_name()
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01002572 mkdir('Xmisdir/autoload', 'pR')
Bram Moolenaar2017d6f2022-01-20 19:38:46 +00002573
2574 var lines =<< trim END
2575 vim9script
2576
2577 def loadme#()
2578 enddef
2579 END
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002580 writefile(lines, 'Xmisdir/autoload/loadme.vim')
2581 assert_fails('source Xmisdir/autoload/loadme.vim', 'E129:')
Bram Moolenaar2017d6f2022-01-20 19:38:46 +00002582enddef
2583
Bram Moolenaar848fadd2022-01-30 15:28:30 +00002584def Test_autoload_name_wrong()
Bram Moolenaar19e69a62022-01-21 20:37:05 +00002585 var lines =<< trim END
Bram Moolenaar19e69a62022-01-21 20:37:05 +00002586 def Xscriptname#Func()
2587 enddef
2588 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01002589 writefile(lines, 'Xscriptname.vim', 'D')
Bram Moolenaard8fe6d32022-01-30 18:40:44 +00002590 v9.CheckScriptFailure(lines, 'E746:')
Bram Moolenaard8fe6d32022-01-30 18:40:44 +00002591
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01002592 mkdir('Xwrodir/autoload', 'pR')
Bram Moolenaard8fe6d32022-01-30 18:40:44 +00002593 lines =<< trim END
2594 vim9script
2595 def somescript#Func()
2596 enddef
2597 END
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002598 writefile(lines, 'Xwrodir/autoload/somescript.vim')
2599 assert_fails('source Xwrodir/autoload/somescript.vim', 'E1263:')
Bram Moolenaard8fe6d32022-01-30 18:40:44 +00002600
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002601 delete('Xwrodir', 'rf')
Bram Moolenaar19e69a62022-01-21 20:37:05 +00002602enddef
2603
Bram Moolenaard041f422022-01-12 19:54:00 +00002604def Test_import_autoload_postponed()
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01002605 mkdir('Xpostdir/autoload', 'pR')
Bram Moolenaard041f422022-01-12 19:54:00 +00002606 var save_rtp = &rtp
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002607 exe 'set rtp^=' .. getcwd() .. '/Xpostdir'
Bram Moolenaard041f422022-01-12 19:54:00 +00002608
2609 var lines =<< trim END
Bram Moolenaarfd218c82022-01-18 16:26:24 +00002610 vim9script
Bram Moolenaard041f422022-01-12 19:54:00 +00002611
2612 g:loaded_postponed = 'true'
2613 export var variable = 'bla'
2614 export def Function(): string
2615 return 'bla'
2616 enddef
2617 END
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002618 writefile(lines, 'Xpostdir/autoload/postponed.vim')
Bram Moolenaard041f422022-01-12 19:54:00 +00002619
2620 lines =<< trim END
2621 vim9script
2622
2623 import autoload 'postponed.vim'
2624 def Tryit()
2625 echo postponed.variable
2626 echo postponed.Function()
2627 enddef
2628 defcompile
2629 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002630 v9.CheckScriptSuccess(lines)
Bram Moolenaard041f422022-01-12 19:54:00 +00002631 assert_false(exists('g:loaded_postponed'))
Bram Moolenaar62aec932022-01-29 21:45:34 +00002632 v9.CheckScriptSuccess(lines + ['Tryit()'])
Bram Moolenaard041f422022-01-12 19:54:00 +00002633 assert_equal('true', g:loaded_postponed)
2634
2635 unlet g:loaded_postponed
Bram Moolenaard041f422022-01-12 19:54:00 +00002636 &rtp = save_rtp
2637enddef
2638
Bram Moolenaar3e4fa3d2022-01-13 22:05:09 +00002639def Test_import_autoload_override()
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01002640 mkdir('Xoverdir/autoload', 'pR')
Bram Moolenaar3e4fa3d2022-01-13 22:05:09 +00002641 var save_rtp = &rtp
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002642 exe 'set rtp^=' .. getcwd() .. '/Xoverdir'
Bram Moolenaar3e4fa3d2022-01-13 22:05:09 +00002643 test_override('autoload', 1)
2644
2645 var lines =<< trim END
Bram Moolenaarfd218c82022-01-18 16:26:24 +00002646 vim9script
Bram Moolenaar3e4fa3d2022-01-13 22:05:09 +00002647
2648 g:loaded_override = 'true'
2649 export var variable = 'bla'
2650 export def Function(): string
2651 return 'bla'
2652 enddef
2653 END
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002654 writefile(lines, 'Xoverdir/autoload/override.vim')
Bram Moolenaar3e4fa3d2022-01-13 22:05:09 +00002655
2656 lines =<< trim END
2657 vim9script
2658
2659 import autoload 'override.vim'
2660 assert_equal('true', g:loaded_override)
2661
2662 def Tryit()
2663 echo override.doesNotExist
2664 enddef
2665 defcompile
2666 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002667 v9.CheckScriptFailure(lines, 'E1048: Item not found in script: doesNotExist', 1)
Bram Moolenaar3e4fa3d2022-01-13 22:05:09 +00002668
2669 test_override('autoload', 0)
2670 unlet g:loaded_override
Bram Moolenaar3e4fa3d2022-01-13 22:05:09 +00002671 &rtp = save_rtp
2672enddef
2673
Bram Moolenaar19db9e62022-01-11 11:58:19 +00002674def Test_autoload_mapping()
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01002675 mkdir('Xmapdir/autoload', 'pR')
Bram Moolenaar19db9e62022-01-11 11:58:19 +00002676 var save_rtp = &rtp
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002677 exe 'set rtp^=' .. getcwd() .. '/Xmapdir'
Bram Moolenaar19db9e62022-01-11 11:58:19 +00002678
2679 var lines =<< trim END
Bram Moolenaarfd218c82022-01-18 16:26:24 +00002680 vim9script
Bram Moolenaar19db9e62022-01-11 11:58:19 +00002681
2682 g:toggle_loaded = 'yes'
2683
2684 export def Toggle(): string
2685 return ":g:toggle_called = 'yes'\<CR>"
2686 enddef
Bram Moolenaare32c3c42022-01-15 18:26:04 +00002687 export def Doit()
2688 g:doit_called = 'yes'
2689 enddef
Bram Moolenaar19db9e62022-01-11 11:58:19 +00002690 END
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002691 writefile(lines, 'Xmapdir/autoload/toggle.vim')
Bram Moolenaar19db9e62022-01-11 11:58:19 +00002692
2693 lines =<< trim END
2694 vim9script
2695
2696 import autoload 'toggle.vim'
2697
Bram Moolenaar94722c52023-01-28 19:19:03 +00002698 nnoremap <silent> <expr> tt toggle.Toggle()
Bram Moolenaare32c3c42022-01-15 18:26:04 +00002699 nnoremap <silent> xx <ScriptCmd>toggle.Doit()<CR>
2700 nnoremap <silent> yy <Cmd>toggle.Doit()<CR>
Bram Moolenaar19db9e62022-01-11 11:58:19 +00002701 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002702 v9.CheckScriptSuccess(lines)
Bram Moolenaar19db9e62022-01-11 11:58:19 +00002703 assert_false(exists("g:toggle_loaded"))
2704 assert_false(exists("g:toggle_called"))
Bram Moolenaar6079da72022-01-18 14:16:59 +00002705 assert_match('\d A: \f*[/\\]toggle.vim', execute('scriptnames'))
Bram Moolenaar19db9e62022-01-11 11:58:19 +00002706
2707 feedkeys("tt", 'xt')
2708 assert_equal('yes', g:toggle_loaded)
2709 assert_equal('yes', g:toggle_called)
Bram Moolenaar6079da72022-01-18 14:16:59 +00002710 assert_match('\d: \f*[/\\]toggle.vim', execute('scriptnames'))
Bram Moolenaar19db9e62022-01-11 11:58:19 +00002711
Bram Moolenaare32c3c42022-01-15 18:26:04 +00002712 feedkeys("xx", 'xt')
2713 assert_equal('yes', g:doit_called)
2714
2715 assert_fails('call feedkeys("yy", "xt")', 'E121: Undefined variable: toggle')
2716
Bram Moolenaar19db9e62022-01-11 11:58:19 +00002717 nunmap tt
Bram Moolenaare32c3c42022-01-15 18:26:04 +00002718 nunmap xx
2719 nunmap yy
Bram Moolenaar19db9e62022-01-11 11:58:19 +00002720 unlet g:toggle_loaded
2721 unlet g:toggle_called
Bram Moolenaar19db9e62022-01-11 11:58:19 +00002722 &rtp = save_rtp
2723enddef
2724
Bram Moolenaar160aa862022-01-10 21:29:57 +00002725def Test_vim9script_autoload_fails()
2726 var lines =<< trim END
2727 vim9script autoload
2728 var n = 0
2729 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002730 v9.CheckScriptFailure(lines, 'E475: Invalid argument: autoload')
Bram Moolenaarfd218c82022-01-18 16:26:24 +00002731
2732 lines =<< trim END
2733 vim9script noclear noclear
2734 var n = 0
2735 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002736 v9.CheckScriptFailure(lines, 'E983: Duplicate argument: noclear')
Yegappan Lakshmanan885de442022-04-23 10:51:14 +01002737
2738 lines =<< trim END
2739 vim9script noclears
2740 var n = 0
2741 END
2742 v9.CheckScriptFailure(lines, 'E475: Invalid argument: noclears')
Bram Moolenaar160aa862022-01-10 21:29:57 +00002743enddef
2744
2745def Test_import_autoload_fails()
2746 var lines =<< trim END
2747 vim9script
2748 import autoload autoload 'prefixed.vim'
2749 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002750 v9.CheckScriptFailure(lines, 'E121: Undefined variable: autoload')
Bram Moolenaar160aa862022-01-10 21:29:57 +00002751
2752 lines =<< trim END
2753 vim9script
Bram Moolenaar1836d612022-01-18 13:14:47 +00002754 import autoload './doesNotExist.vim'
Bram Moolenaar160aa862022-01-10 21:29:57 +00002755 END
Bram Moolenaar4dea2d92022-03-31 11:37:57 +01002756 v9.CheckScriptFailure(lines, 'E282:', 2)
Bram Moolenaar1836d612022-01-18 13:14:47 +00002757
2758 lines =<< trim END
2759 vim9script
2760 import autoload '/dir/doesNotExist.vim'
2761 END
Bram Moolenaar4dea2d92022-03-31 11:37:57 +01002762 v9.CheckScriptFailure(lines, 'E282:', 2)
2763
2764 lines =<< trim END
2765 vim9script
2766 import autoload '../testdir'
2767 END
2768 v9.CheckScriptFailure(lines, 'E17:', 2)
Bram Moolenaar1836d612022-01-18 13:14:47 +00002769
2770 lines =<< trim END
2771 vim9script
2772 import autoload 'doesNotExist.vim'
2773 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002774 v9.CheckScriptFailure(lines, 'E1053: Could not import "doesNotExist.vim"')
Bram Moolenaar160aa862022-01-10 21:29:57 +00002775enddef
2776
2777" test disassembling an auto-loaded function starting with "debug"
2778def Test_vim9_autoload_disass()
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01002779 mkdir('Xdasdir/autoload', 'pR')
Bram Moolenaar160aa862022-01-10 21:29:57 +00002780 var save_rtp = &rtp
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002781 exe 'set rtp^=' .. getcwd() .. '/Xdasdir'
Bram Moolenaar160aa862022-01-10 21:29:57 +00002782
2783 var lines =<< trim END
2784 vim9script
Bram Moolenaard8fe6d32022-01-30 18:40:44 +00002785 export def Test(): string
Bram Moolenaar160aa862022-01-10 21:29:57 +00002786 return 'debug'
2787 enddef
2788 END
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002789 writefile(lines, 'Xdasdir/autoload/debugit.vim')
Bram Moolenaar160aa862022-01-10 21:29:57 +00002790
2791 lines =<< trim END
2792 vim9script
Bram Moolenaard8fe6d32022-01-30 18:40:44 +00002793 export def Test(): string
Bram Moolenaar160aa862022-01-10 21:29:57 +00002794 return 'profile'
2795 enddef
2796 END
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002797 writefile(lines, 'Xdasdir/autoload/profileit.vim')
Bram Moolenaar160aa862022-01-10 21:29:57 +00002798
2799 lines =<< trim END
2800 vim9script
Bram Moolenaard8fe6d32022-01-30 18:40:44 +00002801 assert_equal('debug', debugit#Test())
2802 disass debugit#Test
2803 assert_equal('profile', profileit#Test())
2804 disass profileit#Test
Bram Moolenaar160aa862022-01-10 21:29:57 +00002805 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002806 v9.CheckScriptSuccess(lines)
Bram Moolenaar160aa862022-01-10 21:29:57 +00002807
Bram Moolenaar160aa862022-01-10 21:29:57 +00002808 &rtp = save_rtp
2809enddef
2810
2811" test using a vim9script that is auto-loaded from an autocmd
2812def Test_vim9_aucmd_autoload()
2813 var lines =<< trim END
2814 vim9script
Bram Moolenaard8fe6d32022-01-30 18:40:44 +00002815 export def Test()
Bram Moolenaar160aa862022-01-10 21:29:57 +00002816 echomsg getreg('"')
2817 enddef
2818 END
2819
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01002820 mkdir('Xauldir/autoload', 'pR')
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002821 writefile(lines, 'Xauldir/autoload/foo.vim')
Bram Moolenaar160aa862022-01-10 21:29:57 +00002822 var save_rtp = &rtp
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002823 exe 'set rtp^=' .. getcwd() .. '/Xauldir'
Bram Moolenaar160aa862022-01-10 21:29:57 +00002824 augroup test
Bram Moolenaard8fe6d32022-01-30 18:40:44 +00002825 autocmd TextYankPost * call foo#Test()
Bram Moolenaar160aa862022-01-10 21:29:57 +00002826 augroup END
2827
2828 normal Y
2829
2830 augroup test
2831 autocmd!
2832 augroup END
Bram Moolenaar160aa862022-01-10 21:29:57 +00002833 &rtp = save_rtp
2834enddef
2835
Bram Moolenaar3049fcf2022-01-13 19:25:50 +00002836" test using a autoloaded file that is case sensitive
2837def Test_vim9_autoload_case_sensitive()
2838 var lines =<< trim END
Bram Moolenaarfd218c82022-01-18 16:26:24 +00002839 vim9script
Bram Moolenaar3049fcf2022-01-13 19:25:50 +00002840 export def CaseSensitive(): string
2841 return 'done'
2842 enddef
2843 END
2844
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01002845 mkdir('Xcasedir/autoload', 'pR')
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002846 writefile(lines, 'Xcasedir/autoload/CaseSensitive.vim')
Bram Moolenaar3049fcf2022-01-13 19:25:50 +00002847 var save_rtp = &rtp
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002848 exe 'set rtp^=' .. getcwd() .. '/Xcasedir'
Bram Moolenaar3049fcf2022-01-13 19:25:50 +00002849
2850 lines =<< trim END
2851 vim9script
2852 import autoload 'CaseSensitive.vim'
2853 assert_equal('done', CaseSensitive.CaseSensitive())
2854 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002855 v9.CheckScriptSuccess(lines)
Bram Moolenaar3049fcf2022-01-13 19:25:50 +00002856
Bram Moolenaarbfac4092022-01-16 11:12:12 +00002857 if !has('fname_case')
2858 lines =<< trim END
2859 vim9script
2860 import autoload 'CaseSensitive.vim'
2861 import autoload 'casesensitive.vim'
2862 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002863 v9.CheckScriptFailure(lines, 'E1262:')
Bram Moolenaarbfac4092022-01-16 11:12:12 +00002864 endif
2865
Bram Moolenaar3049fcf2022-01-13 19:25:50 +00002866 &rtp = save_rtp
2867enddef
2868
Bram Moolenaar160aa862022-01-10 21:29:57 +00002869" This was causing a crash because suppress_errthrow wasn't reset.
2870def Test_vim9_autoload_error()
2871 var lines =<< trim END
2872 vim9script
2873 def crash#func()
2874 try
2875 for x in List()
2876 endfor
2877 catch
2878 endtry
2879 g:ok = true
2880 enddef
2881 fu List()
2882 invalid
2883 endfu
2884 try
2885 alsoinvalid
2886 catch /wontmatch/
2887 endtry
2888 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01002889 call mkdir('Xruntime/autoload', 'pR')
Bram Moolenaar160aa862022-01-10 21:29:57 +00002890 call writefile(lines, 'Xruntime/autoload/crash.vim')
2891
2892 # run in a separate Vim to avoid the side effects of assert_fails()
2893 lines =<< trim END
2894 exe 'set rtp^=' .. getcwd() .. '/Xruntime'
2895 call crash#func()
2896 call writefile(['ok'], 'Xdidit')
2897 qall!
2898 END
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01002899 writefile(lines, 'Xscript', 'D')
Bram Moolenaar62aec932022-01-29 21:45:34 +00002900 g:RunVim([], [], '-S Xscript')
Bram Moolenaar160aa862022-01-10 21:29:57 +00002901 assert_equal(['ok'], readfile('Xdidit'))
2902
2903 delete('Xdidit')
Bram Moolenaar160aa862022-01-10 21:29:57 +00002904
2905 lines =<< trim END
2906 vim9script
2907 var foo#bar = 'asdf'
2908 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002909 v9.CheckScriptFailure(lines, 'E461: Illegal variable name: foo#bar', 2)
Bram Moolenaar160aa862022-01-10 21:29:57 +00002910enddef
2911
Bram Moolenaar753885b2022-08-24 16:30:36 +01002912def Test_vim9_import_symlink()
2913 if !has('unix')
2914 CheckUnix
2915 else
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01002916 mkdir('Xto/plugin', 'pR')
Bram Moolenaar753885b2022-08-24 16:30:36 +01002917 var lines =<< trim END
2918 vim9script
2919 import autoload 'bar.vim'
2920 g:resultFunc = bar.Func()
2921 g:resultValue = bar.value
2922 END
2923 writefile(lines, 'Xto/plugin/foo.vim')
2924
Bram Moolenaar0e9bdad2022-10-15 20:06:33 +01002925 mkdir('Xto/autoload', 'pR')
Bram Moolenaar753885b2022-08-24 16:30:36 +01002926 lines =<< trim END
2927 vim9script
2928 export def Func(): string
2929 return 'func'
2930 enddef
2931 export var value = 'val'
2932 END
2933 writefile(lines, 'Xto/autoload/bar.vim')
2934
2935 var save_rtp = &rtp
2936 &rtp = getcwd() .. '/Xfrom'
2937 system('ln -s ' .. getcwd() .. '/Xto Xfrom')
2938
2939 source Xfrom/plugin/foo.vim
2940 assert_equal('func', g:resultFunc)
2941 assert_equal('val', g:resultValue)
2942
2943 var infoTo = getscriptinfo()->filter((_, v) => v.name =~ 'Xto/autoload/bar')
2944 var infoFrom = getscriptinfo()->filter((_, v) => v.name =~ 'Xfrom/autoload/bar')
2945 assert_equal(1, len(infoTo))
2946 assert_equal(1, len(infoFrom))
2947 assert_equal(infoTo[0].sid, infoFrom[0].sourced)
Bram Moolenaar7ea9fcb2022-08-24 17:46:12 +01002948 var output: string
2949 redir => output
2950 scriptnames
2951 redir END
2952 assert_match(infoFrom[0].sid .. '->' .. infoFrom[0].sourced .. '.*Xfrom', output)
Bram Moolenaar753885b2022-08-24 16:30:36 +01002953
2954 unlet g:resultFunc
2955 unlet g:resultValue
2956 &rtp = save_rtp
Bram Moolenaar753885b2022-08-24 16:30:36 +01002957 delete('Xfrom', 'rf')
Ernie Rael9a901792024-04-16 22:11:56 +02002958
2959 # Access item from :def imported through symbolic linked directory. #14536
2960 mkdir('Xto/real_dir', 'pR')
2961 lines =<< trim END
2962 vim9script
2963 export const val = 17
2964 export def F(): number
2965 return 23
2966 enddef
2967 END
2968 writefile(lines, 'Xto/real_dir/real_file.vim')
2969 system('ln -s real_dir Xto/syml_dir')
2970 defer delete('Xto/syml_dir')
2971 lines =<< trim END
2972 vim9script
2973 import autoload './Xto/syml_dir/real_file.vim'
2974
2975 def Fmain()
2976 assert_equal(17, real_file.val)
2977 enddef
2978 def F2()
2979 assert_equal(23, real_file.F())
2980 enddef
2981 Fmain()
2982 F2()
2983 END
2984 v9.CheckScriptSuccess(lines)
Bram Moolenaar753885b2022-08-24 16:30:36 +01002985 endif
2986enddef
2987
LemonBoy90c27b22023-08-27 19:28:15 +02002988def Test_export_in_conditional_block()
2989 var lines =<< trim END
2990 vim9script
2991 if exists('this_will_fail')
2992 export var MyVar = "hello"
2993 endif
2994 END
2995 v9.CheckScriptSuccess(lines)
2996enddef
2997
Yegappan Lakshmananfa630082024-03-10 19:22:38 +01002998" Import fails when an autoloaded script is imported again.
2999" Github issue #14171
3000def Test_import_autloaded_script()
3001 mkdir('Ximporttwice', 'pR')
3002 mkdir('Ximporttwice/plugin')
3003 mkdir('Ximporttwice/autoload')
3004 var save_rtp = &rtp
3005 exe 'set rtp^=' .. getcwd() .. '/Ximporttwice'
3006
3007 var lines =<< trim END
3008 vim9script
3009
3010 export def H(): number
3011 return 10
3012 enddef
3013 END
3014 writefile(lines, 'Ximporttwice/autoload/hello.vim')
3015
3016 lines =<< trim END
3017 vim9script
3018
3019 import "./hello.vim"
3020 export def W(): number
3021 return 20
3022 enddef
3023 END
3024 writefile(lines, 'Ximporttwice/autoload/world.vim')
3025
3026 lines =<< trim END
3027 vim9script
3028
3029 import autoload '../autoload/hello.vim'
3030 import autoload '../autoload/world.vim'
3031
3032 command Hello echo hello.H()
3033 command World echo world.W()
3034 END
3035 writefile(lines, 'Ximporttwice/plugin/main.vim')
3036
3037 lines =<< trim END
3038 vim9script
3039
3040 source ./Ximporttwice/plugin/main.vim
3041 assert_equal(['20'], execute('World')->split("\n"))
3042 END
3043 v9.CheckScriptSuccess(lines)
3044
3045 &rtp = save_rtp
3046enddef
Bram Moolenaard8448622022-01-07 21:39:52 +00003047
Yegappan Lakshmanan3fa8f772024-04-04 21:42:07 +02003048" Test for autoloading an imported dict func
3049def Test_autoload_import_dict_func()
3050 mkdir('Xdir/autoload', 'pR')
3051 var lines =<< trim END
3052 vim9script
3053 export var al_exported_nr: number = 33
3054 def Al_AddNum(n: number)
3055 al_exported_nr += n
3056 enddef
3057 export var al_exportedDict: dict<func> = {Fn: Al_AddNum}
3058 END
3059 writefile(lines, 'Xdir/autoload/Xdictfunc.vim')
3060
3061 var save_rtp = &rtp
3062 exe 'set rtp^=' .. getcwd() .. '/Xdir'
3063 lines =<< trim END
3064 import './Xdir/autoload/Xdictfunc.vim'
3065 call Xdictfunc#al_exportedDict.Fn(5)
3066 call assert_equal(38, Xdictfunc#al_exported_nr)
3067 call call(Xdictfunc#al_exportedDict.Fn, [3])
3068 call assert_equal(41, Xdictfunc#al_exported_nr)
3069 END
3070 v9.CheckScriptSuccess(lines)
3071 &rtp = save_rtp
3072enddef
3073
Bram Moolenaard8448622022-01-07 21:39:52 +00003074" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker