static RE: OnceLock<Regex> = OnceLock::new();

RE.get_or_init(|| Regex::new(

r"^(?:[A-Za-z_][A-Za-z0-9_:]*[ \t\r\n]+)+[*& \t\r\n]*([A-Za-z_][A-Za-z0-9_]*)[ \t\r\n]*\([^(){};#]*\)[ \t\r\n]*$"

).unwrap())

static RE: OnceLock<Regex> = OnceLock::new();

RE.get_or_init(|| {

Regex::new(r"\b(?:std\s*::\s*)?(?:unique_ptr|shared_ptr|weak_ptr|optional)\s*<\s*([^,>]+?)\s*>")

.unwrap()

})

matches!(

name,

"void" | "bool" | "char" | "short" | "int" | "long" | "float" | "double" | "unsigned"

| "signed" | "size_t" | "ssize_t" | "auto" | "wchar_t" | "char8_t" | "char16_t"

| "char32_t" | "int8_t" | "int16_t" | "int32_t" | "int64_t" | "uint8_t" | "uint16_t"

| "uint32_t" | "uint64_t" | "intptr_t" | "uintptr_t" | "nullptr_t"

)

matches!(

name,

"bool" | "void" | "int" | "char" | "short" | "long" | "float" | "double" | "unsigned"

| "signed" | "wchar_t" | "char8_t" | "char16_t" | "char32_t" | "char_t" | "size_t"

| "auto" | "const" | "struct" | "class" | "enum" | "union" | "typename"

)

matches!(

name,

"this" | "self" | "super" | "null" | "nil" | "true" | "false" | "undefined" | "new"

| "NULL" | "nullptr" | "None"

)

matches!(

kind,

"string" | "string_literal" | "interpreted_string_literal" | "raw_string_literal"

| "template_string" | "concatenated_string" | "formatted_string" | "f_string"

| "line_string_literal" | "string_content" | "heredoc_body"

| "number" | "number_literal" | "integer" | "integer_literal" | "float"

| "float_literal" | "int_literal" | "decimal_integer_literal" | "real_literal"

| "char_literal" | "character_literal" | "rune_literal" | "regex" | "regex_literal"

| "true" | "false" | "boolean_literal" | "bool_literal" | "none" | "null" | "nil"

| "null_literal" | "undefined"

| "list" | "list_literal" | "array" | "array_literal" | "array_creation_expression"

| "dictionary" | "dict_literal" | "object" | "tuple" | "set"

)

if !name.contains('<') {

return name.to_string();

}

let mut out = String::with_capacity(name.len());

let mut depth = 0u32;

for ch in name.chars() {

if ch == '<' {

depth += 1;

} else if ch == '>' {

depth = depth.saturating_sub(1);

} else if depth == 0 {

out.push(ch);

}

}

out.trim().to_string()

if !name.chars().any(|c| c.is_whitespace())

|| name.starts_with("operator")

|| name.starts_with('~')

{

return name;

}

if ret_paren_name_re().is_match(&name) {

return name; // `Ret (name)` idiom — leave alone

}

let before_params = match name.find('(') {

Some(i) => &name[..i],

None => &name[..],

};

// (JS: `beforeParams.trim().split(/\s+/)` — split_whitespace already

// ignores leading/trailing whitespace, so no explicit trim.)

let candidate = before_params.split_whitespace().last().unwrap_or("");

if candidate.is_empty()

|| !simple_ident_re().is_match(candidate)

|| is_cpp_primitive_name(candidate)

{

return name;

}

candidate.to_string()

let mut t = raw.trim().to_string();

if t.is_empty() {

return None;

}

if let Some(c) = ret_wrapper_re().captures(&t) {

if let Some(inner) = c.get(1) {

t = inner.as_str().to_string();

}

}

let t = ret_keyword_re().replace_all(&t, " ");

let t = angle_group_re().replace_all(&t, " ");

let t = ptr_ref_re().replace_all(&t, " ");

let t = ws_run_re().replace_all(&t, " ");

let t = t.trim();

if t.is_empty() {

return None;

}

