use cpp_parser::CppAstNode;
use super::borrowed::{Borrowed, Origin, origin_of, view_name_of};
use super::{Check, CheckContext, DiagnosticCode};
pub struct DanglingField;
impl Check for DanglingField {
const CODES: &'static [DiagnosticCode] = &[DiagnosticCode::DanglingField];
fn check(context: &mut CheckContext<'_>) {
let bodies: Vec<cpp_parser::CppSyntaxNode> = context
.own::<cpp_parser::CppClassBody>()
.map(|body| body.syntax().clone())
.collect();
for body in bodies {
let Some(body) = cpp_parser::CppClassBody::cast(body) else {
continue;
};
let Some(class_name) = the_class_name(&body) else {
continue;
};
let members = borrowing_members(&body);
if members.is_empty() {
continue;
}
for declaration in body.get_members() {
let Some((name, _)) = the_member_type(&declaration) else {
continue;
};
let Some(borrowing) = members.get(&name) else {
continue;
};
let Some(initializer) = declaration
.get_init_declarator()
.and_then(|init| init.get_initializer())
else {
continue;
};
let Some(expression) = initializer.get_expr() else {
continue;
};
let Some(borrowed) = origin_of(context, expression.syntax(), declaration.syntax())
else {
continue;
};
if let Some(message) = the_message(borrowing, &borrowed, &name, "initialised from")
{
let range = cpp_parser::source_range(expression.get_range());
context.add(DiagnosticCode::DanglingField, range, name, message);
}
}
for constructor in constructors_of(&body, &class_name) {
let Some(body_of_the_constructor) = constructor.get_body() else {
continue;
};
for initializer in member_initialisers_of(&constructor) {
let Some(member_name) = initializer.get_name_text() else {
continue;
};
let Some(borrowing) = members.get(&member_name) else {
continue;
};
let Some(argument) = initializer.get_argument() else {
continue;
};
let Some(borrowed) =
origin_of(context, argument.syntax(), body_of_the_constructor.syntax())
else {
continue;
};
if let Some(message) =
the_message(borrowing, &borrowed, &member_name, "initialised from")
{
let range = cpp_parser::source_range(argument.get_range());
context.add(DiagnosticCode::DanglingField, range, member_name, message);
}
}
}
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
enum Borrowing {
View(String),
Reference,
Pointer,
}
fn the_class_name(body: &cpp_parser::CppClassBody) -> Option<String> {
let class = body
.syntax()
.parent()
.and_then(cpp_parser::CppClassDef::cast)?;
class.get_name_text()
}
fn borrowing_members(
body: &cpp_parser::CppClassBody,
) -> std::collections::BTreeMap<String, Borrowing> {
let mut members = std::collections::BTreeMap::new();
for declaration in body.get_members() {
if let Some((name, borrowing)) = the_member_type(&declaration) {
members.insert(name, borrowing);
}
}
members
}
fn the_member_type(declaration: &cpp_parser::CppDeclaration) -> Option<(String, Borrowing)> {
let declarator = declaration.get_init_declarator()?.get_declarator()?;
let name = declarator.get_name()?.get_name_text().to_string();
let borrowing = if declarator.is_a_reference() {
Borrowing::Reference
} else if declarator.is_a_pointer() {
Borrowing::Pointer
} else {
let head = declaration
.get_decl_specifiers()
.map(|specifiers| specifiers.get_type_text())
.unwrap_or_default();
Borrowing::View(view_name_of(&head)?)
};
Some((name, borrowing))
}
fn constructors_of(
body: &cpp_parser::CppClassBody,
class_name: &str,
) -> Vec<cpp_parser::CppDeclaration> {
body.get_members()
.filter(|declaration| declaration.get_decl_specifiers().is_none())
.filter(|declaration| declaration.get_init_declarator().is_none())
.filter(|declaration| declaration.get_body().is_some())
.filter(|declaration| {
declaration
.children::<cpp_parser::CppDeclaration>()
.any(|inner| inner.get_name_text().as_deref() == Some(class_name))
})
.collect()
}
fn member_initialisers_of(
constructor: &cpp_parser::CppDeclaration,
) -> Vec<cpp_parser::CppMemberInitializer> {
let mut found = Vec::new();
for child in constructor.children::<cpp_parser::CppDeclaration>() {
found.extend(child.children::<cpp_parser::CppMemberInitializer>());
}
found.extend(constructor.children::<cpp_parser::CppMemberInitializer>());
found
}
fn the_message(
borrowing: &Borrowing,
borrowed: &Borrowed,
member: &str,
verb: &str,
) -> Option<String> {
if !matches!(borrowed.kind, Origin::ByValueParameter | Origin::Temporary) {
return None;
}
if matches!(borrowing, Borrowing::View(_))
&& borrowed.kind == Origin::ByValueParameter
&& borrowed.owner_owns_nothing
{
return None;
}
let described = match borrowing {
Borrowing::View(view) => view.as_str(),
Borrowing::Reference => "reference",
Borrowing::Pointer => "pointer",
};
match (borrowing, borrowed.kind) {
(Borrowing::Pointer, Origin::ByValueParameter)
if !borrowed.address_of && borrowed.through.is_none() =>
{
None
}
(Borrowing::Pointer, Origin::Temporary)
if !borrowed.address_of && borrowed.through.is_none() =>
{
None
}
(_, Origin::ByValueParameter) => Some(format!(
"`{member}` is a `{described}` {verb} `{name}`, a parameter that is destroyed when the constructor returns",
name = borrowed.description
)),
(Borrowing::Pointer, Origin::Temporary) => Some(format!(
"`{member}` is a pointer {verb} a temporary, which is destroyed at the end of the statement",
)),
(_, Origin::Temporary) => Some(format!(
"`{member}` is a `{described}` {verb} a temporary, which is destroyed at the end of the statement",
)),
_ => None,
}
}