Method bare_call_name

codegraph-kernel/src/dart.rs:940–1025

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

    // --- extractBareCall (dart.ts:305-379) --------------------------------

    fn bare_call_name(&self, node: Node<'t>) -> Option<String> {
        if node.kind() == "selector" {
            let mut cursor = node.walk();
            let has_arg_part = node.named_children(&mut cursor).any(|c| c.kind() == "argument_part");
            if !has_arg_part {
                return None;
            }
            let prev = node.prev_named_sibling()?;
            if prev.kind() == "identifier" {
                return Some(self.text(prev).to_string());
            }
            if prev.kind() == "selector" {
                let mut pc = prev.walk();
                let accessor = prev.named_children(&mut pc).find(|c| {
                    matches!(
                        c.kind(),
                        "unconditional_assignable_selector" | "conditional_assignable_selector"
                    )
                });
                if let Some(accessor) = accessor {
                    let mut ac = accessor.walk();
                    let method_id = accessor.named_children(&mut ac).find(|c| c.kind() == "identifier");
                    if let Some(method_id) = method_id {
                        let accessor_prev = prev.prev_named_sibling();
                        if let Some(ap) = accessor_prev {
                            if ap.kind() == "identifier" {
                                return Some(format!("{}.{}", self.text(ap), self.text(method_id)));
                            }
                            // Chained static-factory: the receiver is itself
                            // a call — re-encode `<inner>().<method>` when
                            // the chain starts capitalized (#750).
                            if ap.kind() == "selector" {
                                let mut apc = ap.walk();
                                if ap.named_children(&mut apc).any(|c| c.kind() == "argument_part") {
                                    if let Some(inner) = self.callee_of_arg_part(ap) {
                                        if starts_upper_re().is_match(&inner) {
                                            return Some(format!("{}().{}", inner, self.text(method_id)));
                                        }
                                    }
                                }
                            }
                        }
                        return Some(self.text(method_id).to_string());
                    }
                }
            }
            // super.method() / this.method(): prev is a bare accessor.
            if matches!(
                prev.kind(),
                "unconditional_assignable_selector" | "conditional_assignable_selector"
            ) {
                let mut pc = prev.walk();
                let id = prev.named_children(&mut pc).find(|c| c.kind() == "identifier");
                if let Some(id) = id {
                    return Some(self.text(id).to_string());
                }
            }
            return None;