Struct CppVisitor 

pub struct CppVisitor<'a> {
    pub file: &'a ProjectFile,
    pub source: &'a str,
    pub parsed: &'a mut ParsedFile,
    pub c_tag_semantics: bool,
    pub recovered_class_sibling_scopes: HashMap<usize, ScopeInfo>,
    pub consumed_fragment_regions: Vec<(usize, usize)>,
    pub namespace_forward_scans: HashMap<CppTreeIdentity, CppNamespaceForwardScan>,
    pub field_owners: Option<CppFieldOwnerIndex>,
    pub recovery_captures: Vec<CppRecoveryCapture>,
}

Fields

file: &'a ProjectFile

source: &'a str

parsed: &'a mut ParsedFile

c_tag_semantics: bool

Whether this translation unit is compiled as C – the CppC dialect of LanguageDialect, i.e. an exact lowercase .c extension.

C has no nested tag scope: a struct/union/enum tag declared inside another aggregate’s member list has the scope of the outer declaration itself (C17 6.2.1, 6.7.2.3). struct outer { struct inner { int v; } i; }; therefore declares a file-scope inner that a later file-scope struct inner *p; legitimately references, where C++ would make the same shape a nested class outer::inner. Headers carry no compilation language of their own and keep the conservative C++ interpretation.

recovered_class_sibling_scopes: HashMap<usize, ScopeInfo>

consumed_fragment_regions: Vec<(usize, usize)>

Byte regions whose contents were re-owned by a fragmented export-class recovery (#938): the scattered members between the fragmented declaration and its displaced closing brace are indexed as members of the recovered class by the region reparse, so the ordinary sibling walk must not ALSO index them as top-level declarations (that double-indexing made a scattered nested class ambiguous between Inner and Widget$Inner). Regions are rare (one per fragmented recovery), so a linear scan at visit time is fine.

namespace_forward_scans: HashMap<CppTreeIdentity, CppNamespaceForwardScan>

The namespace forward declarations already folded out of each tree this walk has asked CppVisitor::unique_earlier_namespace_forward about. Empty until the first question, which the overwhelming majority of files never ask.

field_owners: Option<CppFieldOwnerIndex>

Which owners already have field declarations in the parse product, as CppVisitor::has_enum_enumerator_units needs to know. None until the first enum asks, which most files never do (#2786).

recovery_captures: Vec<CppRecoveryCapture>

What each open CppVisitor::record_recovered_declarations has watched happen to the declaration set, innermost last. Empty outside a recovery reparse, which is almost always (#2787).

Implementations

impl<'a> CppVisitor<'a>

pub fn visit_container<'tree>( &mut self, node: Node<'tree>, ancestry: &ParentIndex<'tree>, package_name: &str, module: Option<CodeUnit>, class_unit: Option<CodeUnit>, template_signature: Option<String>, visible_using_namespaces: Vec<String>, )

Walk node’s container, answering every ancestor question from ancestry.

ancestry must index the tree node belongs to. The caller owns it because one tree can be walked more than once – a header’s C and C++ readings are the same tree under different tag semantics – and the parent relation is a property of the tree, not of the reading.