use cpp_parser::{CppAstNode, CppAstToken};
use super::{Check, CheckContext, DiagnosticCode};
pub struct AssignmentInCondition;
#[allow(dead_code)]
fn condition_of(node: &cpp_parser::CppSyntaxNode) -> Option<cpp_parser::CppSyntaxNode> {
node.children().find(|child| {
cpp_parser::CppSyntaxKind::from(child.kind()) != cpp_parser::CppSyntaxKind::CompoundStat
})
}
impl Check for AssignmentInCondition {
const CODES: &'static [DiagnosticCode] = &[DiagnosticCode::AssignmentInCondition];
fn check(context: &mut CheckContext<'_>) {
for node in context.own::<cpp_parser::CppAst>().collect::<Vec<_>>() {
let parenthesised = match &node {
cpp_parser::CppAst::Stat(cpp_parser::CppStat::IfStat(statement)) => {
statement.children::<cpp_parser::CppParenExpr>().next()
}
cpp_parser::CppAst::Stat(cpp_parser::CppStat::WhileStat(statement)) => {
statement.children::<cpp_parser::CppParenExpr>().next()
}
_ => None,
};
let Some(condition) = parenthesised.map(|p| p.syntax().clone()) else {
continue;
};
if !is_an_assignment(&condition) {
continue;
}
let is_a_comparison = cpp_parser::CppParenExpr::cast(condition.clone())
.and_then(|parenthesised| parenthesised.child::<cpp_parser::CppBinaryExpr>())
.and_then(|binary| binary.token::<cpp_parser::CppOperatorToken>())
.is_some_and(|operator| {
matches!(
operator.syntax().text().to_string().as_str(),
"==" | "!=" | "<" | ">" | "<=" | ">="
)
});
if is_a_comparison {
continue;
}
let text = context.node_text(&condition);
let text = text.trim();
context.add(
DiagnosticCode::AssignmentInCondition,
cpp_parser::source_range(condition.text_range()),
String::new(),
t!(
"`%{text}` assigns rather than compares: `=` in a condition is almost always a `==`", text = text
),
);
}
}
}
fn is_an_assignment(condition: &cpp_parser::CppSyntaxNode) -> bool {
let mut significant = condition
.descendants_with_tokens()
.filter_map(|element| element.into_token())
.filter(|token| !cpp_parser::is_trivia(cpp_parser::CppTokenKind::from(token.kind())))
.map(|token| cpp_parser::CppTokenKind::from(token.kind()))
.collect::<Vec<_>>();
while matches!(
significant.first(),
Some(cpp_parser::CppTokenKind::LeftParen)
) {
significant.remove(0);
}
while matches!(
significant.last(),
Some(cpp_parser::CppTokenKind::RightParen)
) {
significant.pop();
}
let mut significant = significant.into_iter();
if significant.next().is_none() {
return false;
}
let is_the_operator = significant.next() == Some(cpp_parser::CppTokenKind::Assign);
is_the_operator
&& !condition
.descendants_with_tokens()
.filter_map(|element| element.into_token())
.any(|token| {
matches!(
cpp_parser::CppTokenKind::from(token.kind()),
cpp_parser::CppTokenKind::LogicalAnd
| cpp_parser::CppTokenKind::LogicalOr
| cpp_parser::CppTokenKind::Comma
)
})
}