Sharing state between callbacks

[gbishop]

I've got a snippet that uses a couple of callbacks and a dynamic node to create jsdoc with types specified using typescript like syntax.

I need to pass state derived in the callbacks to the dynamic node. As a hack I simply added a key to the parent node table where I stored the shared state.

I'm wondering if there is some better way to pass state among different elements of a snip?

[L3MON4D3]

Oh, no, the only way to do that is storing stuff in the snippet (but I don't know what you mean with callbacks. FunctionNode?)

[gbishop]

I mean snippet callbacks.

I should have included my code. I'm just beginning to learn both lua and luasnips so any suggestions will be gladly accepted.

This snippet started with your javadoc demo and evolved to include specifying the types inline as in typescript. For example typing:

jf<RET><C-k>test<C-k>a:number, b:string<C-k>:string<C-k> produces

/**
 * A short Description
 * 
 * @param {string} a 
 * @param {number} b 
 * @returns {string} 
 */
function test(a, b) {
  
}

My goal is making it easy to create the jsdoc first rather than as an afterthought. This way I get the benefits of type checking from tsserver in my javascript code.

All that said, here is my code with the actual snippet down at the end.

local ls = require("luasnip")
local s = ls.snippet
local sn = ls.snippet_node
local t = ls.text_node
local i = ls.insert_node
local d = ls.dynamic_node
local r = ls.restore_node
local c = ls.choice_node
local l = require("luasnip.extras").lambda
local events = require("luasnip.util.events")

-- from https://github.com/L3MON4D3/LuaSnip/blob/master/Examples/snippets.lua#L81-L166
-- hacked up for javascript and jsdoc
local function jsdoc(_, parent)
	-- communication between functions uses the jsdoc key in the parent node
	-- if the jsdoc key isn't present add it
	if parent.jsdoc == nil then
		parent.jsdoc = { types = {}, parameters = {} }
	end
	-- these are filled in by the callbacks in the snippet
	local types = parent.jsdoc.types
	local parameters = parent.jsdoc.parameters

	-- build up the resulting snippet here
	local nodes = {
		t({ "/**", " * " }),
		r(1, "desc", i(1, "A short Description")),
		t({ "", "" }),
	}

	-- At least one param.
	if #parameters > 0 then
		vim.list_extend(nodes, { t({ " * ", "" }) })
	end

	local insert = 2

	for pindex = 1, #parameters do
		local parameter = parameters[pindex]
		local type = types[parameter]
		local inode
		if #type > 0 then
			inode = t(type)
		else
			inode = i(insert, "any")
			insert = insert + 1
		end
		vim.list_extend(nodes, {
			t({ " * @param {" }),
			inode,
			t({ "} " .. parameter .. " ", "" }),
		})
	end

	local returns = types["returns"] or ""
	if #returns > 0 then
		vim.list_extend(nodes, {
			t({ " * @returns {" }),
			t({ returns }),
			t({ "} ", "" }),
		})
	end
	vim.list_extend(nodes, { t({ " */" }) })

	local snip = sn(nil, nodes)
	return snip
end

-- parse a type declaration
-- a:number
-- a:number[]
-- complicated types can be written like ::type here:: and the whole thing will be used
-- a::Map<string,string>::
local function parseType(string, start)
	local patterns = {
		"^::(.-)::", -- everything complicated goes here
		"^:(%w+%[%])", -- arrays of simple types are here
		"^:(%w+)", -- simple types
	}

	for index = 1, #patterns do
		local _, tend, type = string.find(string, patterns[index], start)
		if type ~= nil then
			return type, tend + 1
		end
	end
	return "", start -- didn't find a type
end

local function parseParameters(node)
	local types = node.parent.jsdoc.types
	local parameterstring = table.concat(node:get_text(), "\n")
	local index = 1
	local parameters = {}
	while index < #parameterstring do
		local _, aend, parameter =
			string.find(parameterstring, "%s*(%w+)%s*", index)
		if parameter ~= nil then
			index = aend + 1
			local type, nextindex = parseType(parameterstring, index)
			if type ~= "" or types[parameter] == nil then
				types[parameter] = type
			end
			table.insert(parameters, parameter)
			index = nextindex
		end
		if string.match(parameterstring, ",", index) ~= nil then
			index = index + 1
		end
	end

	-- pass the parameters to jsdoc through our parent
	node.parent.jsdoc.parameters = parameters

	-- rewrite the parameters
	local from_pos, to_pos = node.mark:pos_begin_end_raw()
	vim.api.nvim_buf_set_text(
		0,
		from_pos[1],
		from_pos[2],
		to_pos[1],
		to_pos[2],
		{ table.concat(parameters, ", ") }
	)
end

local function parseReturns(node)
	local rstring = table.concat(node:get_text(), "\n")
	local type = parseType(rstring, 1)
	local types = node.parent.jsdoc.types
	types["returns"] = type
	-- rewrite the returns
	local from_pos, to_pos = node.mark:pos_begin_end_raw()
	vim.api.nvim_buf_set_text(
		0,
		from_pos[1],
		from_pos[2],
		to_pos[1],
		to_pos[2],
		{ "" }
	)
end

return {
	-- function with jsdoc
	s("jfunction", {
		d(5, jsdoc, { 3, 4 }), -- generate the jsdoc
		t({ "", "" }),
		c(1, { -- choose function or method
			t({ "function " }),
			t({ "" }),
		}),
		i(2, "myfunc"), -- give it a name
		t("("),
		i(3), -- parameters
		t(")"),
		i(4, " "), -- return type
		t({ " {", "\t" }),
		i(0), -- body
		t({ "", "}" }),
	}, {
		callbacks = {
			[3] = { -- parameters
				[events.leave] = parseParameters,
			},
			[4] = { -- return type
				[events.leave] = parseReturns,
			},
		},
	}),
)

[L3MON4D3]

Ahhh those callbacks😅😅
Yeah, just storing it in a dedicated table in the parent-node/snippet is the only way to share results between those functions.
I'd like to note though, this is a bit dangerous(could break in the future) since it relies on the leave-callback being run before the function of the dynamicNode, I don't think this is currently guaranteed (maybe we should do it though, there's no way to get your desired behaviour, reliably otherwise)

[gbishop]

Yes, I wondered about the call order. I could do it all in the the dynamicNode function if I could figure out how to find the other nodes so I could rewrite their content. I poked around in a dump of the parent and couldn't find my way.

I need to rewrite two nodes and it is easy enough if I can find them. Is there a reliable method for finding the nodes in my snippet? Maybe absolute indexer?

[L3MON4D3]

Right!
You can use node:resolve_position(i) to resolve the i-th node of node. What exactly i-th means depends on node (absolute_indexer uses this behind the scenes, so take a look at its doc for the definition of i-th for the different nodes) (in your snippet, parent_of_dynamicnode:resolve_position(3/4) would be the parameters/return-type)

I'll consider adding a nice interface to this, probably compatible with absolute_indexer, then something like this can be done a bit more reliably.

Whoops, I didn't check thoroughly, resolve_position is not compatible with absolute_indexer (it uses the "textual position" (or just position I guess) as opposed to jump-index in snippetNodes), so there's no good general solution for getting the position via absolute_indexer.
For this case though, you can just use parent_of_dynamicnode.insert_nodes[3/4]

[gbishop]

Thanks! This is a great plugin and your level of support is way beyond what anyone could expect.

[L3MON4D3]

Thank you!
Have fun writing snippets :)