Method extract_call

codegraph-kernel/src/tsjs/extractors.rs:1161–1245

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

    }

    pub(super) fn extract_call(&mut self, node: Node<'t>) {
        if self.stack.is_empty() {
            return;
        }
        let func = node
            .child_by_field_name("function")
            .or_else(|| node.named_child(0));
        let mut callee_name = String::new();

        if let Some(func) = func {
            if func.kind() == "member_expression" {
                let property = func
                    .child_by_field_name("property")
                    .or_else(|| func.child_by_field_name("field"))
                    .or_else(|| func.named_child(1));
                if let Some(property) = property {
                    let method_name = self.text(property);
                    let receiver = func
                        .child_by_field_name("object")
                        .or_else(|| func.child_by_field_name("operand"))
                        .or_else(|| func.child_by_field_name("argument"))
                        .or_else(|| func.named_child(0))
                        // Look through `(x)`, `x!`, `(x as T)`, `(await f())`
                        // (mirrors peelTsJsReceiver).
                        .map(peel_receiver);
                    // Literal receivers call builtins, never project symbols (#1230).
                    if let Some(r) = receiver {
                        if is_literal_receiver(r.kind()) {
                            return;
                        }
                    }
                    let recv_ident = receiver.filter(|r| {
                        matches!(r.kind(), "identifier" | "simple_identifier" | "field_identifier")
                    });
                    if let Some(r) = recv_ident {
                        let receiver_name = self.text(r);
                        if !matches!(receiver_name, "self" | "this" | "cls" | "super") {
                            callee_name = format!("{receiver_name}.{method_name}");
                        } else {
                            callee_name = method_name.to_string();
                        }
                    } else if receiver.is_some_and(|r| self.is_unresolved_member_chain(r)) {
                        // Retain the call site for effects without guessing a
                        // project method. Mirrors the TS extraction path.
                        let chain = self.text(func).replace("?.", ".");
                        let Some(chain) = Self::plain_member_name(&chain) else { return };
                        callee_name = chain;
                    } else if let Some(field) = receiver.and_then(|r| self.this_field_of(r)) {
                        // `this.<field>.<method>()` — keep the field so the
                        // resolver can read its declared type (#1496). Mirrors
                        // TreeSitterExtractor.extractCall.
                        callee_name = format!("this.{field}.{method_name}");
                    } else if let Some(r) = receiver.filter(|r| r.kind() == "call_expression") {
                        // Call receiver — `make().run()` (#1683): keep the inner
                        // callee as `<inner>().<method>`, or emit nothing when it
                        // is not a plain name / member chain. Mirrors
                        // TreeSitterExtractor.extractCall.
                        let Some(inner) = self.plain_inner_callee(r) else { return };