LuaSnip Documentation

A dynamicNode can be updated in response to changes made to a node within itself. To implement this successfully:

1. Use an Optional Noderef: Wrap the internal node reference with opt() (e.g., opt(k("key"))). This is necessary because a dynamicNode will not update if its argument nodes are missing.
2. Set snippetstring_args: In the dynamicNode options, set snippetstring_args = true. This ensures that snippets expanded inside the dynamicNode are preserved during updates, preventing the loss of jump-points.
3. Use Unique Keys: Assign unique keys to nodes that trigger updates, or wrap them in a restoreNode, to prevent LuaSnip from losing the cursor position during an update.
4. Avoid Infinite Loops: Be careful with logic that replaces text with a version of itself that triggers another update (e.g., replacing "a" with "aa").

ls.snip_expand(s("trig", {
    d(1, function(args) 
        if not args[1] then
            return sn(nil, {i(1, "asdf", {key = "ins"})})
        else
            return sn(nil, {i(1, args[1]:gsub("a", "e"), {key = "ins"})})
        end
    end, {opt(k("ins"))}, { snippetstring_args = true })
}))

The treesitter_postfix helper allows you to trigger snippets based on Tree-sitter nodes that surround or precede the trigger. This is useful for transformations like wrapping an expression in a function call (e.g., std::move()).

You can define matching logic in two ways:

1. Using a Query: Provide a Tree-sitter query and a capture name.
2. Using a Function: Manually walk the node tree for maximum flexibility.

When a match is found, the text of the matched node is available in the snippet environment via snip.env.LS_TSMATCH (as a string array of lines).

local treesitter_postfix = require("luasnip.extras.treesitter_postfix").treesitter_postfix

treesitter_postfix({
    trig = ".mv",
    matchTSNode = {
        query = "[
            (call_expression)
            (identifier)
            (template_function)
            (subscript_expression)
            (field_expression)
            (user_defined_literal)
        ] @prefix",
        query_lang = "cpp"
    },
},{
    f(function(_, parent) 
        -- Use LS_TSMATCH to access the matched node text
        local node_content = table.concat(parent.snippet.env.LS_TSMATCH, '\n')
        local replaced_content = ("std::move(%s)"):format(node_content)
        return vim.split(replaced_content, "\n", { trimempty = false })
    end)
})

LuaSnip supports loading snippets from multiple formats using specialized loaders.

Loader Interface: require("luasnip.loaders.from_{vscode,snipmate,lua}").{lazy_,}load(opts)

Options (opts):

• paths: List of paths or a comma-separated string. If omitted, runtimepath is searched (looking for luasnippets for Lua, snippets for SnipMate, or package.json for VSCode).
• lazy_paths: Similar to paths, but paths are loaded on creation and do not default to runtimepath if nil.
• exclude: List of languages to exclude.
• include: List of languages to include.
• {override,default}_priority: Priority for snippet loading.
• fs_event_providers: Mechanisms to watch for file updates. Use autocmd (default) or libuv (for cross-instance updates).

Loading Modes:

• load(): Immediately loads snippets.
• lazy_load(): Defers loading until the filetype is encountered in a buffer.

Manual Reloading: To manually reload a specific file: require("luasnip.loaders").reload_file(path)

On-the-fly (OTF) snippets allow you to quickly expand text from a register as a snippet. This is useful for repetitive tasks where you don't want to define a permanent snippet.

Syntax

• $anytext: A placeholder (insertNode) with the text "anytext". The text acts as a unique key; multiple placeholders with the same key will mirror the first one.
• $$: Escapes the $ symbol.

Expansion

Use require('luasnip.extras.otf').on_the_fly("<register>") to interpret the contents of a specific register as a snippet and expand it immediately. If no register is provided, it defaults to the unnamed register.

Example Keybindings (Vim/Neovim)

" Expand from the 'e' register
vnoremap <c-f>  "ec<cmd>lua require('luasnip.extras.otf').on_the_fly("e")<cr>
inoremap <c-f>  <cmd>lua require('luasnip.extras.otf').on_the_fly("e")<cr>

" Expand from register 'a'
vnoremap <c-f>a  "ac<cmd>lua require('luasnip.extras.otf').on_the_fly()<cr>
inoremap <c-f>a  <cmd>lua require('luasnip.extras.otf').on_the_fly("a")<cr>