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;
13 use crate::ty::is_type_diagnostic_item;
14 use rustc_hir::def::{DefKind, Res};
16 use rustc_hir::intravisit;
17 use rustc_hir::intravisit::{NestedVisitorMap, Visitor};
19 use rustc_hir::{Block, Expr, ExprKind, Path, QPath};
20 use rustc_lint::LateContext;
21 use rustc_middle::hir::map::Map;
24 /// Is the expr pure (is it free from side-effects)?
25 /// This function is named so to stress that it isn't exhaustive and returns FNs.
26 fn identify_some_pure_patterns(expr: &Expr<'_>) -> bool {
28 ExprKind::Lit(..) | ExprKind::ConstBlock(..) | ExprKind::Path(..) | ExprKind::Field(..) => true,
29 ExprKind::AddrOf(_, _, addr_of_expr) => identify_some_pure_patterns(addr_of_expr),
30 ExprKind::Tup(tup_exprs) => tup_exprs.iter().all(|expr| identify_some_pure_patterns(expr)),
31 ExprKind::Struct(_, fields, expr) => {
32 fields.iter().all(|f| identify_some_pure_patterns(f.expr))
33 && expr.map_or(true, |e| identify_some_pure_patterns(e))
38 ExprKind::Path(QPath::Resolved(
41 res: Res::Def(DefKind::Ctor(..) | DefKind::Variant, ..),
48 ) => args.iter().all(|expr| identify_some_pure_patterns(expr)),
56 ) => stmts.is_empty() && identify_some_pure_patterns(expr),
60 | ExprKind::MethodCall(..)
61 | ExprKind::Binary(..)
65 | ExprKind::DropTemps(..)
69 | ExprKind::Closure(..)
71 | ExprKind::Assign(..)
72 | ExprKind::AssignOp(..)
75 | ExprKind::Continue(..)
77 | ExprKind::InlineAsm(..)
78 | ExprKind::LlvmInlineAsm(..)
79 | ExprKind::Repeat(..)
81 | ExprKind::Err => false,
85 /// Identify some potentially computationally expensive patterns.
86 /// This function is named so to stress that its implementation is non-exhaustive.
87 /// It returns FNs and FPs.
88 fn identify_some_potentially_expensive_patterns<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
89 // Searches an expression for method calls or function calls that aren't ctors
90 struct FunCallFinder<'a, 'tcx> {
91 cx: &'a LateContext<'tcx>,
95 impl<'a, 'tcx> intravisit::Visitor<'tcx> for FunCallFinder<'a, 'tcx> {
98 fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
99 let call_found = match &expr.kind {
100 // ignore enum and struct constructors
101 ExprKind::Call(..) => !is_ctor_or_promotable_const_function(self.cx, expr),
102 ExprKind::Index(obj, _) => {
103 let ty = self.cx.typeck_results().expr_ty(obj);
104 is_type_diagnostic_item(self.cx, ty, sym::hashmap_type)
105 || is_type_diagnostic_item(self.cx, ty, sym::BTreeMap)
107 ExprKind::MethodCall(..) => true,
116 intravisit::walk_expr(self, expr);
120 fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
121 NestedVisitorMap::None
125 let mut finder = FunCallFinder { cx, found: false };
126 finder.visit_expr(expr);
130 pub fn is_eagerness_candidate<'a, 'tcx>(cx: &'a LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
131 !identify_some_potentially_expensive_patterns(cx, expr) && identify_some_pure_patterns(expr)
134 pub fn is_lazyness_candidate<'a, 'tcx>(cx: &'a LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
135 identify_some_potentially_expensive_patterns(cx, expr)