let parts: Vec<&str> = t.split("::").filter(|p| !p.is_empty()).collect();

let last = *parts.last()?;

if is_non_class_return(last) || !simple_ident_re().is_match(last) {

return None;

}

Some(last.to_string())

row: u32,

kind: &'static str,

name: String,

docstring: Option<String>,

signature: Option<String>,

visibility: Option<u8>,

is_exported: Option<bool>,

is_abstract: Option<bool>,

return_type: Option<String>,

qualified_name: Option<String>,

row: u32,

node: Node<'t>,

name: String,

Args,

Rhs,

Value,

List,

Varinit,

from: u32,

name: String,

mode: Mode,

explicit_ref: bool,

line: u32,

column_byte: usize,

row: usize,

src: &'t str,

file_path: &'t str,

variant: Variant,

line_starts: Vec<usize>,

arena: Arena,

node_id_allocator: ids::NodeIdAllocator,

tables: Tables,

stack: Vec<Scope>,

nodes_meta: Vec<NodeMeta>,

node_ids: Vec<String>,

/// C/C++ enclosing `namespace ns { … }` names (cpp only ever non-empty).

namespace_prefix: Vec<String>,

/// cppLocalFnPtrs: caller row → local name → insertion-ordered targets.

local_fn_ptrs: HashMap<u32, HashMap<String, Vec<String>>>,

defined_fn_names: HashSet<String>,

imported_names: HashSet<String>,

fn_ref_cands: Vec<Cand>,

fs_values: HashMap<String, u32>,

fs_value_counts: HashMap<String, u32>,

value_scopes: Vec<ValueScope<'t>>,

let variant = match language {

"c" => Variant::C,

"cpp" => Variant::Cpp,

other => return Err(format!("ccpp walker got language '{other}'")),

};

let grammar = crate::langs::grammar_for(language).ok_or("no c/cpp grammar")?;

let t0 = std::time::Instant::now();

let mut parser = Parser::new();

parser

.set_language(&grammar)

.map_err(|e| format!("set_language({language}) failed: {e}"))?;

let tree = parser

.parse(source, None)

.ok_or_else(|| "parser returned null tree".to_string())?;

// Measurement hatch (parity sweeps only — never set in production): skip

// the defer so the sweep can QUANTIFY how often UTF-8 vs UTF-16 error

// recovery actually diverges on this language's erroring files.

let no_defer = std::env::var("CODEGRAPH_KERNEL_CCPP_ERROR_EXTRACT").as_deref() == Ok("1");

if tree.root_node().has_error() && !no_defer {

return Err("defer: parse tree contains errors — wasm recovery is canonical".to_string());

}

let mut w = Walker {

src: source,

file_path,

variant,

line_starts: util::line_starts(source),

arena: Arena::default(),

node_id_allocator: ids::NodeIdAllocator::default(),

tables: Tables::default(),

stack: Vec::new(),

nodes_meta: Vec::new(),

node_ids: Vec::new(),

namespace_prefix: Vec::new(),

local_fn_ptrs: HashMap::new(),

defined_fn_names: HashSet::new(),

imported_names: HashSet::new(),

fn_ref_cands: Vec::new(),

fs_values: HashMap::new(),

fs_value_counts: HashMap::new(),

value_scopes: Vec::new(),

};

let line_count = source.bytes().filter(|b| *b == b'\n').count() as u32 + 1;

let base_name = file_path.rsplit(['/', '\\']).next().unwrap_or(file_path);

let mut flags = BoolFlags::default();

flags.set(FLAG_IS_EXPORTED, false);

let file_id = w.arena.put(&ids::file_node_id(file_path));

let name_ref = w.arena.put(base_name);

let qn_ref = w.arena.put(file_path);

w.tables.push_node(&NodeRow {

kind: node_kind_index("file").unwrap(),

visibility: 0,

flags,

start_line: 1,

end_line: line_count,

start_column: 0,

end_column: 0,

name: name_ref,

qualified_name: qn_ref,

id: file_id,

docstring: NONE_STR,

signature: NONE_STR,

decorators: NONE_STR,

type_parameters: NONE_STR,

return_type: NONE_STR,

extra_json: NONE_STR,

});

