Struct OrphanedNamespaceScopeIndex 

pub struct OrphanedNamespaceScopeIndex { /* private fields */ }

The namespaces C++ parse recovery drops from a file’s tree.

When tree-sitter cannot parse a construct inside a namespace body it closes an inner scope with a MISSING brace, or skips an opening brace into an ERROR node. Every real } after that then closes one scope too early: a class body’s } closes the namespace, the namespace’s own } closes its parent, and the outermost real closes land in a trailing ERROR node. The declarations between a stolen close and the real one keep their byte positions but lose their namespace_definition ancestors (Catch2’s catch_matchers_templated.hpp, issue #1537).

A file-global stack over real AST brace tokens restores both lost and overextended namespaces. Missing braces do nothing; error-free subtrees are balanced and can be skipped. For each child of a damaged container, compare the namespaces still open on that stack with the parsed ancestor path. A difference yields a region carrying the complete lexical path, including an empty path when recovery swallowed file-scope declarations. Consecutive children sharing that path form one RecoveredNamespaceRegion. The same pass retains matching brace positions for declaration partitioning (#3087). A file without parse errors needs neither correction nor a brace index.

The stack restores the source’s nesting only while the tree’s brace tokens are the source’s braces. Severe recovery breaks that: in simdjson’s compile_time_json-inl.h the C++26 reflection syntax leaves the whole translation unit an ERROR, and inside it case '{': re-lexes as a compound_literal_expression whose initializer_list opens on the char literal’s own {, while the statement’s real { is consumed as character tokens of a char literal that never terminates. That file’s tree holds 219 real } against 211 real {; eight closes therefore find the stack empty, and the two namespace levels are paired with interior closes 245 lines before their own (#3328). An unpaired close proves the stream lost an open at a position the stack cannot recover, so the pairing of that file is not evidence of any extent: Self::matching_close_brace then answers nothing and each restored level keeps the head that writes it. The namespace paths remain, as the best-effort structure recovery they are.

Implementations

impl OrphanedNamespaceScopeIndex

pub fn build(root: Node<'_>, source: &str) -> Self

pub fn matching_close_brace(&self, open: usize) -> Option<Range>

The real AST brace matching an opening brace in a damaged subtree. Missing tokens and braces inside comments or literals do not participate.

None when this open has no close in the file, and for every open in a file whose brace token stream lost an opening token: a caller cannot treat a pairing the walk could not prove as an enclosing extent (#3328).

pub fn is_empty(&self) -> bool

pub fn approximate_size(&self) -> usize

The bytes this index holds, for the analyzer cache’s weight.

pub fn region_at(&self, byte: usize) -> Option<&RecoveredNamespaceRegion>

The innermost recovered region containing byte.

pub fn enclosing_namespace_components( &self, node: Node<'_>, source: &str, ) -> Vec<String>

The enclosing namespaces of node, outermost first, restoring the ones parse recovery dropped from its ancestor chain. The one answer both lookup directions and declaration collection use (issue #1537).

pub fn enclosing_namespace_levels( &self, node: Node<'_>, source: &str, ) -> Vec<(String, Range)>

Self::enclosing_namespace_components with the construct that writes each level, for the declaration walk that has to record a range for it.

A level the brace stack restored carries the range this index recorded for its head; a surviving namespace_definition ancestor carries its own node range, which is what the ordinary namespace visit records.

pub fn restore_enclosing_namespaces( &self, parsed: Vec<(usize, Vec<String>)>, node_start: usize, ) -> Vec<String>

Self::enclosing_namespace_components for a caller that has already climbed the ancestor chain: parsed lists the node’s named namespace_definition ancestors outermost first, each with its start byte. A region covering the node supplies every namespace outside it; only the parsed ancestors that start inside the region still apply.

Trait Implementations

impl Clone for OrphanedNamespaceScopeIndex

fn clone(&self) -> OrphanedNamespaceScopeIndex

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for OrphanedNamespaceScopeIndex

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for OrphanedNamespaceScopeIndex

fn default() -> OrphanedNamespaceScopeIndex

Returns the “default value” for a type.