1 use super::WHILE_IMMUTABLE_CONDITION;
2 use clippy_utils::consts::constant;
3 use clippy_utils::diagnostics::span_lint_and_then;
4 use clippy_utils::usage::mutated_variables;
5 use if_chain::if_chain;
6 use rustc_hir::def::{DefKind, Res};
7 use rustc_hir::def_id::DefIdMap;
8 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
9 use rustc_hir::HirIdSet;
10 use rustc_hir::{Expr, ExprKind, QPath};
11 use rustc_lint::LateContext;
12 use rustc_middle::hir::map::Map;
14 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, cond: &'tcx Expr<'_>, expr: &'tcx Expr<'_>) {
15 if constant(cx, cx.typeck_results(), cond).is_some() {
16 // A pure constant condition (e.g., `while false`) is not linted.
20 let mut var_visitor = VarCollectorVisitor {
22 ids: HirIdSet::default(),
23 def_ids: DefIdMap::default(),
26 var_visitor.visit_expr(cond);
30 let used_in_condition = &var_visitor.ids;
31 let mutated_in_body = mutated_variables(expr, cx);
32 let mutated_in_condition = mutated_variables(cond, cx);
33 let no_cond_variable_mutated =
34 if let (Some(used_mutably_body), Some(used_mutably_cond)) = (mutated_in_body, mutated_in_condition) {
35 used_in_condition.is_disjoint(&used_mutably_body) && used_in_condition.is_disjoint(&used_mutably_cond)
39 let mutable_static_in_cond = var_visitor.def_ids.iter().any(|(_, v)| *v);
41 let mut has_break_or_return_visitor = HasBreakOrReturnVisitor {
42 has_break_or_return: false,
44 has_break_or_return_visitor.visit_expr(expr);
45 let has_break_or_return = has_break_or_return_visitor.has_break_or_return;
47 if no_cond_variable_mutated && !mutable_static_in_cond {
50 WHILE_IMMUTABLE_CONDITION,
52 "variables in the condition are not mutated in the loop body",
54 diag.note("this may lead to an infinite or to a never running loop");
56 if has_break_or_return {
57 diag.note("this loop contains `return`s or `break`s");
58 diag.help("rewrite it as `if cond { loop { } }`");
65 struct HasBreakOrReturnVisitor {
66 has_break_or_return: bool,
69 impl<'tcx> Visitor<'tcx> for HasBreakOrReturnVisitor {
72 fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
73 if self.has_break_or_return {
78 ExprKind::Ret(_) | ExprKind::Break(_, _) => {
79 self.has_break_or_return = true;
85 walk_expr(self, expr);
88 fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
89 NestedVisitorMap::None
93 /// Collects the set of variables in an expression
94 /// Stops analysis if a function call is found
95 /// Note: In some cases such as `self`, there are no mutable annotation,
96 /// All variables definition IDs are collected
97 struct VarCollectorVisitor<'a, 'tcx> {
98 cx: &'a LateContext<'tcx>,
100 def_ids: DefIdMap<bool>,
104 impl<'a, 'tcx> VarCollectorVisitor<'a, 'tcx> {
105 fn insert_def_id(&mut self, ex: &'tcx Expr<'_>) {
107 if let ExprKind::Path(ref qpath) = ex.kind;
108 if let QPath::Resolved(None, _) = *qpath;
110 match self.cx.qpath_res(qpath, ex.hir_id) {
111 Res::Local(hir_id) => {
112 self.ids.insert(hir_id);
114 Res::Def(DefKind::Static, def_id) => {
115 let mutable = self.cx.tcx.is_mutable_static(def_id);
116 self.def_ids.insert(def_id, mutable);
125 impl<'a, 'tcx> Visitor<'tcx> for VarCollectorVisitor<'a, 'tcx> {
126 type Map = Map<'tcx>;
128 fn visit_expr(&mut self, ex: &'tcx Expr<'_>) {
130 ExprKind::Path(_) => self.insert_def_id(ex),
131 // If there is any function/method call… we just stop analysis
132 ExprKind::Call(..) | ExprKind::MethodCall(..) => self.skip = true,
134 _ => walk_expr(self, ex),
138 fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
139 NestedVisitorMap::None