fix(native/cpp): strip reference modifier from parameter names (#1192)

* fix(native/cpp): strip reference modifier from parameter names

tree-sitter-cpp's `reference_declarator` rule (covering `&` and `&&`)
doesn't expose a `declarator` field, so `child_by_field_name("declarator")`
returns None and `unwrap_cpp_declarator` falls through to emitting the full
node text (`& action`). Native C++ parameter nodes ended up named
`& action` while WASM emitted `action`, producing divergent `contains` and
`parameter_of` edges across engines.

Fall back to scanning children for the next nested declarator or identifier
when the field lookup misses. Covers lvalue (`int& x`) and rvalue
(`int&& x`) references, and applies transitively to fields, type-map entries,
and function-name extraction since they all route through the helper.

Closes #1187

* fix(native/cpp): drop function_declarator from declarator-child fallback (#1192)

unwrap_cpp_declarator's main loop has no arm for function_declarator, so
including it in next_cpp_declarator_child's match list stalls the loop
on a node it cannot unwrap and emits the full node text (e.g.
`callback(int)` instead of `callback`) for exotic parameter types like
`void (&callback)(int)`. Removing it lets the loop break cleanly and
fall back to node_text without the extra detour through a node kind it
does not handle.

Author: carlos-alm

crates/codegraph-core/src/extractors/cpp.rs

@@ -71,7 +71,14 @@ fn unwrap_cpp_declarator(node: &Node, source: &[u8]) -> String {
         match current.kind() {
             "pointer_declarator" | "reference_declarator" | "array_declarator"
             | "parenthesized_declarator" => {
-                if let Some(inner) = current.child_by_field_name("declarator") {
+                // tree-sitter-cpp's `reference_declarator` rule does not expose a
+                // `declarator` field, so `child_by_field_name` returns None and
+                // the full node text (`& name`) leaks out. Fall back to scanning
+                // children for the next nested declarator or identifier.
+                let inner = current
+                    .child_by_field_name("declarator")
+                    .or_else(|| next_cpp_declarator_child(&current));
+                if let Some(inner) = inner {
                     current = inner;
                 } else {
                     break;
@@ -84,6 +91,23 @@ fn unwrap_cpp_declarator(node: &Node, source: &[u8]) -> String {
     node_text(&current, source).to_string()
 }
 
+fn next_cpp_declarator_child<'a>(node: &Node<'a>) -> Option<Node<'a>> {
+    for i in 0..node.child_count() {
+        if let Some(child) = node.child(i) {
+            match child.kind() {
+                "identifier"
+                | "field_identifier"
+                | "pointer_declarator"
+                | "reference_declarator"
+                | "array_declarator"
+                | "parenthesized_declarator" => return Some(child),
+                _ => {}
+            }
+        }
+    }
+    None
+}
+
 fn extract_cpp_function_name(node: &Node, source: &[u8]) -> Option<String> {
     let declarator = node.child_by_field_name("declarator")?;
     extract_cpp_func_name_from_declarator(&declarator, source)
@@ -433,4 +457,26 @@ mod tests {
         assert_eq!(s.imports.len(), 2);
         assert!(s.imports[0].c_include.unwrap());
     }
+
+    #[test]
+    fn reference_parameter_name_strips_ampersand() {
+        // tree-sitter-cpp's `reference_declarator` does not expose a `declarator`
+        // field, so the unwrap helper has to scan children for the underlying
+        // identifier — otherwise the parameter name comes back as `& action`.
+        let s = parse_cpp("void log_action(const std::string& action) {}");
+        let func = s.definitions.iter().find(|d| d.name == "log_action").unwrap();
+        let params = func.children.as_ref().expect("function has children");
+        assert_eq!(params.len(), 1);
+        assert_eq!(params[0].name, "action");
+        assert_eq!(params[0].kind, "parameter");
+    }
+
+    #[test]
+    fn rvalue_reference_parameter_name_strips_ampersand() {
+        let s = parse_cpp("void take(int&& x) {}");
+        let func = s.definitions.iter().find(|d| d.name == "take").unwrap();
+        let params = func.children.as_ref().expect("function has children");
+        assert_eq!(params.len(), 1);
+        assert_eq!(params[0].name, "x");
+    }
 }