1 use clippy_utils::diagnostics::span_lint_and_sugg;
2 use clippy_utils::sugg::Sugg;
3 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
4 use if_chain::if_chain;
5 use rustc_errors::Applicability;
6 use rustc_hir::{Expr, ExprKind, Mutability, Param, Pat, PatKind, Path, PathSegment, QPath};
7 use rustc_lint::{LateContext, LateLintPass};
8 use rustc_middle::ty::{self, subst::GenericArgKind};
9 use rustc_session::{declare_lint_pass, declare_tool_lint};
11 use rustc_span::symbol::Ident;
14 declare_clippy_lint! {
16 /// Detects uses of `Vec::sort_by` passing in a closure
17 /// which compares the two arguments, either directly or indirectly.
19 /// ### Why is this bad?
20 /// It is more clear to use `Vec::sort_by_key` (or `Vec::sort` if
21 /// possible) than to use `Vec::sort_by` and a more complicated
24 /// ### Known problems
25 /// If the suggested `Vec::sort_by_key` uses Reverse and it isn't already
26 /// imported by a use statement, then it will need to be added manually.
31 /// # impl A { fn foo(&self) {} }
32 /// # let mut vec: Vec<A> = Vec::new();
33 /// vec.sort_by(|a, b| a.foo().cmp(&b.foo()));
38 /// # impl A { fn foo(&self) {} }
39 /// # let mut vec: Vec<A> = Vec::new();
40 /// vec.sort_by_key(|a| a.foo());
42 #[clippy::version = "1.46.0"]
43 pub UNNECESSARY_SORT_BY,
45 "Use of `Vec::sort_by` when `Vec::sort_by_key` or `Vec::sort` would be clearer"
48 declare_lint_pass!(UnnecessarySortBy => [UNNECESSARY_SORT_BY]);
52 SortByKey(SortByKeyDetection),
55 struct SortDetection {
60 struct SortByKeyDetection {
68 /// Detect if the two expressions are mirrored (identical, except one
69 /// contains a and the other replaces it with b)
77 match (&a_expr.kind, &b_expr.kind) {
78 // Two boxes with mirrored contents
79 (ExprKind::Box(left_expr), ExprKind::Box(right_expr)) => {
80 mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident)
82 // Two arrays with mirrored contents
83 (ExprKind::Array(left_exprs), ExprKind::Array(right_exprs)) => {
84 iter::zip(*left_exprs, *right_exprs).all(|(left, right)| mirrored_exprs(cx, left, a_ident, right, b_ident))
86 // The two exprs are function calls.
87 // Check to see that the function itself and its arguments are mirrored
88 (ExprKind::Call(left_expr, left_args), ExprKind::Call(right_expr, right_args)) => {
89 mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident)
90 && iter::zip(*left_args, *right_args)
91 .all(|(left, right)| mirrored_exprs(cx, left, a_ident, right, b_ident))
93 // The two exprs are method calls.
94 // Check to see that the function is the same and the arguments are mirrored
95 // This is enough because the receiver of the method is listed in the arguments
97 ExprKind::MethodCall(left_segment, _, left_args, _),
98 ExprKind::MethodCall(right_segment, _, right_args, _),
100 left_segment.ident == right_segment.ident
101 && iter::zip(*left_args, *right_args)
102 .all(|(left, right)| mirrored_exprs(cx, left, a_ident, right, b_ident))
104 // Two tuples with mirrored contents
105 (ExprKind::Tup(left_exprs), ExprKind::Tup(right_exprs)) => {
106 iter::zip(*left_exprs, *right_exprs).all(|(left, right)| mirrored_exprs(cx, left, a_ident, right, b_ident))
108 // Two binary ops, which are the same operation and which have mirrored arguments
109 (ExprKind::Binary(left_op, left_left, left_right), ExprKind::Binary(right_op, right_left, right_right)) => {
110 left_op.node == right_op.node
111 && mirrored_exprs(cx, left_left, a_ident, right_left, b_ident)
112 && mirrored_exprs(cx, left_right, a_ident, right_right, b_ident)
114 // Two unary ops, which are the same operation and which have the same argument
115 (ExprKind::Unary(left_op, left_expr), ExprKind::Unary(right_op, right_expr)) => {
116 left_op == right_op && mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident)
118 // The two exprs are literals of some kind
119 (ExprKind::Lit(left_lit), ExprKind::Lit(right_lit)) => left_lit.node == right_lit.node,
120 (ExprKind::Cast(left, _), ExprKind::Cast(right, _)) => mirrored_exprs(cx, left, a_ident, right, b_ident),
121 (ExprKind::DropTemps(left_block), ExprKind::DropTemps(right_block)) => {
122 mirrored_exprs(cx, left_block, a_ident, right_block, b_ident)
124 (ExprKind::Field(left_expr, left_ident), ExprKind::Field(right_expr, right_ident)) => {
125 left_ident.name == right_ident.name && mirrored_exprs(cx, left_expr, a_ident, right_expr, right_ident)
127 // Two paths: either one is a and the other is b, or they're identical to each other
129 ExprKind::Path(QPath::Resolved(
132 segments: left_segments,
136 ExprKind::Path(QPath::Resolved(
139 segments: right_segments,
144 (iter::zip(*left_segments, *right_segments).all(|(left, right)| left.ident == right.ident)
147 .all(|seg| &seg.ident != a_ident && &seg.ident != b_ident))
148 || (left_segments.len() == 1
149 && &left_segments[0].ident == a_ident
150 && right_segments.len() == 1
151 && &right_segments[0].ident == b_ident)
153 // Matching expressions, but one or both is borrowed
155 ExprKind::AddrOf(left_kind, Mutability::Not, left_expr),
156 ExprKind::AddrOf(right_kind, Mutability::Not, right_expr),
157 ) => left_kind == right_kind && mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident),
158 (_, ExprKind::AddrOf(_, Mutability::Not, right_expr)) => {
159 mirrored_exprs(cx, a_expr, a_ident, right_expr, b_ident)
161 (ExprKind::AddrOf(_, Mutability::Not, left_expr), _) => mirrored_exprs(cx, left_expr, a_ident, b_expr, b_ident),
166 fn detect_lint(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<LintTrigger> {
168 if let ExprKind::MethodCall(name_ident, _, args, _) = &expr.kind;
169 if let name = name_ident.ident.name.to_ident_string();
170 if name == "sort_by" || name == "sort_unstable_by";
171 if let [vec, Expr { kind: ExprKind::Closure(_, _, closure_body_id, _, _), .. }] = args;
172 if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(vec), sym::Vec);
173 if let closure_body = cx.tcx.hir().body(*closure_body_id);
175 Param { pat: Pat { kind: PatKind::Binding(_, _, left_ident, _), .. }, ..},
176 Param { pat: Pat { kind: PatKind::Binding(_, _, right_ident, _), .. }, .. }
177 ] = &closure_body.params;
178 if let ExprKind::MethodCall(method_path, _, [ref left_expr, ref right_expr], _) = &closure_body.value.kind;
179 if method_path.ident.name == sym::cmp;
181 let (closure_body, closure_arg, reverse) = if mirrored_exprs(
188 (Sugg::hir(cx, left_expr, "..").to_string(), left_ident.name.to_string(), false)
189 } else if mirrored_exprs(cx, left_expr, right_ident, right_expr, left_ident) {
190 (Sugg::hir(cx, left_expr, "..").to_string(), right_ident.name.to_string(), true)
194 let vec_name = Sugg::hir(cx, &args[0], "..").to_string();
195 let unstable = name == "sort_unstable_by";
198 if let ExprKind::Path(QPath::Resolved(_, Path {
199 segments: [PathSegment { ident: left_name, .. }], ..
200 })) = &left_expr.kind;
201 if left_name == left_ident;
202 if cx.tcx.get_diagnostic_item(sym::Ord).map_or(false, |id| {
203 implements_trait(cx, cx.typeck_results().expr_ty(left_expr), id, &[])
206 return Some(LintTrigger::Sort(SortDetection { vec_name, unstable }));
210 if !expr_borrows(cx, left_expr) {
211 return Some(LintTrigger::SortByKey(SortByKeyDetection {
225 fn expr_borrows(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
226 let ty = cx.typeck_results().expr_ty(expr);
227 matches!(ty.kind(), ty::Ref(..))
230 .any(|arg| matches!(arg.unpack(), GenericArgKind::Lifetime(_)))
233 impl LateLintPass<'_> for UnnecessarySortBy {
234 fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
235 match detect_lint(cx, expr) {
236 Some(LintTrigger::SortByKey(trigger)) => span_lint_and_sugg(
240 "use Vec::sort_by_key here instead",
243 "{}.sort{}_by_key(|{}| {})",
245 if trigger.unstable { "_unstable" } else { "" },
248 format!("Reverse({})", trigger.closure_body)
250 trigger.closure_body.to_string()
254 Applicability::MaybeIncorrect
256 Applicability::MachineApplicable
259 Some(LintTrigger::Sort(trigger)) => span_lint_and_sugg(
263 "use Vec::sort here instead",
268 if trigger.unstable { "_unstable" } else { "" },
270 Applicability::MachineApplicable,