Method extract_call

codegraph-kernel/src/scala.rs:849–925

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

    // --- extractCall (:3684) ----------------------------------------------

    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 Some(func) = func else { return };

        let mut callee: Option<String> = None;
        if func.kind() == "field_expression" {
            // Member branch (:4364): property = `field` field for scala.
            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));
                if let Some(receiver) = receiver {
                    if is_literal_receiver(receiver.kind()) {
                        return; // literal receivers emit NOTHING (#1230)
                    }
                    if matches!(receiver.kind(), "identifier" | "simple_identifier" | "field_identifier") {
                        let recv_name = self.text(receiver);
                        if matches!(recv_name, "self" | "this" | "cls" | "super") {
                            callee = Some(method_name.to_string());
                        } else {
                            callee = Some(format!("{recv_name}.{method_name}"));
                        }
                    } else if receiver.kind() == "call_expression" {
                        // The #750 re-encode, scala arm (:4443-4464): inner
                        // callee via the REAL `function` field; re-encode only
                        // capitalized (companion-factory / apply) chains.
                        let inner_fn = receiver.child_by_field_name("function");
                        let inner_callee = inner_fn
                            .map(|f| {
                                let t = self.text(f).replace("->", ".");
                                ws_re().replace_all(&t, "").into_owned()
                            })
                            .unwrap_or_default();
                        let reencode = starts_upper_re().is_match(&inner_callee);
                        callee = Some(if reencode {
                            format!("{inner_callee}().{method_name}")
                        } else {
                            method_name.to_string()
                        });
                    } else {
                        callee = Some(method_name.to_string());
                    }
                } else {
                    callee = Some(method_name.to_string());
                }