Rustup to rust-lang/rust#66936

clippy_lints/src/approx_const.rs

@@ -60,14 +60,14 @@ const KNOWN_CONSTS: [(f64, &str, usize); 16] = [
 declare_lint_pass!(ApproxConstant => [APPROX_CONSTANT]);
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ApproxConstant {
- fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) {
+ fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr<'_>) {
  if let ExprKind::Lit(lit) = &e.kind {
  check_lit(cx, &lit.node, e);
  }
  }
 }
 
-fn check_lit(cx: &LateContext<'_, '_>, lit: &LitKind, e: &Expr) {
+fn check_lit(cx: &LateContext<'_, '_>, lit: &LitKind, e: &Expr<'_>) {
  match *lit {
  LitKind::Float(s, LitFloatType::Suffixed(fty)) => match fty {
  FloatTy::F32 => check_known_consts(cx, e, s, "f32"),
@@ -78,7 +78,7 @@ fn check_lit(cx: &LateContext<'_, '_>, lit: &LitKind, e: &Expr) {
  }
 }
 
-fn check_known_consts(cx: &LateContext<'_, '_>, e: &Expr, s: symbol::Symbol, module: &str) {
+fn check_known_consts(cx: &LateContext<'_, '_>, e: &Expr<'_>, s: symbol::Symbol, module: &str) {
  let s = s.as_str();
  if s.parse::<f64>().is_ok() {
  for &(constant, name, min_digits) in &KNOWN_CONSTS {

clippy_lints/src/arithmetic.rs

@@ -54,7 +54,7 @@ pub struct Arithmetic {
 impl_lint_pass!(Arithmetic => [INTEGER_ARITHMETIC, FLOAT_ARITHMETIC]);
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Arithmetic {
- fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) {
+ fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr<'_>) {
  if self.expr_span.is_some() {
  return;
  }
@@ -107,7 +107,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Arithmetic {
  }
  }
 
- fn check_expr_post(&mut self, _: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) {
+ fn check_expr_post(&mut self, _: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr<'_>) {
  if Some(expr.span) == self.expr_span {
  self.expr_span = None;
  }

clippy_lints/src/assertions_on_constants.rs

@@ -33,7 +33,7 @@ declare_clippy_lint! {
 declare_lint_pass!(AssertionsOnConstants => [ASSERTIONS_ON_CONSTANTS]);
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssertionsOnConstants {
- fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) {
+ fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr<'_>) {
  let lint_true = || {
  span_help_and_lint(
  cx,
@@ -110,7 +110,7 @@ enum AssertKind {
 /// ```
 ///
 /// where `message` is any expression and `c` is a constant bool.
-fn match_assert_with_message<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) -> Option<AssertKind> {
+fn match_assert_with_message<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr<'_>) -> Option<AssertKind> {
  if_chain! {
  if let ExprKind::Match(ref expr, ref arms, _) = expr.kind;
  // matches { let _t = expr; _t }
@@ -124,7 +124,7 @@ fn match_assert_with_message<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx E
  if let LitKind::Bool(true) = lit.node;
  // arm 1 block
  if let ExprKind::Block(ref block, _) = arms[0].body.kind;
- if block.stmts.len() == 0;
+ if block.stmts.is_empty();
  if let Some(block_expr) = &block.expr;
  if let ExprKind::Block(ref inner_block, _) = block_expr.kind;
  if let Some(begin_panic_call) = &inner_block.expr;

clippy_lints/src/assign_ops.rs

@@ -59,7 +59,7 @@ declare_lint_pass!(AssignOps => [ASSIGN_OP_PATTERN, MISREFACTORED_ASSIGN_OP]);
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssignOps {
  #[allow(clippy::too_many_lines)]
- fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) {
+ fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr<'_>) {
  match &expr.kind {
  hir::ExprKind::AssignOp(op, lhs, rhs) => {
  if let hir::ExprKind::Binary(binop, l, r) = &rhs.kind {
@@ -79,7 +79,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssignOps {
  hir::ExprKind::Assign(assignee, e, _) => {
  if let hir::ExprKind::Binary(op, l, r) = &e.kind {
  #[allow(clippy::cognitive_complexity)]
- let lint = |assignee: &hir::Expr, rhs: &hir::Expr| {
+ let lint = |assignee: &hir::Expr<'_>, rhs: &hir::Expr<'_>| {
  let ty = cx.tables.expr_ty(assignee);
  let rty = cx.tables.expr_ty(rhs);
  macro_rules! ops {
@@ -190,11 +190,11 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssignOps {
 
 fn lint_misrefactored_assign_op(
  cx: &LateContext<'_, '_>,
- expr: &hir::Expr,
+ expr: &hir::Expr<'_>,
  op: hir::BinOp,
- rhs: &hir::Expr,
- assignee: &hir::Expr,
- rhs_other: &hir::Expr,
+ rhs: &hir::Expr<'_>,
+ assignee: &hir::Expr<'_>,
+ rhs_other: &hir::Expr<'_>,
 ) {
  span_lint_and_then(
  cx,
@@ -240,13 +240,13 @@ fn is_commutative(op: hir::BinOpKind) -> bool {
 }
 
 struct ExprVisitor<'a, 'tcx> {
- assignee: &'a hir::Expr,
+ assignee: &'a hir::Expr<'a>,
  counter: u8,
  cx: &'a LateContext<'a, 'tcx>,
 }
 
 impl<'a, 'tcx> Visitor<'tcx> for ExprVisitor<'a, 'tcx> {
- fn visit_expr(&mut self, expr: &'tcx hir::Expr) {
+ fn visit_expr(&mut self, expr: &'tcx hir::Expr<'_>) {
  if SpanlessEq::new(self.cx).ignore_fn().eq_expr(self.assignee, expr) {
  self.counter += 1;
  }

clippy_lints/src/attrs.rs

@@ -380,7 +380,7 @@ fn is_relevant_trait(cx: &LateContext<'_, '_>, item: &TraitItem<'_>) -> bool {
  }
 }
 
-fn is_relevant_block(cx: &LateContext<'_, '_>, tables: &ty::TypeckTables<'_>, block: &Block) -> bool {
+fn is_relevant_block(cx: &LateContext<'_, '_>, tables: &ty::TypeckTables<'_>, block: &Block<'_>) -> bool {
  if let Some(stmt) = block.stmts.first() {
  match &stmt.kind {
  StmtKind::Local(_) => true,
@@ -392,7 +392,7 @@ fn is_relevant_block(cx: &LateContext<'_, '_>, tables: &ty::TypeckTables<'_>, bl
  }
 }
 
-fn is_relevant_expr(cx: &LateContext<'_, '_>, tables: &ty::TypeckTables<'_>, expr: &Expr) -> bool {
+fn is_relevant_expr(cx: &LateContext<'_, '_>, tables: &ty::TypeckTables<'_>, expr: &Expr<'_>) -> bool {
  match &expr.kind {
  ExprKind::Block(block, _) => is_relevant_block(cx, tables, block),
  ExprKind::Ret(Some(e)) => is_relevant_expr(cx, tables, e),

clippy_lints/src/bit_mask.rs

@@ -112,7 +112,7 @@ impl BitMask {
 impl_lint_pass!(BitMask => [BAD_BIT_MASK, INEFFECTIVE_BIT_MASK, VERBOSE_BIT_MASK]);
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BitMask {
- fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) {
+ fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr<'_>) {
  if let ExprKind::Binary(cmp, left, right) = &e.kind {
  if cmp.node.is_comparison() {
  if let Some(cmp_opt) = fetch_int_literal(cx, right) {
@@ -165,7 +165,7 @@ fn invert_cmp(cmp: BinOpKind) -> BinOpKind {
  }
 }
 
-fn check_compare(cx: &LateContext<'_, '_>, bit_op: &Expr, cmp_op: BinOpKind, cmp_value: u128, span: Span) {
+fn check_compare(cx: &LateContext<'_, '_>, bit_op: &Expr<'_>, cmp_op: BinOpKind, cmp_value: u128, span: Span) {
  if let ExprKind::Binary(op, left, right) = &bit_op.kind {
  if op.node != BinOpKind::BitAnd && op.node != BinOpKind::BitOr {
  return;
@@ -319,7 +319,7 @@ fn check_ineffective_gt(cx: &LateContext<'_, '_>, span: Span, m: u128, c: u128,
  }
 }
 
-fn fetch_int_literal(cx: &LateContext<'_, '_>, lit: &Expr) -> Option<u128> {
+fn fetch_int_literal(cx: &LateContext<'_, '_>, lit: &Expr<'_>) -> Option<u128> {
  match constant(cx, cx.tables, lit)?.0 {
  Constant::Int(n) => Some(n),
  _ => None,

clippy_lints/src/blacklisted_name.rs

@@ -37,7 +37,7 @@ impl BlacklistedName {
 impl_lint_pass!(BlacklistedName => [BLACKLISTED_NAME]);
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BlacklistedName {
- fn check_pat(&mut self, cx: &LateContext<'a, 'tcx>, pat: &'tcx Pat) {
+ fn check_pat(&mut self, cx: &LateContext<'a, 'tcx>, pat: &'tcx Pat<'_>) {
  if let PatKind::Binding(.., ident, _) = pat.kind {
  if self.blacklist.contains(&ident.name.to_string()) {
  span_lint(

clippy_lints/src/block_in_if_condition.rs

@@ -46,12 +46,12 @@ declare_clippy_lint! {
 declare_lint_pass!(BlockInIfCondition => [BLOCK_IN_IF_CONDITION_EXPR, BLOCK_IN_IF_CONDITION_STMT]);
 
 struct ExVisitor<'a, 'tcx> {
- found_block: Option<&'tcx Expr>,
+ found_block: Option<&'tcx Expr<'tcx>>,
  cx: &'a LateContext<'a, 'tcx>,
 }
 
 impl<'a, 'tcx> Visitor<'tcx> for ExVisitor<'a, 'tcx> {
- fn visit_expr(&mut self, expr: &'tcx Expr) {
+ fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
  if let ExprKind::Closure(_, _, eid, _, _) = expr.kind {
  let body = self.cx.tcx.hir().body(eid);
  let ex = &body.value;
@@ -72,7 +72,7 @@ const COMPLEX_BLOCK_MESSAGE: &str = "in an 'if' condition, avoid complex blocks
  instead, move the block or closure higher and bind it with a 'let'";
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BlockInIfCondition {
- fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
+ fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr<'_>) {
  if in_external_macro(cx.sess(), expr.span) {
  return;
  }

clippy_lints/src/booleans.rs

@@ -75,12 +75,12 @@ struct NonminimalBoolVisitor<'a, 'tcx> {
 
 use quine_mc_cluskey::Bool;
 struct Hir2Qmm<'a, 'tcx, 'v> {
- terminals: Vec<&'v Expr>,
+ terminals: Vec<&'v Expr<'v>>,
  cx: &'a LateContext<'a, 'tcx>,
 }
 
 impl<'a, 'tcx, 'v> Hir2Qmm<'a, 'tcx, 'v> {
- fn extract(&mut self, op: BinOpKind, a: &[&'v Expr], mut v: Vec<Bool>) -> Result<Vec<Bool>, String> {
+ fn extract(&mut self, op: BinOpKind, a: &[&'v Expr<'_>], mut v: Vec<Bool>) -> Result<Vec<Bool>, String> {
  for a in a {
  if let ExprKind::Binary(binop, lhs, rhs) = &a.kind {
  if binop.node == op {
@@ -93,7 +93,7 @@ impl<'a, 'tcx, 'v> Hir2Qmm<'a, 'tcx, 'v> {
  Ok(v)
  }
 
- fn run(&mut self, e: &'v Expr) -> Result<Bool, String> {
+ fn run(&mut self, e: &'v Expr<'_>) -> Result<Bool, String> {
  fn negate(bin_op_kind: BinOpKind) -> Option<BinOpKind> {
  match bin_op_kind {
  BinOpKind::Eq => Some(BinOpKind::Ne),
@@ -154,7 +154,7 @@ impl<'a, 'tcx, 'v> Hir2Qmm<'a, 'tcx, 'v> {
 }
 
 struct SuggestContext<'a, 'tcx, 'v> {
- terminals: &'v [&'v Expr],
+ terminals: &'v [&'v Expr<'v>],
  cx: &'a LateContext<'a, 'tcx>,
  output: String,
 }
@@ -222,7 +222,7 @@ impl<'a, 'tcx, 'v> SuggestContext<'a, 'tcx, 'v> {
  }
 }
 
-fn simplify_not(cx: &LateContext<'_, '_>, expr: &Expr) -> Option<String> {
+fn simplify_not(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> Option<String> {
  match &expr.kind {
  ExprKind::Binary(binop, lhs, rhs) => {
  if !implements_ord(cx, lhs) {
@@ -266,7 +266,7 @@ fn simplify_not(cx: &LateContext<'_, '_>, expr: &Expr) -> Option<String> {
  }
 }
 
-fn suggest(cx: &LateContext<'_, '_>, suggestion: &Bool, terminals: &[&Expr]) -> String {
+fn suggest(cx: &LateContext<'_, '_>, suggestion: &Bool, terminals: &[&Expr<'_>]) -> String {
  let mut suggest_context = SuggestContext {
  terminals,
  cx,
@@ -332,7 +332,7 @@ fn terminal_stats(b: &Bool) -> Stats {
 }
 
 impl<'a, 'tcx> NonminimalBoolVisitor<'a, 'tcx> {
- fn bool_expr(&self, e: &'tcx Expr) {
+ fn bool_expr(&self, e: &'tcx Expr<'_>) {
  let mut h2q = Hir2Qmm {
  terminals: Vec::new(),
  cx: self.cx,
@@ -437,7 +437,7 @@ impl<'a, 'tcx> NonminimalBoolVisitor<'a, 'tcx> {
 }
 
 impl<'a, 'tcx> Visitor<'tcx> for NonminimalBoolVisitor<'a, 'tcx> {
- fn visit_expr(&mut self, e: &'tcx Expr) {
+ fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
  if in_macro(e.span) {
  return;
  }
@@ -460,7 +460,7 @@ impl<'a, 'tcx> Visitor<'tcx> for NonminimalBoolVisitor<'a, 'tcx> {
  }
 }
 
-fn implements_ord<'a, 'tcx>(cx: &'a LateContext<'a, 'tcx>, expr: &Expr) -> bool {
+fn implements_ord<'a, 'tcx>(cx: &'a LateContext<'a, 'tcx>, expr: &Expr<'_>) -> bool {
  let ty = cx.tables.expr_ty(expr);
  get_trait_def_id(cx, &paths::ORD).map_or(false, |id| implements_trait(cx, ty, id, &[]))
 }
@@ -470,7 +470,7 @@ struct NotSimplificationVisitor<'a, 'tcx> {
 }
 
 impl<'a, 'tcx> Visitor<'tcx> for NotSimplificationVisitor<'a, 'tcx> {
- fn visit_expr(&mut self, expr: &'tcx Expr) {
+ fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
  if let ExprKind::Unary(UnNot, inner) = &expr.kind {
  if let Some(suggestion) = simplify_not(self.cx, inner) {
  span_lint_and_sugg(

clippy_lints/src/bytecount.rs

@@ -36,7 +36,7 @@ declare_clippy_lint! {
 declare_lint_pass!(ByteCount => [NAIVE_BYTECOUNT]);
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ByteCount {
- fn check_expr(&mut self, cx: &LateContext<'_, '_>, expr: &Expr) {
+ fn check_expr(&mut self, cx: &LateContext<'_, '_>, expr: &Expr<'_>) {
  if_chain! {
  if let ExprKind::MethodCall(ref count, _, ref count_args) = expr.kind;
  if count.ident.name == sym!(count);
@@ -96,11 +96,11 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ByteCount {
  }
 }
 
-fn check_arg(name: Name, arg: Name, needle: &Expr) -> bool {
+fn check_arg(name: Name, arg: Name, needle: &Expr<'_>) -> bool {
  name == arg && !contains_name(name, needle)
 }
 
-fn get_path_name(expr: &Expr) -> Option<Name> {
+fn get_path_name(expr: &Expr<'_>) -> Option<Name> {
  match expr.kind {
  ExprKind::Box(ref e) | ExprKind::AddrOf(BorrowKind::Ref, _, ref e) | ExprKind::Unary(UnOp::UnDeref, ref e) => {
  get_path_name(e)