Method try_visit_hook

codegraph-kernel/src/ruby.rs:385–449

Returns true when the hook handled the node (mixin call or module). The DISPATCHER then runs scan_fn_ref_subtree on the handled subtree — the source of the module multiply-capture quirk (scan runs with the module already POPPED, so candidates re-attribute to the outer scope).

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

    /// the source of the module multiply-capture quirk (scan runs with the
    /// module already POPPED, so candidates re-attribute to the outer scope).
    fn try_visit_hook(&mut self, node: Node<'t>) -> bool {
        let kind = node.kind();
        if kind == "call" && node.child_by_field_name("receiver").is_none() {
            if let Some(method) = node.child_by_field_name("method") {
                if matches!(self.text(method), "include" | "extend" | "prepend") {
                    let args = node.child_by_field_name("arguments").or_else(|| {
                        (0..node.named_child_count())
                            .filter_map(|i| node.named_child(i))
                            .find(|c| c.kind() == "argument_list")
                    });
                    // (nodeStack is never empty — the file node is pushed.)
                    if let Some(args) = args {
                        let parent = self.top_row();
                        let implements = edge_kind_index("implements").unwrap();
                        let line = self.line_of(node);
                        let col = self.col_of(node);
                        for i in 0..args.named_child_count() {
                            let Some(arg) = args.named_child(i) else { continue };
                            // `Mod` is constant, `Foo::Bar` is scope_resolution;
                            // `extend self` / dynamic args are skipped. Unlike
                            // every other extraction ref, the hook sets
                            // `filePath: ctx.filePath` — flagged on the wire.
                            if matches!(arg.kind(), "constant" | "scope_resolution") {
                                let name_ref = self.arena.put(self.text(arg));
                                self.tables.push_ref_flagged(
                                    &RefRow {
                                        from_idx: parent,
                                        kind: implements,
                                        line,
                                        column: col,
                                        reference_name: name_ref,
                                        candidates: NONE_STR,
                                        from_id_str: NONE_STR,
                                    },
                                    REF_FLAG_FILE_PATH,
                                );
                            }
                        }
                        return true;
                    }
                    // no args node → hook declines (falls to extractImport → nothing)
                }
            }
        }

        if kind != "module" {
            return false;
        }
        let Some(name_node) = node.child_by_field_name("name") else { return false };
        // `module A::B` keeps the scope_resolution text verbatim as the name.
        let name = self.text(name_node).to_string();
        let Some(row) = self.create_node("module", &name, node, Extra::default()) else {
            return false;
        };
        self.stack.push(Scope { row, kind: "module", name });
        if let Some(body) = node.child_by_field_name("body") {
            for i in 0..body.named_child_count() {
                if let Some(c) = body.named_child(i) {