vimlrs 0.2.1

Faithful Rust port of the Vimscript (VimL) interpreter, from the Neovim C eval engine
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

" deferred_function.vim — a `:function` nested inside a control-flow block
" (`:if`/`:while`/`:for`/`:try`) or another function body is registered when its
" line EXECUTES, not at parse time (userfunc.c:2485-2511: those blocks only
" adjust `indent`, and an inner `:function …(` is defined when the enclosing code
" runs). This is the idempotent `if !exists('*F') | function F() … | endif`
" idiom that real `.vimrc`s and colour schemes (e.g. zpwrmarklar.vim) rely on.
" Verified against Vim 9.2. Self-test: asserts into v:errors, throws if any fail.

" --- 1. a function defined inside a TRUE :if block is callable afterward
if 1
  function! TrueGuard()
    return 42
  endfunction
endif
call assert_equal(1, exists('*TrueGuard'))
call assert_equal(42, TrueGuard())

" --- 2. a function inside a FALSE :if guard is never defined
if 0
  function! FalseGuard()
    return 7
  endfunction
endif
call assert_equal(0, exists('*FalseGuard'))

" --- 3. the `if !exists('*F')` idiom is idempotent: a second guard block at
"        script level (as a re-source would hit) sees the function already
"        defined and does NOT redefine it — the original body wins.
if !exists('*ScriptGuard')
  function! ScriptGuard()
    return 'first'
  endfunction
endif
if !exists('*ScriptGuard')
  function! ScriptGuard()
    return 'second'
  endfunction
endif
call assert_equal('first', ScriptGuard())

" --- 4. a function defined inside ANOTHER function's body (def-in-def) is
"        registered when the OUTER function runs — not at parse time, and NOT an
"        error (Vim's E120 is unrelated: "Using <SID> not in a script context").
function! Outer()
  function! Inner()
    return 'inner'
  endfunction
endfunction
call assert_equal(0, exists('*Inner'))
call Outer()
call assert_equal(1, exists('*Inner'))
call assert_equal('inner', Inner())

" --- 5. the guarded idiom inside an init function is also idempotent across
"        repeated calls (the common autoload/plugin-init shape).
function! s:init() abort
  if !exists('*InitFn')
    function! InitFn()
      return 'v1'
    endfunction
  endif
endfunction
call s:init()
call assert_equal('v1', InitFn())
call s:init()
call assert_equal('v1', InitFn())

" --- 6. deferred inside a :while loop: defined on the first reached iteration
let s:n = 0
while s:n < 3
  if !exists('*LoopFn')
    function! LoopFn()
      return 'looped'
    endfunction
  endif
  let s:n += 1
endwhile
call assert_equal('looped', LoopFn())

if len(v:errors) > 0
  for err in v:errors
    echo err
  endfor
  throw 'deferred_function.vim: ' . len(v:errors) . ' assertion(s) failed'
endif
echo 'deferred_function.vim: all assertions passed'