w.nodes_meta.push(NodeMeta { kind: "file", name: base_name.to_string() });

w.node_ids.push(ids::file_node_id(file_path));

w.stack.push(Scope { row: 0, kind: "file", name: base_name.to_string() });

w.visit_node(tree.root_node());

w.flush_fn_ref_candidates();

w.flush_value_refs(tree.root_node());

w.stack.pop();

let duration_ms = t0.elapsed().as_secs_f64() * 1000.0;

let meta = build_meta(&w.tables, w.arena.len(), NONE_STR, duration_ms);

Ok(EmitOut {

meta,

nodes: w.tables.nodes,

edges: w.tables.edges,

refs: w.tables.refs,

arena: w.arena.into_vec(),

})

fn text(&self, node: Node) -> &'t str {

&self.src[node.byte_range()]

}

fn line_of(&self, node: Node) -> u32 {

node.start_position().row as u32 + 1

}

fn col_of(&self, node: Node) -> u32 {

util::col16(self.src, &self.line_starts, node.start_position().row, node.start_byte())

}

fn end_col_of(&self, node: Node) -> u32 {

util::col16(self.src, &self.line_starts, node.end_position().row, node.end_byte())

}

fn top_row(&self) -> u32 {

self.stack.last().map(|s| s.row).unwrap_or(0)

}

fn inside_class_like(&self) -> bool {

self.stack

.last()

.map(|s| matches!(s.kind, "class" | "struct" | "union" | "interface" | "trait" | "enum" | "module"))

.unwrap_or(false)

}

fn push_ref_at(&mut self, from_row: u32, name: &str, kind_code: u8, node: Node) {

let name_ref = self.arena.put(name);

self.tables.push_ref(&RefRow {

from_idx: from_row,

kind: kind_code,

line: self.line_of(node),

column: self.col_of(node),

reference_name: name_ref,

candidates: NONE_STR,

from_id_str: NONE_STR,

});

if kind_code == edge_kind_index("imports").unwrap() {

if util::simple_name().is_match(name) {

self.imported_names.insert(name.to_string());

} else if let Some(c) = util::qualified_import().captures(name) {

self.imported_names.insert(c[1].to_string());

}

}

}

fn create_node(&mut self, kind: &'static str, name: &str, node: Node<'t>, extra: Extra) -> Option<u32> {

if name.is_empty() {

return None;

}

let start_line = self.line_of(node);

let column = self.col_of(node);

let id = self.node_id_allocator.generate(self.file_path, kind, name, start_line, column);

// (c/cpp define no resolveBody hook, so createNode's endLine extension

// for sibling-body grammars never fires — endLine is the node's own.)

let end_line = node.end_position().row as u32 + 1;

let qualified = extra.qualified_name.unwrap_or_else(|| {

let mut parts: Vec<&str> = self.namespace_prefix.iter().map(|s| s.as_str()).collect();

for s in &self.stack {

if s.kind != "file" {

parts.push(&s.name);

}

}

let mut qn = parts.join("::");

if !qn.is_empty() {

qn.push_str("::");

}

qn.push_str(name);

qn

});

let mut flags = BoolFlags::default();

if let Some(v) = extra.is_exported {

flags.set(FLAG_IS_EXPORTED, v);

}

if let Some(v) = extra.is_abstract {

flags.set(FLAG_IS_ABSTRACT, v);

}

let name_ref = self.arena.put(name);

let qn_ref = self.arena.put(&qualified);

let id_ref = self.arena.put(&id);

let doc_ref = opt_str(&mut self.arena, extra.docstring.as_deref());

let sig_ref = opt_str(&mut self.arena, extra.signature.as_deref());

let ret_ref = opt_str(&mut self.arena, extra.return_type.as_deref());

let row = self.tables.push_node(&NodeRow {

kind: node_kind_index(kind).unwrap(),

visibility: extra.visibility.unwrap_or(0),

flags,

start_line,

end_line,

start_column: self.col_of(node),

end_column: self.end_col_of(node),

name: name_ref,

qualified_name: qn_ref,

id: id_ref,

docstring: doc_ref,

signature: sig_ref,

decorators: NONE_STR,

type_parameters: NONE_STR,

return_type: ret_ref,

extra_json: NONE_STR,

});

self.nodes_meta.push(NodeMeta { kind, name: name.to_string() });

self.node_ids.push(id);

let parent_row = self.top_row();

self.tables.push_edge(&EdgeRow {

source_idx: parent_row,

target_idx: row,

kind: edge_kind_index("contains").unwrap(),

provenance: 0,

line: NONE,

column: NONE,

metadata_json: NONE_STR,

source_id_str: NONE_STR,

target_id_str: NONE_STR,

});

if kind == "function" || kind == "method" {

self.defined_fn_names.insert(name.to_string());

}

// captureValueRefScope (capture is variant-agnostic like the TS side;

// flushValueRefs gates on the language — C only).

let target_kind_ok = kind == "constant" || kind == "variable";

if target_kind_ok

&& util::utf16_len(name) >= 3

&& util::has_upper_or_underscore().is_match(name)

{

let parent_ok = self

.stack

.last()

.map(|s| matches!(s.kind, "file" | "class" | "module" | "struct" | "union" | "enum"))

.unwrap_or(false);

if parent_ok {

self.fs_values.insert(name.to_string(), row);

*self.fs_value_counts.entry(name.to_string()).or_insert(0) += 1;

}

}

if matches!(kind, "function" | "method" | "constant" | "variable") {

self.value_scopes.push(ValueScope { row, node, name: name.to_string() });

}

Some(row)

}

