icb_parser/

cpp_tree_sitter.rs

//! Lightweight C/C++ parser using [`tree-sitter-cpp`].
//!
//! This module provides a fast, zero‑dependency alternative to Clang for
//! extracting call‑graph facts from C and C++ source code.  It does not
//! perform semantic analysis (types, overload resolution); it only produces
//! syntactic nodes suitable for building a call graph.
//!
//! # Supported node kinds
//!
//! * `Function` – function definitions, declarations, and template
//!   instantiations,
//! * `Class` – class/struct/union/interface definitions, including
//!   template specialisations,
//! * `CallSite` – call expressions,
//! * `Variable` – variable declarations outside parameter lists,
//! * `Parameter` – parameter declarations inside parameter lists.
//!
//! # Class detection
//!
//! Unlike the original implementation, this version correctly reads the
//! `name` field of `class_specifier`, `struct_specifier` and
//! `interface_specifier` nodes, which contains the class name as a
//! `type_identifier` or `identifier`.  Template parameters are ignored.
//!
//! # Example
//!
//! ```rust
//! use icb_parser::cpp_tree_sitter::parse_cpp_file;
//!
//! let code = r#"
//!     template <typename T>
//!     class MyClass {
//!         void method() {}
//!     };
//! "#;
//! let facts = parse_cpp_file(code).unwrap();
//! assert!(facts.iter().any(|n| n.kind == icb_common::NodeKind::Class
//!     && n.name.as_deref() == Some("MyClass")));
//! ```

use icb_common::{IcbError, Language, NodeKind};
use tree_sitter::{Node, Parser};

use crate::facts::RawNode;

/// Parse a C/C++ source file and return a flat list of facts.
pub fn parse_cpp_file(source: &str) -> Result<Vec<RawNode>, IcbError> {
    let mut parser = Parser::new();
    parser
        .set_language(&tree_sitter_cpp::language())
        .map_err(|e| IcbError::Parse(format!("cannot set tree-sitter-cpp language: {e}")))?;

    let tree = parser
        .parse(source, None)
        .ok_or_else(|| IcbError::Parse("tree-sitter parse returned None".into()))?;

    let mut facts = Vec::new();
    traverse_node(tree.root_node(), source, &mut facts, None);
    Ok(facts)
}

fn traverse_node(
    node: Node,
    source: &str,
    facts: &mut Vec<RawNode>,
    parent_idx: Option<usize>,
) -> Option<usize> {
    let kind = node.kind();

    let (node_kind, name, is_container) = match kind {
        "function_definition" | "function_declaration" | "template_declaration" => {
            let name = function_name(node, source).unwrap_or_default();
            (NodeKind::Function, Some(name), true)
        }
        "class_specifier" | "struct_specifier" | "interface_specifier" | "union_specifier" => {
            let name = node
                .child_by_field_name("name")
                .map(|n| {
                    n.utf8_text(source.as_bytes())
                        .unwrap_or_default()
                        .to_string()
                })
                .unwrap_or_default();
            (NodeKind::Class, Some(name), true)
        }
        "call_expression" => {
            let name = node
                .child_by_field_name("function")
                .map(|n| {
                    n.utf8_text(source.as_bytes())
                        .unwrap_or_default()
                        .to_string()
                })
                .unwrap_or_default();
            (NodeKind::CallSite, Some(name), false)
        }
        "declaration" => {
            let name = node
                .child_by_field_name("declarator")
                .or_else(|| node.child_by_field_name("name"))
                .map(|n| {
                    n.utf8_text(source.as_bytes())
                        .unwrap_or_default()
                        .to_string()
                })
                .unwrap_or_default();
            if parent_kind_is(node, "parameter_list") {
                (NodeKind::Parameter, Some(name), false)
            } else {
                (NodeKind::Variable, Some(name), false)
            }
        }
        _ => {
            let mut current_parent = parent_idx;
            for child in node.children(&mut node.walk()) {
                current_parent = traverse_node(child, source, facts, current_parent);
            }
            return current_parent;
        }
    };

    let start = node.start_position();
    let end = node.end_position();

    let start_line = start.row + 1;
    let end_line = std::cmp::max(end.row + 1, start_line);

    let idx = facts.len();
    facts.push(RawNode {
        language: Language::CppTreeSitter,
        kind: node_kind,
        name,
        usr: None,
        start_line,
        start_col: start.column,
        end_line,
        end_col: end.column,
        children: Vec::new(),
        source_file: None,
    });

    debug_assert!(
        end_line >= start_line,
        "end_line {} must be >= start_line {}",
        end_line,
        start_line
    );

    if let Some(pidx) = parent_idx {
        facts[pidx].children.push(idx);
    }

    if is_container {
        let new_parent = Some(idx);
        let mut current_parent = new_parent;
        for child in node.children(&mut node.walk()) {
            current_parent = traverse_node(child, source, facts, current_parent);
        }
        new_parent
    } else {
        parent_idx
    }
}

/// Extract the function name from a function definition/declaration node.
fn function_name(node: Node, source: &str) -> Option<String> {
    if let Some(decl) = node.child_by_field_name("declarator") {
        if decl.kind() == "function_declarator" {
            if let Some(name_node) = decl.child_by_field_name("declarator") {
                return Some(name_node.utf8_text(source.as_bytes()).ok()?.to_string());
            }
            return Some(decl.utf8_text(source.as_bytes()).ok()?.to_string());
        }
        return Some(decl.utf8_text(source.as_bytes()).ok()?.to_string());
    }
    let mut cursor = node.walk();
    for child in node.children(&mut cursor) {
        if child.kind() == "identifier" {
            return child
                .utf8_text(source.as_bytes())
                .ok()
                .map(|s| s.to_string());
        }
    }
    None
}

/// Check whether the node's immediate parent has the expected kind.
fn parent_kind_is(node: Node, expected: &str) -> bool {
    node.parent().is_some_and(|p| p.kind() == expected)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn parse_simple_function() {
        let facts = parse_cpp_file("void foo() {}").unwrap();
        assert_eq!(facts.len(), 1);
        assert_eq!(facts[0].kind, NodeKind::Function);
        assert_eq!(facts[0].name.as_deref(), Some("foo"));
        assert!(facts[0].end_line >= facts[0].start_line);
    }

    #[test]
    fn parse_class() {
        let code = "class MyClass { void bar(); };";
        let facts = parse_cpp_file(code).unwrap();
        assert!(facts
            .iter()
            .any(|n| n.kind == NodeKind::Class && n.name.as_deref() == Some("MyClass")));
    }

    #[test]
    fn parse_template_class() {
        let code = "template <typename T> class Container { T value; };";
        let facts = parse_cpp_file(code).unwrap();
        assert!(facts
            .iter()
            .any(|n| n.kind == NodeKind::Class && n.name.as_deref() == Some("Container")));
    }

    #[test]
    fn parse_function_with_call() {
        let code = "void bar() {} void baz() { bar(); }";
        let facts = parse_cpp_file(code).unwrap();
        let calls: Vec<_> = facts
            .iter()
            .filter(|n| n.kind == NodeKind::CallSite)
            .collect();
        assert!(!calls.is_empty());
    }
}