How to remove virtual text (or trigger events.leave) when exiting insert mode

[cydmium]

I have been playing around with the virtual text on choice nodes, and I would like to be able to remove the virtual text when I leave insert mode. I am hoping to use this in conjunction with #258 (I would love a setting to toggle this somehow, but the workaround works) to effectively remove all traces of the snippet when I enter normal mode.

To accomplish this, my ideas so far are to somehow trigger the events.leave event within the leave_snippet autocommand described in #258, example below:

leave_snippet = function()
  if ... then
    ls.get_current_node():leave()  -- Not real code, but the idea of what I want to do
    ls.unlink_current()
  end
end

autocmd * ModeChanged "lua leave_snippet()"

Or, to allow a callback within the node_with_virtual_text on ModeChanged:

...
  callbacks = {
    [1] = {
      ...
      ["ModeChanged"] = function(nd)
        <remove virtual text>
      end
    }}

[L3MON4D3]

Using node:leave() should do it, but it might have side-effects (for example, if the content of the left node should be modified on leave)
Here's something that works, but consider it "unsupported" (I'll include something like it as ls.hide/show_extmarks in some time, I'm not sure yet if a simple hide/show_extmarks really is what we want here (as opposed to some abstraction one could do more with))

vim.api.nvim_create_autocmd("InsertLeave", {
	callback = function()
		local active_node = ls.session.current_nodes[1]
		if not active_node then
			return
		end
		local snippet = active_node.parent.snippet
		snippet:set_ext_opts("snippet_passive")
		snippet.mark:update_opts(snippet.ext_opts.snippet_passive)
	end
})

vim.api.nvim_create_autocmd("InsertEnter", {
	callback = function()
		local active_node = ls.session.current_nodes[1]
		if not active_node then
			return
		end
		local snippet = active_node.parent.snippet
		snippet:set_ext_opts("passive")
		local nodes_between = require("luasnip.nodes.util").get_nodes_between(snippet, active_node.absolute_position)
		for _, node in ipairs(nodes_between) do
			node.mark:update_opts(node.ext_opts.active)
		end
	end
})

