1 //! Utilities for evaluating whether eagerly evaluated expressions can be made lazy and vice versa.
3 //! Things to consider:
4 //! - has the expression side-effects?
5 //! - is the expression computationally expensive?
8 //! - unnecessary-lazy-evaluations
10 //! - option-if-let-else
12 use crate::{is_ctor_or_promotable_const_function, is_type_diagnostic_item, match_type, paths};
13 use rustc_hir::def::{DefKind, Res};
15 use rustc_hir::intravisit;
16 use rustc_hir::intravisit::{NestedVisitorMap, Visitor};
18 use rustc_hir::{Block, Expr, ExprKind, Path, QPath};
19 use rustc_lint::LateContext;
20 use rustc_middle::hir::map::Map;
22 /// Is the expr pure (is it free from side-effects)?
23 /// This function is named so to stress that it isn't exhaustive and returns FNs.
24 fn identify_some_pure_patterns(expr: &Expr<'_>) -> bool {
26 ExprKind::Lit(..) | ExprKind::ConstBlock(..) | ExprKind::Path(..) | ExprKind::Field(..) => true,
27 ExprKind::AddrOf(_, _, addr_of_expr) => identify_some_pure_patterns(addr_of_expr),
28 ExprKind::Tup(tup_exprs) => tup_exprs.iter().all(|expr| identify_some_pure_patterns(expr)),
29 ExprKind::Struct(_, fields, expr) => {
30 fields.iter().all(|f| identify_some_pure_patterns(f.expr))
31 && expr.map_or(true, |e| identify_some_pure_patterns(e))
36 ExprKind::Path(QPath::Resolved(
39 res: Res::Def(DefKind::Ctor(..) | DefKind::Variant, ..),
46 ) => args.iter().all(|expr| identify_some_pure_patterns(expr)),
54 ) => stmts.is_empty() && identify_some_pure_patterns(expr),
58 | ExprKind::MethodCall(..)
59 | ExprKind::Binary(..)
63 | ExprKind::DropTemps(..)
67 | ExprKind::Closure(..)
69 | ExprKind::Assign(..)
70 | ExprKind::AssignOp(..)
73 | ExprKind::Continue(..)
75 | ExprKind::InlineAsm(..)
76 | ExprKind::LlvmInlineAsm(..)
77 | ExprKind::Repeat(..)
79 | ExprKind::Err => false,
83 /// Identify some potentially computationally expensive patterns.
84 /// This function is named so to stress that its implementation is non-exhaustive.
85 /// It returns FNs and FPs.
86 fn identify_some_potentially_expensive_patterns<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
87 // Searches an expression for method calls or function calls that aren't ctors
88 struct FunCallFinder<'a, 'tcx> {
89 cx: &'a LateContext<'tcx>,
93 impl<'a, 'tcx> intravisit::Visitor<'tcx> for FunCallFinder<'a, 'tcx> {
96 fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
97 let call_found = match &expr.kind {
98 // ignore enum and struct constructors
99 ExprKind::Call(..) => !is_ctor_or_promotable_const_function(self.cx, expr),
100 ExprKind::Index(obj, _) => {
101 let ty = self.cx.typeck_results().expr_ty(obj);
102 is_type_diagnostic_item(self.cx, ty, sym!(hashmap_type))
103 || match_type(self.cx, ty, &paths::BTREEMAP)
105 ExprKind::MethodCall(..) => true,
114 intravisit::walk_expr(self, expr);
118 fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
119 NestedVisitorMap::None
123 let mut finder = FunCallFinder { cx, found: false };
124 finder.visit_expr(expr);
128 pub fn is_eagerness_candidate<'a, 'tcx>(cx: &'a LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
129 !identify_some_potentially_expensive_patterns(cx, expr) && identify_some_pure_patterns(expr)
132 pub fn is_lazyness_candidate<'a, 'tcx>(cx: &'a LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
133 identify_some_potentially_expensive_patterns(cx, expr)