// --- name extraction -----------------------------------------------------

/// extractName: extractNameRaw + the universal recoverMangledName net

/// (wired for BOTH c and cpp in languages/c-cpp.ts).

fn extract_name(&self, node: Node) -> String {

recover_mangled_cpp_name(self.extract_name_raw(node))

}

/// extractNameRaw for the c/cpp extractor configs (nameField 'declarator';

/// cpp resolveName = extractCppQualifiedMethodName).

fn extract_name_raw(&self, node: Node) -> String {

if let Some(name) = self.recover_single_arg_macro_defined_name(node) {

return name;

}

if self.variant == Variant::Cpp {

if let Some(hook) = self.extract_cpp_qualified_method_name(node) {

return hook;

}

}

if let Some(name_node) = node.child_by_field_name("declarator") {

let mut resolved = name_node;

// Unwrap pointer/reference declarators (`int* f()`, `T& f()`).

while matches!(resolved.kind(), "pointer_declarator" | "reference_declarator") {

let inner = resolved

.child_by_field_name("declarator")

.or_else(|| resolved.named_child(0));

match inner {

Some(i) => resolved = i,

None => break,

}

}

// C++ conversion operator: `operator <type>`.

if resolved.kind() == "operator_cast" {

return match resolved.named_child(0) {

Some(t) => format!("operator {}", self.text(t).trim()),

None => self.text(resolved).to_string(),

};

}

if resolved.kind() == "function_declarator" || resolved.kind() == "declarator" {

let inner = resolved

.child_by_field_name("declarator")

.or_else(|| resolved.named_child(0));

return match inner {

Some(i) => self.text(i).to_string(),

None => self.text(resolved).to_string(),

};

}

return self.text(resolved).to_string();

}

for i in 0..node.named_child_count() {

if let Some(c) = node.named_child(i) {

if matches!(c.kind(), "identifier" | "type_identifier" | "simple_identifier" | "constant") {

return self.text(c).to_string();

}

}

}

"<anonymous>".to_string()

}

/// extractCppQualifiedMethodName (languages/c-cpp.ts:75).

fn extract_cpp_qualified_method_name(&self, node: Node) -> Option<String> {

if let Some(n) = self.recover_cpp_macro_defined_name(node) {

return Some(n);

}

let declarator = node.child_by_field_name("declarator")?;

let qid = find_declarator_qualified_id(declarator)?;

let text = self.text(qid).trim();

let parts: Vec<&str> = text.split("::").filter(|p| !p.is_empty()).collect();

parts.last().map(|s| s.to_string())

}

