use crate::utils::sugg::Sugg;
use crate::utils::{
- differing_macro_contexts, is_type_diagnostic_item, match_type, paths, snippet, span_lint_and_then, walk_ptrs_ty,
- SpanlessEq,
+ differing_macro_contexts, eq_expr_value, is_type_diagnostic_item, snippet_with_applicability, span_lint_and_then,
};
use if_chain::if_chain;
-use matches::matches;
-use rustc::hir::*;
-use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
-use rustc::ty;
-use rustc::{declare_lint_pass, declare_tool_lint};
use rustc_errors::Applicability;
-use syntax_pos::Symbol;
+use rustc_hir::{Block, Expr, ExprKind, PatKind, QPath, StmtKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
declare_clippy_lint! {
/// **What it does:** Checks for manual swapping.
/// a = b;
/// b = a;
/// ```
- /// Could be written as:
+ /// If swapping is intended, use `swap()` instead:
/// ```rust
/// # let mut a = 1;
/// # let mut b = 2;
declare_lint_pass!(Swap => [MANUAL_SWAP, ALMOST_SWAPPED]);
-impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Swap {
- fn check_block(&mut self, cx: &LateContext<'a, 'tcx>, block: &'tcx Block) {
+impl<'tcx> LateLintPass<'tcx> for Swap {
+ fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'_>) {
check_manual_swap(cx, block);
check_suspicious_swap(cx, block);
}
}
/// Implementation of the `MANUAL_SWAP` lint.
-fn check_manual_swap(cx: &LateContext<'_, '_>, block: &Block) {
+fn check_manual_swap(cx: &LateContext<'_>, block: &Block<'_>) {
for w in block.stmts.windows(3) {
if_chain! {
// let t = foo();
// foo() = bar();
if let StmtKind::Semi(ref first) = w[1].kind;
- if let ExprKind::Assign(ref lhs1, ref rhs1) = first.kind;
+ if let ExprKind::Assign(ref lhs1, ref rhs1, _) = first.kind;
// bar() = t;
if let StmtKind::Semi(ref second) = w[2].kind;
- if let ExprKind::Assign(ref lhs2, ref rhs2) = second.kind;
+ if let ExprKind::Assign(ref lhs2, ref rhs2, _) = second.kind;
if let ExprKind::Path(QPath::Resolved(None, ref rhs2)) = rhs2.kind;
if rhs2.segments.len() == 1;
- if ident.as_str() == rhs2.segments[0].ident.as_str();
- if SpanlessEq::new(cx).ignore_fn().eq_expr(tmp_init, lhs1);
- if SpanlessEq::new(cx).ignore_fn().eq_expr(rhs1, lhs2);
+ if ident.name == rhs2.segments[0].ident.name;
+ if eq_expr_value(cx, tmp_init, lhs1);
+ if eq_expr_value(cx, rhs1, lhs2);
then {
if let ExprKind::Field(ref lhs1, _) = lhs1.kind {
if let ExprKind::Field(ref lhs2, _) = lhs2.kind {
- if lhs1.hir_id.owner_def_id() == lhs2.hir_id.owner_def_id() {
+ if lhs1.hir_id.owner == lhs2.hir_id.owner {
return;
}
}
}
- let slice = check_for_slice(cx, lhs1, lhs2);
+ let mut applicability = Applicability::MachineApplicable;
+ let slice = check_for_slice(cx, lhs1, lhs2);
let (replace, what, sugg) = if let Slice::NotSwappable = slice {
return;
} else if let Slice::Swappable(slice, idx1, idx2) = slice {
format!(
"{}.swap({}, {})",
slice.maybe_par(),
- snippet(cx, idx1.span, ".."),
- snippet(cx, idx2.span, ".."),
+ snippet_with_applicability(cx, idx1.span, "..", &mut applicability),
+ snippet_with_applicability(cx, idx2.span, "..", &mut applicability),
),
)
} else {
MANUAL_SWAP,
span,
&format!("this looks like you are swapping{} manually", what),
- |db| {
+ |diag| {
if !sugg.is_empty() {
- db.span_suggestion(
+ diag.span_suggestion(
span,
"try",
sugg,
- Applicability::Unspecified,
+ applicability,
);
if replace {
- db.note("or maybe you should use `std::mem::replace`?");
+ diag.note("or maybe you should use `std::mem::replace`?");
}
}
}
/// ## Example
///
/// ```rust
+ /// # let mut a = vec![0, 1];
/// let t = a[1];
/// a[1] = a[0];
/// a[0] = t;
/// // can be written as
/// a.swap(0, 1);
/// ```
- Swappable(&'a Expr, &'a Expr, &'a Expr),
+ Swappable(&'a Expr<'a>, &'a Expr<'a>, &'a Expr<'a>),
/// The `swap` function cannot be used.
///
/// ## Example
///
/// ```rust
+ /// # let mut a = [vec![1, 2], vec![3, 4]];
/// let t = a[0][1];
/// a[0][1] = a[1][0];
/// a[1][0] = t;
}
/// Checks if both expressions are index operations into "slice-like" types.
-fn check_for_slice<'a>(cx: &LateContext<'_, '_>, lhs1: &'a Expr, lhs2: &'a Expr) -> Slice<'a> {
+fn check_for_slice<'a>(cx: &LateContext<'_>, lhs1: &'a Expr<'_>, lhs2: &'a Expr<'_>) -> Slice<'a> {
if let ExprKind::Index(ref lhs1, ref idx1) = lhs1.kind {
if let ExprKind::Index(ref lhs2, ref idx2) = lhs2.kind {
- if SpanlessEq::new(cx).ignore_fn().eq_expr(lhs1, lhs2) {
- let ty = walk_ptrs_ty(cx.tables.expr_ty(lhs1));
+ if eq_expr_value(cx, lhs1, lhs2) {
+ let ty = cx.typeck_results().expr_ty(lhs1).peel_refs();
- if matches!(ty.kind, ty::Slice(_))
- || matches!(ty.kind, ty::Array(_, _))
- || is_type_diagnostic_item(cx, ty, Symbol::intern("vec_type"))
- || match_type(cx, ty, &paths::VEC_DEQUE)
+ if matches!(ty.kind(), ty::Slice(_))
+ || matches!(ty.kind(), ty::Array(_, _))
+ || is_type_diagnostic_item(cx, ty, sym::vec_type)
+ || is_type_diagnostic_item(cx, ty, sym!(vecdeque_type))
{
return Slice::Swappable(lhs1, idx1, idx2);
}
}
/// Implementation of the `ALMOST_SWAPPED` lint.
-fn check_suspicious_swap(cx: &LateContext<'_, '_>, block: &Block) {
+fn check_suspicious_swap(cx: &LateContext<'_>, block: &Block<'_>) {
for w in block.stmts.windows(2) {
if_chain! {
if let StmtKind::Semi(ref first) = w[0].kind;
if let StmtKind::Semi(ref second) = w[1].kind;
if !differing_macro_contexts(first.span, second.span);
- if let ExprKind::Assign(ref lhs0, ref rhs0) = first.kind;
- if let ExprKind::Assign(ref lhs1, ref rhs1) = second.kind;
- if SpanlessEq::new(cx).ignore_fn().eq_expr(lhs0, rhs1);
- if SpanlessEq::new(cx).ignore_fn().eq_expr(lhs1, rhs0);
+ if let ExprKind::Assign(ref lhs0, ref rhs0, _) = first.kind;
+ if let ExprKind::Assign(ref lhs1, ref rhs1, _) = second.kind;
+ if eq_expr_value(cx, lhs0, rhs1);
+ if eq_expr_value(cx, lhs1, rhs0);
then {
let lhs0 = Sugg::hir_opt(cx, lhs0);
let rhs0 = Sugg::hir_opt(cx, rhs0);
ALMOST_SWAPPED,
span,
&format!("this looks like you are trying to swap{}", what),
- |db| {
+ |diag| {
if !what.is_empty() {
- db.span_suggestion(
+ diag.span_suggestion(
span,
"try",
format!(
),
Applicability::MaybeIncorrect,
);
- db.note("or maybe you should use `std::mem::replace`?");
+ diag.note("or maybe you should use `std::mem::replace`?");
}
});
}