Method normalize_fn_ref_value

codegraph-kernel/src/ruby.rs:881–932

normalizeValue for RUBY_SPEC: idTypes EMPTY (bare identifiers never qualify); `block_argument` is a transparent layer; specials are the `method(:sym)` call form and hook-DSL `simple_symbol`s.

(&mut self, v: Node<'t>, from: u32, depth: u32)

    /// qualify); `block_argument` is a transparent layer; specials are the
    /// `method(:sym)` call form and hook-DSL `simple_symbol`s.
    fn normalize_fn_ref_value(&mut self, v: Node<'t>, from: u32, depth: u32) {
        stack_guard!();
        if depth > 4 {
            return;
        }
        match v.kind() {
            "block_argument" => {
                for i in 0..v.named_child_count() {
                    if let Some(c) = v.named_child(i) {
                        self.normalize_fn_ref_value(c, from, depth + 1);
                    }
                }
            }
            "call" => {
                // `method(:target_cb)` — method field literally `method`, one
                // simple_symbol argument. Candidate = bare symbol name at the
                // SYMBOL node (gated at flush on defined-in-file ∪ imports).
                let Some(method) = v.child_by_field_name("method") else { return };
                if self.text(method) != "method" {
                    return;
                }
                let Some(args) = v.child_by_field_name("arguments") else { return };
                if args.named_child_count() != 1 {
                    return;
                }
                let Some(sym) = args.named_child(0) else { return };
                if sym.kind() != "simple_symbol" {
                    return;
                }
                let name = self.text(sym).strip_prefix(':').unwrap_or(self.text(sym));
                if !name.is_empty() {
                    self.push_fn_ref_cand(from, name, sym);
                }
            }
            "simple_symbol" => {
                // Hook-DSL symbols (`before_action :authenticate`) → class-
                // scoped `this.<sym>` candidates (always flushed).
                let Some(call) = ruby_enclosing_call(v) else { return };
                let Some(method) = call.child_by_field_name("method") else { return };
                if !is_ruby_hook_call(self.text(method)) {
                    return;
                }
                let sym = self.text(v).strip_prefix(':').unwrap_or(self.text(v));
                if !ruby_sym_re().is_match(sym) {
                    return;
                }
                let name = format!("this.{sym}");
                self.push_fn_ref_cand(from, &name, v);
            }
            _ => {}
        }
    }

    fn push_fn_ref_cand(&mut self, from: u32, name: &str, node: Node) {
        if name.is_empty() || is_stoplisted(name) {