+use crate::utils::{last_path_segment, snippet, span_lint_and_sugg};+use rustc_hir::{GenericArg, Mutability, Ty, TyKind};+use rustc_lint::{LateContext, LateLintPass};+use rustc_session::{declare_lint_pass, declare_tool_lint};++use if_chain::if_chain;+use rustc_errors::Applicability;++declare_clippy_lint! {+    /// **What it does:** Checks for usage of `&Option<&T>`.+    ///+    /// **Why is this bad?** Since `&` is Copy, it's useless to have a+    /// reference on `Option<&T>`.+    ///+    /// **Known problems:** It may be irrevelent to use this lint on+    /// public API code as it will make a breaking change to apply it.+    ///+    /// **Example:**+    ///+    /// ```rust,ignore+    /// let x: &Option<&u32> = &Some(&0u32);+    /// ```+    /// Use instead:+    /// ```rust,ignore+    /// let x: Option<&u32> = Some(&0u32);+    /// ```+    pub REF_OPTION_REF,+    style,

 LL | |     indirect_contains.contains(&&5);    | help: Check if the original Iterator contains an element instead of collecting then checking    |-LL |      LL |     sample.iter().any(|x| x == &&5);+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: avoid using `collect()` when not needed+  --> $DIR/needless_collect_indirect.rs:21:5+   |+LL | /     let indirect_contains_with_comments = sample.iter().collect::<VecDeque<_>>();+LL | |     // This is some stuff,+LL | |     // to pretend that we have some more+LL | |     // code present here+...  |+LL | |     // deal.+LL | |     indirect_contains_with_comments.contains(&&5);+   | |____^+   |+help: Check if the original Iterator contains an element instead of collecting then checking    |+LL |     sample.iter().any(|x| x == &&5);+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

 declare_clippy_lint! {     "functions taking small copyable arguments by reference" } +declare_clippy_lint! {+    /// **What it does:** Checks for functions taking arguments by value, where+    /// the argument type is not `Copy` (or an array) and large enough to be worth+    /// considering passing by reference.+    ///+    /// **Why is this bad?** Arguments passed by value might require a shallow copy,+    /// which can be expensive and can be easily improved with passing by reference.+    ///

 declare_clippy_lint! {     "integer literals with digits grouped inconsistently" } +declare_clippy_lint! {+    /// **What it does:** Warns if a hexadecimal or binary literal is not grouped

+#![warn(clippy::undropped_manually_drops)]++struct S;++fn main() {+    let f = std::mem::drop;+    let g = std::mem::ManuallyDrop::drop;+    let mut manual1 = std::mem::ManuallyDrop::new(S);+    let mut manual2 = std::mem::ManuallyDrop::new(S);+    let mut manual3 = std::mem::ManuallyDrop::new(S);+    let mut manual4 = std::mem::ManuallyDrop::new(S);++    // These lines will not drop `S` and should be linted+    drop(std::mem::ManuallyDrop::new(S));+    drop(manual1);+    f(manual2);

 impl<'tcx> LateLintPass<'tcx> for Ranges {     } } +fn check_possible_range_contains(cx: &LateContext<'_>, op: BinOpKind, l: &Expr<'_>, r: &Expr<'_>, span: Span) {+    let combine_and = match op {+        BinOpKind::And | BinOpKind::BitAnd => true,+        BinOpKind::Or | BinOpKind::BitOr => false,+        _ => return,+    };+    // value, name, order (higher/lower), inclusiveness+    if let (Some((lval, lname, name_span, lval_span, lord, linc)), Some((rval, rname, _, rval_span, rord, rinc))) =+        (check_range_bounds(cx, l), check_range_bounds(cx, r))+    {+        // we only lint comparisons on the same name and with different+        // direction+        if lname != rname || lord == rord {+            return;+        }+        let ord = Constant::partial_cmp(cx.tcx, cx.typeck_results().expr_ty(l), &lval, &rval);+        if combine_and && ord == Some(rord) {+            // order lower bound and upper bound+            let (l_span, u_span, l_inc, u_inc) = if rord == Ordering::Less {+                (lval_span, rval_span, linc, rinc)+            } else {+                (rval_span, lval_span, rinc, linc)+            };+            // we only lint inclusive lower bounds+            if !l_inc {+                return;+            }+            let (range_type, range_op) = if u_inc {+                ("RangeInclusive", "..=")+            } else {+                ("Range", "..")+            };+            span_lint_and_then(+                cx,+                MANUAL_RANGE_CONTAINS,+                span,+                &format!("manual `{}::contains` implementation", range_type),+                |diag| {+                    let mut applicability = Applicability::MachineApplicable;+                    let name = snippet_with_applicability(cx, name_span, "_", &mut applicability);+                    let lo = snippet_with_applicability(cx, l_span, "_", &mut applicability);+                    let hi = snippet_with_applicability(cx, u_span, "_", &mut applicability);+                    diag.span_suggestion(+                        span,+                        "use",+                        format!("({}{}{}).contains({})", lo, range_op, hi, name),+                        applicability,+                    );+                },+            );+        } else if !combine_and && ord == Some(lord) {+            // `!_.contains(_)`+            // order lower bound and upper bound+            let (l_span, u_span, l_inc, u_inc) = if lord == Ordering::Less {+                (lval_span, rval_span, linc, rinc)+            } else {+                (rval_span, lval_span, rinc, linc)+            };+            if l_inc {+                return;+            }+            let (range_type, range_op) = if u_inc {+                ("Range", "..")+            } else {+                ("RangeInclusive", "..=")+            };+            span_lint_and_then(+                cx,+                MANUAL_RANGE_CONTAINS,+                span,+                &format!("manual `!{}::contains` implementation", range_type),+                |diag| {+                    let mut applicability = Applicability::MachineApplicable;+                    let name = snippet_with_applicability(cx, name_span, "_", &mut applicability);+                    let lo = snippet_with_applicability(cx, l_span, "_", &mut applicability);+                    let hi = snippet_with_applicability(cx, u_span, "_", &mut applicability);+                    diag.span_suggestion(+                        span,+                        "use",+                        format!("!({}{}{}).contains({})", lo, range_op, hi, name),+                        applicability,+                    );+                },+            );+        }+    }+}++fn check_range_bounds(cx: &LateContext<'_>, ex: &Expr<'_>) -> Option<(Constant, Ident, Span, Span, Ordering, bool)> {+    if let ExprKind::Binary(ref op, ref l, ref r) = ex.kind {+        let (inclusive, ordering) = match op.node {+            BinOpKind::Gt => (false, Ordering::Greater),+            BinOpKind::Ge => (true, Ordering::Greater),+            BinOpKind::Lt => (false, Ordering::Less),+            BinOpKind::Le => (true, Ordering::Less),+            _ => return None,+        };+        if let Some(id) = match_ident(l) {+            if let Some((c, _)) = constant(cx, cx.typeck_results(), r) {+                return Some((c, id, l.span, r.span, ordering, inclusive));+            }+        } else if let Some(id) = match_ident(r) {+            if let Some((c, _)) = constant(cx, cx.typeck_results(), l) {+                return Some((c, id, r.span, l.span, ordering.reverse(), inclusive));+            }+        }+    }+    None+}++fn match_ident(e: &Expr<'_>) -> Option<Ident> {+    if let ExprKind::Path(ref qpath) = e.kind {+        if let Some(seg) = single_segment_path(qpath) {+            if seg.args.is_none() {+                return Some(seg.ident);+            }+        }+    }+    None+}++fn check_range_zip_with_len(cx: &LateContext<'_>, path: &PathSegment<'_>, args: &[Expr<'_>], span: Span) {+    let name = path.ident.as_str();+    if name == "zip" && args.len() == 2 {+        let iter = &args[0].kind;+        let zip_arg = &args[1];+        if_chain! {+            // `.iter()` call+            if let ExprKind::MethodCall(ref iter_path, _, ref iter_args, _) = *iter;+            if iter_path.ident.name == sym!(iter);+            // range expression in `.zip()` call: `0..x.len()`+            if let Some(higher::Range { start: Some(start), end: Some(end), .. }) = higher::range(zip_arg);+            if is_integer_const(cx, start, 0);+            // `.len()` call+            if let ExprKind::MethodCall(ref len_path, _, ref len_args, _) = end.kind;+            if len_path.ident.name == sym!(len) && len_args.len() == 1;+            // `.iter()` and `.len()` called on same `Path`+            if let ExprKind::Path(QPath::Resolved(_, ref iter_path)) = iter_args[0].kind;+            if let ExprKind::Path(QPath::Resolved(_, ref len_path)) = len_args[0].kind;+            if SpanlessEq::new(cx).eq_path_segments(&iter_path.segments, &len_path.segments);+            then {+                span_lint(cx,+                RANGE_ZIP_WITH_LEN,+                span,+                &format!("it is more idiomatic to use `{}.iter().enumerate()`",+                    snippet(cx, iter_args[0].span, "_")));

 impl<'tcx> LateLintPass<'tcx> for Ranges {     } } +fn check_possible_range_contains(cx: &LateContext<'_>, op: BinOpKind, l: &Expr<'_>, r: &Expr<'_>, span: Span) {+    let combine_and = match op {+        BinOpKind::And | BinOpKind::BitAnd => true,+        BinOpKind::Or | BinOpKind::BitOr => false,+        _ => return,+    };+    // value, name, order (higher/lower), inclusiveness+    if let (Some((lval, lname, name_span, lval_span, lord, linc)), Some((rval, rname, _, rval_span, rord, rinc))) =+        (check_range_bounds(cx, l), check_range_bounds(cx, r))+    {+        // we only lint comparisons on the same name and with different+        // direction+        if lname != rname || lord == rord {+            return;+        }+        let ord = Constant::partial_cmp(cx.tcx, cx.typeck_results().expr_ty(l), &lval, &rval);+        if combine_and && ord == Some(rord) {+            // order lower bound and upper bound+            let (l_span, u_span, l_inc, u_inc) = if rord == Ordering::Less {+                (lval_span, rval_span, linc, rinc)+            } else {+                (rval_span, lval_span, rinc, linc)+            };+            // we only lint inclusive lower bounds+            if !l_inc {+                return;+            }+            let (range_type, range_op) = if u_inc {+                ("RangeInclusive", "..=")+            } else {+                ("Range", "..")+            };+            span_lint_and_then(+                cx,+                MANUAL_RANGE_CONTAINS,+                span,+                &format!("manual `{}::contains` implementation", range_type),+                |diag| {+                    let mut applicability = Applicability::MachineApplicable;+                    let name = snippet_with_applicability(cx, name_span, "_", &mut applicability);+                    let lo = snippet_with_applicability(cx, l_span, "_", &mut applicability);+                    let hi = snippet_with_applicability(cx, u_span, "_", &mut applicability);+                    diag.span_suggestion(+                        span,+                        "use",+                        format!("({}{}{}).contains({})", lo, range_op, hi, name),+                        applicability,+                    );+                },+            );+        } else if !combine_and && ord == Some(lord) {+            // `!_.contains(_)`+            // order lower bound and upper bound+            let (l_span, u_span, l_inc, u_inc) = if lord == Ordering::Less {+                (lval_span, rval_span, linc, rinc)+            } else {+                (rval_span, lval_span, rinc, linc)+            };+            if l_inc {+                return;+            }+            let (range_type, range_op) = if u_inc {+                ("Range", "..")+            } else {+                ("RangeInclusive", "..=")+            };+            span_lint_and_then(

 fn no_panic_with_fake_range_types() {      let _ = Range { foo: 0 }; }++#[warn(clippy::manual_range_contains)]

+use crate::utils::{last_path_segment, match_def_path, paths, snippet, span_lint_and_sugg};+use rustc_hir::{GenericArg, Mutability, Ty, TyKind};+use rustc_lint::{LateContext, LateLintPass};+use rustc_session::{declare_lint_pass, declare_tool_lint};++use if_chain::if_chain;+use rustc_errors::Applicability;++declare_clippy_lint! {+    /// **What it does:** Checks for usage of `&Option<&T>`.+    ///+    /// **Why is this bad?** Since `&` is Copy, it's useless to have a+    /// reference on `Option<&T>`.+    ///+    /// **Known problems:** None.+    ///+    /// **Example:**+    ///+    /// ```rust,ignore+    /// // example code where clippy issues a warning+    /// let x: &Option<&u32> = &Some(&0u32);+    /// ```+    /// Use instead:+    /// ```rust,ignore+    /// // example code which does not raise clippy warning+    /// let x: Option<&u32> = Some(&0u32);+    /// ```+    pub REF_OPTION_REF,+    style,+    "use `Option<&T>` instead of `&Option<&T>`"+}++declare_lint_pass!(RefOptionRef => [REF_OPTION_REF]);++impl<'tcx> LateLintPass<'tcx> for RefOptionRef {+    fn check_ty(&mut self, cx: &LateContext<'tcx>, ty: &'tcx Ty<'tcx>) {+        if_chain! {+            if let TyKind::Rptr(_, ref mut_ty) = ty.kind;+            if mut_ty.mutbl == Mutability::Not;+            if let TyKind::Path(ref qpath) = &mut_ty.ty.kind;+            let last = last_path_segment(qpath);+            if let Some(res) = last.res;+            if let Some(def_id) = res.opt_def_id();++            if match_def_path(cx, def_id, &paths::OPTION);

+use crate::utils::{last_path_segment, match_def_path, paths, snippet, span_lint_and_sugg};+use rustc_hir::{GenericArg, Mutability, Ty, TyKind};+use rustc_lint::{LateContext, LateLintPass};+use rustc_session::{declare_lint_pass, declare_tool_lint};++use if_chain::if_chain;+use rustc_errors::Applicability;++declare_clippy_lint! {+    /// **What it does:** Checks for usage of `&Option<&T>`.+    ///+    /// **Why is this bad?** Since `&` is Copy, it's useless to have a+    /// reference on `Option<&T>`.+    ///+    /// **Known problems:** None.+    ///+    /// **Example:**+    ///+    /// ```rust,ignore+    /// // example code where clippy issues a warning+    /// let x: &Option<&u32> = &Some(&0u32);+    /// ```+    /// Use instead:+    /// ```rust,ignore+    /// // example code which does not raise clippy warning+    /// let x: Option<&u32> = Some(&0u32);

 fn search_is_some() {                                    x < 0                                }                    ).is_some();--    // Check that we don't lint if the caller is not an `Iterator`.+    +    let s1 = String::from("hello world");+    let s2 = String::from("world");+    // Check caller `find()` is a &`static str case+    let _ = "hello world".find("world").is_some();+    let _ = "hello world".find(&s2).is_some();+    let _ = "hello world".find(&s2[2..]).is_some();+    // Check caller of `find()` is a String case+    let _ = s1.find("world").is_some();+    let _ = s1.find(&s2).is_some();+    let _ = s1.find(&s2[2..]).is_some();+    //  Check caller of `find()` is a slice of String case+    let _ = s1[2..].find("world").is_some();+    let _ = s1[2..].find(&s2).is_some();+    let _ = s1[2..].find(&s2[2..]).is_some();++    // Check that we don't lint if `find()` is called with+    // Pattern that is not a string+    let _ = s1.find(|c: char| c == 'o' || c == 'l').is_some();++    // Check that we don't lint if the caller is not an `Iterator` or string     let foo = IteratorFalsePositives { foo: 0 };     let _ = foo.find().is_some();     let _ = foo.position().is_some();

+use crate::utils::{is_type_diagnostic_item, span_lint_and_sugg};+use if_chain::if_chain;+use rustc_errors::Applicability;+use rustc_hir::{Expr, ExprKind, Mutability};+use rustc_lint::{LateContext, LateLintPass};+use rustc_middle::ty;+use rustc_session::{declare_lint_pass, declare_tool_lint};++declare_clippy_lint! {+    /// **What it does:** Checks for `&mut Mutex::lock` calls+    ///+    /// **Why is this bad?** `Mutex::lock` is less efficient than+    /// calling `Mutex::get_mut`. In addition you also have a statically+    /// guarantee that the mutex isn't locked, instead of just a runtime+    /// guarantee.+    ///+    /// **Known problems:** None.+    ///+    /// **Example:**+    ///+    /// ```rust+    /// use std::sync::{Arc, Mutex};+    ///+    /// let mut value_rc = Arc::new(Mutex::new(42_u8));+    /// let value_mutex = Arc::get_mut(&mut value_rc).unwrap();+    ///+    /// let mut value = value_mutex.lock().unwrap();+    /// *value += 1;+    /// ```+    /// Use instead:+    /// ```rust+    /// use std::sync::{Arc, Mutex};+    ///+    /// let mut value_rc = Arc::new(Mutex::new(42_u8));+    /// let value_mutex = Arc::get_mut(&mut value_rc).unwrap();+    ///+    /// let value = value_mutex.get_mut().unwrap();+    /// *value += 1;+    /// ```+    pub MUT_MUTEX_LOCK,+    correctness,+    "`&mut Mutex::lock` does unnecessary locking"+}++declare_lint_pass!(MutMutexLock => [MUT_MUTEX_LOCK]);++impl<'tcx> LateLintPass<'tcx> for MutMutexLock {+    fn check_expr(&mut self, cx: &LateContext<'tcx>, ex: &'tcx Expr<'tcx>) {+        if_chain! {+            if let ExprKind::MethodCall(path, method_span, args, _) = &ex.kind;+            if path.ident.name == sym!(lock);+            let ty = cx.typeck_results().expr_ty(&args[0]);+            if let ty::Ref(_, inner_ty, Mutability::Mut) = ty.kind();+            if is_type_diagnostic_item(cx, inner_ty, sym!(mutex_type));+            then {+                span_lint_and_sugg(+                    cx,+                    MUT_MUTEX_LOCK,+                    *method_span,+                    "calling `&mut Mutex::lock` unnecessarily locks an exclusive (mutable) reference",+                    "change this to",+                    "get_mut".to_owned(),+                    Applicability::MachineApplicable,

+use crate::utils::{is_type_diagnostic_item, span_lint_and_sugg};+use if_chain::if_chain;+use rustc_errors::Applicability;+use rustc_hir::{Expr, ExprKind, Mutability};+use rustc_lint::{LateContext, LateLintPass};+use rustc_middle::ty;+use rustc_session::{declare_lint_pass, declare_tool_lint};++declare_clippy_lint! {+    /// **What it does:** Checks for `&mut Mutex::lock` calls+    ///+    /// **Why is this bad?** `Mutex::lock` is less efficient than+    /// calling `Mutex::get_mut`. In addition you also have a statically+    /// guarantee that the mutex isn't locked, instead of just a runtime+    /// guarantee.+    ///+    /// **Known problems:** None.+    ///+    /// **Example:**+    ///+    /// ```rust+    /// use std::sync::{Arc, Mutex};+    ///+    /// let mut value_rc = Arc::new(Mutex::new(42_u8));+    /// let value_mutex = Arc::get_mut(&mut value_rc).unwrap();+    ///+    /// let mut value = value_mutex.lock().unwrap();+    /// *value += 1;+    /// ```+    /// Use instead:+    /// ```rust+    /// use std::sync::{Arc, Mutex};+    ///+    /// let mut value_rc = Arc::new(Mutex::new(42_u8));+    /// let value_mutex = Arc::get_mut(&mut value_rc).unwrap();+    ///+    /// let value = value_mutex.get_mut().unwrap();+    /// *value += 1;+    /// ```+    pub MUT_MUTEX_LOCK,+    correctness,

+use crate::utils::{+    is_type_diagnostic_item, match_qpath, paths, return_ty, snippet, span_lint_and_then,+    visitors::find_all_ret_expressions,+};+use if_chain::if_chain;+use rustc_errors::Applicability;+use rustc_hir::intravisit::FnKind;+use rustc_hir::*;+use rustc_lint::{LateContext, LateLintPass};+use rustc_middle::ty::subst::GenericArgKind;+use rustc_session::{declare_lint_pass, declare_tool_lint};+use rustc_span::Span;++declare_clippy_lint! {+    /// **What it does:** Checks for private functions that only return `Ok` or `Some`.+    ///+    /// **Why is this bad?** It is not meaningful to wrap values when no `None` or `Err` is returned.+    ///+    /// **Known problems:** Since this lint changes function type signature, you may need to+    /// adjust some code at callee side.+    ///+    /// **Example:**+    ///+    /// ```rust+    /// fn get_cool_number(a: bool, b: bool) -> Option<i32> {+    ///     if a && b {+    ///         return Some(50);+    ///     }+    ///     if a {+    ///         Some(0)+    ///     } else {+    ///         Some(10)+    ///     }+    /// }+    /// ```+    /// Use instead:+    /// ```rust+    /// fn get_cool_number(a: bool, b: bool) -> i32 {+    ///     if a && b {+    ///         return 50;+    ///     }+    ///     if a {+    ///         0+    ///     } else {+    ///         10+    ///     }+    /// }+    /// ```+    pub UNNECESSARY_WRAP,+    complexity,+    "functions that only return `Ok` or `Some`"+}++declare_lint_pass!(UnnecessaryWrap => [UNNECESSARY_WRAP]);++impl<'tcx> LateLintPass<'tcx> for UnnecessaryWrap {+    fn check_fn(+        &mut self,+        cx: &LateContext<'tcx>,+        fn_kind: FnKind<'tcx>,+        fn_decl: &FnDecl<'tcx>,+        body: &Body<'tcx>,+        span: Span,+        hir_id: HirId,+    ) {+        if_chain! {+            if let FnKind::ItemFn(.., visibility, _) = fn_kind;+            if visibility.node.is_pub();+            then {+                return;+            }+        }++        let (return_type, path) = if is_type_diagnostic_item(cx, return_ty(cx, hir_id), sym!(option_type)) {

+use rustc_hir as hir;

 fn is_mutex_guard(cx: &LateContext<'_>, def_id: DefId) -> bool {         || match_def_path(cx, def_id, &paths::PARKING_LOT_RWLOCK_READ_GUARD)         || match_def_path(cx, def_id, &paths::PARKING_LOT_RWLOCK_WRITE_GUARD) }++declare_clippy_lint! {

 fn is_mutex_guard(cx: &LateContext<'_>, def_id: DefId) -> bool {         || match_def_path(cx, def_id, &paths::PARKING_LOT_RWLOCK_READ_GUARD)         || match_def_path(cx, def_id, &paths::PARKING_LOT_RWLOCK_WRITE_GUARD) }++declare_clippy_lint! {+    /// **What it does:** Checks for calls to await while holding a+    /// `RefCell` `Ref` or `RefMut`.+    ///+    /// **Why is this bad?** `RefCell` refs only check for exclusive mutable access+    /// at runtime. Holding onto a `RefCell` ref across an `await` suspension point+    /// risks panics from a mutable ref shared while other refs are outstanding.+    ///+    /// **Known problems:** None.+    ///+    /// **Example:**+    ///+    /// ```rust,ignore+    /// use std::cell::RefCell;+    ///+    /// async fn foo(x: &RefCell<u32>) {+    ///   let b = x.borrow_mut()();+    ///   *ref += 1;+    ///   bar.await;+    /// }+    /// ```+    ///+    /// Use instead:+    /// ```rust,ignore+    /// use std::cell::RefCell;+    ///+    /// async fn foo(x: &RefCell<u32>) {+    ///   {+    ///     let b = x.borrow_mut();+    ///     *ref += 1;+    ///   }+    ///   bar.await;+    /// }+    /// ```+    pub AWAIT_HOLDING_REFCELL_REF,+    pedantic,+    "Inside an async function, holding a RefCell ref while calling await"+}++declare_lint_pass!(AwaitHoldingRefCellRef => [AWAIT_HOLDING_REFCELL_REF]);++impl LateLintPass<'_> for AwaitHoldingRefCellRef {+    fn check_body(&mut self, cx: &LateContext<'_>, body: &'_ Body<'_>) {+        use AsyncGeneratorKind::{Block, Closure, Fn};+        if let Some(GeneratorKind::Async(Block | Closure | Fn)) = body.generator_kind {+            let body_id = BodyId {+                hir_id: body.value.hir_id,+            };+            let def_id = cx.tcx.hir().body_owner_def_id(body_id);+            let typeck_results = cx.tcx.typeck(def_id);

 LL | | }    | |_^  error: this MutexGuard is held across an 'await' point. Consider using an async-aware Mutex type or ensuring the MutexGuard is dropped before calling await.-  --> $DIR/await_holding_invalid.rs:41:13+  --> $DIR/await_holding_invalid.rs:42:13    | LL |         let guard = x.lock().unwrap();    |             ^^^^^    | note: these are all the await points this lock is held through-  --> $DIR/await_holding_invalid.rs:41:9+  --> $DIR/await_holding_invalid.rs:42:9    | LL | /         let guard = x.lock().unwrap(); LL | |         baz().await LL | |     };    | |_____^  error: this MutexGuard is held across an 'await' point. Consider using an async-aware Mutex type or ensuring the MutexGuard is dropped before calling await.-  --> $DIR/await_holding_invalid.rs:53:13+  --> $DIR/await_holding_invalid.rs:54:13    | LL |         let guard = x.lock().unwrap();    |             ^^^^^    | note: these are all the await points this lock is held through-  --> $DIR/await_holding_invalid.rs:53:9+  --> $DIR/await_holding_invalid.rs:54:9    | LL | /         let guard = x.lock().unwrap(); LL | |         baz().await LL | |     }    | |_____^ -error: aborting due to 4 previous errors+error: this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await.

+// Tests from for_loop.rs that don't have suggestions

 fn check_for_loop_over_map_kv<'tcx>(     } } +fn check_for_single_element_loop<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, arg: &'tcx Expr<'_>) {+    if_chain! {+        if let ExprKind::AddrOf(BorrowKind::Ref, _, ref expr) = arg.kind;+        if let PatKind::Binding(.., target, _) = pat.kind;+        if let ExprKind::Array(ref expr_list) = expr.kind;+        if expr_list.len() == 1;+        if let ExprKind::Path(ref list_item) = expr_list[0].kind;+        if let Some(list_tem_name) = single_segment_path(list_item).map(|ps| ps.ident.name);++        then {+            span_lint_and_sugg(+                cx,+                SINGLE_ELEMENT_LOOP,+                expr.span,

 fn check_for_loop_over_map_kv<'tcx>(     } } +fn check_for_single_element_loop<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, arg: &'tcx Expr<'_>) {+    if_chain! {+        if let ExprKind::AddrOf(BorrowKind::Ref, _, ref expr) = arg.kind;+        if let PatKind::Binding(.., target, _) = pat.kind;+        if let ExprKind::Array(ref expr_list) = expr.kind;+        if expr_list.len() == 1;+        if let ExprKind::Path(ref list_item) = expr_list[0].kind;+        if let Some(list_tem_name) = single_segment_path(list_item).map(|ps| ps.ident.name);++        then {+            span_lint_and_sugg(+                cx,+                SINGLE_ELEMENT_LOOP,+                expr.span,+                "do not iterate over a single element array",+                "try",

 fn check_for_loop_over_map_kv<'tcx>(     } } +fn check_for_single_element_loop<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, arg: &'tcx Expr<'_>) {+    if_chain! {+        if let ExprKind::AddrOf(BorrowKind::Ref, _, ref expr) = arg.kind;+        if let PatKind::Binding(.., target, _) = pat.kind;+        if let ExprKind::Array(ref expr_list) = expr.kind;+        if expr_list.len() == 1;+        if let ExprKind::Path(ref list_item) = expr_list[0].kind;

 fn check_for_loop_over_map_kv<'tcx>(     } } +fn check_for_single_element_loop<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, arg: &'tcx Expr<'_>) {+    if_chain! {+        if let ExprKind::AddrOf(BorrowKind::Ref, _, ref expr) = arg.kind;+        if let PatKind::Binding(.., target, _) = pat.kind;+        if let ExprKind::Array(ref expr_list) = expr.kind;+        if expr_list.len() == 1;+        if let ExprKind::Path(ref list_item) = expr_list[0].kind;+        if let Some(list_tem_name) = single_segment_path(list_item).map(|ps| ps.ident.name);

 declare_clippy_lint! {     "unnecessary structure name repetition whereas `Self` is applicable" } -declare_lint_pass!(UseSelf => [USE_SELF]);+#[derive(Default)]+pub struct UseSelf {+    stack: Vec<StackItem>,+    types_to_skip: Vec<HirId>,+    types_to_lint: Vec<HirId>,+}++#[derive(Debug, PartialEq, Eq, Copy, Clone)]+enum StackItem {+    Check {+        hir_id: HirId,+        impl_trait_ref_def_id: Option<LocalDefId>,+    },+    NoCheck,+}++impl_lint_pass!(UseSelf => [USE_SELF]);  const SEGMENTS_MSG: &str = "segments should be composed of at least 1 element"; +impl<'tcx> LateLintPass<'tcx> for UseSelf {+    fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {+        // We push the self types of `impl`s on a stack here. Only the top type on the stack is+        // relevant for linting, since this is the self type of the `impl` we're currently in. To+        // avoid linting on nested items, we push `StackItem::NoCheck` on the stack to signal, that+        // we're in an `impl` or nested item, that we don't want to lint+        //+        // NB: If you push something on the stack in this method, remember to also pop it in the+        // `check_item_post` method.+        use ItemKind::{Const, Enum, Fn, Impl, Static, Struct, Trait, Union};+        match &item.kind {+            Impl {+                self_ty: hir_self_ty,+                of_trait,+                ..+            } => {+                let should_check = if let TyKind::Path(QPath::Resolved(_, ref item_path)) = hir_self_ty.kind {+                    let parameters = &item_path.segments.last().expect(SEGMENTS_MSG).args;+                    parameters.as_ref().map_or(true, |params| {+                        !params.parenthesized && !params.args.iter().any(|arg| matches!(arg, GenericArg::Lifetime(_)))+                    })+                } else {+                    false+                };+                let impl_trait_ref_def_id = of_trait.as_ref().map(|_| cx.tcx.hir().local_def_id(item.hir_id));+                if should_check {+                    self.stack.push(StackItem::Check {+                        hir_id: hir_self_ty.hir_id,+                        impl_trait_ref_def_id,+                    });+                } else {+                    self.stack.push(StackItem::NoCheck);+                }+            },+            Static(..) | Const(..) | Fn(..) | Enum(..) | Struct(..) | Union(..) | Trait(..) => {+                self.stack.push(StackItem::NoCheck);+            },+            _ => (),+        }+    }++    fn check_item_post(&mut self, _: &LateContext<'_>, item: &Item<'_>) {+        use ItemKind::{Const, Enum, Fn, Impl, Static, Struct, Trait, Union};+        match item.kind {+            Impl { .. } | Static(..) | Const(..) | Fn(..) | Enum(..) | Struct(..) | Union(..) | Trait(..) => {+                self.stack.pop();+            },+            _ => (),+        }+    }++    fn check_impl_item(&mut self, cx: &LateContext<'_>, impl_item: &hir::ImplItem<'_>) {+        // We want to skip types in trait `impl`s that aren't declared as `Self` in the trait+        // declaration. The collection of those types is all this method implementation does.+        if_chain! {+            if let ImplItemKind::Fn(FnSig { decl, .. }, ..) = impl_item.kind;+            if let Some(StackItem::Check { impl_trait_ref_def_id: Some(def_id), .. }) = self.stack.last().copied();+            if let Some(impl_trait_ref) = cx.tcx.impl_trait_ref(def_id);+            then {+                // `self_ty` is the semantic self type of `impl <trait> for <type>`. This cannot be+                // `Self`.+                let self_ty = impl_trait_ref.self_ty();++                // `trait_method_sig` is the signature of the function, how it is declared in the+                // trait, not in the impl of the trait.+                let trait_method = cx+                    .tcx+                    .associated_items(impl_trait_ref.def_id)+                    .find_by_name_and_kind(cx.tcx, impl_item.ident, AssocKind::Fn, impl_trait_ref.def_id)+                    .expect("impl method matches a trait method");+                let trait_method_sig = cx.tcx.fn_sig(trait_method.def_id);+                let trait_method_sig = cx.tcx.erase_late_bound_regions(&trait_method_sig);++                // `impl_inputs_outputs` is an iterator over the types (`hir::Ty`) declared in the+                // implementation of the trait.+                let output_hir_ty = if let FnRetTy::Return(ty) = &decl.output {+                    Some(&**ty)+                } else {+                    None+                };+                let impl_inputs_outputs = decl.inputs.iter().chain(output_hir_ty);++                // `impl_hir_ty` (of type `hir::Ty`) represents the type written in the signature.+                //+                // `trait_sem_ty` (of type `ty::Ty`) is the semantic type for the signature in the+                // trait declaration. This is used to check if `Self` was used in the trait+                // declaration.+                //+                // If `any`where in the `trait_sem_ty` the `self_ty` was used verbatim (as opposed+                // to `Self`), we want to skip linting that type and all subtypes of it. This+                // avoids suggestions to e.g. replace `Vec<u8>` with `Vec<Self>`, in an `impl Trait+                // for u8`, when the trait always uses `Vec<u8>`.+                //+                // See also https://github.com/rust-lang/rust-clippy/issues/2894.+                for (impl_hir_ty, trait_sem_ty) in impl_inputs_outputs.zip(trait_method_sig.inputs_and_output) {+                    if trait_sem_ty.walk().any(|inner| inner == self_ty.into()) {+                        let mut visitor = SkipTyCollector::default();+                        visitor.visit_ty(&impl_hir_ty);+                        self.types_to_skip.extend(visitor.types_to_skip);+                    }+                }+            }+        }+    }++    fn check_impl_item_post(&mut self, _: &LateContext<'_>, _: &hir::ImplItem<'_>) {+        self.types_to_skip.clear();+    }++    fn check_body(&mut self, cx: &LateContext<'tcx>, body: &'tcx hir::Body<'_>) {+        // `hir_ty_to_ty` cannot be called in `Body`s or it will panic (sometimes). But in bodies+        // we can use `cx.typeck_results.node_type(..)` to get the `ty::Ty` from a `hir::Ty`.

 impl<'a, 'tcx> Visitor<'tcx> for ImplVisitor<'a, 'tcx> {     } } +struct FnSigVisitor<'a, 'tcx> {+    cx: &'a LateContext<'tcx>,+    self_ty: Ty<'tcx>,+}++impl<'a, 'tcx> Visitor<'tcx> for FnSigVisitor<'a, 'tcx> {+    type Map = Map<'tcx>;++    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {+        NestedVisitorMap::None+    }++    fn visit_ty(&mut self, hir_ty: &'tcx hir::Ty<'tcx>) {+        if let TyKind::Path(QPath::Resolved(_, path)) = hir_ty.kind {+            match path.res {+                def::Res::SelfTy(..) => {},+                _ => {+                    match self.cx.tcx.hir().find(self.cx.tcx.hir().get_parent_node(hir_ty.hir_id)) {+                        Some(Node::Expr(Expr {+                            kind: ExprKind::Path(QPath::TypeRelative(_, segment)),+                            ..+                        })) => {+                            // The following block correctly identifies applicable lint locations+                            // but `hir_ty_to_ty` calls cause odd ICEs.+                            //

 declare_clippy_lint! { declare_clippy_lint! {     /// **What it does:** Checks for empty `loop` expressions.     ///-    /// **Why is this bad?** Those busy loops burn CPU cycles without doing-    /// anything. Think of the environment and either block on something or at least-    /// make the thread sleep for some microseconds.+    /// **Why is this bad?** Due to [an LLVM codegen bug](https://github.com/rust-lang/rust/issues/28728)+    /// these expressions can be miscompiled or 'optimized' out. Also, these busy loops+    /// burn CPU cycles without doing anything.     ///-    /// **Known problems:** None.+    /// It is _almost always_ a better idea to `panic!` than to have a busy loop.+    ///+    /// If panicking isn't possible, think of the environment and either:+    ///   - block on something+    ///   - sleep the thread for some microseconds+    ///   - yield or pause the thread+    ///+    /// For `std` targets, this can be done with+    /// [`std::thread::sleep`](https://doc.rust-lang.org/std/thread/fn.sleep.html)+    /// or [`std::thread::yield_now`](https://doc.rust-lang.org/std/thread/fn.yield_now.html).+    ///+    /// For `no_std` targets, doing this is more complicated, especially because+    /// `#[panic_handler]`s can't panic. To stop/pause the thread, you will+    /// probably need to invoke some target-specific intrinsic. Examples include:+    ///   - [`x86_64::instructions::hlt`](https://docs.rs/x86_64/0.12.2/x86_64/instructions/fn.hlt.html)+    ///   - [`cortex_m::asm::wfi`](https://docs.rs/cortex-m/0.6.3/cortex_m/asm/fn.wfi.html)+    ///+    /// If you just care about fixing the LLVM bug (and don't care about burning+    /// CPU), you can:+    ///   - On nightly, insert a non-`pure` `asm!` statement. For example:

 declare_clippy_lint! { declare_clippy_lint! {     /// **What it does:** Checks for empty `loop` expressions.     ///-    /// **Why is this bad?** Those busy loops burn CPU cycles without doing-    /// anything. Think of the environment and either block on something or at least-    /// make the thread sleep for some microseconds.+    /// **Why is this bad?** Due to [an LLVM codegen bug](https://github.com/rust-lang/rust/issues/28728)+    /// these expressions can produce undefined behavior. Also, these busy loops+    /// burn CPU cycles without doing anything.     ///-    /// **Known problems:** None.+    /// It is _almost always_ a better idea to `panic!` than to have a busy loop.+    ///+    /// If panicking isn't possible, think of the environment and either:+    ///   - block on something+    ///   - sleep the thread for some microseconds+    ///   - yield or pause the thread+    ///+    /// For `std` targets, this can be done with+    /// [`std::thread::sleep`](https://doc.rust-lang.org/std/thread/fn.sleep.html)+    /// or [`std::thread::yield_now`](https://doc.rust-lang.org/std/thread/fn.yield_now.html).+    ///+    /// For `no_std` targets, doing this is more complicated, especially because+    /// `#[panic_handler]`s can't panic. To stop/pause the thread, you will+    /// probably need to invoke some target-specific intrinsic. Examples include:+    ///   - [`x86_64::instructions::hlt`](https://docs.rs/x86_64/0.12.2/x86_64/instructions/fn.hlt.html)+    ///   - [`cortex_m::asm::wfi`](https://docs.rs/cortex-m/0.6.3/cortex_m/asm/fn.wfi.html)+    ///+    /// If you just care about fixing the LLVM bug (and don't care about burning+    /// CPU), you can:+    ///   - On nightly, compile your code with `-Z insert-sideeffect`

 declare_clippy_lint! { declare_clippy_lint! {     /// **What it does:** Checks for empty `loop` expressions.     ///-    /// **Why is this bad?** Those busy loops burn CPU cycles without doing-    /// anything. Think of the environment and either block on something or at least-    /// make the thread sleep for some microseconds.+    /// **Why is this bad?** Due to [an LLVM codegen bug](https://github.com/rust-lang/rust/issues/28728)+    /// these expressions can produce undefined behavior. Also, these busy loops+    /// burn CPU cycles without doing anything.     ///-    /// **Known problems:** None.+    /// It is _almost always_ a better idea to `panic!` than to have a busy loop.+    ///+    /// If panicking isn't possible, think of the environment and either:+    ///   - block on something+    ///   - sleep the thread for some microseconds+    ///   - yield or pause the thread+    ///+    /// For `std` targets, this can be done with+    /// [`std::thread::sleep`](https://doc.rust-lang.org/std/thread/fn.sleep.html)+    /// or [`std::thread::yield_now`](https://doc.rust-lang.org/std/thread/fn.yield_now.html).+    ///+    /// For `no_std` targets, doing this is more complicated, especially because+    /// `#[panic_handler]`s can't panic. To stop/pause the thread, you will+    /// probably need to invoke some target-specific intrinsic. Examples include:+    ///   - [`x86_64::instructions::hlt`](https://docs.rs/x86_64/0.12.2/x86_64/instructions/fn.hlt.html)+    ///   - [`cortex_m::asm::wfi`](https://docs.rs/cortex-m/0.6.3/cortex_m/asm/fn.wfi.html)+    ///+    /// If you just care about fixing the LLVM bug (and don't care about burning+    /// CPU), you can:+    ///   - On nightly, compile your code with `-Z insert-sideeffect`

 declare_clippy_lint! { declare_clippy_lint! {     /// **What it does:** Checks for empty `loop` expressions.     ///-    /// **Why is this bad?** Those busy loops burn CPU cycles without doing-    /// anything. Think of the environment and either block on something or at least-    /// make the thread sleep for some microseconds.+    /// **Why is this bad?** Due to [an LLVM codegen bug](https://github.com/rust-lang/rust/issues/28728)+    /// these expressions can produce undefined behavior. Also, these busy loops+    /// burn CPU cycles without doing anything.     ///-    /// **Known problems:** None.+    /// It is _almost always_ a better idea to `panic!` than to have a busy loop.+    ///+    /// If panicking isn't possible, think of the environment and either:+    ///   - block on something+    ///   - sleep the thread for some microseconds+    ///   - yield or pause the thread+    ///+    /// For `std` targets, this can be done with+    /// [`std::thread::sleep`](https://doc.rust-lang.org/std/thread/fn.sleep.html)+    /// or [`std::thread::yield_now`](https://doc.rust-lang.org/std/thread/fn.yield_now.html).+    ///+    /// For `no_std` targets, doing this is more complicated, especially because+    /// `#[panic_handler]`s can't panic. To stop/pause the thread, you will+    /// probably need to invoke some target-specific intrinsic. Examples include:+    ///   - [`x86_64::instructions::hlt`](https://docs.rs/x86_64/0.12.2/x86_64/instructions/fn.hlt.html)+    ///   - [`cortex_m::asm::wfi`](https://docs.rs/cortex-m/0.6.3/cortex_m/asm/fn.wfi.html)+    ///+    /// If you just care about fixing the LLVM bug (and don't care about burning+    /// CPU), you can:+    ///   - On nightly, compile your code with `-Z insert-sideeffect`

 declare_clippy_lint! { declare_clippy_lint! {     /// **What it does:** Checks for empty `loop` expressions.     ///-    /// **Why is this bad?** Those busy loops burn CPU cycles without doing-    /// anything. Think of the environment and either block on something or at least-    /// make the thread sleep for some microseconds.+    /// **Why is this bad?** Due to [an LLVM codegen bug](https://github.com/rust-lang/rust/issues/28728)+    /// these expressions can produce undefined behavior. Also, these busy loops

 declare_clippy_lint! { declare_clippy_lint! {     /// **What it does:** Checks for empty `loop` expressions.     ///-    /// **Why is this bad?** Those busy loops burn CPU cycles without doing-    /// anything. Think of the environment and either block on something or at least-    /// make the thread sleep for some microseconds.+    /// **Why is this bad?** Due to [an LLVM codegen bug](https://github.com/rust-lang/rust/issues/28728)+    /// these expressions can produce undefined behavior. Also, these busy loops

 declare_clippy_lint! { declare_clippy_lint! {     /// **What it does:** Checks for empty `loop` expressions.     ///-    /// **Why is this bad?** Those busy loops burn CPU cycles without doing-    /// anything. Think of the environment and either block on something or at least-    /// make the thread sleep for some microseconds.+    /// **Why is this bad?** Due to [an LLVM codegen bug](https://github.com/rust-lang/rust/issues/28728)+    /// these expressions can produce undefined behavior. Also, these busy loops+    /// burn CPU cycles without doing anything.     ///-    /// **Known problems:** None.+    /// It is _almost always_ a better idea to `panic!` than to have a busy loop.+    ///+    /// If panicking isn't possible, think of the environment and either:+    ///   - block on something+    ///   - sleep the thread for some microseconds+    ///   - yield or pause the thread+    ///+    /// For `std` targets, this can be done with+    /// [`std::thread::sleep`](https://doc.rust-lang.org/std/thread/fn.sleep.html)+    /// or [`std::thread::yield_now`](https://doc.rust-lang.org/std/thread/fn.yield_now.html).+    ///+    /// For `no_std` targets, doing this is more complicated, especially because+    /// `#[panic_handler]`s can't panic. To stop/pause the thread, you will+    /// probably need to invoke some target-specific intrinsic. Examples include:+    ///   - [`x86_64::instructions::hlt`](https://docs.rs/x86_64/0.12.2/x86_64/instructions/fn.hlt.html)+    ///   - [`cortex_m::asm::wfi`](https://docs.rs/cortex-m/0.6.3/cortex_m/asm/fn.wfi.html)+    ///+    /// If you just care about fixing the LLVM bug (and don't care about burning+    /// CPU), you can:+    ///   - On nightly, compile your code with `-Z insert-sideeffect`