How to copy content of nodes in recursive calls?

[medwatt]

I am trying to write a snippet that generates ternary statements of any depth.

For example, a depth of 1:

condition ? value_if_true : value_if_false

A depth of 2:

condition_2 ? (condition_1 ? value_if_true : value_if_false)
            : (condition_1 ? value_if_true : value_if_false)

The difficulty I am facing is not in generating the structure, but in using the repeat node. What I mean is, the user only has to change condition_1 once and this should propagate to all other condition_1.

I tried doing this, but I haven't been able to get it to work. The code below works for the case of a depth of 2, but not reports an error for anything larger.

E5108: Error executing lua: ...local/share/nvim/lazy/LuaSnip/lua/luasnip/nodes/node.lua:424: attempt to index field 'effective_child_ext_opts' (a nil value)

local function condition_nodes (depth)
    local T = {}
    for level = 1, depth do
        table.insert(T, i(1, "condition_" .. tostring(level), {key = "k" .. tostring(level)}))
    end
    return T
end

local function generate_ternary (condition_nodes, current_depth, node_index, child_index, condition_node)
    if current_depth <= 1 then
        local child_index = child_index or 2
        return sn(node_index, fmt("{} ? {} : {}", {
                condition_node or i(1, "condition"),
                i(child_index, "value_if_true"),
                i(child_index + 1, "value_if_false")
            })
        )
    else
        local child_index = current_depth - 1
        local key_string = "k" .. tostring(child_index)
        local child_condition_node = condition_nodes[child_index]
        return isn(node_index, fmt([[
            {} ? ({})
            : ({})
            ]], {
                i(1, "condition_" .. tostring(current_depth)),
                generate_ternary(condition_nodes, current_depth - 1, 2, 2, child_condition_node), -- Recursive call for true case
                generate_ternary(condition_nodes, current_depth - 1, 3, 1, f(function(args) return args[1] end, k(key_string))),  -- Recursive call for false case
            }), "$PARENT_INDENT" .. string.rep("\t", 3))
    end
end

return {
    s(
        { trig = "ternary(%d*)", regTrig = true, dscr = "SystemVerilog ternary operator"},
        d(1, function(_, snip)
            local depth = tonumber(snip.captures[1]) or 1
            return generate_ternary(condition_nodes(depth), depth, nil)
        end, {}),
        { condition = line_begin }
    ),
}

[L3MON4D3]

Hey!
Nice idea, I think the issue is simply that the nodes in condition_nodes are reused, replacing

local child_condition_node = condition_nodes[child_index]

with

local child_condition_node = vim.deepcopy(condition_nodes[child_index])

makes it work on my end :)
(although, I think the better solution is to just generate the node there :D)

[medwatt]

Thanks for your answer. While this causes the code to run, it doesn't result in the codes repeating, which is the goal of the snippet.

[L3MON4D3]

Ahh I see... so all condition nodes at eg. level 1 should always contain the same text?
You'd have to make sure to return an insertNode the first time condition_nodes[child_index] is accessed, and then always return a functionNode that copies from that insertNode... maybe make condition_nodes a function that checks if it's been called already with that i, and then return the appropriate node?