(I did get some errors initially, but can't reproduce them now. If you do, please post them)

[cydmium]

The autocommands don't seem to be doing anything on my end. They are definitely being called though; confirmed through adding print statements. Based on the way the virtual text is being added in virtual text on choice nodes, my understanding is the only way to remove it is either triggering the leave event, or obtaining the node.virt_text_id. This may be due to my inexperience with lua, but I have no idea how to call the node:leave() on the current node. Using active_node:leave() just says it cannot call a nil value.

Your autocommands did inspire a workaround to search backwards through the node.parent to find any instances of virt_text_id and delete them manually, see below:

leave_snippet = function()
  local active_node = ls.session.current_nodes[api.nvim_get_current_buf()]
  if ((vim.v.event.old_mode == "s" and vim.v.event.new_mode == "n") or
      vim.v.event.old_mode == "i") and active_node and not ls.session.jump_active then
    while active_node do
      if active_node.virt_text_id then
        api.nvim_buf_del_extmark(0, ls.session.ns_id, active_node.virt_text_id)
        -- break -- If you know there will only ever be a single instance of virtual text
      end
      active_node = active_node.parent
    end
    ls.unlink_current()
  end
end

local snippet_augroup = api.nvim_create_augroup("snippets", {clear = true})
api.nvim_create_autocmd({"ModeChanged"}, {
  pattern = {"*"},
  command = "lua leave_snippet()",
  group = snippet_augroup
})

This seems to work in all situations I've encountered except with restore nodes. However, if the restore node is wrapped in a snippet node it seems to work fine. It also incorporates the unlinking when leaving insert mode from #258.

[L3MON4D3]

I think I misunderstood what you're trying to do; could you show the snippet you want to use this with?
The autocommands should remove anyarks set by luasnip via node_ext_opts, or any ext_opts-setting

[cydmium]

Yes, I'm happy to explain as much as I can. I am using the choice text node defined in the cool-snippets wiki page. I'm not familiar with extmarks, other than I imagine it is an extension of vim's original marking system. But, if you think that might be a good replacement for the virtual text example on the wiki, I'd be happy to play around with it some (just need some direction to find out more about how they work). To keep this thread self-contained, I have included the code to create the choice text node from the wiki below:

local ls = require "luasnip"

local function node_with_virtual_text(pos, node, text)
  local nodes
  if node.type == types.textNode then
    node.pos = 2
    nodes = {i(1), node}
  else
    node.pos = 1
    nodes = {node}
  end
  return sn(pos, nodes, {
    callbacks = {
      -- node has pos 1 inside the snippetNode.
      [1] = {
        [events.enter] = function(nd)
          -- node_pos: {line, column}
          local node_pos = nd.mark:pos_begin()
          -- reuse luasnips namespace, column doesn't matter, just 0 it.
          nd.virt_text_id = vim.api.nvim_buf_set_extmark(0, ls.session.ns_id,
                                                         node_pos[1], 0, {
            virt_text = {{text, "GruvboxOrange"}}
          })
        end,
        [events.leave] = function(nd)
          vim.api.nvim_buf_del_extmark(0, ls.session.ns_id, nd.virt_text_id)
        end
      }
    }
  })
end

local function nodes_with_virtual_text(nodes, opts)
  if opts == nil then
    opts = {}
  end
  local new_nodes = {}
  for pos, node in ipairs(nodes) do
    if opts.texts[pos] ~= nil then
      node = node_with_virtual_text(pos, node, opts.texts[pos])
    end
    table.insert(new_nodes, node)
  end
  return new_nodes
end

local function choice_text_node(pos, choices, opts)
  choices = nodes_with_virtual_text(choices, opts)
  return c(pos, choices, opts)
end

local ct = choice_text_node

To demonstrate what I am describing in a simple case consider the following snippet:

s("test", ct(1, {t("1"), t("2")}, {texts={"(in choice 1)", "(in choice 2)"}}))

This snippet will expand to 1 while showing (in choice 1) via virtual text and can be swapped to 2 while showing (in choice 2) via virtual text.
My desired behavior is that on hitting esc, regardless of whether I'm in insert or select mode the virtual text should disappear. It is possible to basically kill the snippet via ls.unlink_current() (#258), but that does not leave the current node; therefore the virtual text hangs around. My current solution combines #258 with searching back through the active nodes and its parents to find the node with the virtual text associated with it.

The workaround I posted above (#480 (reply in thread)) will work for the example snippet above, but it will break with restore nodes. Here is an example where the virtual text is not removed by hitting esc, but is removed by leaving the snippet "correctly" via a jump

s("test", ct(1, {r(1, "1", i(nil, "Test 1")), r(1, "1", i(nil, "test 2"))}, {texts={"(in choice 1)", "(in choice 2)"}}))

This can be fixed by wrapping the restore nodes in snippet nodes, but I have no idea why that fixes anything.

Finally, in case you are interested, the snippet I am actually making, that is causing all this is:

local docstring = function(args)
  local arg_list = args[1][1]
  -- Remove any occurances of self from list
  arg_list = arg_list:gsub("self,", "")
  -- Remove -> from return type hint
  local return_type = args[2][1]:gsub(" %-> ", "")

  -- Create Full Description Choice
  local full_desc = {}
  table.insert(full_desc, t("\t" .. [[""" ]]))
  table.insert(full_desc, r(1, "description", i(nil)))
  table.insert(full_desc, t({"", "", "\tParameters", "\t----------", ""}))
  local insert_index = 2
  -- Loop through function arguments
  for str in string.gmatch(arg_list, "([^" .. "," .. "]+)") do
    -- Remove all spaces from argument
    str = str:gsub("%s+", "")
    -- If argument has a type hint, just use that
    if not str:find(":") then
      table.insert(full_desc, t("\t" .. str .. ": "))
      table.insert(full_desc, i(insert_index, "Type"))
      insert_index = insert_index + 1
    else
      -- Replace : with ": " for better formatting
      str = str:gsub(":", ": ")
      table.insert(full_desc, t("\t" .. str))
    end
    table.insert(full_desc, t({"", "\t\t"}))
    table.insert(full_desc, i(insert_index, "Argument Description"))
    insert_index = insert_index + 1
    table.insert(full_desc, t({"", ""}))
  end
  table.insert(full_desc, t({"", "\tReturns", "\t-------", ""}))
  -- If return type is provided, insert it; otherwise, ask
  if return_type ~= "" then
    table.insert(full_desc, t({"\t" .. return_type .. ":", "\t\t"}))
  else
    table.insert(full_desc, t("\t"))
  end
  table.insert(full_desc, i(insert_index))
  insert_index = insert_index + 1
  table.insert(full_desc, t({"", "\t" .. [["""]]}))
  local full_desc_node = sn(nil, full_desc)

  -- Create Short Description Choice
  local short_desc = {}
  table.insert(short_desc, t("\t" .. [[""" ]]))
  table.insert(short_desc, r(1, "description", i(nil)))
  table.insert(short_desc, t([[ """]]))
  local short_desc_node = sn(nil, short_desc)

  return sn(nil, ct(1, {full_desc_node, short_desc_node, t("")}, {
    texts = {"(full docstring)", "(single line docstring)", "(no docstring)"}
  }))
end

local func_body = function(args)
  local docstring = args[1][1]
  local nodes = {}
  if docstring == "" then
    table.insert(nodes, t("\t"))
  else
    table.insert(nodes, t({"", "\t"}))
  end
  table.insert(nodes, r(1, "function_definition", i(nil, "pass")))
  return sn(nil, nodes)
end

s("d", fmt([[
          def {func}({args}){ret}:
          {doc}{body}
        ]], {
  func = i(1, "my_function"),
  args = ct(2, {
    sn(nil, {r(1, "arguments", i(nil, "arg1"))}),
    sn(nil, {t("self, "), r(1, "arguments", i(nil, "arg1"))})
  }, {texts = {"(function)", "(method)"}}),
  ret = ct(3, {t(""), sn(nil, {t(" -> "), i(1)})},
           {texts = {"(no return type)", "(return type)"}}),
  doc = d(4, docstring, {2, 3}),
  body = d(5, func_body, {4})
}))

Sorry for the long response, I just want to try to clarify as best I can. Hopefully this is helpful in understanding. I want to say thanks for making such a great, and powerful plugin. If it wasn't so useful I wouldn't be digging into it this much to do so much cool stuff.

[L3MON4D3]

Thanks for being so detailed, that made it pretty clear 👍

What is described in the wiki needs updating, it is possible to give nodes virtual text in a more regular way, check this doc-entry. (:h extmark gives a brief overview, for all the options that can be passed to ext_opts, see the opts-parameter of nvim_buf_set_extmark)
As for why walking through the nodes with parent does not work, restoreNodes are invisible to their children, the children are supposed to behave as if they were at the restoreNodes position inside the snippet (though this does not apply to the insert_position) (so a restoreNodes child has the restoreNodes parent as their parent).

Also thank you for the kind words, I love to see luasnip used to its full potential :D