use cpp_parser::{
CppAstNode, CppAstToken, CppSyntaxKind, CppSyntaxNode, CppTokenKind, MacroBodies,
};
use crate::summary::MacroScopeReading;
use crate::symbol::{
Binding, BindingKind, BindingOrigin, DeclName, Name, QualifiedName, ScopeId, ScopeKind,
ScopeTree,
};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Body {
OpensAScope,
}
pub use cpp_parser::NothingAtAll as NoMacroBodies;
pub fn build_scopes(root: &CppSyntaxNode, bodies: &dyn MacroBodies) -> ScopeTree {
build_scopes_with(root, bodies, true)
}
pub fn build_scopes_with(
root: &CppSyntaxNode,
bodies: &dyn MacroBodies,
want_bodies: bool,
) -> ScopeTree {
let mut walker = ScopeWalker {
table: ScopeTree::new(),
bodies,
own: Default::default(),
want_bodies,
};
let file = walker.table.create_scope(
ScopeKind::TranslationUnit,
None,
Some(cpp_parser::source_range(root.text_range())),
);
walker.items(root, file);
walker.table
}
struct ScopeWalker<'a> {
table: ScopeTree,
bodies: &'a dyn MacroBodies,
want_bodies: bool,
own: rustc_hash::FxHashMap<Box<str>, Box<str>>,
}
struct OwnAndIncluded<'a> {
own: &'a rustc_hash::FxHashMap<Box<str>, Box<str>>,
included: &'a dyn MacroBodies,
}
impl MacroBodies for OwnAndIncluded<'_> {
fn body_at(&self, name: &str, at: usize) -> Option<std::borrow::Cow<'_, str>> {
if let Some(body) = self.own.get(name) {
return Some(std::borrow::Cow::Borrowed(body));
}
self.included.body_at(name, at)
}
}
fn begins_an_inline_namespace(node: &CppSyntaxNode) -> bool {
let mut previous = node.prev_sibling_or_token();
while let Some(element) = previous {
if let Some(token) = element.as_token() {
if cpp_parser::is_trivia(CppTokenKind::from(token.kind())) {
previous = token.prev_sibling_or_token();
continue;
}
return CppTokenKind::from(token.kind()) == CppTokenKind::InlineKeyword;
}
return false;
}
false
}
fn a_define_at(node: &CppSyntaxNode) -> Option<(String, String)> {
if !cpp_parser::CppPreprocessorDirective::can_cast(node.kind().into()) {
return None;
}
let tokens: Vec<_> = node
.children_with_tokens()
.filter_map(|child| child.into_token())
.filter(|token| !token.text().trim().is_empty())
.collect();
if CppTokenKind::from(tokens.first()?.kind()) != CppTokenKind::Hash {
return None;
}
if tokens.get(1)?.text() != "define" {
return None;
}
let name = tokens.get(2)?;
if CppTokenKind::from(name.kind()) != CppTokenKind::Identifier {
return None;
}
if tokens
.get(3)
.is_some_and(|token| CppTokenKind::from(token.kind()) == CppTokenKind::LeftParen)
{
return None;
}
let body = tokens[3..]
.iter()
.take_while(|token| !token.text().contains('\n'))
.map(|token| token.text())
.collect::<Vec<_>>()
.join(" ");
Some((name.text().to_string(), body))
}
enum OpenedByBody {
Opens {
name: String,
segments: Vec<String>,
body: String,
range: cpp_parser::SourceRange,
},
Closes {
name: String,
body: String,
range: cpp_parser::SourceRange,
},
OpensABrace {
#[allow(dead_code)]
name: String,
#[allow(dead_code)]
range: cpp_parser::SourceRange,
},
}
impl ScopeWalker<'_> {
fn items(&mut self, node: &CppSyntaxNode, scope: ScopeId) {
self.walk_children(node, scope, None);
}
fn items_in_scope(&mut self, node: &CppSyntaxNode, scope: ScopeId, bodies: &[CppSyntaxKind]) {
self.walk_children(node, scope, Some(bodies));
}
fn walk_children(
&mut self,
node: &CppSyntaxNode,
scope: ScopeId,
same_scope_bodies: Option<&[CppSyntaxKind]>,
) {
let mut current = scope;
let mut opened: Vec<(ScopeId, ScopeId)> = Vec::new();
for child in node.children() {
if let Some((name, body)) = a_define_at(&child) {
self.own
.insert(name.into_boxed_str(), body.into_boxed_str());
}
match self.opened_by_a_body(&child) {
Some(OpenedByBody::Opens {
name,
segments,
body,
range,
}) => {
let inner = self.open_from_a_body(&segments, current, range, &name, &body);
opened.push((inner, current));
current = inner;
}
Some(OpenedByBody::OpensABrace { name: _, range: _ }) => {
opened.push((current, current));
}
Some(OpenedByBody::Closes { name, body, range }) => {
self.table.macro_readings.push(MacroScopeReading {
range,
name,
body,
opens: None,
});
if let Some((_, enclosing)) = opened.pop() {
current = enclosing;
}
}
None => match same_scope_bodies {
Some(bodies) if bodies.contains(&CppSyntaxKind::from(child.kind())) => {
self.items(&child, current);
}
_ => self.item(&child, current),
},
}
}
}
fn opened_by_a_body(&self, node: &CppSyntaxNode) -> Option<OpenedByBody> {
if CppSyntaxKind::from(node.kind()) != CppSyntaxKind::MacroCall {
return None;
}
let name = invocation_name(node)?;
let range = cpp_parser::source_range(node.text_range());
let bodies = OwnAndIncluded {
own: &self.own,
included: self.bodies,
};
let body = bodies.body_at(&name, range.start_offset)?;
match cpp_parser::shape_of_a_body_at(&body, &bodies, range.start_offset) {
cpp_parser::BodyShape::OpensANamespace(segments) => Some(OpenedByBody::Opens {
name,
segments,
body: body.to_string(),
range,
}),
cpp_parser::BodyShape::ClosesABlock => Some(OpenedByBody::Closes {
name,
body: body.to_string(),
range,
}),
cpp_parser::BodyShape::OpensABlock => Some(OpenedByBody::OpensABrace { name, range }),
cpp_parser::BodyShape::QualifiesAName | cpp_parser::BodyShape::Other => None,
}
}
fn open_from_a_body(
&mut self,
segments: &[String],
parent: ScopeId,
range: cpp_parser::SourceRange,
name: &str,
body: &str,
) -> ScopeId {
let inner = if segments.is_empty() {
self.table
.create_scope(ScopeKind::Namespace, Some(parent), Some(range))
} else {
let inline = cpp_parser::a_body_opens_an_inline_namespace(body);
self.open_namespace_chain(segments, parent, range, inline)
};
self.table.macro_readings.push(MacroScopeReading {
range,
name: name.to_string(),
body: body.to_string(),
opens: Some(segments.to_vec()),
});
inner
}
fn item(&mut self, node: &CppSyntaxNode, scope: ScopeId) {
match CppSyntaxKind::from(node.kind()) {
CppSyntaxKind::NamespaceDecl => self.namespace(node, scope),
CppSyntaxKind::ClassDef
| CppSyntaxKind::StructDef
| CppSyntaxKind::UnionDef
| CppSyntaxKind::ClassDecl
| CppSyntaxKind::StructDecl
| CppSyntaxKind::UnionDecl => self.class_like(node, scope, scope, BindingKind::Class),
CppSyntaxKind::EnumDef | CppSyntaxKind::EnumClassDef => {
self.enum_like(node, scope, scope)
}
CppSyntaxKind::TemplateDecl => {
let parameters = self.table.create_scope(
ScopeKind::TemplateParameters,
Some(scope),
Some(cpp_parser::source_range(node.text_range())),
);
for list in node
.children()
.filter(|child| cpp_parser::CppTemplateParamList::can_cast(child.kind().into()))
{
self.template_parameters(&list, parameters);
}
self.items(node, parameters);
}
CppSyntaxKind::TypedefDecl => {
self.typedef_decl(node, scope);
self.specifiers(node, scope, scope, false);
}
CppSyntaxKind::ConceptDecl => self.concept_decl(node, scope),
CppSyntaxKind::FriendDecl => self.items(node, scope),
CppSyntaxKind::LambdaExpr => self.lambda(node, scope),
CppSyntaxKind::UsingDecl => self.using_decl(node, scope),
CppSyntaxKind::UsingDirective => self.using_directive(node, scope),
CppSyntaxKind::Declaration => self.declaration(node, scope),
CppSyntaxKind::LabelStat => self.label(node, scope),
CppSyntaxKind::ForStat
| CppSyntaxKind::RangeForStat
| CppSyntaxKind::WhileStat
| CppSyntaxKind::DoWhileStat
| CppSyntaxKind::SwitchStat
| CppSyntaxKind::TryStat
| CppSyntaxKind::IfStat => self.statement_scope(node, scope),
CppSyntaxKind::CatchStat => self.catch_handler(node, scope),
_ => self.descend(node, scope, Body::OpensAScope),
}
}
fn descend(&mut self, node: &CppSyntaxNode, scope: ScopeId, body: Body) {
if cpp_parser::CppCompoundStat::can_cast(node.kind().into()) {
if !self.want_bodies {
return;
}
let inner = self.block(node, scope, body);
self.items(node, inner);
return;
}
self.items(node, scope);
}
fn catch_handler(&mut self, node: &CppSyntaxNode, parent: ScopeId) {
let handler = self.table.create_scope(
ScopeKind::Block,
Some(parent),
Some(cpp_parser::source_range(node.text_range())),
);
for list in node
.children()
.filter(|child| cpp_parser::CppParamList::can_cast(child.kind().into()))
{
self.parameters(&list, handler);
}
for body in node
.children()
.filter(|child| cpp_parser::CppCompoundStat::can_cast(child.kind().into()))
{
let block = self.block(&body, handler, Body::OpensAScope);
self.items(&body, block);
}
}
fn block(&mut self, node: &CppSyntaxNode, parent: ScopeId, body: Body) -> ScopeId {
match body {
Body::OpensAScope => self.table.create_scope(
ScopeKind::Block,
Some(parent),
Some(cpp_parser::source_range(node.text_range())),
),
}
}
fn namespace(&mut self, node: &CppSyntaxNode, parent: ScopeId) {
let range = cpp_parser::source_range(node.text_range());
let body = first_child(node, CppSyntaxKind::CompoundStat);
let segments = namespace_segments(node);
let segment_ranges = namespace_segment_ranges(node);
let inline = begins_an_inline_namespace(node);
let scope = match (segments.as_slice(), body) {
([], _) => self
.table
.create_scope(ScopeKind::Namespace, Some(parent), Some(range)),
(segments, Some(_)) => self.open_namespace_chain(segments, parent, range, inline),
(segments, None) => self.table.create_named_scope(
ScopeKind::Namespace,
Some(parent),
Some(range),
segments.last().map(String::as_str),
),
};
self.bind_namespace_segments(&segments, &segment_ranges, scope, parent, node, range);
self.items_in_scope(node, scope, &[CppSyntaxKind::CompoundStat]);
}
fn bind_namespace_segments(
&mut self,
segments: &[String],
ranges: &[cpp_parser::SourceRange],
inner: ScopeId,
parent: ScopeId,
node: &CppSyntaxNode,
whole: cpp_parser::SourceRange,
) {
let mut enclosing = self
.table
.scope(inner)
.and_then(|scope| scope.parent)
.unwrap_or(parent);
for index in (0..segments.len()).rev() {
let name_range = ranges.get(index).copied().unwrap_or(whole);
self.bind(
enclosing,
Name::identifier(&segments[index]),
BindingKind::Namespace,
node,
name_range,
);
enclosing = self
.table
.scope(enclosing)
.and_then(|scope| scope.parent)
.unwrap_or(parent);
}
}
fn open_namespace_chain(
&mut self,
segments: &[String],
parent: ScopeId,
range: cpp_parser::SourceRange,
inline: bool,
) -> ScopeId {
let mut enclosing = parent;
for segment in segments {
enclosing = self.table.create_named_scope(
ScopeKind::Namespace,
Some(enclosing),
Some(range),
if inline { None } else { Some(segment) },
);
}
enclosing
}
fn class_like(
&mut self,
node: &CppSyntaxNode,
outer: ScopeId,
inner: ScopeId,
kind: BindingKind,
) {
let body = first_child(node, CppSyntaxKind::ClassBody);
let body_start = body
.as_ref()
.map(|body| usize::from(body.text_range().start()));
let declared = declared_name(node)
.filter(|(_, range)| body_start.is_none_or(|start| range.start_offset < start));
let declared_text = declared
.as_ref()
.map(|(name, _)| name.kind.text())
.or_else(|| the_typedef_name_around(node))
.or_else(|| Self::the_declarators_name_around(node));
if let Some((name, name_range)) = declared {
self.bind(outer, name, kind, node, name_range);
}
let Some(body) = body else {
return;
};
if body.children().next().is_none() {
return;
}
let anonymous_member = declared_text.is_none()
&& !Self::declares_a_name_after_the_body(node, &body)
&& Self::sits_in_a_class_body(node);
let scope = if anonymous_member {
inner
} else {
self.table.create_named_scope(
ScopeKind::Class,
Some(inner),
Some(cpp_parser::source_range(node.text_range())),
declared_text.as_deref(),
)
};
self.items_in_scope(node, scope, &[CppSyntaxKind::ClassBody]);
if let Some(class_name) = declared_text.as_deref()
&& let Some(data) = self.table.scope_mut(scope)
{
for binding in &mut data.bindings {
if binding.kind == BindingKind::Function && binding.name.is(class_name) {
binding.kind = BindingKind::Constructor;
}
}
}
}
fn enum_like(&mut self, node: &CppSyntaxNode, outer: ScopeId, inner: ScopeId) {
let from_the_parser = cpp_parser::CppEnumDef::cast(node.clone())
.and_then(|definition| definition.get_name())
.and_then(|token| {
use cpp_parser::CppAstToken as _;
let text = token.syntax().text().to_string();
let range = cpp_parser::source_range(token.syntax().text_range());
name_from_text(&text, node).map(|name| (name, range))
});
let declared = from_the_parser.or_else(|| declared_name(node));
let declared_text = declared.as_ref().map(|(name, _)| name.kind.text());
let scope = self.table.create_named_scope(
ScopeKind::Enum,
Some(inner),
Some(cpp_parser::source_range(node.text_range())),
declared_text.as_deref(),
);
let head: String = node
.text()
.to_string()
.chars()
.take_while(|character| *character != '{')
.collect();
let scoped = head
.split(|character: char| character.is_whitespace() || character == ':')
.any(|word| matches!(word, "class" | "struct"));
if !scoped && let Some(enum_scope) = self.table.scope_mut(scope) {
enum_scope.unscoped_enum = true;
}
if let Some((name, name_range)) = declared {
self.bind(outer, name, BindingKind::Enum, node, name_range);
}
for body in node
.descendants()
.filter(|child| cpp_parser::CppCompoundStat::can_cast(child.kind().into()))
{
self.enumerators(&body, scope);
}
}
fn enumerators(&mut self, body: &CppSyntaxNode, scope: ScopeId) {
for enumerator in body.children() {
if !cpp_parser::CppEnumerator::can_cast(enumerator.kind().into()) {
continue;
}
if let Some((name, name_range)) = declared_name(&enumerator) {
self.bind(
scope,
name,
BindingKind::Enumerator,
&enumerator,
name_range,
);
}
}
}
fn concept_decl(&mut self, node: &CppSyntaxNode, scope: ScopeId) {
let Some(name_expr) = node
.children()
.find(|child| cpp_parser::CppNameExpr::can_cast(child.kind().into()))
else {
return;
};
let Some(token) = name_expr
.descendants_with_tokens()
.filter_map(|element| element.into_token())
.find(|token| CppTokenKind::from(token.kind()) == CppTokenKind::Identifier)
else {
return;
};
let text = token.text().to_string();
if text.is_empty() {
return;
}
self.bind(
scope,
Name::identifier(text),
BindingKind::Alias,
node,
cpp_parser::source_range(token.text_range()),
);
}
fn typedef_decl(&mut self, node: &CppSyntaxNode, scope: ScopeId) {
for declarator in node
.children()
.filter(|child| cpp_parser::CppDeclarator::can_cast(child.kind().into()))
{
if let Some((name, name_range)) = declared_name(&declarator) {
self.bind(scope, name, BindingKind::Typedef, node, name_range);
}
}
}
fn using_decl(&mut self, node: &CppSyntaxNode, scope: ScopeId) {
let is_alias = first_child(node, CppSyntaxKind::TypeId).is_some();
if let Some(directive) = first_child(node, CppSyntaxKind::UsingDirective) {
self.using_directive(&directive, scope);
return;
}
let kind = if is_alias {
BindingKind::Alias
} else {
BindingKind::UsingDeclaration
};
let Some(name_node) = find_name_node(node) else {
return;
};
let Some(token) = last_identifier(&name_node) else {
return;
};
let text = token.text().to_string();
let name_range = cpp_parser::source_range(token.text_range());
let Some(name) = name_from_text(&text, node) else {
return;
};
self.bind(scope, name, kind, node, name_range);
}
fn using_directive(&mut self, node: &CppSyntaxNode, scope: ScopeId) {
if let Some((name, name_range)) = declared_name(node) {
self.bind(scope, name, BindingKind::UsingDirective, node, name_range);
}
}
fn declaration(&mut self, node: &CppSyntaxNode, scope: ScopeId) {
if self.linkage(node, scope) {
return;
}
if let Some(template) = first_child(node, CppSyntaxKind::TemplateDecl) {
self.templated_declaration(node, &template, scope);
return;
}
self.declaration_parts(node, scope, scope);
}
fn linkage(&mut self, node: &CppSyntaxNode, scope: ScopeId) -> bool {
let is_linkage = first_child(node, CppSyntaxKind::DeclSpecifierSeq)
.and_then(|specifiers| first_child(&specifiers, CppSyntaxKind::ExternSpec))
.is_some_and(|specification| {
specification
.children_with_tokens()
.filter_map(|child| child.into_token())
.any(|token| CppTokenKind::from(token.kind()) == CppTokenKind::StringLiteral)
});
if !is_linkage {
return false;
}
let mut walked = false;
for child in node.children() {
match CppSyntaxKind::from(child.kind()) {
CppSyntaxKind::Declaration => {
self.declaration(&child, scope);
walked = true;
}
CppSyntaxKind::CompoundStat => {
self.items(&child, scope);
walked = true;
}
_ => {}
}
}
walked
}
fn templated_declaration(
&mut self,
node: &CppSyntaxNode,
template: &CppSyntaxNode,
scope: ScopeId,
) {
let parameters = self.table.create_scope(
ScopeKind::TemplateParameters,
Some(scope),
Some(cpp_parser::source_range(template.text_range())),
);
for list in template
.children()
.filter(|child| cpp_parser::CppTemplateParamList::can_cast(child.kind().into()))
{
self.template_parameters(&list, parameters);
}
if let Some(using) = first_child(node, CppSyntaxKind::UsingDecl) {
self.using_decl(&using, scope);
return;
}
if let Some(concept) = first_child(node, CppSyntaxKind::ConceptDecl) {
self.concept_decl(&concept, scope);
return;
}
self.declaration_parts(node, scope, parameters);
}
fn template_parameters(&mut self, list: &CppSyntaxNode, scope: ScopeId) {
for parameter in list.children() {
if !cpp_parser::CppTemplateParam::can_cast(parameter.kind().into()) {
continue;
}
if let Some((name, name_range)) = declared_name(¶meter) {
self.bind(
scope,
name,
BindingKind::TemplateParameter,
¶meter,
name_range,
);
}
}
}
fn declares_a_name_after_the_body(node: &CppSyntaxNode, body: &CppSyntaxNode) -> bool {
let declaration = node
.ancestors()
.find(|ancestor| cpp_parser::CppDeclaration::can_cast(ancestor.kind().into()))
.unwrap_or_else(|| node.clone());
let body_end = usize::from(body.text_range().end());
declarators(&declaration).into_iter().any(|declarator| {
usize::from(declarator.text_range().start()) >= body_end
&& declared_name(&declarator).is_some()
})
}
fn the_declarators_name_around(node: &CppSyntaxNode) -> Option<String> {
let declaration = node
.ancestors()
.find(|ancestor| cpp_parser::CppDeclaration::can_cast(ancestor.kind().into()))?;
let declaration = cpp_parser::CppDeclaration::cast(declaration)?;
declaration.get_name_text()
}
fn sits_in_a_class_body(node: &CppSyntaxNode) -> bool {
for ancestor in node.ancestors() {
if cpp_parser::CppClassBody::can_cast(ancestor.kind().into()) {
return true;
}
if cpp_parser::CppCompoundStat::can_cast(ancestor.kind().into())
|| CppSyntaxKind::from(ancestor.kind()) == CppSyntaxKind::TranslationUnit
{
return false;
}
}
false
}
fn declaration_parts(&mut self, node: &CppSyntaxNode, outer: ScopeId, inner: ScopeId) {
let qualified_name = the_qualified_name_of_a_declaration(node);
if qualified_name.is_some()
&& node.ancestors().any(|ancestor| {
ancestor.parent().is_some_and(|parent| {
cpp_parser::CppCompoundStat::can_cast(ancestor.kind().into())
&& !cpp_parser::CppNamespaceDecl::can_cast(parent.kind().into())
})
})
{
return;
}
let is_friend = node
.children()
.any(|child| cpp_parser::CppFriendDecl::can_cast(child.kind().into()))
|| node
.parent()
.is_some_and(|parent| cpp_parser::CppFriendDecl::can_cast(parent.kind().into()));
if let Some((qualifier, _)) = &qualified_name
&& self.scope_of_the_qualifier(qualifier, outer).is_none()
{
self.read_the_inside_of_a_foreign_definition(node, outer);
return;
} else if qualified_name.is_none() && is_unnamed_declaration(node) {
if declares_a_body(node) {
self.specifiers(node, outer, inner, false);
return;
}
if !is_friend {
return;
}
}
if let Some(names) = ScopeWalker::structured_binding_names(node) {
for name_node in names {
if let Some((name, name_range)) = declared_name(&name_node) {
self.bind(outer, name, BindingKind::Variable, &name_node, name_range);
}
}
return;
}
let body = function_body(node);
let mut function_scope = None;
match self.specifiers(node, outer, inner, is_friend) {
SpecifierName::Bound => return,
SpecifierName::InDeclarator(kind) => {
if declarators(node).is_empty() {
if let Some((name, name_range)) = elaborated_type_name(node) {
self.bind(outer, name, kind, node, name_range);
}
return;
}
for declarator in declarators(node) {
function_scope = self
.declarator_as(
&declarator,
outer,
inner,
is_friend,
Some(kind),
body.as_ref(),
)
.or(function_scope);
}
}
SpecifierName::None => {
for declarator in declarators(node) {
function_scope = self
.declarator_as(&declarator, outer, inner, is_friend, None, body.as_ref())
.or(function_scope);
}
}
}
if declarators(node)
.iter()
.all(|declarator| declared_name(declarator).is_none())
&& let Some(declaration) = cpp_parser::CppDeclaration::cast(node.clone())
&& declaration.get_param_list().is_some()
&& let Some(token) = declaration.get_name()
{
let text = token.get_name_text().to_string();
if let Some(name) = name_from_text(&text, node) {
self.bind(
inner,
name,
BindingKind::Constructor,
node,
cpp_parser::source_range(token.get_range()),
);
}
}
for declarator in declarators(node) {
for lambda in cpp_parser::typed_descendants::<cpp_parser::CppLambdaExpr>(&declarator) {
self.lambda(lambda.syntax(), outer);
}
}
if let Some(function) = function_scope
&& let Some(body) = body
{
self.items(&body, function);
}
}
fn structured_binding_names(node: &CppSyntaxNode) -> Option<Vec<CppSyntaxNode>> {
for declarator in declarators(node) {
if let Some(binding) = declarator
.descendants()
.find(|child| cpp_parser::CppStructuredBinding::can_cast(child.kind().into()))
{
return Some(binding.children().collect());
}
}
None
}
fn specifiers(
&mut self,
node: &CppSyntaxNode,
outer: ScopeId,
inner: ScopeId,
is_friend: bool,
) -> SpecifierName {
let Some(specifiers) = first_child(node, CppSyntaxKind::DeclSpecifierSeq) else {
return SpecifierName::None;
};
for child in specifiers.children() {
match CppSyntaxKind::from(child.kind()) {
CppSyntaxKind::InitDeclarator | CppSyntaxKind::Declarator => {}
CppSyntaxKind::ClassDef
| CppSyntaxKind::StructDef
| CppSyntaxKind::UnionDef
| CppSyntaxKind::ClassDecl
| CppSyntaxKind::StructDecl
| CppSyntaxKind::UnionDecl => {
if !is_friend {
self.class_like(&child, outer, inner, BindingKind::Class);
}
if declarators(node).is_empty() {
return SpecifierName::Bound;
}
}
CppSyntaxKind::FriendDecl => {
self.items(&child, outer);
}
CppSyntaxKind::EnumDef | CppSyntaxKind::EnumClassDef => {
if !is_friend {
self.enum_like(&child, outer, inner);
}
if declarators(node).is_empty() {
return SpecifierName::Bound;
}
}
CppSyntaxKind::BuiltinType => {
let Some(binding) = class_like_binding_of(&child) else {
continue;
};
if is_friend {
return SpecifierName::Bound;
}
let named_here = self.bare_class_like(&child, outer, inner, binding);
return if named_here {
SpecifierName::Bound
} else {
SpecifierName::InDeclarator(binding)
};
}
_ => {}
}
}
SpecifierName::None
}
fn scope_of_a_qualifier(&self, qualifier: &str) -> Option<ScopeId> {
let mut segments: Vec<String> = Vec::new();
let mut depth = 0usize;
let mut letters = String::new();
for character in qualifier.chars() {
match character {
'<' => depth += 1,
'>' => depth = depth.saturating_sub(1),
':' if depth == 0 => {
if !letters.is_empty() {
segments.push(std::mem::take(&mut letters));
}
}
_ if depth == 0 => letters.push(character),
_ => {}
}
}
if !letters.is_empty() {
segments.push(letters);
}
let mut walked = String::new();
let mut found = None;
for segment in segments {
if !walked.is_empty() {
walked.push_str("::");
}
walked.push_str(&segment);
found = self.table.scope_with_qualified_name(&walked);
found?;
}
found
}
fn scope_of_the_qualifier(&self, qualifier: &str, from: ScopeId) -> Option<ScopeId> {
let mut ancestor = Some(from);
let mut seen = std::collections::HashSet::new();
while let Some(scope) = ancestor {
if !seen.insert(scope) {
break;
}
let Some(data) = self.table.scope(scope) else {
break;
};
let usable = matches!(
data.kind,
ScopeKind::TranslationUnit
| ScopeKind::Namespace
| ScopeKind::Class
| ScopeKind::Enum
);
if usable && let Some(found) = self.scope_of_a_qualifier_inside(qualifier, scope) {
return Some(found);
}
ancestor = data.parent;
}
self.scope_of_a_qualifier(qualifier)
}
fn scope_of_a_qualifier_inside(&self, qualifier: &str, prefix: ScopeId) -> Option<ScopeId> {
let base = self.table.qualified_name_of(prefix);
let mut segments: Vec<String> = Vec::new();
let mut depth = 0usize;
let mut letters = String::new();
for character in qualifier.chars() {
match character {
'<' => depth += 1,
'>' => depth = depth.saturating_sub(1),
':' if depth == 0 => {
if !letters.is_empty() {
segments.push(std::mem::take(&mut letters));
}
}
_ if depth == 0 => letters.push(character),
_ => {}
}
}
if !letters.is_empty() {
segments.push(letters);
}
if segments.is_empty() {
return None;
}
let mut walked = base.unwrap_or_default();
let mut found = None;
for segment in segments {
if !walked.is_empty() {
walked.push_str("::");
}
walked.push_str(&segment);
found = self.table.scope_with_qualified_name(&walked);
found?;
}
found
}
fn read_the_inside_of_a_foreign_definition(&mut self, node: &CppSyntaxNode, outer: ScopeId) {
let Some(body) = function_body(node) else {
return;
};
let Some(declarator) = declarators(node).into_iter().next() else {
return;
};
let range = span_of(
cpp_parser::source_range(declarator.text_range()),
cpp_parser::source_range(body.text_range()),
);
let spelled = the_qualified_name_of_a_declaration(node)
.map(|(qualifier, (name, _))| format!("{qualifier}::{}", name.text()));
let function = match &spelled {
Some(spelled) => {
let qualifier = spelled.rsplit_once("::").map(|(qualifier, _)| qualifier);
let parent = qualifier
.and_then(|qualifier| self.scope_of_the_qualifier(qualifier, outer))
.unwrap_or(outer);
self.table.create_named_scope(
ScopeKind::Function,
Some(parent),
Some(range),
Some(spelled),
)
}
None => self
.table
.create_scope(ScopeKind::Function, Some(outer), Some(range)),
};
for parameter_list in parameter_lists(&declarator) {
self.parameters(¶meter_list, function);
}
self.items(&body, function);
}
fn a_value_named(&self, scope: ScopeId, text: &str) -> bool {
if text.is_empty() {
return false;
}
let mut current = Some(scope);
while let Some(id) = current {
let Some(data) = self.table.scope(id) else {
return false;
};
if data.bindings.iter().any(|binding| {
matches!(
binding.kind,
BindingKind::Variable | BindingKind::Enumerator
) && binding.name.is(text)
}) {
return true;
}
current = data.parent;
}
false
}
fn declarator_as(
&mut self,
declarator: &CppSyntaxNode,
outer: ScopeId,
inner: ScopeId,
is_friend: bool,
as_kind: Option<BindingKind>,
body: Option<&CppSyntaxNode>,
) -> Option<ScopeId> {
let mut qualified_spelling = None;
let qualified =
qualified_declarator_name(declarator).or_else(|| qualified_specifier_name(declarator));
let (enclosing, name, name_range) = match qualified {
Some((qualifier, name)) => {
qualified_spelling = name
.0
.identifier_text()
.map(|name| format!("{qualifier}::{name}"));
(
self.scope_of_the_qualifier(&qualifier, outer)
.unwrap_or(outer),
name.0,
name.1,
)
}
None => match declared_name(declarator) {
Some((name, name_range)) => (outer, name, name_range),
None => {
let function = self.table.create_scope(
ScopeKind::Function,
Some(outer),
Some(cpp_parser::source_range(declarator.text_range())),
);
for parameter_list in parameter_lists(declarator) {
self.parameters(¶meter_list, function);
}
return Some(function);
}
},
};
let spelled = declarator.text().to_string();
let trimmed = spelled.trim_start();
let parenthesised_a_pointer = trimmed.starts_with("(*") || trimmed.starts_with("(&");
let is_function = !parenthesised_a_pointer
&& declarator
.descendants()
.any(|child| cpp_parser::CppParamList::can_cast(child.kind().into()));
if let Some(kind) = as_kind {
self.bind(enclosing, name, kind, declarator, name_range);
return None;
}
let parentheses_hold_a_value = is_function
&& declarator
.ancestors()
.any(|ancestor| cpp_parser::CppCompoundStat::can_cast(ancestor.kind().into()))
&& parameter_lists(declarator).iter().any(|list| {
list.children().any(|parameter| {
let Some(named) = parameter
.descendants()
.find(|child| cpp_parser::CppNameExpr::can_cast(child.kind().into()))
else {
return false;
};
let spelled = named.text().to_string();
let last = spelled.rsplit("::").next().unwrap_or(&spelled).trim();
!spelled.contains("::") && self.a_value_named(enclosing, last)
})
});
if !is_function || parentheses_hold_a_value {
self.bind(
enclosing,
name,
BindingKind::Variable,
declarator,
name_range,
);
return None;
}
let kind = function_binding_kind(&name);
if !is_friend {
self.bind(enclosing, name, kind, declarator, name_range);
}
let has_parameters = parameter_lists(declarator)
.iter()
.any(|list| list.children().next().is_some());
if body.is_none() && !has_parameters {
return None;
}
let parent = if enclosing == outer { inner } else { enclosing };
let range = match body {
Some(body) => span_of(
cpp_parser::source_range(declarator.text_range()),
cpp_parser::source_range(body.text_range()),
),
None => cpp_parser::source_range(declarator.text_range()),
};
let function = match qualified_spelling {
Some(spelling) => self.table.create_named_scope(
ScopeKind::Function,
Some(parent),
Some(range),
Some(&spelling),
),
None => self
.table
.create_scope(ScopeKind::Function, Some(parent), Some(range)),
};
for parameter_list in parameter_lists(declarator) {
self.parameters(¶meter_list, function);
}
Some(function)
}
fn bare_class_like(
&mut self,
specifier: &CppSyntaxNode,
outer: ScopeId,
inner: ScopeId,
binding: BindingKind,
) -> bool {
let scope_kind = match binding {
BindingKind::Enum => ScopeKind::Enum,
_ => ScopeKind::Class,
};
let named = specifier_name(specifier).or_else(|| declared_name(specifier));
let named_here = named.is_some();
let named_text = named.as_ref().map(|(name, _)| name.kind.text());
if let Some((name, name_range)) = named {
self.bind(outer, name, binding, specifier, name_range);
}
let has_body = specifier
.descendants()
.any(|child| cpp_parser::CppCompoundStat::can_cast(child.kind().into()));
if !has_body {
return named_here;
}
let scope = self.table.create_named_scope(
scope_kind,
Some(inner),
Some(cpp_parser::source_range(specifier.text_range())),
named_text.as_deref(),
);
for body in specifier
.descendants()
.filter(|child| cpp_parser::CppCompoundStat::can_cast(child.kind().into()))
{
self.enumerators(&body, scope);
}
named_here
}
fn parameters(&mut self, list: &CppSyntaxNode, scope: ScopeId) {
for (declarator, declared) in parameters_of(list) {
if let Some((name, name_range)) = declared {
self.bind(scope, name, BindingKind::Variable, &declarator, name_range);
}
}
}
fn statement_scope(&mut self, node: &CppSyntaxNode, parent: ScopeId) {
let scope = self.table.create_scope(
ScopeKind::Block,
Some(parent),
Some(cpp_parser::source_range(node.text_range())),
);
self.items(node, scope);
}
fn lambda(&mut self, node: &CppSyntaxNode, scope: ScopeId) {
let inner = self.table.create_scope(
ScopeKind::Lambda,
Some(scope),
Some(cpp_parser::source_range(node.text_range())),
);
let mut inside = inner;
if let Some(list) = node
.children()
.find(|child| cpp_parser::CppTemplateParamList::can_cast(child.kind().into()))
{
let parameters = self.table.create_scope(
ScopeKind::TemplateParameters,
Some(inner),
Some(cpp_parser::source_range(list.text_range())),
);
self.template_parameters(&list, parameters);
inside = parameters;
}
for list in node
.children()
.filter(|child| cpp_parser::CppParamList::can_cast(child.kind().into()))
{
self.parameters(&list, inside);
}
for body in node
.children()
.filter(|child| cpp_parser::CppCompoundStat::can_cast(child.kind().into()))
{
self.items(&body, inside);
}
}
fn label(&mut self, node: &CppSyntaxNode, scope: ScopeId) {
if let Some((name, name_range)) = declared_name(node) {
self.bind(scope, name, BindingKind::Label, node, name_range);
}
}
fn bind(
&mut self,
scope: ScopeId,
name: Name,
kind: BindingKind,
node: &CppSyntaxNode,
name_range: cpp_parser::SourceRange,
) {
self.table.add_binding(
scope,
Binding {
name,
kind,
range: without_trailing_trivia(node),
name_range,
scope,
origin: None,
},
);
}
}
pub(crate) fn without_trailing_trivia(node: &CppSyntaxNode) -> cpp_parser::SourceRange {
let range = cpp_parser::source_range(node.text_range());
let end = significant_end(node).unwrap_or(range.end_offset());
cpp_parser::SourceRange::new(
range.start_offset,
end.max(range.start_offset) - range.start_offset,
)
}
fn significant_end(node: &CppSyntaxNode) -> Option<usize> {
for element in node
.children_with_tokens()
.collect::<Vec<_>>()
.into_iter()
.rev()
{
match element.clone().into_token() {
Some(token) => {
if !cpp_parser::is_trivia(cpp_parser::CppTokenKind::from(token.kind())) {
return Some(cpp_parser::source_range(token.text_range()).end_offset());
}
}
None => {
let inner = element
.into_node()
.expect("a node-or-token is one of the two");
match significant_end(&inner) {
Some(inner_end) => return Some(inner_end),
None => continue,
}
}
}
}
None
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum SpecifierName {
None,
Bound,
InDeclarator(BindingKind),
}
fn function_body(node: &CppSyntaxNode) -> Option<CppSyntaxNode> {
if let Some(direct) = first_child(node, CppSyntaxKind::CompoundStat) {
return Some(direct);
}
for declarator in declarators(node) {
for child in declarator.children() {
if cpp_parser::CppCompoundStat::can_cast(child.kind().into()) {
return Some(child);
}
}
}
let specifiers = first_child(node, CppSyntaxKind::DeclSpecifierSeq)?;
for child in specifiers.descendants() {
if !cpp_parser::CppClassBody::can_cast(child.kind().into()) {
continue;
}
for member in child.children() {
if let Some(body) = function_body(&member) {
return Some(body);
}
}
}
None
}
fn parameter_lists(declarator: &CppSyntaxNode) -> Vec<CppSyntaxNode> {
fn collect(node: &CppSyntaxNode, out: &mut Vec<CppSyntaxNode>) {
for child in node.children() {
match CppSyntaxKind::from(child.kind()) {
CppSyntaxKind::ParameterList => out.push(child),
CppSyntaxKind::CompoundStat | CppSyntaxKind::ClassBody => {}
CppSyntaxKind::Declarator => collect(&child, out),
_ => {}
}
}
}
let mut lists = Vec::new();
collect(declarator, &mut lists);
lists
}
fn function_binding_kind(name: &Name) -> BindingKind {
match name.kind {
crate::symbol::NameKind::Destructor(_) => BindingKind::Destructor,
crate::symbol::NameKind::Conversion(_) => BindingKind::ConversionFunction,
crate::symbol::NameKind::Operator(_) => BindingKind::OperatorFunction,
crate::symbol::NameKind::Literal(_) => BindingKind::LiteralOperator,
crate::symbol::NameKind::Identifier(_) => BindingKind::Function,
}
}
fn declares_a_body(node: &CppSyntaxNode) -> bool {
node.descendants().any(|child| {
matches!(
CppSyntaxKind::from(child.kind()),
CppSyntaxKind::EnumDef
| CppSyntaxKind::EnumClassDef
| CppSyntaxKind::ClassDef
| CppSyntaxKind::StructDef
| CppSyntaxKind::UnionDef
)
})
}
fn is_unnamed_declaration(node: &CppSyntaxNode) -> bool {
if !cpp_parser::CppDeclaration::can_cast(node.kind().into()) {
return false;
}
let declares_an_operator = node
.children()
.filter(|child| !cpp_parser::CppInitializer::can_cast(child.kind().into()))
.flat_map(|child| child.descendants_with_tokens())
.filter_map(|element| element.into_token())
.any(|token| CppTokenKind::from(token.kind()) == CppTokenKind::OperatorKeyword);
if declares_an_operator {
return false;
}
if declarators(node)
.iter()
.any(|declarator| declared_name(declarator).is_some())
{
return false;
}
match cpp_parser::CppDeclaration::cast(node.clone()) {
Some(declaration) => declaration.get_name_text().is_none(),
None => false,
}
}
fn declaration_is_qualified(node: &CppSyntaxNode) -> bool {
let Some(specifiers) = first_child(node, CppSyntaxKind::DeclSpecifierSeq) else {
return false;
};
if !mentions_a_qualified_name(&specifiers, true) {
return false;
}
!declarators(node).iter().any(named_in_a_declarator)
}
fn mentions_a_qualified_name(node: &CppSyntaxNode, outside_a_declarator: bool) -> bool {
for child in node.children() {
let kind = CppSyntaxKind::from(child.kind());
if matches!(
kind,
CppSyntaxKind::ClassBody
| CppSyntaxKind::Declaration
| CppSyntaxKind::CompoundStat
| CppSyntaxKind::BaseSpecifier
) {
continue;
}
if outside_a_declarator && kind == CppSyntaxKind::NameExpr && is_qualified(&child) {
return true;
}
let still_outside = outside_a_declarator && kind != CppSyntaxKind::Declarator;
if mentions_a_qualified_name(&child, still_outside) {
return true;
}
}
false
}
fn named_in_a_declarator(declarator: &CppSyntaxNode) -> bool {
for child in declarator.children_with_tokens() {
if let Some(token) = child.clone().into_token() {
if CppTokenKind::from(token.kind()) == CppTokenKind::Identifier {
return true;
}
continue;
}
if let Some(node) = child.into_node() {
if cpp_parser::CppParamList::can_cast(node.kind().into()) {
continue;
}
if named_in_a_declarator(&node) {
return true;
}
}
}
false
}
fn first_child(node: &CppSyntaxNode, kind: CppSyntaxKind) -> Option<CppSyntaxNode> {
node.children()
.find(|child| CppSyntaxKind::from(child.kind()) == kind)
}
fn invocation_name(node: &CppSyntaxNode) -> Option<String> {
let name = first_child(node, CppSyntaxKind::NameExpr)?;
name.children_with_tokens()
.filter_map(|child| child.into_token())
.find(|token| CppTokenKind::from(token.kind()) == CppTokenKind::Identifier)
.map(|token| token.text().to_string())
}
fn class_like_binding_of(specifier: &CppSyntaxNode) -> Option<BindingKind> {
let mut is_enum = false;
let mut is_class_like = false;
for token in specifier
.children_with_tokens()
.filter_map(|child| child.into_token())
{
match CppTokenKind::from(token.kind()) {
CppTokenKind::EnumKeyword => is_enum = true,
CppTokenKind::ClassKeyword
| CppTokenKind::StructKeyword
| CppTokenKind::UnionKeyword => {
is_class_like = true;
}
_ => {}
}
}
match (is_enum, is_class_like) {
(true, _) => Some(BindingKind::Enum),
(false, true) => Some(BindingKind::Class),
(false, false) => None,
}
}
fn declarators(node: &CppSyntaxNode) -> Vec<CppSyntaxNode> {
let a_declarator = |child: &CppSyntaxNode| {
matches!(
CppSyntaxKind::from(child.kind()),
CppSyntaxKind::InitDeclarator | CppSyntaxKind::Declarator
) && !child.text_range().is_empty()
};
let init: Vec<CppSyntaxNode> = node
.children()
.filter(|child| cpp_parser::CppInitDeclarator::can_cast(child.kind().into()))
.filter(a_declarator)
.collect();
if !init.is_empty() {
return init;
}
let direct: Vec<CppSyntaxNode> = node
.children()
.filter(|child| cpp_parser::CppDeclarator::can_cast(child.kind().into()))
.filter(a_declarator)
.collect();
if !direct.is_empty() {
return direct;
}
node.children()
.filter(|child| cpp_parser::CppDeclaration::can_cast(child.kind().into()))
.flat_map(|wrapped| declarators(&wrapped))
.collect()
}
fn specifier_name(specifier: &CppSyntaxNode) -> Option<(Name, cpp_parser::SourceRange)> {
for element in specifier.descendants_with_tokens() {
let Some(node) = element.as_node() else {
let Some(token) = element.as_token() else {
continue;
};
if CppTokenKind::from(token.kind()) != CppTokenKind::Identifier {
continue;
}
let text = token.text();
let name = name_from_text(text, specifier)?;
return Some((name, cpp_parser::source_range(token.text_range())));
};
if cpp_parser::CppCompoundStat::can_cast(node.kind().into()) {
return None;
}
}
None
}
fn the_typedef_name_around(node: &CppSyntaxNode) -> Option<String> {
let declaration = node
.ancestors()
.find_map(cpp_parser::CppDeclaration::cast)?;
let owns_a_typedef = declaration.is_a_typedef();
if !owns_a_typedef {
return None;
}
let body_end = node
.children()
.find(|child| {
cpp_parser::CppClassBody::can_cast(child.kind().into())
|| cpp_parser::CppCompoundStat::can_cast(child.kind().into())
})
.map(|body| usize::from(body.text_range().end()))
.unwrap_or(0);
let mut last = None;
for element in declaration.syntax().descendants_with_tokens() {
let Some(token) = element.into_token() else {
continue;
};
if usize::from(token.text_range().start()) < body_end {
continue;
}
if CppTokenKind::from(token.kind()) == CppTokenKind::Identifier {
last = Some(token.text().to_string());
}
}
last.filter(|name| !name.is_empty())
}
fn declared_name(node: &CppSyntaxNode) -> Option<(Name, cpp_parser::SourceRange)> {
if let Some(name_node) = name_node_along_declarator(node) {
if is_qualified(&name_node) {
return None;
}
if name_node
.descendants_with_tokens()
.filter_map(|child| child.into_token())
.any(|token| CppTokenKind::from(token.kind()) == CppTokenKind::OperatorKeyword)
{
let spelling = name_node.text().to_string();
let spelling = spelling.trim();
let symbol = spelling
.strip_prefix("operator")
.map(str::trim)
.unwrap_or(spelling);
if !symbol.is_empty() {
return Some((
Name::operator(symbol),
cpp_parser::source_range(name_node.text_range()),
));
}
}
let token = first_identifier_in_name(&name_node)?;
let text = token.text();
let range = if token.text_range().is_empty() {
cpp_parser::source_range(name_node.text_range())
} else {
cpp_parser::source_range(token.text_range())
};
if let Some(name) = name_from_text(text, &name_node) {
return Some((name, range));
}
}
if let Some(declaration) = cpp_parser::CppDeclaration::cast(node.clone())
&& let Some(token) = declaration.get_name()
{
let text = token.get_name_text().to_string();
if let Some(name) = name_from_text(&text, node) {
return Some((name, cpp_parser::source_range(token.get_range())));
}
}
let token = last_identifier(node)?;
let text = token.text();
let name = name_from_text(text, node)?;
Some((name, cpp_parser::source_range(token.text_range())))
}
pub(crate) fn parameters_of(
list: &CppSyntaxNode,
) -> Vec<(CppSyntaxNode, Option<(Name, cpp_parser::SourceRange)>)> {
list.children()
.filter(|child| cpp_parser::CppParam::can_cast(child.kind().into()))
.map(|parameter| {
let declared = parameter
.children()
.filter(|child| cpp_parser::CppDeclarator::can_cast(child.kind().into()))
.find_map(|declarator| declared_name(&declarator));
(parameter, declared)
})
.collect()
}
fn namespace_segments(node: &CppSyntaxNode) -> Vec<String> {
namespace_segments_with_ranges(node)
.into_iter()
.map(|(name, _)| name)
.collect()
}
fn namespace_segment_ranges(node: &CppSyntaxNode) -> Vec<cpp_parser::SourceRange> {
namespace_segments_with_ranges(node)
.into_iter()
.map(|(_, range)| range)
.collect()
}
fn namespace_segments_with_ranges(node: &CppSyntaxNode) -> Vec<(String, cpp_parser::SourceRange)> {
let Some(name) = first_child(node, CppSyntaxKind::NameExpr) else {
return Vec::new();
};
name.children_with_tokens()
.filter_map(|child| child.into_token())
.filter(|token| CppTokenKind::from(token.kind()) == CppTokenKind::Identifier)
.map(|token| {
(
token.text().to_string(),
cpp_parser::source_range(token.text_range()),
)
})
.collect()
}
fn name_node_along_declarator(node: &CppSyntaxNode) -> Option<CppSyntaxNode> {
match CppSyntaxKind::from(node.kind()) {
CppSyntaxKind::NameExpr => return Some(node.clone()),
CppSyntaxKind::DeclSpecifierSeq
| CppSyntaxKind::TemplateParameter
| CppSyntaxKind::TypenameType
| CppSyntaxKind::TemplateType
| CppSyntaxKind::NamedType
| CppSyntaxKind::QualifiedType
| CppSyntaxKind::PointerType
| CppSyntaxKind::ReferenceType
| CppSyntaxKind::RValueReferenceType
| CppSyntaxKind::BuiltinType => {
for child in node.children() {
if let Some(found) = name_node_along_declarator(&child) {
return Some(found);
}
}
return None;
}
CppSyntaxKind::Declarator => {
for child in node.children() {
if cpp_parser::CppDeclarator::can_cast(child.kind().into())
&& let Some(found) = name_node_along_declarator(&child)
{
return Some(found);
}
}
for child in node.children() {
if cpp_parser::CppNameExpr::can_cast(child.kind().into()) {
return Some(child);
}
}
return None;
}
_ => {}
}
for child in node.children() {
if matches!(
CppSyntaxKind::from(child.kind()),
CppSyntaxKind::Declarator | CppSyntaxKind::NameExpr
) && let Some(found) = name_node_along_declarator(&child)
{
return Some(found);
}
}
None
}
fn first_identifier_in_name(node: &CppSyntaxNode) -> Option<cpp_parser::CppSyntaxToken> {
if let Some(token) = last_identifier(node) {
return Some(token);
}
for child in node.children() {
if !cpp_parser::CppNameExpr::can_cast(child.kind().into()) {
continue;
}
if let Some(token) = first_identifier_in_name(&child) {
return Some(token);
}
}
None
}
fn span_of(
first: cpp_parser::SourceRange,
second: cpp_parser::SourceRange,
) -> cpp_parser::SourceRange {
let start = first.start_offset.min(second.start_offset);
let end = first.end_offset().max(second.end_offset());
cpp_parser::SourceRange {
start_offset: start,
length: end.saturating_sub(start),
}
}
fn find_name_node(node: &CppSyntaxNode) -> Option<CppSyntaxNode> {
if !cpp_parser::CppNameExpr::can_cast(node.kind().into()) {
return find_name_child(node);
}
find_name_child(node).or_else(|| Some(node.clone()))
}
fn find_name_child(node: &CppSyntaxNode) -> Option<CppSyntaxNode> {
for child in node.children() {
if matches!(
CppSyntaxKind::from(child.kind()),
CppSyntaxKind::ParameterList | CppSyntaxKind::CompoundStat | CppSyntaxKind::ClassBody
) {
continue;
}
if let Some(found) = find_name_node(&child) {
return Some(found);
}
}
None
}
fn elaborated_type_name(node: &CppSyntaxNode) -> Option<(Name, cpp_parser::SourceRange)> {
let specifiers = first_child(node, CppSyntaxKind::DeclSpecifierSeq)?;
let has_class_keyword = specifiers.children().any(|child| {
CppSyntaxKind::from(child.kind()) == CppSyntaxKind::BuiltinType
&& is_class_like_keyword_token(&child)
});
if !has_class_keyword {
return None;
}
let name_node = specifiers.children().find(|child| {
matches!(
CppSyntaxKind::from(child.kind()),
CppSyntaxKind::TemplateType | CppSyntaxKind::NamedType
)
})?;
let token = first_identifier_in_name(&name_node)?;
let name = name_from_text(token.text(), node)?;
Some((name, cpp_parser::source_range(token.text_range())))
}
fn is_class_like_keyword_token(node: &CppSyntaxNode) -> bool {
node.children_with_tokens()
.filter_map(|element| element.into_token())
.any(|token| {
matches!(
token.kind(),
cpp_parser::CppKind::Token(CppTokenKind::ClassKeyword)
| cpp_parser::CppKind::Token(CppTokenKind::StructKeyword)
| cpp_parser::CppKind::Token(CppTokenKind::UnionKeyword)
| cpp_parser::CppKind::Token(CppTokenKind::EnumKeyword)
)
})
}
fn qualified_declarator_name(
declarator: &CppSyntaxNode,
) -> Option<(String, (Name, cpp_parser::SourceRange))> {
let node = name_node_along_declarator(declarator)?;
if is_qualified(&node) {
return qualified_name(node);
}
None
}
pub(crate) fn the_qualified_name_of_a_declaration(
node: &CppSyntaxNode,
) -> Option<(String, (Name, cpp_parser::SourceRange))> {
declarators(node)
.iter()
.find_map(qualified_declarator_name)
.or_else(|| qualified_specifier_name_of_the_declaration(node))
}
fn qualified_specifier_name(
declarator: &CppSyntaxNode,
) -> Option<(String, (Name, cpp_parser::SourceRange))> {
let declaration = declarator
.ancestors()
.find(|node| cpp_parser::CppDeclaration::can_cast(node.kind().into()))?;
qualified_specifier_name_of_the_declaration(&declaration)
}
fn qualified_specifier_name_of_the_declaration(
declaration: &CppSyntaxNode,
) -> Option<(String, (Name, cpp_parser::SourceRange))> {
qualified_name(qualified_specifier_name_node(declaration)?)
}
fn qualified_specifier_name_node(declaration: &CppSyntaxNode) -> Option<CppSyntaxNode> {
if !declaration_is_qualified(declaration) {
return None;
}
let specifiers = first_child(declaration, CppSyntaxKind::DeclSpecifierSeq)?;
cpp_parser::typed_descendants::<cpp_parser::CppNameExpr>(&specifiers)
.find(|name| name.is_qualified())
.map(|name| name.syntax().clone())
}
fn qualified_name(node: CppSyntaxNode) -> Option<(String, (Name, cpp_parser::SourceRange))> {
struct Spelled {
characters: Vec<char>,
origins: Vec<(cpp_parser::CppSyntaxToken, usize)>,
}
fn spell(node: &CppSyntaxNode, into: &mut Spelled) {
for child in node.children_with_tokens() {
if let Some(token) = child.clone().into_token() {
let kind = CppTokenKind::from(token.kind());
if matches!(
kind,
CppTokenKind::Whitespace
| CppTokenKind::LineComment
| CppTokenKind::BlockComment
) {
continue;
}
for (at, character) in token.text().chars().enumerate() {
into.characters.push(character);
into.origins.push((token.clone(), at));
}
continue;
}
if let Some(child) = child.into_node() {
spell(&child, into);
}
}
}
let mut spelled = Spelled {
characters: Vec::new(),
origins: Vec::new(),
};
spell(&node, &mut spelled);
let mut depth = 0usize;
let mut last_separator = None;
let mut at = 0usize;
while at < spelled.characters.len() {
match spelled.characters[at] {
'<' => depth += 1,
'>' => depth = depth.saturating_sub(1),
':' if depth == 0 && spelled.characters.get(at + 1) == Some(&':') => {
last_separator = Some(at);
at += 1;
}
_ => {}
}
at += 1;
}
let last_separator = last_separator?;
let after_the_separator = last_separator + 2;
let qualifier: String = spelled.characters[..last_separator].iter().collect();
let written: String = spelled.characters[after_the_separator..].iter().collect();
if written
.chars()
.next()
.is_none_or(|first| !is_identifier_start(first))
|| !written.chars().all(is_identifier_character)
{
return None;
}
let (token, offset_in_it) = spelled.origins.get(after_the_separator)?;
let starts_at = usize::from(token.text_range().start()) + offset_in_it;
Some((
qualifier,
(
Name::identifier(written.clone()),
cpp_parser::SourceRange::new(starts_at, written.len()),
),
))
}
fn is_identifier_start(character: char) -> bool {
character.is_alphabetic() || character == '_'
}
fn is_identifier_character(character: char) -> bool {
character.is_alphanumeric() || character == '_'
}
fn is_qualified(node: &CppSyntaxNode) -> bool {
node.children_with_tokens()
.filter_map(|child| child.into_token())
.any(|token| CppTokenKind::from(token.kind()) == CppTokenKind::Scope)
}
fn last_identifier(node: &CppSyntaxNode) -> Option<cpp_parser::CppSyntaxToken> {
node.children_with_tokens()
.filter_map(|child| child.into_token())
.filter(|token| CppTokenKind::from(token.kind()) == CppTokenKind::Identifier)
.last()
}
fn name_from_text(text: &str, node: &CppSyntaxNode) -> Option<Name> {
let has_operator_keyword = node
.descendants_with_tokens()
.filter_map(|child| child.into_token())
.any(|token| CppTokenKind::from(token.kind()) == CppTokenKind::OperatorKeyword);
if has_operator_keyword {
return Some(Name::operator(text));
}
let declarator_text = node
.parent()
.filter(|parent| cpp_parser::CppDeclarator::can_cast(parent.kind().into()))
.map(|parent| parent.text().to_string())
.unwrap_or_else(|| node.text().to_string());
let has_tilde = declarator_text.trim_start().starts_with('~');
if has_tilde {
let spelling: String = if text.is_empty() {
declarator_text
} else {
text.to_string()
}
.chars()
.filter(|character| !character.is_whitespace())
.collect();
let class = spelling.strip_prefix('~').unwrap_or(&spelling);
let class = class.split(['(', '<']).next().unwrap_or(class);
if class.is_empty() {
return None;
}
return Some(Name::destructor(class));
}
if text.is_empty() {
return None;
}
Some(Name::identifier(text))
}
pub fn declared_module_names(root: &CppSyntaxNode) -> Vec<DeclName> {
let mut names = Vec::new();
for node in root.descendants() {
match CppSyntaxKind::from(node.kind()) {
CppSyntaxKind::ModuleDecl => {
if let Some(name) = module_name_of(&node, CppSyntaxKind::ModuleName) {
names.push(DeclName::Module(name));
}
if let Some(partition) = module_name_of(&node, CppSyntaxKind::ModulePartition) {
names.push(DeclName::Partition(partition));
}
}
CppSyntaxKind::ImportDecl => {
if let Some(name) = module_name_of(&node, CppSyntaxKind::ModuleName) {
names.push(DeclName::Module(name));
}
if let Some(partition) = module_name_of(&node, CppSyntaxKind::ModulePartition) {
names.push(DeclName::Partition(partition));
}
}
_ => {}
}
}
names
}
fn module_name_of(node: &CppSyntaxNode, wrapper: CppSyntaxKind) -> Option<QualifiedName> {
let holder = if wrapper == CppSyntaxKind::ModuleName {
node.clone()
} else {
first_child(node, wrapper)?
};
let components: Vec<String> = holder
.children_with_tokens()
.filter_map(|child| child.into_token())
.filter(|token| CppTokenKind::from(token.kind()) == CppTokenKind::Identifier)
.map(|token| token.text().to_string())
.collect();
if components.is_empty() {
return None;
}
Some(QualifiedName::from_components(components))
}
pub fn included_origin(file: crate::paths::FileId) -> BindingOrigin {
BindingOrigin::Included { file }
}
pub fn macro_origin(
macro_name: impl Into<String>,
definition: cpp_parser::SourceRange,
) -> BindingOrigin {
BindingOrigin::MacroExpansion {
macro_name: macro_name.into(),
definition,
}
}
pub fn declaring_kinds() -> &'static [CppSyntaxKind] {
&[
CppSyntaxKind::NamespaceDecl,
CppSyntaxKind::ClassDef,
CppSyntaxKind::StructDef,
CppSyntaxKind::UnionDef,
CppSyntaxKind::ClassDecl,
CppSyntaxKind::StructDecl,
CppSyntaxKind::UnionDecl,
CppSyntaxKind::EnumDef,
CppSyntaxKind::EnumClassDef,
CppSyntaxKind::TemplateDecl,
CppSyntaxKind::TypedefDecl,
CppSyntaxKind::UsingDecl,
CppSyntaxKind::UsingDirective,
CppSyntaxKind::Declaration,
CppSyntaxKind::LabelStat,
]
}
pub fn declares_a_binding(node: &CppSyntaxNode) -> bool {
declaring_kinds().contains(&CppSyntaxKind::from(node.kind()))
}
pub fn kind_name(node: &CppSyntaxNode) -> String {
format!("{:?}", CppSyntaxKind::from(node.kind()))
}