use rustc_lint::{LateContext, LateLintPass};
use rustc_middle::ty::{self, subst::GenericArgKind};
use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
use rustc_span::symbol::Ident;
declare_clippy_lint! {
}
fn detect_lint(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<LintTrigger> {
- // NOTE: Vectors of references are not supported. In order to avoid hitting https://github.com/rust-lang/rust/issues/34162,
- // (different unnamed lifetimes for closure arg and return type) we need to make sure the suggested
- // closure parameter is not a reference in case we suggest `Reverse`. Trying to destructure more
- // than one level of references would add some extra complexity as we would have to compensate
- // in the closure body.
-
if_chain! {
if let ExprKind::MethodCall(name_ident, _, args, _) = &expr.kind;
if let name = name_ident.ident.name.to_ident_string();
if name == "sort_by" || name == "sort_unstable_by";
if let [vec, Expr { kind: ExprKind::Closure(_, _, closure_body_id, _, _), .. }] = args;
- let vec_ty = cx.typeck_results().expr_ty(vec);
- if utils::is_type_diagnostic_item(cx, vec_ty, sym!(vec_type));
- let ty = vec_ty.walk().nth(1).unwrap().expect_ty(); // T in Vec<T>
- if !matches!(&ty.kind(), ty::Ref(..));
- if utils::is_copy(cx, ty);
+ if utils::is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(vec), sym::vec_type);
if let closure_body = cx.tcx.hir().body(*closure_body_id);
if let &[
Param { pat: Pat { kind: PatKind::Binding(_, _, left_ident, _), .. }, ..},
Param { pat: Pat { kind: PatKind::Binding(_, _, right_ident, _), .. }, .. }
] = &closure_body.params;
if let ExprKind::MethodCall(method_path, _, [ref left_expr, ref right_expr], _) = &closure_body.value.kind;
- if method_path.ident.name.to_ident_string() == "cmp";
+ if method_path.ident.name == sym::cmp;
then {
let (closure_body, closure_arg, reverse) = if mirrored_exprs(
&cx,
let vec_name = Sugg::hir(cx, &args[0], "..").to_string();
let unstable = name == "sort_unstable_by";
- if_chain! {
- if let ExprKind::Path(QPath::Resolved(_, Path {
- segments: [PathSegment { ident: left_name, .. }], ..
- })) = &left_expr.kind;
- if left_name == left_ident;
- then {
- return Some(LintTrigger::Sort(SortDetection { vec_name, unstable }))
- } else {
- if !key_returns_borrow(cx, left_expr) {
- return Some(LintTrigger::SortByKey(SortByKeyDetection {
- vec_name,
- unstable,
- closure_arg,
- closure_body,
- reverse
- }))
- }
+ if let ExprKind::Path(QPath::Resolved(_, Path {
+ segments: [PathSegment { ident: left_name, .. }], ..
+ })) = &left_expr.kind {
+ if left_name == left_ident {
+ return Some(LintTrigger::Sort(SortDetection { vec_name, unstable }));
}
}
+
+ if !expr_borrows(cx, left_expr) {
+ return Some(LintTrigger::SortByKey(SortByKeyDetection {
+ vec_name,
+ closure_arg,
+ closure_body,
+ reverse,
+ unstable,
+ }));
+ }
}
}
None
}
-fn key_returns_borrow(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
- if let Some(def_id) = utils::fn_def_id(cx, expr) {
- let output = cx.tcx.fn_sig(def_id).output();
- let ty = output.skip_binder();
- return matches!(ty.kind(), ty::Ref(..))
- || ty.walk().any(|arg| matches!(arg.unpack(), GenericArgKind::Lifetime(_)));
- }
-
- false
+fn expr_borrows(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+ let ty = cx.typeck_results().expr_ty(expr);
+ matches!(ty.kind(), ty::Ref(..)) || ty.walk().any(|arg| matches!(arg.unpack(), GenericArgKind::Lifetime(_)))
}
impl LateLintPass<'_> for UnnecessarySortBy {
"use Vec::sort_by_key here instead",
"try",
format!(
- "{}.sort{}_by_key(|&{}| {})",
+ "{}.sort{}_by_key(|{}| {})",
trigger.vec_name,
if trigger.unstable { "_unstable" } else { "" },
trigger.closure_arg,