Method extract_call

codegraph-kernel/src/ccpp/mod.rs:1209–1349

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

    // --- calls / instantiation ----------------------------------------------

    fn extract_call(&mut self, node: Node<'t>) {
        if self.stack.is_empty() {
            return;
        }
        let caller_row = self.top_row();
        let func = node
            .child_by_field_name("function")
            .or_else(|| node.named_child(0));
        let calls_kind = edge_kind_index("calls").unwrap();

        // C++ explicit operator call `a.operator+(b)` (#1247): the
        // operator_name hides in an ERROR child. (has_error() defers such
        // files to wasm, so this scan is a faithful no-op today.)
        if self.variant == Variant::Cpp {
            if let Some(func) = func {
                let mut operator_name = String::new();
                'err: for i in 0..node.named_child_count() {
                    let Some(child) = node.named_child(i) else { continue };
                    if child.kind() != "ERROR" {
                        continue;
                    }
                    for j in 0..child.named_child_count() {
                        if let Some(op) = child.named_child(j) {
                            if op.kind() == "operator_name" {
                                operator_name = self.text(op).to_string();
                                break 'err;
                            }
                        }
                    }
                }
                if !operator_name.is_empty() {
                    let sym = operator_name["operator".len()..].trim().to_string();
                    if symbolic_op_re().is_match(&sym) {
                        let compact: String = sym.chars().filter(|c| !c.is_whitespace()).collect();
                        operator_name = format!("operator{compact}");
                    }
                    let receiver = arrow_dot_no_ws(self.text(func));
                    if receiver != "this" && !operator_receiver_re().is_match(&receiver) {
                        return;
                    }
                    let callee = if receiver == "this" {
                        operator_name
                    } else {
                        format!("{receiver}.{operator_name}")
                    };
                    self.push_ref_at(caller_row, &callee, calls_kind, node);
                    return;
                }
            }
        }

        let mut callee_name = String::new();
        if let Some(func) = func {
            if func.kind() == "field_expression" {
                // `obj.method()` / `ptr->method()` — the `field` field.
                let property = func
                    .child_by_field_name("property")
                    .or_else(|| func.child_by_field_name("field"))