OpenE2K/rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Rollup merge of #81913 - osa1:rename_unop_variants, r=matthewjasper

Browse Source 
Rename HIR UnOp variants

This renames the variants in HIR UnOp from

    enum UnOp {
        UnDeref,
        UnNot,
        UnNeg,
    }

to

    enum UnOp {
        Deref,
        Not,
        Neg,
    }

Motivations:

- This is more consistent with the rest of the code base where most enum
  variants don't have a prefix.

- These variants are never used without the `UnOp` prefix so the extra
  `Un` prefix doesn't help with readability. E.g. we don't have any
  `UnDeref`s in the code, we only have `UnOp::UnDeref`.

- MIR `UnOp` type variants don't have a prefix so this is more
  consistent with MIR types.

- "un" prefix reads like "inverse" or "reverse", so as a beginner in
  rustc code base when I see "UnDeref" what comes to my mind is
  something like `&*` instead of just `*`.
This commit is contained in:
Yuki Okushi 2021-02-10 12:24:28 +09:00 committed by GitHub
commit a58feb9282
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
41 changed files with 80 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
compiler/rustc_ast_lowering/src/expr.rs
View File

@ -260,9 +260,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
fn lower_unop(&mut self, u: UnOp) -> hir::UnOp {
match u {
UnOp::Deref => hir::UnOp::UnDeref,
UnOp::Not => hir::UnOp::UnNot,
UnOp::Neg => hir::UnOp::UnNeg,
UnOp::Deref => hir::UnOp::Deref,
UnOp::Not => hir::UnOp::Not,
UnOp::Neg => hir::UnOp::Neg,
}
}

16
compiler/rustc_hir/src/hir.rs
View File

