Method extract_call

codegraph-kernel/src/java.rs:826–892

extractCall — the Java method_invocation paths.

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

    /// extractCall — the Java method_invocation paths.
    fn extract_call(&mut self, node: Node<'t>) {
        if self.stack.is_empty() {
            return;
        }
        let caller = self.top_row();
        let name_field = node.child_by_field_name("name");
        let object_field = node
            .child_by_field_name("object")
            .or_else(|| node.child_by_field_name("scope"));

        let mut callee_name = String::new();
        if let (Some(name_field), Some(object_field)) = (name_field, object_field) {
            let method_name = self.text(name_field);

            // Static-factory / fluent chain: `Foo.getInstance().bar()` →
            // `<inner-receiver>.<inner-method>().<method>` (#645/#608).
            if !method_name.is_empty() && object_field.kind() == "method_invocation" {
                let inner_obj = object_field.child_by_field_name("object");
                let inner_name = object_field.child_by_field_name("name");
                if let (Some(io), Some(inm)) = (inner_obj, inner_name) {
                    let callee = format!("{}.{}().{}", self.text(io), self.text(inm), method_name);
                    self.push_ref_at(caller, &callee, edge_kind_index("calls").unwrap(), node);
                    return;
                }
            }

            // `this.userbo.toLogin2()` — unwrap the field after `this.`.
            let receiver_name = if object_field.kind() == "field_access" {
                let inner = object_field.child_by_field_name("object");
                let fld = object_field.child_by_field_name("field");
                match (inner, fld) {
                    (Some(inner), Some(fld))
                        if matches!(inner.kind(), "this" | "this_expression") =>
                    {
                        self.text(fld).to_string()
                    }
                    _ => self.text(object_field).to_string(),
                }
            } else {
                self.text(object_field).to_string()
            };
            let receiver_name = receiver_name.strip_prefix('$').unwrap_or(&receiver_name);

            if !method_name.is_empty() {
                if matches!(receiver_name, "self" | "this" | "cls" | "super" | "parent" | "static") {
                    callee_name = method_name.to_string();
                } else {
                    callee_name = format!("{receiver_name}.{method_name}");
                }
            }
        } else {
            // Bare call `foo()` — the generic tail: function field ?? first child.
            let func = node
                .child_by_field_name("function")
                .or_else(|| node.named_child(0));
            if let Some(func) = func {
                callee_name = self.text(func).to_string();
            }