]> git.lizzy.rs Git - rust.git/blob - src/tools/clippy/clippy_utils/src/eager_or_lazy.rs
Rollup merge of #102761 - est31:let_else_uninhabited_test, r=compiler-errors
[rust.git] / src / tools / clippy / clippy_utils / src / eager_or_lazy.rs
1 //! Utilities for evaluating whether eagerly evaluated expressions can be made lazy and vice versa.
2 //!
3 //! Things to consider:
4 //!  - has the expression side-effects?
5 //!  - is the expression computationally expensive?
6 //!
7 //! See lints:
8 //!  - unnecessary-lazy-evaluations
9 //!  - or-fun-call
10 //!  - option-if-let-else
11
12 use crate::ty::{all_predicates_of, is_copy};
13 use crate::visitors::is_const_evaluatable;
14 use rustc_hir::def::{DefKind, Res};
15 use rustc_hir::intravisit::{walk_expr, Visitor};
16 use rustc_hir::{def_id::DefId, Block, Expr, ExprKind, QPath, UnOp};
17 use rustc_lint::LateContext;
18 use rustc_middle::ty::{self, PredicateKind};
19 use rustc_span::{sym, Symbol};
20 use std::cmp;
21 use std::ops;
22
23 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
24 enum EagernessSuggestion {
25     // The expression is cheap and should be evaluated eagerly
26     Eager,
27     // The expression may be cheap, so don't suggested lazy evaluation; or the expression may not be safe to switch to
28     // eager evaluation.
29     NoChange,
30     // The expression is likely expensive and should be evaluated lazily.
31     Lazy,
32     // The expression cannot be placed into a closure.
33     ForceNoChange,
34 }
35 impl ops::BitOr for EagernessSuggestion {
36     type Output = Self;
37     fn bitor(self, rhs: Self) -> Self {
38         cmp::max(self, rhs)
39     }
40 }
41 impl ops::BitOrAssign for EagernessSuggestion {
42     fn bitor_assign(&mut self, rhs: Self) {
43         *self = *self | rhs;
44     }
45 }
46
47 /// Determine the eagerness of the given function call.
48 fn fn_eagerness(cx: &LateContext<'_>, fn_id: DefId, name: Symbol, have_one_arg: bool) -> EagernessSuggestion {
49     use EagernessSuggestion::{Eager, Lazy, NoChange};
50     let name = name.as_str();
51
52     let ty = match cx.tcx.impl_of_method(fn_id) {
53         Some(id) => cx.tcx.type_of(id),
54         None => return Lazy,
55     };
56
57     if (name.starts_with("as_") || name == "len" || name == "is_empty") && have_one_arg {
58         if matches!(
59             cx.tcx.crate_name(fn_id.krate),
60             sym::std | sym::core | sym::alloc | sym::proc_macro
61         ) {
62             Eager
63         } else {
64             NoChange
65         }
66     } else if let ty::Adt(def, subs) = ty.kind() {
67         // Types where the only fields are generic types (or references to) with no trait bounds other
68         // than marker traits.
69         // Due to the limited operations on these types functions should be fairly cheap.
70         if def
71             .variants()
72             .iter()
73             .flat_map(|v| v.fields.iter())
74             .any(|x| matches!(cx.tcx.type_of(x.did).peel_refs().kind(), ty::Param(_)))
75             && all_predicates_of(cx.tcx, fn_id).all(|(pred, _)| match pred.kind().skip_binder() {
76                 PredicateKind::Trait(pred) => cx.tcx.trait_def(pred.trait_ref.def_id).is_marker,
77                 _ => true,
78             })
79             && subs.types().all(|x| matches!(x.peel_refs().kind(), ty::Param(_)))
80         {
81             // Limit the function to either `(self) -> bool` or `(&self) -> bool`
82             match &**cx.tcx.fn_sig(fn_id).skip_binder().inputs_and_output {
83                 [arg, res] if !arg.is_mutable_ptr() && arg.peel_refs() == ty && res.is_bool() => NoChange,
84                 _ => Lazy,
85             }
86         } else {
87             Lazy
88         }
89     } else {
90         Lazy
91     }
92 }
93
94 #[expect(clippy::too_many_lines)]
95 fn expr_eagerness<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> EagernessSuggestion {
96     struct V<'cx, 'tcx> {
97         cx: &'cx LateContext<'tcx>,
98         eagerness: EagernessSuggestion,
99     }
100
101     impl<'cx, 'tcx> Visitor<'tcx> for V<'cx, 'tcx> {
102         fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
103             use EagernessSuggestion::{ForceNoChange, Lazy, NoChange};
104             if self.eagerness == ForceNoChange {
105                 return;
106             }
107             match e.kind {
108                 ExprKind::Call(
109                     &Expr {
110                         kind: ExprKind::Path(ref path),
111                         hir_id,
112                         ..
113                     },
114                     args,
115                 ) => match self.cx.qpath_res(path, hir_id) {
116                     Res::Def(DefKind::Ctor(..) | DefKind::Variant, _) | Res::SelfCtor(_) => {
117                         if self
118                             .cx
119                             .typeck_results()
120                             .expr_ty(e)
121                             .has_significant_drop(self.cx.tcx, self.cx.param_env)
122                         {
123                             self.eagerness = Lazy;
124                             return;
125                         }
126                     },
127                     Res::Def(_, id) if self.cx.tcx.is_promotable_const_fn(id) => (),
128                     // No need to walk the arguments here, `is_const_evaluatable` already did
129                     Res::Def(..) if is_const_evaluatable(self.cx, e) => {
130                         self.eagerness |= NoChange;
131                         return;
132                     },
133                     Res::Def(_, id) => match path {
134                         QPath::Resolved(_, p) => {
135                             self.eagerness |=
136                                 fn_eagerness(self.cx, id, p.segments.last().unwrap().ident.name, !args.is_empty());
137                         },
138                         QPath::TypeRelative(_, name) => {
139                             self.eagerness |= fn_eagerness(self.cx, id, name.ident.name, !args.is_empty());
140                         },
141                         QPath::LangItem(..) => self.eagerness = Lazy,
142                     },
143                     _ => self.eagerness = Lazy,
144                 },
145                 // No need to walk the arguments here, `is_const_evaluatable` already did
146                 ExprKind::MethodCall(..) if is_const_evaluatable(self.cx, e) => {
147                     self.eagerness |= NoChange;
148                     return;
149                 },
150                 ExprKind::MethodCall(name, ..) => {
151                     self.eagerness |= self
152                         .cx
153                         .typeck_results()
154                         .type_dependent_def_id(e.hir_id)
155                         .map_or(Lazy, |id| fn_eagerness(self.cx, id, name.ident.name, true));
156                 },
157                 ExprKind::Index(_, e) => {
158                     let ty = self.cx.typeck_results().expr_ty_adjusted(e);
159                     if is_copy(self.cx, ty) && !ty.is_ref() {
160                         self.eagerness |= NoChange;
161                     } else {
162                         self.eagerness = Lazy;
163                     }
164                 },
165
166                 // Dereferences should be cheap, but dereferencing a raw pointer earlier may not be safe.
167                 ExprKind::Unary(UnOp::Deref, e) if !self.cx.typeck_results().expr_ty(e).is_unsafe_ptr() => (),
168                 ExprKind::Unary(UnOp::Deref, _) => self.eagerness |= NoChange,
169
170                 ExprKind::Unary(_, e)
171                     if matches!(
172                         self.cx.typeck_results().expr_ty(e).kind(),
173                         ty::Bool | ty::Int(_) | ty::Uint(_),
174                     ) => {},
175                 ExprKind::Binary(_, lhs, rhs)
176                     if self.cx.typeck_results().expr_ty(lhs).is_primitive()
177                         && self.cx.typeck_results().expr_ty(rhs).is_primitive() => {},
178
179                 // Can't be moved into a closure
180                 ExprKind::Break(..)
181                 | ExprKind::Continue(_)
182                 | ExprKind::Ret(_)
183                 | ExprKind::InlineAsm(_)
184                 | ExprKind::Yield(..)
185                 | ExprKind::Err => {
186                     self.eagerness = ForceNoChange;
187                     return;
188                 },
189
190                 // Memory allocation, custom operator, loop, or call to an unknown function
191                 ExprKind::Box(_)
192                 | ExprKind::Unary(..)
193                 | ExprKind::Binary(..)
194                 | ExprKind::Loop(..)
195                 | ExprKind::Call(..) => self.eagerness = Lazy,
196
197                 ExprKind::ConstBlock(_)
198                 | ExprKind::Array(_)
199                 | ExprKind::Tup(_)
200                 | ExprKind::Lit(_)
201                 | ExprKind::Cast(..)
202                 | ExprKind::Type(..)
203                 | ExprKind::DropTemps(_)
204                 | ExprKind::Let(..)
205                 | ExprKind::If(..)
206                 | ExprKind::Match(..)
207                 | ExprKind::Closure { .. }
208                 | ExprKind::Field(..)
209                 | ExprKind::Path(_)
210                 | ExprKind::AddrOf(..)
211                 | ExprKind::Struct(..)
212                 | ExprKind::Repeat(..)
213                 | ExprKind::Block(Block { stmts: [], .. }, _) => (),
214
215                 // Assignment might be to a local defined earlier, so don't eagerly evaluate.
216                 // Blocks with multiple statements might be expensive, so don't eagerly evaluate.
217                 // TODO: Actually check if either of these are true here.
218                 ExprKind::Assign(..) | ExprKind::AssignOp(..) | ExprKind::Block(..) => self.eagerness |= NoChange,
219             }
220             walk_expr(self, e);
221         }
222     }
223
224     let mut v = V {
225         cx,
226         eagerness: EagernessSuggestion::Eager,
227     };
228     v.visit_expr(e);
229     v.eagerness
230 }
231
232 /// Whether the given expression should be changed to evaluate eagerly
233 pub fn switch_to_eager_eval<'tcx>(cx: &'_ LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
234     expr_eagerness(cx, expr) == EagernessSuggestion::Eager
235 }
236
237 /// Whether the given expression should be changed to evaluate lazily
238 pub fn switch_to_lazy_eval<'tcx>(cx: &'_ LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
239     expr_eagerness(cx, expr) == EagernessSuggestion::Lazy
240 }