@ -1112,25 +1112,25 @@ pub type BinOp = Spanned<BinOpKind>;
#[derive(Copy, Clone, PartialEq, Encodable, Debug, HashStable_Generic)]
pub enum UnOp {
/// The `*` operator (deferencing).
UnDeref,
Deref,
/// The `!` operator (logical negation).
UnNot,
Not,
/// The `-` operator (negation).
UnNeg,
Neg,
}
impl UnOp {
pub fn as_str(self) -> &'static str {
match self {
Self::UnDeref => "*",
Self::UnNot => "!",
Self::UnNeg => "-",
Self::Deref => "*",
Self::Not => "!",
Self::Neg => "-",
}
}
/// Returns `true` if the unary operator takes its argument by value.
pub fn is_by_value(self) -> bool {
matches!(self, Self::UnNeg | Self::UnNot)
matches!(self, Self::Neg | Self::Not)
}
}
@ -1477,7 +1477,7 @@ impl Expr<'_> {
// https://github.com/rust-lang/rfcs/blob/master/text/0803-type-ascription.md#type-ascription-and-temporaries
ExprKind::Type(ref e, _) => e.is_place_expr(allow_projections_from),
ExprKind::Unary(UnOp::UnDeref, _) => true,
ExprKind::Unary(UnOp::Deref, _) => true,
ExprKind::Field(ref base, _) | ExprKind::Index(ref base, _) => {
allow_projections_from(base) || base.is_place_expr(allow_projections_from)

2
compiler/rustc_lint/src/types.rs
View File

@ -472,7 +472,7 @@ fn lint_literal<'tcx>(
impl<'tcx> LateLintPass<'tcx> for TypeLimits {
fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx hir::Expr<'tcx>) {
match e.kind {
hir::ExprKind::Unary(hir::UnOp::UnNeg, ref expr) => {
hir::ExprKind::Unary(hir::UnOp::Neg, ref expr) => {
// propagate negation, if the negation itself isn't negated
if self.negated_expr_id != Some(e.hir_id) {
self.negated_expr_id = Some(expr.hir_id);

2
compiler/rustc_middle/src/ty/consts.rs
View File

@ -55,7 +55,7 @@ impl<'tcx> Const<'tcx> {
let lit_input = match expr.kind {
hir::ExprKind::Lit(ref lit) => Some(LitToConstInput { lit: &lit.node, ty, neg: false }),
hir::ExprKind::Unary(hir::UnOp::UnNeg, ref expr) => match expr.kind {
hir::ExprKind::Unary(hir::UnOp::Neg, ref expr) => match expr.kind {
hir::ExprKind::Lit(ref lit) => {
Some(LitToConstInput { lit: &lit.node, ty, neg: true })
}

6
compiler/rustc_mir_build/src/thir/cx/expr.rs
View File

@ -299,7 +299,7 @@ fn make_mirror_unadjusted<'a, 'tcx>(
}
}
hir::ExprKind::Unary(hir::UnOp::UnDeref, ref arg) => {
hir::ExprKind::Unary(hir::UnOp::Deref, ref arg) => {
if cx.typeck_results().is_method_call(expr) {
overloaded_place(cx, expr, expr_ty, None, vec![arg.to_ref()], expr.span)
} else {
@ -307,7 +307,7 @@ fn make_mirror_unadjusted<'a, 'tcx>(
}
}
hir::ExprKind::Unary(hir::UnOp::UnNot, ref arg) => {
hir::ExprKind::Unary(hir::UnOp::Not, ref arg) => {
if cx.typeck_results().is_method_call(expr) {
overloaded_operator(cx, expr, vec![arg.to_ref()])
} else {
@ -315,7 +315,7 @@ fn make_mirror_unadjusted<'a, 'tcx>(
}
}
hir::ExprKind::Unary(hir::UnOp::UnNeg, ref arg) => {
hir::ExprKind::Unary(hir::UnOp::Neg, ref arg) => {
if cx.typeck_results().is_method_call(expr) {
overloaded_operator(cx, expr, vec![arg.to_ref()])
} else if let hir::ExprKind::Lit(ref lit) = arg.kind {

2
compiler/rustc_mir_build/src/thir/pattern/mod.rs
View File

@ -866,7 +866,7 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
return *self.const_to_pat(value, expr.hir_id, expr.span, false).kind;
}
hir::ExprKind::Lit(ref lit) => (lit, false),
hir::ExprKind::Unary(hir::UnOp::UnNeg, ref expr) => {
hir::ExprKind::Unary(hir::UnOp::Neg, ref expr) => {
let lit = match expr.kind {
hir::ExprKind::Lit(ref lit) => lit,
_ => span_bug!(expr.span, "not a literal: {:?}", expr),

2
compiler/rustc_passes/src/region.rs
View File

@ -664,7 +664,7 @@ fn resolve_local<'tcx>(
match expr.kind {
hir::ExprKind::AddrOf(_, _, ref subexpr)
| hir::ExprKind::Unary(hir::UnOp::UnDeref, ref subexpr)
| hir::ExprKind::Unary(hir::UnOp::Deref, ref subexpr)
| hir::ExprKind::Field(ref subexpr, _)
| hir::ExprKind::Index(ref subexpr, _) => {
expr = &subexpr;

2
compiler/rustc_typeck/src/check/demand.rs
View File

@ -773,7 +773,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
if let hir::ExprKind::Lit(lit) = &expr.kind { lit.node.is_suffixed() } else { false }
};
let is_negative_int =
|expr: &hir::Expr<'_>| matches!(expr.kind, hir::ExprKind::Unary(hir::UnOp::UnNeg, ..));
|expr: &hir::Expr<'_>| matches!(expr.kind, hir::ExprKind::Unary(hir::UnOp::Neg, ..));
let is_uint = |ty: Ty<'_>| matches!(ty.kind(), ty::Uint(..));
let in_const_context = self.tcx.hir().is_inside_const_context(expr.hir_id);

10
compiler/rustc_typeck/src/check/expr.rs
View File

@ -321,15 +321,15 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
) -> Ty<'tcx> {
let tcx = self.tcx;
let expected_inner = match unop {
hir::UnOp::UnNot | hir::UnOp::UnNeg => expected,
hir::UnOp::UnDeref => NoExpectation,
hir::UnOp::Not | hir::UnOp::Neg => expected,
hir::UnOp::Deref => NoExpectation,
};
let mut oprnd_t = self.check_expr_with_expectation(&oprnd, expected_inner);
if !oprnd_t.references_error() {
oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
match unop {
hir::UnOp::UnDeref => {
hir::UnOp::Deref => {
if let Some(ty) = self.lookup_derefing(expr, oprnd, oprnd_t) {
oprnd_t = ty;
} else {
@ -351,14 +351,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
oprnd_t = tcx.ty_error();
}
}
hir::UnOp::UnNot => {
hir::UnOp::Not => {
let result = self.check_user_unop(expr, oprnd_t, unop);
// If it's builtin, we can reuse the type, this helps inference.
if !(oprnd_t.is_integral() || *oprnd_t.kind() == ty::Bool) {
oprnd_t = result;
}
}
hir::UnOp::UnNeg => {
hir::UnOp::Neg => {
let result = self.check_user_unop(expr, oprnd_t, unop);
// If it's builtin, we can reuse the type, this helps inference.
if !oprnd_t.is_numeric() {

12
compiler/rustc_typeck/src/check/op.rs
View File

@ -681,7 +681,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
format!("cannot apply unary operator `{}`", op.as_str()),
);
match actual.kind() {
Uint(_) if op == hir::UnOp::UnNeg => {
Uint(_) if op == hir::UnOp::Neg => {
err.note("unsigned values cannot be negated");
if let hir::ExprKind::Unary(
@ -711,9 +711,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
Ref(_, ref lty, _) if *lty.kind() == Str => {}
_ => {
let missing_trait = match op {
hir::UnOp::UnNeg => "std::ops::Neg",
hir::UnOp::UnNot => "std::ops::Not",
hir::UnOp::UnDeref => "std::ops::UnDerf",
hir::UnOp::Neg => "std::ops::Neg",
hir::UnOp::Not => "std::ops::Not",
hir::UnOp::Deref => "std::ops::UnDerf",
};
suggest_impl_missing(&mut err, operand_ty, &missing_trait);
}
@ -782,9 +782,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
span_bug!(span, "&& and || are not overloadable")
}
}
} else if let Op::Unary(hir::UnOp::UnNot, _) = op {
} else if let Op::Unary(hir::UnOp::Not, _) = op {
(sym::not, lang.not_trait())
} else if let Op::Unary(hir::UnOp::UnNeg, _) = op {
} else if let Op::Unary(hir::UnOp::Neg, _) = op {
(sym::neg, lang.neg_trait())
} else {
bug!("lookup_op_method: op not supported: {:?}", op)

6
compiler/rustc_typeck/src/check/place_op.rs
View File

@ -203,7 +203,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
while let hir::ExprKind::Field(ref expr, _)
| hir::ExprKind::Index(ref expr, _)
| hir::ExprKind::Unary(hir::UnOp::UnDeref, ref expr) = exprs.last().unwrap().kind
| hir::ExprKind::Unary(hir::UnOp::Deref, ref expr) = exprs.last().unwrap().kind
{
exprs.push(&expr);
}
@ -216,7 +216,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
debug!("convert_place_derefs_to_mutable: i={} expr={:?}", i, expr);
let mut source = self.node_ty(expr.hir_id);
if matches!(expr.kind, hir::ExprKind::Unary(hir::UnOp::UnDeref, _)) {
if matches!(expr.kind, hir::ExprKind::Unary(hir::UnOp::Deref, _)) {
// Clear previous flag; after a pointer indirection it does not apply any more.
inside_union = false;
}
@ -270,7 +270,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
hir::ExprKind::Index(ref base_expr, ..) => {
self.convert_place_op_to_mutable(PlaceOp::Index, expr, base_expr);
}
hir::ExprKind::Unary(hir::UnOp::UnDeref, ref base_expr) => {
hir::ExprKind::Unary(hir::UnOp::Deref, ref base_expr) => {
self.convert_place_op_to_mutable(PlaceOp::Deref, expr, base_expr);
}
_ => {}

2
compiler/rustc_typeck/src/check/writeback.rs
View File

@ -138,7 +138,7 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
// operating on scalars, we clear the overload.
fn fix_scalar_builtin_expr(&mut self, e: &hir::Expr<'_>) {
match e.kind {
hir::ExprKind::Unary(hir::UnOp::UnNeg | hir::UnOp::UnNot, ref inner) => {
hir::ExprKind::Unary(hir::UnOp::Neg | hir::UnOp::Not, ref inner) => {
let inner_ty = self.fcx.node_ty(inner.hir_id);
let inner_ty = self.fcx.resolve_vars_if_possible(inner_ty);

2
compiler/rustc_typeck/src/expr_use_visitor.rs
View File

@ -184,7 +184,7 @@ impl<'a, 'tcx> ExprUseVisitor<'a, 'tcx> {
hir::ExprKind::Type(ref subexpr, _) => self.walk_expr(subexpr),
hir::ExprKind::Unary(hir::UnOp::UnDeref, ref base) => {
hir::ExprKind::Unary(hir::UnOp::Deref, ref base) => {
// *base
self.select_from_expr(base);
}

2
compiler/rustc_typeck/src/mem_categorization.rs
View File

@ -303,7 +303,7 @@ impl<'a, 'tcx> MemCategorizationContext<'a, 'tcx> {
let expr_ty = self.expr_ty(expr)?;
match expr.kind {
hir::ExprKind::Unary(hir::UnOp::UnDeref, ref e_base) => {
hir::ExprKind::Unary(hir::UnOp::Deref, ref e_base) => {
if self.typeck_results.is_method_call(expr) {
self.cat_overloaded_place(expr, e_base)
} else {

2
src/librustdoc/clean/utils.rs
View File

@ -316,7 +316,7 @@ crate fn is_literal_expr(cx: &DocContext<'_>, hir_id: hir::HirId) -> bool {
return true;
}
if let hir::ExprKind::Unary(hir::UnOp::UnNeg, expr) = &expr.kind {
if let hir::ExprKind::Unary(hir::UnOp::Neg, expr) = &expr.kind {
if let hir::ExprKind::Lit(_) = &expr.kind {
return true;
}

4
src/tools/clippy/clippy_lints/src/arithmetic.rs
View File

@ -91,7 +91,7 @@ impl<'tcx> LateLintPass<'tcx> for Arithmetic {
match op.node {
hir::BinOpKind::Div | hir::BinOpKind::Rem => match &r.kind {
hir::ExprKind::Lit(_lit) => (),
hir::ExprKind::Unary(hir::UnOp::UnNeg, expr) => {
hir::ExprKind::Unary(hir::UnOp::Neg, expr) => {
if let hir::ExprKind::Lit(lit) = &expr.kind {
if let rustc_ast::ast::LitKind::Int(1, _) = lit.node {
span_lint(cx, INTEGER_ARITHMETIC, expr.span, "integer arithmetic detected");
@ -114,7 +114,7 @@ impl<'tcx> LateLintPass<'tcx> for Arithmetic {
self.expr_span = Some(expr.span);
}
},
hir::ExprKind::Unary(hir::UnOp::UnNeg, arg) => {
hir::ExprKind::Unary(hir::UnOp::Neg, arg) => {
let ty = cx.typeck_results().expr_ty(arg);
if constant_simple(cx, cx.typeck_results(), expr).is_none() {
if ty.is_integral() {

2
src/tools/clippy/clippy_lints/src/assertions_on_constants.rs
View File

@ -112,7 +112,7 @@ enum AssertKind {
fn match_assert_with_message<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<AssertKind> {
if_chain! {
if let ExprKind::If(ref cond, ref then, _) = expr.kind;
if let ExprKind::Unary(UnOp::UnNot, ref expr) = cond.kind;
if let ExprKind::Unary(UnOp::Not, ref expr) = cond.kind;
// bind the first argument of the `assert!` macro
if let Some((Constant::Bool(is_true), _)) = constant(cx, cx.typeck_results(), expr);
// block

6
src/tools/clippy/clippy_lints/src/booleans.rs
View File

@ -110,7 +110,7 @@ impl<'a, 'tcx, 'v> Hir2Qmm<'a, 'tcx, 'v> {
// prevent folding of `cfg!` macros and the like
if !e.span.from_expansion() {
match &e.kind {
ExprKind::Unary(UnOp::UnNot, inner) => return Ok(Bool::Not(box self.run(inner)?)),
ExprKind::Unary(UnOp::Not, inner) => return Ok(Bool::Not(box self.run(inner)?)),
ExprKind::Binary(binop, lhs, rhs) => match &binop.node {
BinOpKind::Or => {
return Ok(Bool::Or(self.extract(BinOpKind::Or, &[lhs, rhs], Vec::new())?));
@ -454,7 +454,7 @@ impl<'a, 'tcx> Visitor<'tcx> for NonminimalBoolVisitor<'a, 'tcx> {
ExprKind::Binary(binop, _, _) if binop.node == BinOpKind::Or || binop.node == BinOpKind::And => {
self.bool_expr(e)
},
ExprKind::Unary(UnOp::UnNot, inner) => {
ExprKind::Unary(UnOp::Not, inner) => {
if self.cx.typeck_results().node_types()[inner.hir_id].is_bool() {
self.bool_expr(e);
} else {
@ -482,7 +482,7 @@ impl<'a, 'tcx> Visitor<'tcx> for NotSimplificationVisitor<'a, 'tcx> {
type Map = Map<'tcx>;
fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
if let ExprKind::Unary(UnOp::UnNot, inner) = &expr.kind {
if let ExprKind::Unary(UnOp::Not, inner) = &expr.kind {
if let Some(suggestion) = simplify_not(self.cx, inner) {
span_lint_and_sugg(
self.cx,

2
src/tools/clippy/clippy_lints/src/bytecount.rs
View File

@ -101,7 +101,7 @@ fn check_arg(name: Symbol, arg: Symbol, needle: &Expr<'_>) -> bool {
fn get_path_name(expr: &Expr<'_>) -> Option<Symbol> {
match expr.kind {
ExprKind::Box(ref e) | ExprKind::AddrOf(BorrowKind::Ref, _, ref e) | ExprKind::Unary(UnOp::UnDeref, ref e) => {
ExprKind::Box(ref e) | ExprKind::AddrOf(BorrowKind::Ref, _, ref e) | ExprKind::Unary(UnOp::Deref, ref e) => {
get_path_name(e)
},
ExprKind::Block(ref b, _) => {

2
src/tools/clippy/clippy_lints/src/collapsible_match.rs
View File

@ -186,7 +186,7 @@ fn addr_adjusted_binding(mut expr: &Expr<'_>, cx: &LateContext<'_>) -> Option<Hi
Res::Local(binding_id) => break Some(binding_id),
_ => break None,
},
ExprKind::Unary(UnOp::UnDeref, e) if cx.typeck_results().expr_ty(e).is_ref() => expr = e,
ExprKind::Unary(UnOp::Deref, e) if cx.typeck_results().expr_ty(e).is_ref() => expr = e,
_ => break None,
}
}

6
src/tools/clippy/clippy_lints/src/consts.rs
View File

@ -242,9 +242,9 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
self.expr(value).map(|v| Constant::Repeat(Box::new(v), n))
},
ExprKind::Unary(op, ref operand) => self.expr(operand).and_then(|o| match op {
UnOp::UnNot => self.constant_not(&o, self.typeck_results.expr_ty(e)),
UnOp::UnNeg => self.constant_negate(&o, self.typeck_results.expr_ty(e)),
UnOp::UnDeref => Some(if let Constant::Ref(r) = o { *r } else { o }),
UnOp::Not => self.constant_not(&o, self.typeck_results.expr_ty(e)),
UnOp::Neg => self.constant_negate(&o, self.typeck_results.expr_ty(e)),
UnOp::Deref => Some(if let Constant::Ref(r) = o { *r } else { o }),
}),
ExprKind::If(ref cond, ref then, ref otherwise) => self.ifthenelse(cond, then, *otherwise),
ExprKind::Binary(op, ref left, ref right) => self.binop(op, left, right),

2
src/tools/clippy/clippy_lints/src/entry.rs
View File

@ -55,7 +55,7 @@ declare_lint_pass!(HashMapPass => [MAP_ENTRY]);
impl<'tcx> LateLintPass<'tcx> for HashMapPass {
fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
if let ExprKind::If(ref check, ref then_block, ref else_block) = expr.kind {
if let ExprKind::Unary(UnOp::UnNot, ref check) = check.kind {
if let ExprKind::Unary(UnOp::Not, ref check) = check.kind {
if let Some((ty, map, key)) = check_cond(cx, check) {
// in case of `if !m.contains_key(&k) { m.insert(k, v); }`
// we can give a better error message

6
src/tools/clippy/clippy_lints/src/floating_point_arithmetic.rs
View File

@ -129,7 +129,7 @@ fn get_specialized_log_method(cx: &LateContext<'_>, base: &Expr<'_>) -> Option<&
fn prepare_receiver_sugg<'a>(cx: &LateContext<'_>, mut expr: &'a Expr<'a>) -> Sugg<'a> {
let mut suggestion = Sugg::hir(cx, expr, "..");
if let ExprKind::Unary(UnOp::UnNeg, inner_expr) = &expr.kind {
if let ExprKind::Unary(UnOp::Neg, inner_expr) = &expr.kind {
expr = &inner_expr;
}
@ -541,12 +541,12 @@ fn is_zero(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
/// If the two expressions are not negations of each other, then it
/// returns None.
fn are_negated<'a>(cx: &LateContext<'_>, expr1: &'a Expr<'a>, expr2: &'a Expr<'a>) -> Option<(bool, &'a Expr<'a>)> {
if let ExprKind::Unary(UnOp::UnNeg, expr1_negated) = &expr1.kind {
if let ExprKind::Unary(UnOp::Neg, expr1_negated) = &expr1.kind {
if eq_expr_value(cx, expr1_negated, expr2) {
return Some((false, expr2));
}
}
if let ExprKind::Unary(UnOp::UnNeg, expr2_negated) = &expr2.kind {
if let ExprKind::Unary(UnOp::Neg, expr2_negated) = &expr2.kind {
if eq_expr_value(cx, expr1, expr2_negated) {
return Some((true, expr1));
}

2
src/tools/clippy/clippy_lints/src/functions.rs
View File

@ -644,7 +644,7 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for DerefVisitor<'a, 'tcx> {
}
}
},
hir::ExprKind::Unary(hir::UnOp::UnDeref, ref ptr) => self.check_arg(ptr),
hir::ExprKind::Unary(hir::UnOp::Deref, ref ptr) => self.check_arg(ptr),
_ => (),
}

2
src/tools/clippy/clippy_lints/src/map_clone.rs
View File

@ -70,7 +70,7 @@ impl<'tcx> LateLintPass<'tcx> for MapClone {
},
hir::PatKind::Binding(hir::BindingAnnotation::Unannotated, .., name, None) => {
match closure_expr.kind {
hir::ExprKind::Unary(hir::UnOp::UnDeref, ref inner) => {
hir::ExprKind::Unary(hir::UnOp::Deref, ref inner) => {
if ident_eq(name, inner) {
if let ty::Ref(.., Mutability::Not) = cx.typeck_results().expr_ty(inner).kind() {
lint(cx, e.span, args[0].span, true);

4
src/tools/clippy/clippy_lints/src/methods/manual_saturating_arithmetic.rs
View File

@ -148,7 +148,7 @@ fn is_min_or_max<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>) -> Option<M
}
if ty.is_signed() {
if let hir::ExprKind::Unary(hir::UnOp::UnNeg, val) = &expr.kind {
if let hir::ExprKind::Unary(hir::UnOp::Neg, val) = &expr.kind {
return check_lit(val, true);
}
}
@ -163,7 +163,7 @@ enum Sign {
}
fn lit_sign(expr: &hir::Expr<'_>) -> Option<Sign> {
if let hir::ExprKind::Unary(hir::UnOp::UnNeg, inner) = &expr.kind {
if let hir::ExprKind::Unary(hir::UnOp::Neg, inner) = &expr.kind {
if let hir::ExprKind::Lit(..) = &inner.kind {
return Some(Sign::Neg);
}

10
src/tools/clippy/clippy_lints/src/methods/mod.rs
View File

@ -2619,7 +2619,7 @@ fn lint_get_unwrap<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, get_args:
if_chain! {
if needs_ref;
if let Some(parent) = get_parent_expr(cx, expr);
if let hir::ExprKind::Unary(hir::UnOp::UnDeref, _) = parent.kind;
if let hir::ExprKind::Unary(hir::UnOp::Deref, _) = parent.kind;
then {
needs_ref = false;
span = parent.span;
@ -3063,7 +3063,7 @@ fn lint_filter_map<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, is_f
// in `filter(|x| ..)`, replace `*x` with `x`
let a_path = if_chain! {
if !is_filter_param_ref;
if let ExprKind::Unary(UnOp::UnDeref, expr_path) = a.kind;
if let ExprKind::Unary(UnOp::Deref, expr_path) = a.kind;
then { expr_path } else { a }
};
// let the filter closure arg and the map closure arg be equal
@ -3708,8 +3708,8 @@ fn lint_option_as_ref_deref<'tcx>(
},
hir::ExprKind::AddrOf(hir::BorrowKind::Ref, m, ref inner) if same_mutability(m) => {
if_chain! {
if let hir::ExprKind::Unary(hir::UnOp::UnDeref, ref inner1) = inner.kind;
if let hir::ExprKind::Unary(hir::UnOp::UnDeref, ref inner2) = inner1.kind;
if let hir::ExprKind::Unary(hir::UnOp::Deref, ref inner1) = inner.kind;
if let hir::ExprKind::Unary(hir::UnOp::Deref, ref inner2) = inner1.kind;
if let hir::ExprKind::Path(ref qpath) = inner2.kind;
if let hir::def::Res::Local(local_id) = cx.qpath_res(qpath, inner2.hir_id);
then {
@ -4065,7 +4065,7 @@ fn lint_filetype_is_file(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir
if_chain! {
if let Some(parent) = get_parent_expr(cx, expr);
if let hir::ExprKind::Unary(op, _) = parent.kind;
if op == hir::UnOp::UnNot;
if op == hir::UnOp::Not;
then {
lint_unary = "!";
verb = "denies";

4
src/tools/clippy/clippy_lints/src/misc.rs
View File

@ -502,7 +502,7 @@ fn is_allowed<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
// Return true if `expr` is the result of `signum()` invoked on a float value.
fn is_signum(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
// The negation of a signum is still a signum
if let ExprKind::Unary(UnOp::UnNeg, ref child_expr) = expr.kind {
if let ExprKind::Unary(UnOp::Neg, ref child_expr) = expr.kind {
return is_signum(cx, &child_expr);
}
@ -586,7 +586,7 @@ fn check_to_owned(cx: &LateContext<'_>, expr: &Expr<'_>, other: &Expr<'_>, left:
return;
}
let other_gets_derefed = matches!(other.kind, ExprKind::Unary(UnOp::UnDeref, _));
let other_gets_derefed = matches!(other.kind, ExprKind::Unary(UnOp::Deref, _));
let lint_span = if other_gets_derefed {
expr.span.to(other.span)

2
src/tools/clippy/clippy_lints/src/needless_bool.rs
View File

@ -195,7 +195,7 @@ struct ExpressionInfoWithSpan {
}
fn is_unary_not(e: &Expr<'_>) -> (bool, Span) {
if let ExprKind::Unary(UnOp::UnNot, operand) = e.kind {
if let ExprKind::Unary(UnOp::Not, operand) = e.kind {
return (true, operand.span);
}
(false, e.span)

2
src/tools/clippy/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
View File

@ -50,7 +50,7 @@ impl<'tcx> LateLintPass<'tcx> for NoNegCompOpForPartialOrd {
if_chain! {
if !in_external_macro(cx.sess(), expr.span);
if let ExprKind::Unary(UnOp::UnNot, ref inner) = expr.kind;
if let ExprKind::Unary(UnOp::Not, ref inner) = expr.kind;
if let ExprKind::Binary(ref op, ref left, _) = inner.kind;
if let BinOpKind::Le | BinOpKind::Ge | BinOpKind::Lt | BinOpKind::Gt = op.node;

4
src/tools/clippy/clippy_lints/src/neg_multiply.rs
View File

@ -32,8 +32,8 @@ impl<'tcx> LateLintPass<'tcx> for NegMultiply {
if BinOpKind::Mul == op.node {
match (&left.kind, &right.kind) {
(&ExprKind::Unary(..), &ExprKind::Unary(..)) => {},
(&ExprKind::Unary(UnOp::UnNeg, ref lit), _) => check_mul(cx, e.span, lit, right),
(_, &ExprKind::Unary(UnOp::UnNeg, ref lit)) => check_mul(cx, e.span, lit, left),
(&ExprKind::Unary(UnOp::Neg, ref lit), _) => check_mul(cx, e.span, lit, right),
(_, &ExprKind::Unary(UnOp::Neg, ref lit)) => check_mul(cx, e.span, lit, left),
_ => {},
}
}

2
src/tools/clippy/clippy_lints/src/non_copy_const.rs
View File

@ -383,7 +383,7 @@ impl<'tcx> LateLintPass<'tcx> for NonCopyConst {
needs_check_adjustment = false;
break;
},
ExprKind::Unary(UnOp::UnDeref, _) => {
ExprKind::Unary(UnOp::Deref, _) => {
// `*e` => desugared to `*Deref::deref(&e)`,
// meaning `e` must be referenced.
// no need to go further up since a method call is involved now.

2
src/tools/clippy/clippy_lints/src/option_if_let_else.rs
View File

@ -181,7 +181,7 @@ fn detect_option_if_let_else<'tcx>(
};
let cond_expr = match &cond_expr.kind {
// Pointer dereferencing happens automatically, so we can omit it in the suggestion
ExprKind::Unary(UnOp::UnDeref, expr) | ExprKind::AddrOf(_, _, expr) => expr,
ExprKind::Unary(UnOp::Deref, expr) | ExprKind::AddrOf(_, _, expr) => expr,
_ => cond_expr,
};
Some(OptionIfLetElseOccurence {

2
src/tools/clippy/clippy_lints/src/shadow.rs
View File

@ -389,7 +389,7 @@ fn is_self_shadow(name: Symbol, expr: &Expr<'_>) -> bool {
ExprKind::Block(ref block, _) => {
block.stmts.is_empty() && block.expr.as_ref().map_or(false, |e| is_self_shadow(name, e))
},
ExprKind::Unary(op, ref inner) => (UnOp::UnDeref == op) && is_self_shadow(name, inner),
ExprKind::Unary(op, ref inner) => (UnOp::Deref == op) && is_self_shadow(name, inner),
ExprKind::Path(QPath::Resolved(_, ref path)) => path_eq_name(name, path),
_ => false,
}

2
src/tools/clippy/clippy_lints/src/suspicious_trait_impl.rs
View File

@ -194,7 +194,7 @@ impl<'tcx> Visitor<'tcx> for BinaryExprVisitor {
fn visit_expr(&mut self, expr: &'tcx hir::Expr<'_>) {
match expr.kind {
hir::ExprKind::Binary(..)
| hir::ExprKind::Unary(hir::UnOp::UnNot | hir::UnOp::UnNeg, _)
| hir::ExprKind::Unary(hir::UnOp::Not | hir::UnOp::Neg, _)
| hir::ExprKind::AssignOp(..) => self.nb_binops += 1,
_ => {},
}

2
src/tools/clippy/clippy_lints/src/transmute.rs
View File

@ -586,7 +586,7 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
let mut expr = &args[0];
let mut arg = sugg::Sugg::hir(cx, expr, "..");
if let ExprKind::Unary(UnOp::UnNeg, inner_expr) = &expr.kind {
if let ExprKind::Unary(UnOp::Neg, inner_expr) = &expr.kind {
expr = &inner_expr;
}

6
src/tools/clippy/clippy_lints/src/types.rs
View File

@ -1706,13 +1706,13 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
}
fn is_unary_neg(expr: &Expr<'_>) -> bool {
matches!(expr.kind, ExprKind::Unary(UnOp::UnNeg, _))
matches!(expr.kind, ExprKind::Unary(UnOp::Neg, _))
}
fn get_numeric_literal<'e>(expr: &'e Expr<'e>) -> Option<&'e Lit> {
match expr.kind {
ExprKind::Lit(ref lit) => Some(lit),
ExprKind::Unary(UnOp::UnNeg, e) => {
ExprKind::Unary(UnOp::Neg, e) => {
if let ExprKind::Lit(ref lit) = e.kind {
Some(lit)
} else {
@ -2868,7 +2868,7 @@ declare_lint_pass!(RefToMut => [CAST_REF_TO_MUT]);
impl<'tcx> LateLintPass<'tcx> for RefToMut {
fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
if_chain! {
if let ExprKind::Unary(UnOp::UnDeref, e) = &expr.kind;
if let ExprKind::Unary(UnOp::Deref, e) = &expr.kind;
if let ExprKind::Cast(e, t) = &e.kind;
if let TyKind::Ptr(MutTy { mutbl: Mutability::Mut, .. }) = t.kind;
if let ExprKind::Cast(e, t) = &e.kind;

2
src/tools/clippy/clippy_lints/src/unwrap.rs
View File

@ -108,7 +108,7 @@ fn collect_unwrap_info<'tcx>(
},
_ => (),
}
} else if let ExprKind::Unary(UnOp::UnNot, expr) = &expr.kind {
} else if let ExprKind::Unary(UnOp::Not, expr) = &expr.kind {
return collect_unwrap_info(cx, expr, branch, !invert);
} else {
if_chain! {

2
src/tools/clippy/clippy_lints/src/utils/higher.rs
View File

@ -243,7 +243,7 @@ pub fn extract_assert_macro_args<'tcx>(e: &'tcx Expr<'tcx>) -> Option<Vec<&'tcx
// macros with unique arg: `{debug_}assert!` (e.g., `debug_assert!(some_condition)`)
if_chain! {
if let ExprKind::If(ref clause, _, _) = matchexpr.kind;
if let ExprKind::Unary(UnOp::UnNot, condition) = clause.kind;
if let ExprKind::Unary(UnOp::Not, condition) = clause.kind;
then {
return Some(vec![condition]);
}

2
src/tools/clippy/clippy_lints/src/utils/internal_lints.rs
View File

@ -1001,7 +1001,7 @@ impl InterningDefinedSymbol {
// SymbolStr might be de-referenced: `&*symbol.as_str()`
let call = if_chain! {
if let ExprKind::AddrOf(_, _, e) = expr.kind;
if let ExprKind::Unary(UnOp::UnDeref, e) = e.kind;
if let ExprKind::Unary(UnOp::Deref, e) = e.kind;
then { e } else { expr }
};
if_chain! {

4
src/tools/clippy/tests/ui/suspicious_arithmetic_impl.rs
View File

@ -117,7 +117,7 @@ impl Add for Bar {
type Output = Bar;
fn add(self, other: Self) -> Self {
Bar(self.0 & !other.0) // OK: UnNot part of BiExpr as child node
Bar(self.0 & !other.0) // OK: Not part of BiExpr as child node
}
}
@ -126,7 +126,7 @@ impl Sub for Bar {
fn sub(self, other: Self) -> Self {
if self.0 <= other.0 {
Bar(-(self.0 & other.0)) // OK: UnNeg part of BiExpr as parent node
Bar(-(self.0 & other.0)) // OK: Neg part of BiExpr as parent node
} else {
Bar(0)
}