1 use super::NEEDLESS_MATCH;
2 use clippy_utils::diagnostics::span_lint_and_sugg;
3 use clippy_utils::source::snippet_with_applicability;
4 use clippy_utils::ty::{is_type_diagnostic_item, same_type_and_consts};
6 eq_expr_value, get_parent_expr_for_hir, get_parent_node, higher, is_else_clause, is_lang_ctor, over,
9 use rustc_errors::Applicability;
10 use rustc_hir::LangItem::OptionNone;
11 use rustc_hir::{Arm, BindingAnnotation, ByRef, Expr, ExprKind, FnRetTy, Guard, Node, Pat, PatKind, Path, QPath};
12 use rustc_lint::LateContext;
14 use rustc_typeck::hir_ty_to_ty;
16 pub(crate) fn check_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr: &Expr<'_>) {
17 if arms.len() > 1 && expr_ty_matches_p_ty(cx, ex, expr) && check_all_arms(cx, ex, arms) {
18 let mut applicability = Applicability::MachineApplicable;
23 "this match expression is unnecessary",
25 snippet_with_applicability(cx, ex.span, "..", &mut applicability).to_string(),
31 /// Check for nop `if let` expression that assembled as unnecessary match
34 /// if let Some(a) = option {
42 /// if let SomeEnum::A = some_enum {
44 /// } else if let SomeEnum::B = some_enum {
50 pub(crate) fn check_if_let<'tcx>(cx: &LateContext<'tcx>, ex: &Expr<'_>, if_let: &higher::IfLet<'tcx>) {
51 if !is_else_clause(cx.tcx, ex) && expr_ty_matches_p_ty(cx, if_let.let_expr, ex) && check_if_let_inner(cx, if_let) {
52 let mut applicability = Applicability::MachineApplicable;
57 "this if-let expression is unnecessary",
59 snippet_with_applicability(cx, if_let.let_expr.span, "..", &mut applicability).to_string(),
65 fn check_all_arms(cx: &LateContext<'_>, match_expr: &Expr<'_>, arms: &[Arm<'_>]) -> bool {
67 let arm_expr = peel_blocks_with_stmt(arm.body);
69 if let Some(guard_expr) = &arm.guard {
71 // gives up if `pat if expr` can have side effects
72 Guard::If(if_cond) => {
73 if if_cond.can_have_side_effects() {
77 // gives up `pat if let ...` arm
84 if let PatKind::Wild = arm.pat.kind {
85 if !eq_expr_value(cx, match_expr, strip_return(arm_expr)) {
88 } else if !pat_same_as_expr(arm.pat, arm_expr) {
96 fn check_if_let_inner(cx: &LateContext<'_>, if_let: &higher::IfLet<'_>) -> bool {
97 if let Some(if_else) = if_let.if_else {
98 if !pat_same_as_expr(if_let.let_pat, peel_blocks_with_stmt(if_let.if_then)) {
102 // Recursively check for each `else if let` phrase,
103 if let Some(ref nested_if_let) = higher::IfLet::hir(cx, if_else) {
104 return check_if_let_inner(cx, nested_if_let);
107 if matches!(if_else.kind, ExprKind::Block(..)) {
108 let else_expr = peel_blocks_with_stmt(if_else);
109 if matches!(else_expr.kind, ExprKind::Block(..)) {
112 let ret = strip_return(else_expr);
113 let let_expr_ty = cx.typeck_results().expr_ty(if_let.let_expr);
114 if is_type_diagnostic_item(cx, let_expr_ty, sym::Option) {
115 if let ExprKind::Path(ref qpath) = ret.kind {
116 return is_lang_ctor(cx, qpath, OptionNone) || eq_expr_value(cx, if_let.let_expr, ret);
120 return eq_expr_value(cx, if_let.let_expr, ret);
127 /// Strip `return` keyword if the expression type is `ExprKind::Ret`.
128 fn strip_return<'hir>(expr: &'hir Expr<'hir>) -> &'hir Expr<'hir> {
129 if let ExprKind::Ret(Some(ret)) = expr.kind {
136 /// Manually check for coercion casting by checking if the type of the match operand or let expr
137 /// differs with the assigned local variable or the function return type.
138 fn expr_ty_matches_p_ty(cx: &LateContext<'_>, expr: &Expr<'_>, p_expr: &Expr<'_>) -> bool {
139 if let Some(p_node) = get_parent_node(cx.tcx, p_expr.hir_id) {
141 // Compare match_expr ty with local in `let local = match match_expr {..}`
142 Node::Local(local) => {
143 let results = cx.typeck_results();
144 return same_type_and_consts(results.node_type(local.hir_id), results.expr_ty(expr));
146 // compare match_expr ty with RetTy in `fn foo() -> RetTy`
148 if let Some(fn_decl) = p_node.fn_decl() {
149 if let FnRetTy::Return(ret_ty) = fn_decl.output {
150 return same_type_and_consts(hir_ty_to_ty(cx.tcx, ret_ty), cx.typeck_results().expr_ty(expr));
154 // check the parent expr for this whole block `{ match match_expr {..} }`
155 Node::Block(block) => {
156 if let Some(block_parent_expr) = get_parent_expr_for_hir(cx, block.hir_id) {
157 return expr_ty_matches_p_ty(cx, expr, block_parent_expr);
160 // recursively call on `if xxx {..}` etc.
161 Node::Expr(p_expr) => {
162 return expr_ty_matches_p_ty(cx, expr, p_expr);
170 fn pat_same_as_expr(pat: &Pat<'_>, expr: &Expr<'_>) -> bool {
171 let expr = strip_return(expr);
172 match (&pat.kind, &expr.kind) {
173 // Example: `Some(val) => Some(val)`
174 (PatKind::TupleStruct(QPath::Resolved(_, path), tuple_params, _), ExprKind::Call(call_expr, call_params)) => {
175 if let ExprKind::Path(QPath::Resolved(_, call_path)) = call_expr.kind {
176 return over(path.segments, call_path.segments, |pat_seg, call_seg| {
177 pat_seg.ident.name == call_seg.ident.name
178 }) && same_non_ref_symbols(tuple_params, call_params);
181 // Example: `val => val`
183 PatKind::Binding(annot, _, pat_ident, _),
184 ExprKind::Path(QPath::Resolved(
187 segments: [first_seg, ..],
192 return !matches!(annot, BindingAnnotation(ByRef::Yes, _)) && pat_ident.name == first_seg.ident.name;
194 // Example: `Custom::TypeA => Custom::TypeB`, or `None => None`
195 (PatKind::Path(QPath::Resolved(_, p_path)), ExprKind::Path(QPath::Resolved(_, e_path))) => {
196 return over(p_path.segments, e_path.segments, |p_seg, e_seg| {
197 p_seg.ident.name == e_seg.ident.name
201 (PatKind::Lit(pat_lit_expr), ExprKind::Lit(expr_spanned)) => {
202 if let ExprKind::Lit(pat_spanned) = &pat_lit_expr.kind {
203 return pat_spanned.node == expr_spanned.node;
212 fn same_non_ref_symbols(pats: &[Pat<'_>], exprs: &[Expr<'_>]) -> bool {
213 if pats.len() != exprs.len() {
217 for i in 0..pats.len() {
218 if !pat_same_as_expr(&pats[i], &exprs[i]) {