use std::collections::BTreeSet;
use cpp_parser::CppAstNode;
use super::{Check, CheckContext, DiagnosticCode};
pub struct UseAfterFree;
impl Check for UseAfterFree {
const CODES: &'static [DiagnosticCode] = &[DiagnosticCode::UseAfterFree];
fn check(context: &mut CheckContext<'_>) {
let bodies: Vec<cpp_parser::CppSyntaxNode> = context
.own::<cpp_parser::CppDeclaration>()
.filter_map(|declaration| declaration.get_body())
.map(|body| body.syntax().clone())
.collect();
for body in bodies {
let mut freed: Freed = BTreeSet::new();
walk(&body, &mut freed, context);
}
}
}
type Freed = BTreeSet<usize>;
fn walk(statement: &cpp_parser::CppSyntaxNode, freed: &mut Freed, context: &mut CheckContext<'_>) {
use cpp_parser::CppAstNode;
let Some(statement_node) = cpp_parser::CppStat::cast(statement.clone()) else {
check_uses(statement, freed, context);
return;
};
match &statement_node {
cpp_parser::CppStat::CompoundStat(_) | cpp_parser::CppStat::ElseStat(_) => {
for child in statement.children() {
walk(&child, freed, context);
}
}
cpp_parser::CppStat::IfStat(_)
| cpp_parser::CppStat::ForStat(_)
| cpp_parser::CppStat::WhileStat(_)
| cpp_parser::CppStat::DoWhileStat(_)
| cpp_parser::CppStat::SwitchStat(_)
| cpp_parser::CppStat::TryStat(_) => {
let mut inside = freed.clone();
for child in statement.children() {
walk(&child, &mut inside, context);
}
}
cpp_parser::CppStat::ExpressionStat(_)
| cpp_parser::CppStat::ReturnStat(_)
| cpp_parser::CppStat::Declaration(_) => {
check_uses(statement, freed, context);
apply_effects(statement, freed, context);
}
_ => check_uses(statement, freed, context),
}
}
fn check_uses(
statement: &cpp_parser::CppSyntaxNode,
freed: &Freed,
context: &mut CheckContext<'_>,
) {
for candidate in statement.descendants() {
let (base, reads_through_it) = match cpp_parser::CppExpr::cast(candidate.clone()) {
Some(cpp_parser::CppExpr::MemberExpr(member)) => {
let Some(base) = member.get_object() else {
continue;
};
(base.syntax().clone(), member.is_arrow())
}
Some(cpp_parser::CppExpr::IndexExpr(index)) => {
let Some(base) = index.get_object() else {
continue;
};
let reads = if index.is_a_subscript() {
true
} else {
index
.syntax()
.children_with_tokens()
.filter_map(|element| element.into_token())
.any(|token| {
cpp_parser::CppTokenKind::from(token.kind())
== cpp_parser::CppTokenKind::Arrow
})
};
(base.syntax().clone(), reads)
}
Some(cpp_parser::CppExpr::UnaryExpr(unary)) => {
let Some(base) = unary.get_operand() else {
continue;
};
(
base.syntax().clone(),
unary.get_operator_text().as_deref() == Some("*"),
)
}
_ => continue,
};
if !reads_through_it {
continue;
}
let Some((offset, name)) = the_variable(&base, context) else {
continue;
};
if !freed.contains(&offset) {
continue;
}
let range = cpp_parser::source_range(base.text_range());
context.add(
DiagnosticCode::UseAfterFree,
range,
name.clone(),
format!("`{name}` is used after the memory it refers to was freed"),
);
}
}
fn apply_effects(
statement: &cpp_parser::CppSyntaxNode,
freed: &mut Freed,
context: &mut CheckContext<'_>,
) {
for candidate in statement.descendants() {
let Some(expression) = cpp_parser::CppExpr::cast(candidate.clone()) else {
continue;
};
match expression {
cpp_parser::CppExpr::UnaryExpr(unary) if unary.is_delete() => {
if let Some(operand) = unary.get_operand()
&& let Some((offset, _)) = the_variable(operand.syntax(), context)
{
freed.insert(offset);
}
}
cpp_parser::CppExpr::CallExpr(call) => {
let Some(callee) = call.get_callee() else {
continue;
};
let arguments: Vec<cpp_parser::CppExpr> = call.get_args();
let name = super::callee_name_of(&callee);
let receiver = a_member_access_object(&callee);
match name.as_deref() {
Some("free") => {
if let Some(argument) = arguments.first()
&& let Some((offset, _)) = the_variable(argument.syntax(), context)
{
freed.insert(offset);
}
}
Some("destroy_at") => {
if let Some(argument) = arguments.first()
&& let Some((offset, _)) = the_variable(argument.syntax(), context)
{
freed.insert(offset);
}
}
Some("reset") => {
if let Some(receiver) = receiver
&& let Some((offset, _)) = the_variable(receiver.syntax(), context)
{
freed.insert(offset);
}
}
_ => {
if let Some(frees) = the_frees_of(context, callee.syntax())
&& frees != 0
{
for (index, argument) in arguments.iter().enumerate() {
if index < 64
&& frees & (1 << index) != 0
&& let Some((offset, _)) =
the_variable(argument.syntax(), context)
{
freed.insert(offset);
}
}
}
}
}
}
cpp_parser::CppExpr::BinaryExpr(binary)
if binary.get_operator_text().as_deref() == Some("=") =>
{
let Some(target) = binary.get_lhs() else {
continue;
};
let Some(value) = binary.syntax().children().nth(1) else {
continue;
};
let Some((offset, _)) = the_variable(target.syntax(), context) else {
continue;
};
match the_variable(&value, context) {
Some((source, _)) if freed.contains(&source) => {
freed.insert(offset);
}
_ => {
freed.remove(&offset);
}
}
}
_ => {}
}
}
}
fn the_frees_of(context: &CheckContext<'_>, callee: &cpp_parser::CppSyntaxNode) -> Option<u64> {
if let Some(offset) = the_last_identifier_offset(callee)
&& let crate::Known::Yes(binding) =
crate::sema::resolve::definition_at(context.scopes(), context.tree(), offset)
{
let name = binding.name.text();
let scope = context.scopes().qualified_name_of(binding.scope);
if let Some(fact) = context.summary.declarations.iter().find(|fact| {
fact.name == name && fact.scope == scope && fact.kind == crate::DeclKind::Function
}) {
return Some(fact.frees);
}
let spelling = match scope.as_deref() {
Some(scope) if !scope.is_empty() => format!("{scope}::{name}"),
_ => name,
};
if let crate::Known::Yes(found) = context.index().definition(&spelling, context.path) {
return Some(found.fact.frees);
}
}
if is_a_member_access(callee) {
return None;
}
let name = super::callee_name_of(&cpp_parser::CppExpr::cast(callee.clone())?)?;
match context.index().definition(&name, context.path) {
crate::Known::Yes(found) => Some(found.fact.frees),
_ => None,
}
}
fn the_variable(
expression: &cpp_parser::CppSyntaxNode,
context: &CheckContext<'_>,
) -> Option<(usize, String)> {
let expression = skip_parentheses(expression);
match cpp_parser::CppExpr::cast(expression.clone()) {
Some(cpp_parser::CppExpr::UnaryExpr(unary)) => {
the_variable(unary.get_operand()?.syntax(), context)
}
Some(cpp_parser::CppExpr::NameExpr(_)) => {
let offset = the_last_identifier_offset(&expression)?;
let crate::Known::Yes(binding) =
crate::sema::resolve::definition_at(context.scopes(), context.tree(), offset)
else {
return None;
};
let scope = context.scopes().scope(binding.scope)?;
if !matches!(
scope.kind,
crate::ScopeKind::Function | crate::ScopeKind::Block | crate::ScopeKind::Lambda
) {
return None;
}
Some((binding.name_range.start_offset, binding.name.text()))
}
_ => None,
}
}
fn skip_parentheses(expression: &cpp_parser::CppSyntaxNode) -> cpp_parser::CppSyntaxNode {
if !cpp_parser::CppParenExpr::can_cast(expression.kind().into()) {
return expression.clone();
}
expression
.children()
.next()
.map(|inner| skip_parentheses(&inner))
.unwrap_or_else(|| expression.clone())
}
fn is_a_member_access(expression: &cpp_parser::CppSyntaxNode) -> bool {
expression
.children_with_tokens()
.filter_map(|element| element.into_token())
.any(|token| {
matches!(
cpp_parser::CppTokenKind::from(token.kind()),
cpp_parser::CppTokenKind::Dot | cpp_parser::CppTokenKind::Arrow
)
})
}
fn the_last_identifier_offset(expression: &cpp_parser::CppSyntaxNode) -> Option<usize> {
expression
.descendants_with_tokens()
.filter_map(|element| element.into_token())
.filter(|token| {
cpp_parser::CppTokenKind::from(token.kind()) == cpp_parser::CppTokenKind::Identifier
})
.last()
.map(|token| usize::from(token.text_range().start()))
}
fn a_member_access_object(expression: &cpp_parser::CppExpr) -> Option<cpp_parser::CppExpr> {
match expression {
cpp_parser::CppExpr::MemberExpr(member) => member.get_object(),
cpp_parser::CppExpr::IndexExpr(index) if index.is_a_member_access() => index.get_object(),
_ => None,
}
}