use cpp_parser::CppSyntaxNode;
use super::{Check, CheckContext, DiagnosticCode};
pub struct AccessInvisible;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Access {
Public,
Protected,
Private,
}
impl Access {
fn keyword(self) -> &'static str {
match self {
Access::Public => "public",
Access::Protected => "protected",
Access::Private => "private",
}
}
}
impl Check for AccessInvisible {
const CODES: &'static [DiagnosticCode] = &[DiagnosticCode::AccessInvisible];
fn check(context: &mut CheckContext<'_>) {
let declared_here: std::collections::HashSet<&str> = context
.summary
.declarations
.iter()
.map(|fact| fact.name.as_str())
.collect();
for (node, access) in context.member_accesses() {
if access.member.is_empty() || !declared_here.contains(access.member.as_str()) {
continue;
}
let crate::Known::Yes((object, _)) = context.type_of(&access.object) else {
continue;
};
let crate::Known::Yes(members) = context
.model
.members_of(object.class_name().unwrap_or_default())
else {
continue;
};
let Some(member) = members
.members
.iter()
.find(|member| member.fact.name == access.member)
else {
continue;
};
let Some(declaration) =
declaration_starting_at(context, member.fact.range.start_offset)
else {
continue;
};
if !context
.view
.was_written_here(cpp_parser::source_range(declaration.text_range()))
{
continue;
}
let Some(class) = enclosing_definition(&declaration) else {
continue;
};
let visibility = visibility_of(&class, member.fact.range.start_offset);
if visibility == Access::Public {
continue;
}
if enclosing_definition(&node).is_some_and(|holder| same_node(&holder, &class)) {
continue;
}
context.add(
DiagnosticCode::AccessInvisible,
access.member_range,
access.member.clone(),
format!(
"`{}` is {} in the class that declares it, and this is not that class's own code",
access.member,
visibility.keyword()
),
);
}
}
}
fn enclosing_definition(node: &CppSyntaxNode) -> Option<CppSyntaxNode> {
let mut current = node.parent();
while let Some(ancestor) = current {
if super::is_a_class_definition(&ancestor) {
return Some(ancestor);
}
current = ancestor.parent();
}
None
}
fn declaration_starting_at(
context: &super::CheckContext<'_>,
offset: usize,
) -> Option<CppSyntaxNode> {
let token = cpp_parser::token_at(context.tree(), offset)?;
token
.parent_ancestors()
.filter(|node| usize::from(node.text_range().start()) == offset)
.last()
}
fn same_node(left: &CppSyntaxNode, right: &CppSyntaxNode) -> bool {
left.text_range() == right.text_range() && left.kind() == right.kind()
}
fn visibility_of(class: &CppSyntaxNode, offset: usize) -> Access {
use cpp_parser::{CppAccessSpecifier, CppAstNode, CppAstToken, CppClassBody};
let mut in_force = default_access_of(class);
let Some(body) = cpp_parser::CppClassDef::cast(class.clone())
.and_then(|definition| definition.children::<CppClassBody>().next())
else {
return in_force;
};
for child in body.syntax().children() {
if usize::from(child.text_range().start()) >= offset {
break;
}
let Some(specifier) = CppAccessSpecifier::cast(child) else {
continue;
};
in_force = match specifier
.get_keyword()
.map(|keyword| cpp_parser::CppTokenKind::from(keyword.syntax().kind()))
{
Some(cpp_parser::CppTokenKind::PublicKeyword) => Access::Public,
Some(cpp_parser::CppTokenKind::ProtectedKeyword) => Access::Protected,
Some(cpp_parser::CppTokenKind::PrivateKeyword) => Access::Private,
_ => in_force,
};
}
in_force
}
fn default_access_of(class: &CppSyntaxNode) -> Access {
use cpp_parser::{CppAstNode, CppClassDef, CppTokenKind};
let keyword = CppClassDef::cast(class.clone()).and_then(|definition| {
definition
.syntax()
.descendants_with_tokens()
.filter_map(|element| element.into_token())
.find(|token| {
matches!(
CppTokenKind::from(token.kind()),
CppTokenKind::ClassKeyword
| CppTokenKind::StructKeyword
| CppTokenKind::UnionKeyword
)
})
});
match keyword.map(|token| CppTokenKind::from(token.kind())) {
Some(CppTokenKind::ClassKeyword) => Access::Private,
_ => Access::Public,
}
}