Method extract_function_name

atomic-semantic/src/parsers/cpp.rs:281–339

Extract the function name from a declarator node. Returns `(Option , is_scoped_method)`. For `ClassName::method`, returns the full qualified name.

(&self, declarator: &Node, source: &str)

    /// Returns `(Option<name>, is_scoped_method)`.
    /// For `ClassName::method`, returns the full qualified name.
    fn extract_function_name(&self, declarator: &Node, source: &str) -> (Option<String>, bool) {
        match declarator.kind() {
            "function_declarator" => {
                // The first child of function_declarator is the name or
                // a qualified_identifier / scoped identifier.
                if let Some(name_node) = declarator.child(0) {
                    match name_node.kind() {
                        "qualified_identifier" | "scoped_identifier" => {
                            let text = self.node_text(&name_node, source);
                            (Some(text), true)
                        }
                        "field_identifier" | "identifier" | "destructor_name" => {
                            let text = self.node_text(&name_node, source);
                            (Some(text), false)
                        }
                        "operator_name" => {
                            let text = self.node_text(&name_node, source);
                            (Some(text), false)
                        }
                        "template_function" => {
                            // template<> void foo<int>() — extract the inner name
                            if let Some(inner) = name_node.child(0) {
                                let text = self.node_text(&inner, source);
                                let scoped = text.contains("::");
                                (Some(text), scoped)
                            } else {
                                (None, false)
                            }
                        }
                        _ => {
                            let text = self.node_text(&name_node, source);
                            let scoped = text.contains("::");
                            (Some(text), scoped)
                        }
                    }
                } else {
                    (None, false)
                }
            }
            "reference_declarator" | "pointer_declarator" => {
                // e.g., `int &foo()` or `int *foo()` — unwrap to inner declarator
                if let Some(inner) = declarator.child(1).or_else(|| declarator.child(0)) {
                    self.extract_function_name(&inner, source)
                } else {
                    (None, false)
                }
            }
            _ => {
                // Try child_by_field_name for other wrapper nodes
                if let Some(inner) = declarator.child_by_field_name("declarator") {
                    self.extract_function_name(&inner, source)
                } else {
                    let text = self.node_text(declarator, source);
                    let scoped = text.contains("::");
                    (Some(text), scoped)
                }
            }
        }