vim9script

# Language:     Vim9 script
# Contributers: @lacygoill
#               Shane-XB-Qian
#               Andrew Radev
#               thinca
# Last Change:  2026 Mar 30
#
# Vim script to handle jumping to the targets of several types of Vim commands
# (:import, :packadd, :runtime, :colorscheme), and to autoloaded functions of
# the style <path>#<function_name>.
#
# see runtime/ftplugin/vim.vim

# Interface {{{1
export def Find(editcmd: string) #{{{2
    var curline: string = getline('.')

    if curline =~ '^\s*\%(:\s*\)\=\%(sil\%[ent]!\=\s\+\)\=packadd!\=\s'
        HandlePackaddLine(editcmd, curline)
        return
    endif

    if curline =~ '^\s*\%(:\s*\)\=\%(sil\%[ent]!\=\s\+\)\=ru\%[ntime]!\='
        HandleRuntimeLine(editcmd, curline, expand('<cfile>'))
        return
    endif

    if curline =~ '^\s*\%(:\s*\)\=\%(sil\%[ent]!\=\s\+\)\=colo\%[rscheme]\s'
        HandleColoLine(editcmd, curline)
        return
    endif

    if curline =~ '^\s*\%(:\s*\)\=import\s'
        HandleImportLine(editcmd, curline)
        return
    endif

    var curfunc = FindCurfunc()

    if stridx(curfunc, '#') >= 0
        var parts = split(curfunc, '#')
        var path = $"autoload/{join(parts[0 : -2], '/')}.vim"
        var resolved_path = globpath(&runtimepath, path, 1, 1)

        if !resolved_path->empty()
            var function_pattern: string = $'^\s*\%(:\s*\)\=fun\%[ction]!\=\s\+\zs{curfunc}('
            resolved_path->Open(editcmd, function_pattern)
        endif
        return
    endif

    try
        execute 'normal! ' .. editcmd
    catch
        Error(v:exception)
    endtry
enddef
#}}}1
# Core {{{1
def HandlePackaddLine(editcmd: string, curline: string) #{{{2
    var pat: string = '\s*\%(:\s*\)\=packadd!\=\s\+\zs\S\+\>\ze'
    var plugin: string = curline
        ->matchstr(pat)
        ->substitute('^vim-\|\.vim$', '', 'g')

    if plugin == ''
        Fallback(editcmd)
    else
        var files: list<string> = getcompletion($'plugin/{plugin}', 'runtime')
            ->map((_, fname: string) => fname->findfile(&rtp)->fnamemodify(':p'))
            ->filter((_, path: string): bool => filereadable(path))
        if empty(files)
            echo 'Could not find any plugin file for ' .. string(plugin)
            return
        endif
        files->Open(editcmd)
    endif
enddef

def HandleRuntimeLine(editcmd: string, curline: string, cfile: string) #{{{2
    var fname: string
    var where_pat: string = '\%(START\|OPT\|PACK\|ALL\)'

    if cfile == 'runtime' || cfile =~# $'^{where_pat}$'
        # then the cursor was not on one of the filenames, jump to the first file:
        var fname_pat: string = $'\s*\%(:\s*\)\=ru\%[ntime]\%(!\s*\|\s\+\)\%({where_pat}\s\+\)\=\zs\S\+\>\ze'
        fname = curline->matchstr(fname_pat)
    else
        fname = cfile
    endif

    if fname == ''
        Fallback(editcmd)
    else
        var file: string = fname
            ->findfile(&rtp)
            ->fnamemodify(':p')
        if file == '' || !filereadable(file)
            echo 'Could not be found in the runtimepath: ' .. string(fname)
            return
        endif
        file->Open(editcmd)
    endif
enddef

def HandleColoLine(editcmd: string, curline: string) #{{{2
    var pat: string = '\s*\%(:\s*\)\=colo\%[rscheme]\s\+\zs\S\+\>\ze'
    var colo: string = curline->matchstr(pat)

    if colo == ''
        Fallback(editcmd)
    else
        var files: list<string> = getcompletion($'colors/{colo}', 'runtime')
            ->map((_, fname: string) => fname->findfile(&rtp)->fnamemodify(':p'))
            ->filter((_, path: string): bool => filereadable(path))
        if empty(files)
            echo 'Could not find any colorscheme file for ' .. string(colo)
            return
        endif
        files->Open(editcmd)
    endif
enddef

def HandleImportLine(editcmd: string, curline: string) #{{{2
    var fname: string
    var import_cmd: string = '^\s*\%(:\s*\)\=import\s\+\%(autoload\s\+\)\='
    var import_alias: string = '\%(\s\+as\s\+\w\+\)\=$'
    var import_string: string = import_cmd .. '\([''"]\)\zs.*\ze\1' .. import_alias
    var import_expr: string = import_cmd .. '\zs.*\ze' .. import_alias
    # the script is referred to by its name in a quoted string
    if curline =~ import_string
        fname = curline->matchstr(import_string)
    # the script is referred to by an expression
    elseif curline =~ import_expr
        try
            sandbox fname = curline
                ->matchstr(import_expr)
                ->eval()
        catch
            Error(v:exception)
            return
        endtry
    endif

    var filepath: string
    if fname->isabsolutepath()
        filepath = fname
    elseif fname[0] == '.'
        filepath = (expand('%:h') .. '/' .. fname)->simplify()
    else
        var subdir: string = curline =~ '^\s*import\s\+autoload\>' ? 'autoload' : 'import'
        # Matching patterns in `'wildignore'` can be slow.
        # Let's set `{nosuf}` to `true` to avoid `globpath()` to be slow.
        filepath = globpath(&runtimepath, subdir .. '/' .. fname, true, true)
            ->get(0, '')
    endif

    if !filepath->filereadable()
        printf('E447: Can''t find file "%s" in path', fname)
            ->Error()
        return
    endif

    var how_to_split: string = {
        gF: 'edit',
        "\<C-W>F": 'split',
        "\<C-W>gF": 'tab split',
    }[editcmd]
    execute how_to_split .. ' ' .. fnameescape(filepath)
enddef

def Open(target: any, editcmd: string, search_pattern: string = '') #{{{2
    var split: string = editcmd[0] == 'g' ? 'edit' : editcmd[1] == 'g' ? 'tabedit' : 'split'
    var fname: string
    var cmd: string

    if target->typename() == 'list<string>'
        if target->empty()
            return
        endif
        fname = target[0]
    else
        if target->typename() != 'string'
            return
        endif
        fname = target
    endif

    if search_pattern != ''
        var escaped_pattern = escape(search_pattern, '\#'' ')
        cmd = $'+silent\ call\ search(''{escaped_pattern}'')'
    endif

    execute $'{split} {cmd} {fnameescape(fname)}'

    # If there are several files to open, put them into an arglist.
    if target->typename() == 'list<string>'
            && target->len() > 1
        var arglist: list<string> = target
            ->copy()
            ->map((_, f: string) => f->fnameescape())
        execute $'arglocal {arglist->join()}'
    endif
enddef
#}}}1
# Util {{{1
def Error(msg: string) #{{{2
    echohl ErrorMsg
    echomsg msg
    echohl NONE
enddef

def Fallback(editcmd: string) #{{{2
    try
        execute 'normal! ' .. editcmd .. 'zv'
    catch
        Error(v:exception)
    endtry
enddef

def FindCurfunc(): string #{{{2
    var curfunc = ''
    var saved_iskeyword = &iskeyword

    try
        set iskeyword+=#
        curfunc = expand('<cword>')
    finally
        &iskeyword = saved_iskeyword
    endtry

    return curfunc
enddef

# vim: sw=4 et
