[Qustion] How to get correct current node position using `get_buf_position` in nested snippets?

[Bekaboo]

Question:
I want to map <Tab> in such a way that it performs jump(1)only when the cursor is at the end of the current snippet node, take the following snippet as an example:

s({ trig = '//' }, { t '\\frac{', i(1), t '}{', i(2), t '}' })

what it looks like after expanding the snippet and inserting some text in i(1):

\frac{abcd + (abcd|)}{}

where | indicates the position of the cursor.

In the situation shown above, pressing <Tab> will not trigger jump(1) but instead calls a "fallback" function. The fallback function will, for example, moves the cursor out of the brackets if possible, like this:

\frac{abcd + (abcd)|}{}

now pressing <Tab> will trigger jump(1) since the cursor is at the end of current node:

\frac{abcd + (abcd)}{|}

---

I (kind of) achieved this with the following config (I manage the behavior of <Tab> in nvim-cmp config):

local cmp = require('cmp')
local luasnip = require('luasnip')
cmp.setup({
    -- ....
    mapping = {
        ['<Tab>'] = cmp.mapping(function(fallback)
          if vim.fn.mode() == 'i' then
            if luasnip.expandable() then
              luasnip.expand()
            elseif luasnip.jumpable(1) then
              local session = require('luasnip.session')
              local current = session.current_nodes[vim.api.nvim_get_current_buf()]
              local _, current_end = current:get_buf_position()
              current_end[1] = current_end[1] + 1 -- (1, 0) indexed
              local cursor = vim.api.nvim_win_get_cursor(0)
              vim.notify('current_end: ' .. vim.inspect(current_end) .. ' cursor: ' .. vim.inspect(cursor))
              if current_end[1] == cursor[1] and current_end[2] == cursor[2] then
                luasnip.jump(1)
              else
                fallback()
              end
            else
              fallback()
            end
          end
        end, { 'i', 'c' }),
    }
    -- ....
})

the notify in the mapping serves for debug purpose only.

The problem is, when I'm inside a nested node, i.e. a snippet triggered inside another snippet, the position of
the end of the current node I get is incorrect. For instance, assume we have another snippet:

s({ trig = '**' }, { t '\\cdot ' })

What it looks like after triggering this snippet inside the first snippet given above with some text inserted after:

\frac{abcd \cdot abcd|}{}

in this case, the current_end I get is the end of \cdot instead of the index before the closing curly braces, which is the end of the insert node.

here is a short video demonstrating the problem, notice the messages in the command line:

simplescreenrecorder-2023-01-27_11.11.16.mp4

Any help is appreciated!

[L3MON4D3]

AH, I think what's going on here is just how luasnip handles the exit-point of snippets.
Here, cdot actually looks like this: {t'\\cdot', i(0)}, and the i(0) is active (the current_node) at the moment you're triggering the jump, and you're getting its location, instead of the end of the insertNode of the surrounding snippet.

I'm not sure how you'd want to proceed here. The actual surrounding insertNode can be retrieved at i(0).next, maybe you want to do some detection-logic for this case?

Is the actual behaviour you want to avoid the spurious jumping-around when snippets are not completely "jumped through"? If yes, there are already some ways to handle this better, for example region_check_events or delete_check_events here

[Bekaboo]

Hi, thanks for your reply!

If i(0) is the current active node, what is the region it occupies in the buffer?

If i(0) contains all texts inserted after \cdot:

          <----i(1)------> (i(1) of frac snippet)
                     <---> (i(0) of cdot snippet)
    \frac{abcd \cdot abcd|}{}

then it should also gives the correct result.

Is the actual behaviour you want to avoid the spurious jumping-around when snippets are not completely "jumped through"? If yes, there are already some ways to handle this better, for example region_check_events or delete_check_events here

Yes exactly. Following your suggestion, I set region_check_events to 'CursorMoved,CursorMovedI,InsertEnter,CursorHold,CursorHoldI', but the problem is not solved.

[L3MON4D3]

If i(0) is the current active node, what is the region it occupies in the buffer?

Oh, nothing, it's completely empty. This is by design, since otherwise jumping into it would select all text after a finished snippet.

but the problem is not solved

Yeah, it's more of prevention-scheme, it'll just make this issue appear less often since the snippet is left as soon as the cursor is outside its region.
Another approach to this is leaving the snippet as soon as INSERT is left, via this

[Bekaboo]

Thanks. I come up with the following solution:

local ls = require('luasnip')
vim.api.nvim_create_autocmd('CursorMovedI', {
  pattern = '*',
  callback = function(ev)
    if not ls.session
        or not ls.session.current_nodes[ev.buf]
        or ls.session.jump_active
    then
      return
    end

    local current_node = ls.session.current_nodes[ev.buf]
    local current_start, current_end = current_node:get_buf_position()
    current_start[1] = current_start[1] + 1 -- (1, 0) indexed
    current_end[1] = current_end[1] + 1 -- (1, 0) indexed
    local cursor = vim.api.nvim_win_get_cursor(0)

    if cursor[1] < current_start[1]
      or cursor[1] > current_end[1]
      or cursor[2] < current_start[2]
      or cursor[2] > current_end[2]
    then
      ls.unlink_current()
    end
  end
})

It now works as expected

[L3MON4D3]

Beautiful 👌
I'll link it as an alternative version in the original thread, might come in handy for others too :D

[Parsifa1]

Why can't We make this beautiful snippet a default optional configuration?