Method maybe_capture_fn_refs

codegraph-kernel/src/lua.rs:686–748

(&mut self, node: Node<'t>)

    // --- function-as-value capture (#756) — LUA_SPEC ----------------------

    fn maybe_capture_fn_refs(&mut self, node: Node<'t>) {
        // LUA_SPEC dispatch: arguments → args; assignment_statement → rhs
        // (no field — last named child; param-storage skip via namedChild(0));
        // field → value (field 'value', last-named-child fallback).
        let mode: &str = match node.kind() {
            "arguments" => "args",
            "assignment_statement" => "rhs",
            "field" => "value",
            _ => return,
        };
        if self.stack.is_empty() {
            return;
        }
        let from = self.top_row();

        let mut values: Vec<Node<'t>> = Vec::new();
        match mode {
            "args" => {
                let mut cursor = node.walk();
                for c in node.named_children(&mut cursor) {
                    values.push(c);
                }
            }
            "rhs" => {
                // No `field` in the rule → RHS = LAST named child (the
                // expression_list). Param-storage skip: lhs =
                // left/lhs/target field ?? namedChild(0) when ≥2 children;
                // its trailing identifier vs the whole RHS text.
                let count = node.named_child_count();
                let rhs = if count > 0 { node.named_child(count - 1) } else { None };
                if let Some(rhs) = rhs {
                    let lhs = node
                        .child_by_field_name("left")
                        .or_else(|| node.child_by_field_name("lhs"))
                        .or_else(|| node.child_by_field_name("target"))
                        .or_else(|| if count >= 2 { node.named_child(0) } else { None });
                    let lhs_text = lhs.map(|l| self.text(l)).unwrap_or("");
                    let lhs_last = util::lhs_last_name()
                        .captures(lhs_text)
                        .and_then(|c| c.get(1))
                        .map(|m| m.as_str());
                    if !(lhs_last.is_some() && lhs_last == Some(self.text(rhs).trim())) {
                        values.push(rhs);
                    }
                }
            }
            _ => {
                // value — the `value` field (keyed AND positional table
                // fields carry it), falling back to the last named child.
                let v = node.child_by_field_name("value").or_else(|| {
                    let count = node.named_child_count();
                    if count > 0 { node.named_child(count - 1) } else { None }
                });
                if let Some(v) = v {
                    values.push(v);
                }
            }
        }