nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-28 17:53:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor ``Sugg::BinOp``

Browse Source
This commit is contained in:
hotate29 2021-12-15 23:23:36 +09:00
parent b3b65a1bf6
commit 0b6d1fdea2
No known key found for this signature in database
GPG Key ID: DB720E72A6380B5A
4 changed files with 166 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
clippy_lints/src/loops/manual_memcpy.rs
View File

@ -12,6 +12,7 @@ use rustc_hir::{BinOpKind, Block, Expr, ExprKind, HirId, Pat, PatKind, StmtKind}
use rustc_lint::LateContext; use rustc_lint::LateContext;
use rustc_middle::ty::{self, Ty}; use rustc_middle::ty::{self, Ty};
use rustc_span::symbol::sym; use rustc_span::symbol::sym;
use std::fmt::Display;
use std::iter::Iterator; use std::iter::Iterator;
/// Checks for for loops that sequentially copy items from one slice-like /// Checks for for loops that sequentially copy items from one slice-like
@ -108,7 +109,7 @@ fn build_manual_memcpy_suggestion<'tcx>(
src: &IndexExpr<'_>, src: &IndexExpr<'_>,
) -> String { ) -> String {
fn print_offset(offset: MinifyingSugg<'static>) -> MinifyingSugg<'static> { fn print_offset(offset: MinifyingSugg<'static>) -> MinifyingSugg<'static> {
if offset.as_str() == "0" { if offset.to_string() == "0" {
sugg::EMPTY.into() sugg::EMPTY.into()
} else { } else {
offset offset
@ -123,7 +124,7 @@ fn build_manual_memcpy_suggestion<'tcx>(
if let Some(arg) = len_args.get(0); if let Some(arg) = len_args.get(0);
if path_to_local(arg) == path_to_local(base); if path_to_local(arg) == path_to_local(base);
then { then {
if sugg.as_str() == end_str { if sugg.to_string() == end_str {
sugg::EMPTY.into() sugg::EMPTY.into()
} else { } else {
sugg sugg
@ -147,7 +148,7 @@ fn build_manual_memcpy_suggestion<'tcx>(
print_offset(apply_offset(&start_str, &idx_expr.idx_offset)).into_sugg(), print_offset(apply_offset(&start_str, &idx_expr.idx_offset)).into_sugg(),
print_limit( print_limit(
end, end,
end_str.as_str(), end_str.to_string().as_str(),
idx_expr.base, idx_expr.base,
apply_offset(&end_str, &idx_expr.idx_offset), apply_offset(&end_str, &idx_expr.idx_offset),
) )
@ -159,7 +160,7 @@ fn build_manual_memcpy_suggestion<'tcx>(
print_offset(apply_offset(&counter_start, &idx_expr.idx_offset)).into_sugg(), print_offset(apply_offset(&counter_start, &idx_expr.idx_offset)).into_sugg(),
print_limit( print_limit(
end, end,
end_str.as_str(), end_str.to_string().as_str(),
idx_expr.base, idx_expr.base,
apply_offset(&end_str, &idx_expr.idx_offset) + &counter_start - &start_str, apply_offset(&end_str, &idx_expr.idx_offset) + &counter_start - &start_str,
) )
@ -202,12 +203,13 @@ fn build_manual_memcpy_suggestion<'tcx>(
#[derive(Clone)] #[derive(Clone)]
struct MinifyingSugg<'a>(Sugg<'a>); struct MinifyingSugg<'a>(Sugg<'a>);
impl<'a> MinifyingSugg<'a> { impl Display for MinifyingSugg<'a> {
fn as_str(&self) -> &str { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let (Sugg::NonParen(s) | Sugg::MaybeParen(s) | Sugg::BinOp(_, s)) = &self.0; self.0.fmt(f)
s.as_ref()
} }
}
impl<'a> MinifyingSugg<'a> {
fn into_sugg(self) -> Sugg<'a> { fn into_sugg(self) -> Sugg<'a> {
self.0 self.0
} }
@ -222,7 +224,7 @@ impl<'a> From<Sugg<'a>> for MinifyingSugg<'a> {
impl std::ops::Add for &MinifyingSugg<'static> { impl std::ops::Add for &MinifyingSugg<'static> {
type Output = MinifyingSugg<'static>; type Output = MinifyingSugg<'static>;
fn add(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> { fn add(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> {
match (self.as_str(), rhs.as_str()) { match (self.to_string().as_str(), rhs.to_string().as_str()) {
("0", _) => rhs.clone(), ("0", _) => rhs.clone(),
(_, "0") => self.clone(), (_, "0") => self.clone(),
(_, _) => (&self.0 + &rhs.0).into(), (_, _) => (&self.0 + &rhs.0).into(),
@ -233,7 +235,7 @@ impl std::ops::Add for &MinifyingSugg<'static> {
impl std::ops::Sub for &MinifyingSugg<'static> { impl std::ops::Sub for &MinifyingSugg<'static> {
type Output = MinifyingSugg<'static>; type Output = MinifyingSugg<'static>;
fn sub(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> { fn sub(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> {
match (self.as_str(), rhs.as_str()) { match (self.to_string().as_str(), rhs.to_string().as_str()) {
(_, "0") => self.clone(), (_, "0") => self.clone(),
("0", _) => (-rhs.0.clone()).into(), ("0", _) => (-rhs.0.clone()).into(),
(x, y) if x == y => sugg::ZERO.into(), (x, y) if x == y => sugg::ZERO.into(),
@ -245,7 +247,7 @@ impl std::ops::Sub for &MinifyingSugg<'static> {
impl std::ops::Add<&MinifyingSugg<'static>> for MinifyingSugg<'static> { impl std::ops::Add<&MinifyingSugg<'static>> for MinifyingSugg<'static> {
type Output = MinifyingSugg<'static>; type Output = MinifyingSugg<'static>;
fn add(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> { fn add(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> {
match (self.as_str(), rhs.as_str()) { match (self.to_string().as_str(), rhs.to_string().as_str()) {
("0", _) => rhs.clone(), ("0", _) => rhs.clone(),
(_, "0") => self, (_, "0") => self,
(_, _) => (self.0 + &rhs.0).into(), (_, _) => (self.0 + &rhs.0).into(),
@ -256,7 +258,7 @@ impl std::ops::Add<&MinifyingSugg<'static>> for MinifyingSugg<'static> {
impl std::ops::Sub<&MinifyingSugg<'static>> for MinifyingSugg<'static> { impl std::ops::Sub<&MinifyingSugg<'static>> for MinifyingSugg<'static> {
type Output = MinifyingSugg<'static>; type Output = MinifyingSugg<'static>;
fn sub(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> { fn sub(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> {
match (self.as_str(), rhs.as_str()) { match (self.to_string().as_str(), rhs.to_string().as_str()) {
(_, "0") => self, (_, "0") => self,
("0", _) => (-rhs.0.clone()).into(), ("0", _) => (-rhs.0.clone()).into(),
(x, y) if x == y => sugg::ZERO.into(), (x, y) if x == y => sugg::ZERO.into(),

12
clippy_lints/src/needless_bool.rs
View File

@ -187,14 +187,14 @@ impl<'tcx> LateLintPass<'tcx> for BoolComparison {
BinOpKind::Eq => { BinOpKind::Eq => {
let true_case = Some((|h| h, "equality checks against true are unnecessary")); let true_case = Some((|h| h, "equality checks against true are unnecessary"));
let false_case = Some(( let false_case = Some((
|h: Sugg<'_>| !h, |h: Sugg<'tcx>| !h,
"equality checks against false can be replaced by a negation", "equality checks against false can be replaced by a negation",
)); ));
check_comparison(cx, e, true_case, false_case, true_case, false_case, ignore_no_literal); check_comparison(cx, e, true_case, false_case, true_case, false_case, ignore_no_literal);
}, },
BinOpKind::Ne => { BinOpKind::Ne => {
let true_case = Some(( let true_case = Some((
|h: Sugg<'_>| !h, |h: Sugg<'tcx>| !h,
"inequality checks against true can be replaced by a negation", "inequality checks against true can be replaced by a negation",
)); ));
let false_case = Some((|h| h, "inequality checks against false are unnecessary")); let false_case = Some((|h| h, "inequality checks against false are unnecessary"));
@ -206,12 +206,12 @@ impl<'tcx> LateLintPass<'tcx> for BoolComparison {
ignore_case, ignore_case,
Some((|h| h, "greater than checks against false are unnecessary")), Some((|h| h, "greater than checks against false are unnecessary")),
Some(( Some((
|h: Sugg<'_>| !h, |h: Sugg<'tcx>| !h,
"less than comparison against true can be replaced by a negation", "less than comparison against true can be replaced by a negation",
)), )),
ignore_case, ignore_case,
Some(( Some((
|l: Sugg<'_>, r: Sugg<'_>| (!l).bit_and(&r), |l: Sugg<'tcx>, r: Sugg<'tcx>| (!l).bit_and(&r),
"order comparisons between booleans can be simplified", "order comparisons between booleans can be simplified",
)), )),
), ),
@ -219,14 +219,14 @@ impl<'tcx> LateLintPass<'tcx> for BoolComparison {
cx, cx,
e, e,
Some(( Some((
|h: Sugg<'_>| !h, |h: Sugg<'tcx>| !h,
"less than comparison against true can be replaced by a negation", "less than comparison against true can be replaced by a negation",
)), )),
ignore_case, ignore_case,
ignore_case, ignore_case,
Some((|h| h, "greater than checks against false are unnecessary")), Some((|h| h, "greater than checks against false are unnecessary")),
Some(( Some((
|l: Sugg<'_>, r: Sugg<'_>| l.bit_and(&(!r)), |l: Sugg<'tcx>, r: Sugg<'tcx>| l.bit_and(&(!r)),
"order comparisons between booleans can be simplified", "order comparisons between booleans can be simplified",
)), )),
), ),

264
clippy_utils/src/sugg.rs
View File

@ -1,9 +1,7 @@
//! Contains utility functions to generate suggestions. //! Contains utility functions to generate suggestions.
#![deny(clippy::missing_docs_in_private_items)] #![deny(clippy::missing_docs_in_private_items)]
use crate::source::{ use crate::source::{snippet, snippet_opt, snippet_with_applicability, snippet_with_macro_callsite};
snippet, snippet_opt, snippet_with_applicability, snippet_with_context, snippet_with_macro_callsite,
};
use crate::{get_parent_expr_for_hir, higher}; use crate::{get_parent_expr_for_hir, higher};
use rustc_ast::util::parser::AssocOp; use rustc_ast::util::parser::AssocOp;
use rustc_ast::{ast, token}; use rustc_ast::{ast, token};
@ -33,7 +31,7 @@ pub enum Sugg<'a> {
MaybeParen(Cow<'a, str>), MaybeParen(Cow<'a, str>),
/// A binary operator expression, including `as`-casts and explicit type /// A binary operator expression, including `as`-casts and explicit type
/// coercion. /// coercion.
BinOp(AssocOp, Cow<'a, str>), BinOp(AssocOp, Cow<'a, str>, Cow<'a, str>),
} }
/// Literal constant `0`, for convenience. /// Literal constant `0`, for convenience.
@ -46,7 +44,8 @@ pub const EMPTY: Sugg<'static> = Sugg::NonParen(Cow::Borrowed(""));
impl Display for Sugg<'_> { impl Display for Sugg<'_> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
match *self { match *self {
Sugg::NonParen(ref s) | Sugg::MaybeParen(ref s) | Sugg::BinOp(_, ref s) => s.fmt(f), Sugg::NonParen(ref s) | Sugg::MaybeParen(ref s) => s.fmt(f),
Sugg::BinOp(op, ref lhs, ref rhs) => binop_to_string(op, lhs, rhs).fmt(f),
} }
} }
} }
@ -55,10 +54,8 @@ impl Display for Sugg<'_> {
impl<'a> Sugg<'a> { impl<'a> Sugg<'a> {
/// Prepare a suggestion from an expression. /// Prepare a suggestion from an expression.
pub fn hir_opt(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<Self> { pub fn hir_opt(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<Self> {
snippet_opt(cx, expr.span).map(|snippet| { let get_snippet = |span| snippet(cx, span, "");
let snippet = Cow::Owned(snippet); snippet_opt(cx, expr.span).map(|_| Self::hir_from_snippet(expr, get_snippet))
Self::hir_from_snippet(expr, snippet)
})
} }
/// Convenience function around `hir_opt` for suggestions with a default /// Convenience function around `hir_opt` for suggestions with a default
@ -93,9 +90,8 @@ impl<'a> Sugg<'a> {
/// Same as `hir`, but will use the pre expansion span if the `expr` was in a macro. /// Same as `hir`, but will use the pre expansion span if the `expr` was in a macro.
pub fn hir_with_macro_callsite(cx: &LateContext<'_>, expr: &hir::Expr<'_>, default: &'a str) -> Self { pub fn hir_with_macro_callsite(cx: &LateContext<'_>, expr: &hir::Expr<'_>, default: &'a str) -> Self {
let snippet = snippet_with_macro_callsite(cx, expr.span, default); let get_snippet = |span| snippet_with_macro_callsite(cx, span, default);
Self::hir_from_snippet(expr, get_snippet)
Self::hir_from_snippet(expr, snippet)
} }
/// Same as `hir`, but first walks the span up to the given context. This will result in the /// Same as `hir`, but first walks the span up to the given context. This will result in the
@ -112,24 +108,26 @@ impl<'a> Sugg<'a> {
default: &'a str, default: &'a str,
applicability: &mut Applicability, applicability: &mut Applicability,
) -> Self { ) -> Self {
let (snippet, in_macro) = snippet_with_context(cx, expr.span, ctxt, default, applicability); if expr.span.ctxt() == ctxt {
Self::hir_from_snippet(expr, |span| snippet(cx, span, default))
if in_macro {
Sugg::NonParen(snippet)
} else { } else {
Self::hir_from_snippet(expr, snippet) let snip = snippet_with_applicability(cx, expr.span, default, applicability);
Sugg::NonParen(snip)
} }
} }
/// Generate a suggestion for an expression with the given snippet. This is used by the `hir_*` /// Generate a suggestion for an expression with the given snippet. This is used by the `hir_*`
/// function variants of `Sugg`, since these use different snippet functions. /// function variants of `Sugg`, since these use different snippet functions.
fn hir_from_snippet(expr: &hir::Expr<'_>, snippet: Cow<'a, str>) -> Self { fn hir_from_snippet(expr: &hir::Expr<'_>, get_snippet: impl Fn(Span) -> Cow<'a, str>) -> Self {
if let Some(range) = higher::Range::hir(expr) { if let Some(range) = higher::Range::hir(expr) {
let op = match range.limits { let op = match range.limits {
ast::RangeLimits::HalfOpen => AssocOp::DotDot, ast::RangeLimits::HalfOpen => AssocOp::DotDot,
ast::RangeLimits::Closed => AssocOp::DotDotEq, ast::RangeLimits::Closed => AssocOp::DotDotEq,
}; };
return Sugg::BinOp(op, snippet); let start = range.start.map_or("".into(), |expr| get_snippet(expr.span));
let end = range.end.map_or("".into(), |expr| get_snippet(expr.span));
return Sugg::BinOp(op, start, end);
} }
match expr.kind { match expr.kind {
@ -139,7 +137,7 @@ impl<'a> Sugg<'a> {
| hir::ExprKind::Let(..) | hir::ExprKind::Let(..)
| hir::ExprKind::Closure(..) | hir::ExprKind::Closure(..)
| hir::ExprKind::Unary(..) | hir::ExprKind::Unary(..)
| hir::ExprKind::Match(..) => Sugg::MaybeParen(snippet), | hir::ExprKind::Match(..) => Sugg::MaybeParen(get_snippet(expr.span)),
hir::ExprKind::Continue(..) hir::ExprKind::Continue(..)
| hir::ExprKind::Yield(..) | hir::ExprKind::Yield(..)
| hir::ExprKind::Array(..) | hir::ExprKind::Array(..)
@ -160,12 +158,20 @@ impl<'a> Sugg<'a> {
| hir::ExprKind::Struct(..) | hir::ExprKind::Struct(..)
| hir::ExprKind::Tup(..) | hir::ExprKind::Tup(..)
| hir::ExprKind::DropTemps(_) | hir::ExprKind::DropTemps(_)
| hir::ExprKind::Err => Sugg::NonParen(snippet), | hir::ExprKind::Err => Sugg::NonParen(get_snippet(expr.span)),
hir::ExprKind::Assign(..) => Sugg::BinOp(AssocOp::Assign, snippet), hir::ExprKind::Assign(lhs, rhs, _) => {
hir::ExprKind::AssignOp(op, ..) => Sugg::BinOp(hirbinop2assignop(op), snippet), Sugg::BinOp(AssocOp::Assign, get_snippet(lhs.span), get_snippet(rhs.span))
hir::ExprKind::Binary(op, ..) => Sugg::BinOp(AssocOp::from_ast_binop(op.node.into()), snippet), },
hir::ExprKind::Cast(..) => Sugg::BinOp(AssocOp::As, snippet), hir::ExprKind::AssignOp(op, lhs, rhs) => {
hir::ExprKind::Type(..) => Sugg::BinOp(AssocOp::Colon, snippet), Sugg::BinOp(hirbinop2assignop(op), get_snippet(lhs.span), get_snippet(rhs.span))
},
hir::ExprKind::Binary(op, lhs, rhs) => Sugg::BinOp(
AssocOp::from_ast_binop(op.node.into()),
get_snippet(lhs.span),
get_snippet(rhs.span),
),
hir::ExprKind::Cast(lhs, ty) => Sugg::BinOp(AssocOp::As, get_snippet(lhs.span), get_snippet(ty.span)),
hir::ExprKind::Type(lhs, ty) => Sugg::BinOp(AssocOp::Colon, get_snippet(lhs.span), get_snippet(ty.span)),
} }
} }
@ -173,10 +179,12 @@ impl<'a> Sugg<'a> {
pub fn ast(cx: &EarlyContext<'_>, expr: &ast::Expr, default: &'a str) -> Self { pub fn ast(cx: &EarlyContext<'_>, expr: &ast::Expr, default: &'a str) -> Self {
use rustc_ast::ast::RangeLimits; use rustc_ast::ast::RangeLimits;
let snippet = if expr.span.from_expansion() { let get_whole_snippet = || {
snippet_with_macro_callsite(cx, expr.span, default) if expr.span.from_expansion() {
} else { snippet_with_macro_callsite(cx, expr.span, default)
snippet(cx, expr.span, default) } else {
snippet(cx, expr.span, default)
}
}; };
match expr.kind { match expr.kind {
@ -186,7 +194,7 @@ impl<'a> Sugg<'a> {
| ast::ExprKind::If(..) | ast::ExprKind::If(..)
| ast::ExprKind::Let(..) | ast::ExprKind::Let(..)
| ast::ExprKind::Unary(..) | ast::ExprKind::Unary(..)
| ast::ExprKind::Match(..) => Sugg::MaybeParen(snippet), | ast::ExprKind::Match(..) => Sugg::MaybeParen(get_whole_snippet()),
ast::ExprKind::Async(..) ast::ExprKind::Async(..)
| ast::ExprKind::Block(..) | ast::ExprKind::Block(..)
| ast::ExprKind::Break(..) | ast::ExprKind::Break(..)
@ -215,14 +223,42 @@ impl<'a> Sugg<'a> {
| ast::ExprKind::Array(..) | ast::ExprKind::Array(..)
| ast::ExprKind::While(..) | ast::ExprKind::While(..)
| ast::ExprKind::Await(..) | ast::ExprKind::Await(..)
| ast::ExprKind::Err => Sugg::NonParen(snippet), | ast::ExprKind::Err => Sugg::NonParen(get_whole_snippet()),
ast::ExprKind::Range(.., RangeLimits::HalfOpen) => Sugg::BinOp(AssocOp::DotDot, snippet), ast::ExprKind::Range(ref lhs, ref rhs, RangeLimits::HalfOpen) => Sugg::BinOp(
ast::ExprKind::Range(.., RangeLimits::Closed) => Sugg::BinOp(AssocOp::DotDotEq, snippet), AssocOp::DotDot,
ast::ExprKind::Assign(..) => Sugg::BinOp(AssocOp::Assign, snippet), lhs.as_ref().map_or("".into(), |lhs| snippet(cx, lhs.span, default)),
ast::ExprKind::AssignOp(op, ..) => Sugg::BinOp(astbinop2assignop(op), snippet), rhs.as_ref().map_or("".into(), |rhs| snippet(cx, rhs.span, default)),
ast::ExprKind::Binary(op, ..) => Sugg::BinOp(AssocOp::from_ast_binop(op.node), snippet), ),
ast::ExprKind::Cast(..) => Sugg::BinOp(AssocOp::As, snippet), ast::ExprKind::Range(ref lhs, ref rhs, RangeLimits::Closed) => Sugg::BinOp(
ast::ExprKind::Type(..) => Sugg::BinOp(AssocOp::Colon, snippet), AssocOp::DotDotEq,
lhs.as_ref().map_or("".into(), |lhs| snippet(cx, lhs.span, default)),
rhs.as_ref().map_or("".into(), |rhs| snippet(cx, rhs.span, default)),
),
ast::ExprKind::Assign(ref lhs, ref rhs, _) => Sugg::BinOp(
AssocOp::Assign,
snippet(cx, lhs.span, default),
snippet(cx, rhs.span, default),
),
ast::ExprKind::AssignOp(op, ref lhs, ref rhs) => Sugg::BinOp(
astbinop2assignop(op),
snippet(cx, lhs.span, default),
snippet(cx, rhs.span, default),
),
ast::ExprKind::Binary(op, ref lhs, ref rhs) => Sugg::BinOp(
AssocOp::from_ast_binop(op.node),
snippet(cx, lhs.span, default),
snippet(cx, rhs.span, default),
),
ast::ExprKind::Cast(ref lhs, ref ty) => Sugg::BinOp(
AssocOp::As,
snippet(cx, lhs.span, default),
snippet(cx, ty.span, default),
),
ast::ExprKind::Type(ref lhs, ref ty) => Sugg::BinOp(
AssocOp::Colon,
snippet(cx, lhs.span, default),
snippet(cx, ty.span, default),
),
} }
} }
@ -306,17 +342,51 @@ impl<'a> Sugg<'a> {
Sugg::NonParen(format!("({})", sugg).into()) Sugg::NonParen(format!("({})", sugg).into())
} }
}, },
Sugg::BinOp(_, sugg) => { Sugg::BinOp(op, lhs, rhs) => {
if has_enclosing_paren(&sugg) { let sugg = binop_to_string(op, &lhs, &rhs);
Sugg::NonParen(sugg) Sugg::NonParen(format!("({})", sugg).into())
} else {
Sugg::NonParen(format!("({})", sugg).into())
}
}, },
} }
} }
} }
/// Generates a string from the operator and both sides.
fn binop_to_string(op: AssocOp, lhs: &str, rhs: &str) -> String {
match op {
AssocOp::Add
| AssocOp::Subtract
| AssocOp::Multiply
| AssocOp::Divide
| AssocOp::Modulus
| AssocOp::LAnd
| AssocOp::LOr
| AssocOp::BitXor
| AssocOp::BitAnd
| AssocOp::BitOr
| AssocOp::ShiftLeft
| AssocOp::ShiftRight
| AssocOp::Equal
| AssocOp::Less
| AssocOp::LessEqual
| AssocOp::NotEqual
| AssocOp::Greater
| AssocOp::GreaterEqual => format!(
"{} {} {}",
lhs,
op.to_ast_binop().expect("Those are AST ops").to_string(),
rhs
),
AssocOp::Assign => format!("{} = {}", lhs, rhs),
AssocOp::AssignOp(op) => {
format!("{} {}= {}", lhs, token_kind_to_string(&token::BinOp(op)), rhs)
},
AssocOp::As => format!("{} as {}", lhs, rhs),
AssocOp::DotDot => format!("{}..{}", lhs, rhs),
AssocOp::DotDotEq => format!("{}..={}", lhs, rhs),
AssocOp::Colon => format!("{}: {}", lhs, rhs),
}
}
/// Return `true` if `sugg` is enclosed in parenthesis. /// Return `true` if `sugg` is enclosed in parenthesis.
fn has_enclosing_paren(sugg: impl AsRef<str>) -> bool { fn has_enclosing_paren(sugg: impl AsRef<str>) -> bool {
let mut chars = sugg.as_ref().chars(); let mut chars = sugg.as_ref().chars();
@ -391,34 +461,22 @@ impl Neg for Sugg<'_> {
} }
} }
impl Not for Sugg<'_> { impl Not for Sugg<'a> {
type Output = Sugg<'static>; type Output = Sugg<'a>;
fn not(self) -> Sugg<'static> { fn not(self) -> Sugg<'a> {
use AssocOp::{Equal, Greater, GreaterEqual, Less, LessEqual, NotEqual}; use AssocOp::{Equal, Greater, GreaterEqual, Less, LessEqual, NotEqual};
/// Convert ```AssocOp``` to a string of operators. if let Sugg::BinOp(op, lhs, rhs) = self {
fn op_as_str(op: AssocOp) -> &'static str { let to_op = match op {
op.to_ast_binop().unwrap().to_string() Equal => NotEqual,
} NotEqual => Equal,
Less => GreaterEqual,
/// Replace the operator in the Snippet. GreaterEqual => Less,
fn replace_op(from_op: AssocOp, to_op: AssocOp, snip: Cow<'_, str>) -> Sugg<'static> { Greater => LessEqual,
let from = op_as_str(from_op); LessEqual => Greater,
let to = op_as_str(to_op); _ => return make_unop("!", Sugg::BinOp(op, lhs, rhs)),
let snip = snip.into_owned().replace(from, to); };
Sugg::BinOp(to_op, Cow::Owned(snip)) Sugg::BinOp(to_op, lhs, rhs)
}
if let Sugg::BinOp(op, snip) = self {
match op {
Equal => replace_op(op, NotEqual, snip),
NotEqual => replace_op(op, Equal, snip),
Less => replace_op(op, GreaterEqual, snip),
GreaterEqual => replace_op(op, Less, snip),
Greater => replace_op(op, LessEqual, snip),
LessEqual => replace_op(op, Greater, snip),
_ => make_unop("!", Sugg::BinOp(op, snip)),
}
} else { } else {
make_unop("!", self) make_unop("!", self)
} }
@ -490,53 +548,21 @@ pub fn make_assoc(op: AssocOp, lhs: &Sugg<'_>, rhs: &Sugg<'_>) -> Sugg<'static>
|| is_shift(other) && is_arith(op) || is_shift(other) && is_arith(op)
} }
let lhs_paren = if let Sugg::BinOp(lop, _) = *lhs { let lhs_paren = if let Sugg::BinOp(lop, _, _) = *lhs {
needs_paren(op, lop, Associativity::Left) needs_paren(op, lop, Associativity::Left)
} else { } else {
false false
}; };
let rhs_paren = if let Sugg::BinOp(rop, _) = *rhs { let rhs_paren = if let Sugg::BinOp(rop, _, _) = *rhs {
needs_paren(op, rop, Associativity::Right) needs_paren(op, rop, Associativity::Right)
} else { } else {
false false
}; };
let lhs = ParenHelper::new(lhs_paren, lhs); let lhs = ParenHelper::new(lhs_paren, lhs).to_string();
let rhs = ParenHelper::new(rhs_paren, rhs); let rhs = ParenHelper::new(rhs_paren, rhs).to_string();
let sugg = match op { Sugg::BinOp(op, lhs.into(), rhs.into())
AssocOp::Add
| AssocOp::BitAnd
| AssocOp::BitOr
| AssocOp::BitXor
| AssocOp::Divide
| AssocOp::Equal
| AssocOp::Greater
| AssocOp::GreaterEqual
| AssocOp::LAnd
| AssocOp::LOr
| AssocOp::Less
| AssocOp::LessEqual
| AssocOp::Modulus
| AssocOp::Multiply
| AssocOp::NotEqual
| AssocOp::ShiftLeft
| AssocOp::ShiftRight
| AssocOp::Subtract => format!(
"{} {} {}",
lhs,
op.to_ast_binop().expect("Those are AST ops").to_string(),
rhs
),
AssocOp::Assign => format!("{} = {}", lhs, rhs),
AssocOp::AssignOp(op) => format!("{} {}= {}", lhs, token_kind_to_string(&token::BinOp(op)), rhs),
AssocOp::As => format!("{} as {}", lhs, rhs),
AssocOp::DotDot => format!("{}..{}", lhs, rhs),
AssocOp::DotDotEq => format!("{}..={}", lhs, rhs),
AssocOp::Colon => format!("{}: {}", lhs, rhs),
};
Sugg::BinOp(op, sugg.into())
} }
/// Convenience wrapper around `make_assoc` and `AssocOp::from_ast_binop`. /// Convenience wrapper around `make_assoc` and `AssocOp::from_ast_binop`.
@ -1034,10 +1060,10 @@ mod test {
#[test] #[test]
fn binop_maybe_par() { fn binop_maybe_par() {
let sugg = Sugg::BinOp(AssocOp::Add, "(1 + 1)".into()); let sugg = Sugg::BinOp(AssocOp::Add, "1".into(), "1".into());
assert_eq!("(1 + 1)", sugg.maybe_par().to_string()); assert_eq!("(1 + 1)", sugg.maybe_par().to_string());
let sugg = Sugg::BinOp(AssocOp::Add, "(1 + 1) + (1 + 1)".into()); let sugg = Sugg::BinOp(AssocOp::Add, "(1 + 1)".into(), "(1 + 1)".into());
assert_eq!("((1 + 1) + (1 + 1))", sugg.maybe_par().to_string()); assert_eq!("((1 + 1) + (1 + 1))", sugg.maybe_par().to_string());
} }
#[test] #[test]
@ -1045,32 +1071,32 @@ mod test {
use AssocOp::{Add, Equal, Greater, GreaterEqual, LAnd, LOr, Less, LessEqual, NotEqual}; use AssocOp::{Add, Equal, Greater, GreaterEqual, LAnd, LOr, Less, LessEqual, NotEqual};
// Invert the comparison operator. // Invert the comparison operator.
let sugg = Sugg::BinOp(Equal, "1 == 1".into()); let sugg = Sugg::BinOp(Equal, "1".into(), "1".into());
assert_eq!("1 != 1", (!sugg).to_string()); assert_eq!("1 != 1", (!sugg).to_string());
let sugg = Sugg::BinOp(NotEqual, "1 != 1".into()); let sugg = Sugg::BinOp(NotEqual, "1".into(), "1".into());
assert_eq!("1 == 1", (!sugg).to_string()); assert_eq!("1 == 1", (!sugg).to_string());
let sugg = Sugg::BinOp(Less, "1 < 1".into()); let sugg = Sugg::BinOp(Less, "1".into(), "1".into());
assert_eq!("1 >= 1", (!sugg).to_string()); assert_eq!("1 >= 1", (!sugg).to_string());
let sugg = Sugg::BinOp(LessEqual, "1 <= 1".into()); let sugg = Sugg::BinOp(LessEqual, "1".into(), "1".into());
assert_eq!("1 > 1", (!sugg).to_string()); assert_eq!("1 > 1", (!sugg).to_string());
let sugg = Sugg::BinOp(Greater, "1 > 1".into()); let sugg = Sugg::BinOp(Greater, "1".into(), "1".into());
assert_eq!("1 <= 1", (!sugg).to_string()); assert_eq!("1 <= 1", (!sugg).to_string());
let sugg = Sugg::BinOp(GreaterEqual, "1 >= 1".into()); let sugg = Sugg::BinOp(GreaterEqual, "1".into(), "1".into());
assert_eq!("1 < 1", (!sugg).to_string()); assert_eq!("1 < 1", (!sugg).to_string());
// Other operators are inverted like !(..). // Other operators are inverted like !(..).
let sugg = Sugg::BinOp(Add, "1 + 1".into()); let sugg = Sugg::BinOp(Add, "1".into(), "1".into());
assert_eq!("!(1 + 1)", (!sugg).to_string()); assert_eq!("!(1 + 1)", (!sugg).to_string());
let sugg = Sugg::BinOp(LAnd, "1 && 1".into()); let sugg = Sugg::BinOp(LAnd, "1".into(), "1".into());
assert_eq!("!(1 && 1)", (!sugg).to_string()); assert_eq!("!(1 && 1)", (!sugg).to_string());
let sugg = Sugg::BinOp(LOr, "1 || 1".into()); let sugg = Sugg::BinOp(LOr, "1".into(), "1".into());
assert_eq!("!(1 || 1)", (!sugg).to_string()); assert_eq!("!(1 || 1)", (!sugg).to_string());
} }
} }

2
tests/ui/manual_memcpy/with_loop_counters.stderr
View File

@ -43,7 +43,7 @@ LL | / for i in 3..(3 + src.len()) {
LL | | dst[i] = src[count]; LL | | dst[i] = src[count];
LL | | count += 1; LL | | count += 1;
LL | | } LL | | }
| |_____^ help: try replacing the loop by: `dst[3..(3 + src.len())].clone_from_slice(&src[..((3 + src.len()) - 3)]);` | |_____^ help: try replacing the loop by: `dst[3..(3 + src.len())].clone_from_slice(&src[..(3 + src.len() - 3)]);`
error: it looks like you're manually copying between slices error: it looks like you're manually copying between slices
--> $DIR/with_loop_counters.rs:35:5 --> $DIR/with_loop_counters.rs:35:5