/// recoverSingleArgMacroDefinedName: only a local macro definition proves

/// that its argument is the function name, in either parser shape (#1373).

fn recover_single_arg_macro_defined_name(&self, node: Node) -> Option<String> {

if node.kind() != "function_definition" {

return None;

}

let declarator = node.child_by_field_name("declarator")?;

let (macro_node, argument) = if declarator.kind() == "parenthesized_declarator"

&& declarator.named_child_count() == 1

{

let m = node.child_by_field_name("type")?;

let a = declarator.named_child(0)?;

if m.kind() != "type_identifier" || a.kind() != "identifier" {

return None;

}

(m, a)

} else if declarator.kind() == "function_declarator"

&& node.child_by_field_name("type").is_none()

{

let m = declarator.child_by_field_name("declarator")?;

let params = declarator.child_by_field_name("parameters")?;

let param = params.named_child(0)?;

if m.kind() != "identifier" || params.named_child_count() != 1

|| param.kind() != "parameter_declaration" || param.named_child_count() != 1

{

return None;

}

let a = param.named_child(0)?;

if a.kind() != "type_identifier" {

return None;

}

(m, a)

} else {

return None;

};

let macro_name = self.text(macro_node);

let mut scope = Some(node);

while let Some(current) = scope {

if current.kind() == "preproc_else" || current.kind().starts_with("preproc_elif") {

return None;

}

let mut previous = current.prev_named_sibling();

while let Some(prev) = previous {

previous = prev.prev_named_sibling();

if prev.kind().starts_with("preproc_if") {

return None;

}

if prev.kind() == "preproc_call"

&& prev.child_by_field_name("directive").map(|n| self.text(n)) == Some("#undef")

&& prev.child_by_field_name("argument").map(|n| self.text(n).trim()) == Some(macro_name)

{

return None;

}

if !matches!(prev.kind(), "preproc_function_def" | "preproc_def")

|| prev.child_by_field_name("name").map(|n| self.text(n)) != Some(macro_name)

{

continue;

}

let params = prev.child_by_field_name("parameters")?;

let param = params.named_child(0)?;

let value = prev.child_by_field_name("value")?;

if params.named_child_count() != 1 || param.kind() != "identifier" {

return None;

}

let replacement = self.text(value).replace("\\\r\n", " ").replace("\\\n", " ");

let captures = single_arg_macro_replacement_re().captures(replacement.trim())?;

if replacement.split(|c: char| !c.is_ascii_alphanumeric() && c != '_').any(|s| s == "typedef")

|| captures.get(1)?.as_str() != self.text(param)

{

return None;

}

return Some(self.text(argument).to_string());

}

scope = current.parent();

}

None

}

/// recoverCppMacroDefinedName (languages/c-cpp.ts:49).

fn recover_cpp_macro_defined_name(&self, node: Node) -> Option<String> {

if node.kind() != "function_definition" {

return None;

}

let declarator = node.child_by_field_name("declarator")?;

if declarator.kind() != "function_declarator" {

return None;

}

let inner = declarator.child_by_field_name("declarator")?;

if inner.kind() != "identifier" {

return None;

}

let macro_name = self.text(inner);

if !macro_shaped_re().is_match(macro_name) {

return None;

}

let params = declarator.child_by_field_name("parameters")?;

if params.named_child_count() < 2 {

return None;

}

let lone_ident_text = |p: Node| -> Option<&'t str> {

if p.kind() == "parameter_declaration"

&& p.named_child_count() == 1

&& p.named_child(0).map(|c| c.kind() == "type_identifier").unwrap_or(false)

{

Some(self.text(p.named_child(0).unwrap()))

} else {

None

}

};

let name = params.named_child(0).and_then(lone_ident_text)?;

if !has_lower_re().is_match(name) {

return None;

}

for i in 1..params.named_child_count() {

if let Some(p) = params.named_child(i) {

if lone_ident_text(p).is_some() {

return None;

}

}

}