Uplift the `invalid_atomic_ordering` lint from clippy to rustc

- Deprecate clippy::invalid_atomic_ordering
- Use rustc_diagnostic_item for the orderings in the invalid_atomic_ordering lint
- Reduce code duplication
- Give up on making enum variants diagnostic items and just look for
`Ordering` instead

  I ran into tons of trouble with this because apparently the change to
  store HIR attrs in a side table also gave the DefIds of the
  constructor instead of the variant itself. So I had to change
  `matches_ordering` to also check the grandparent of the defid as well.

- Rename `atomic_ordering_x` symbols to just the name of the variant
- Fix typos in checks - there were a few places that said "may not be
  Release" in the diagnostic but actually checked for SeqCst in the lint.
- Make constant items const
- Use fewer diagnostic items
- Only look at arguments after making sure the method matches

  This prevents an ICE when there aren't enough arguments.

- Ignore trait methods
- Only check Ctors instead of going through `qpath_res`

  The functions take values, so this couldn't ever be anything else.

- Add if_chain to allowed dependencies
- Fix grammar
- Remove unnecessary allow

28 files changed, 637 insertions, 437 deletions

diff --git a/Cargo.lock b/Cargo.lock
index b7c180012e0..2d66d7d4b21 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3923,6 +3923,7 @@ dependencies = [
 name = "rustc_lint"
 version = "0.0.0"
 dependencies = [
+ "if_chain",
  "rustc_ast",
  "rustc_ast_pretty",
  "rustc_attr",
diff --git a/compiler/rustc_lint/Cargo.toml b/compiler/rustc_lint/Cargo.toml
index 90badd3d573..58988b5ecd0 100644
--- a/compiler/rustc_lint/Cargo.toml
+++ b/compiler/rustc_lint/Cargo.toml
@@ -5,6 +5,7 @@ version = "0.0.0"
 edition = "2018"
 
 [dependencies]
+if_chain = "1.0"
 tracing = "0.1"
 unicode-security = "0.0.5"
 rustc_middle = { path = "../rustc_middle" }
diff --git a/compiler/rustc_lint/src/lib.rs b/compiler/rustc_lint/src/lib.rs
index 1786f1e7034..79f850a781b 100644
--- a/compiler/rustc_lint/src/lib.rs
+++ b/compiler/rustc_lint/src/lib.rs
@@ -170,6 +170,7 @@ macro_rules! late_lint_passes {
                 TemporaryCStringAsPtr: TemporaryCStringAsPtr,
                 NonPanicFmt: NonPanicFmt,
                 NoopMethodCall: NoopMethodCall,
+                InvalidAtomicOrdering: InvalidAtomicOrdering,
             ]
         );
     };
diff --git a/compiler/rustc_lint/src/types.rs b/compiler/rustc_lint/src/types.rs
index a3a87a48768..c9e4fffa50d 100644
--- a/compiler/rustc_lint/src/types.rs
+++ b/compiler/rustc_lint/src/types.rs
@@ -4,17 +4,19 @@ use rustc_attr as attr;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
-use rustc_hir::{is_range_literal, ExprKind, Node};
+use rustc_hir::def_id::DefId;
+use rustc_hir::{is_range_literal, Expr, ExprKind, Node};
 use rustc_middle::ty::layout::{IntegerExt, SizeSkeleton};
 use rustc_middle::ty::subst::SubstsRef;
-use rustc_middle::ty::{self, AdtKind, Ty, TyCtxt, TypeFoldable};
+use rustc_middle::ty::{self, AdtKind, DefIdTree, Ty, TyCtxt, TypeFoldable};
 use rustc_span::source_map;
 use rustc_span::symbol::sym;
-use rustc_span::{Span, DUMMY_SP};
+use rustc_span::{Span, Symbol, DUMMY_SP};
 use rustc_target::abi::Abi;
 use rustc_target::abi::{Integer, LayoutOf, TagEncoding, Variants};
 use rustc_target::spec::abi::Abi as SpecAbi;
 
+use if_chain::if_chain;
 use std::cmp;
 use std::iter;
 use std::ops::ControlFlow;
@@ -1379,3 +1381,234 @@ impl<'tcx> LateLintPass<'tcx> for VariantSizeDifferences {
         }
     }
 }
+
+declare_lint! {
+    /// The `invalid_atomic_ordering` lint detects passing an `Ordering`
+    /// to an atomic operation that does not support that ordering.
+    ///
+    /// ### Example
+    ///
+    /// ```rust,compile_fail
+    /// # use core::sync::atomic::{AtomicU8, Ordering};
+    /// let atom = AtomicU8::new(0);
+    /// let value = atom.load(Ordering::Release);
+    /// # let _ = value;
+    /// ```
+    ///
+    /// {{produces}}
+    ///
+    /// ### Explanation
+    ///
+    /// Some atomic operations are only supported for a subset of the
+    /// `atomic::Ordering` variants. Passing an unsupported variant will cause
+    /// an unconditional panic at runtime, which is detected by this lint.
+    ///
+    /// This lint will trigger in the following cases: (where `AtomicType` is an
+    /// atomic type from `core::sync::atomic`, such as `AtomicBool`,
+    /// `AtomicPtr`, `AtomicUsize`, or any of the other integer atomics).
+    ///
+    /// - Passing `Ordering::Acquire` or `Ordering::AcqRel` to
+    ///   `AtomicType::store`.
+    ///
+    /// - Passing `Ordering::Release` or `Ordering::AcqRel` to
+    ///   `AtomicType::load`.
+    ///
+    /// - Passing `Ordering::Relaxed` to `core::sync::atomic::fence` or
+    ///   `core::sync::atomic::compiler_fence`.
+    ///
+    /// - Passing `Ordering::Release` or `Ordering::AcqRel` as the failure
+    ///   ordering for any of `AtomicType::compare_exchange`,
+    ///   `AtomicType::compare_exchange_weak`, or `AtomicType::fetch_update`.
+    ///
+    /// - Passing in a pair of orderings to `AtomicType::compare_exchange`,
+    ///   `AtomicType::compare_exchange_weak`, or `AtomicType::fetch_update`
+    ///   where the failure ordering is stronger than the success ordering.
+    INVALID_ATOMIC_ORDERING,
+    Deny,
+    "usage of invalid atomic ordering in atomic operations and memory fences"
+}
+
+declare_lint_pass!(InvalidAtomicOrdering => [INVALID_ATOMIC_ORDERING]);
+
+impl InvalidAtomicOrdering {
+    fn inherent_atomic_method_call<'hir>(
+        cx: &LateContext<'_>,
+        expr: &Expr<'hir>,
+    ) -> Option<(Symbol, &'hir [Expr<'hir>])> {
+        const ATOMIC_TYPES: &[Symbol] = &[
+            sym::AtomicBool,
+            sym::AtomicPtr,
+            sym::AtomicUsize,
+            sym::AtomicU8,
+            sym::AtomicU16,
+            sym::AtomicU32,
+            sym::AtomicU64,
+            sym::AtomicU128,
+            sym::AtomicIsize,
+            sym::AtomicI8,
+            sym::AtomicI16,
+            sym::AtomicI32,
+            sym::AtomicI64,
+            sym::AtomicI128,
+        ];
+        if_chain! {
+            if let ExprKind::MethodCall(ref method_path, _, args, _) = &expr.kind;
+            if let Some(m_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
+            if let Some(impl_did) = cx.tcx.impl_of_method(m_def_id);
+            if let Some(adt) = cx.tcx.type_of(impl_did).ty_adt_def();
+            // skip extension traits, only lint functions from the standard library
+            if cx.tcx.trait_id_of_impl(impl_did).is_none();
+
+            if let Some(parent) = cx.tcx.parent(adt.did);
+            if cx.tcx.is_diagnostic_item(sym::atomic_mod, parent);
+            if ATOMIC_TYPES.contains(&cx.tcx.item_name(adt.did));
+            then {
+                return Some((method_path.ident.name, args));
+            }
+        }
+        None
+    }
+
+    fn matches_ordering(cx: &LateContext<'_>, did: DefId, orderings: &[Symbol]) -> bool {
+        let tcx = cx.tcx;
+        let atomic_ordering = tcx.get_diagnostic_item(sym::Ordering);
+        orderings.iter().any(|ordering| {
+            tcx.item_name(did) == *ordering && {
+                let parent = tcx.parent(did);
+                parent == atomic_ordering
+                    // needed in case this is a ctor, not a variant
+                    || parent.map_or(false, |parent| tcx.parent(parent) == atomic_ordering)
+            }
+        })
+    }
+
+    fn opt_ordering_defid(cx: &LateContext<'_>, ord_arg: &Expr<'_>) -> Option<DefId> {
+        if let ExprKind::Path(ref ord_qpath) = ord_arg.kind {
+            cx.qpath_res(ord_qpath, ord_arg.hir_id).opt_def_id()
+        } else {
+            None
+        }
+    }
+
+    fn check_atomic_load_store(cx: &LateContext<'_>, expr: &Expr<'_>) {
+        use rustc_hir::def::{DefKind, Res};
+        use rustc_hir::QPath;
+        if_chain! {
+            if let Some((method, args)) = Self::inherent_atomic_method_call(cx, expr);
+            if let Some((ordering_arg, invalid_ordering)) = match method {
+                sym::load => Some((&args[1], sym::Release)),
+                sym::store => Some((&args[2], sym::Acquire)),
+                _ => None,
+            };
+
+            if let ExprKind::Path(QPath::Resolved(_, path)) = ordering_arg.kind;
+            if let Res::Def(DefKind::Ctor(..), ctor_id) = path.res;
+            if Self::matches_ordering(cx, ctor_id, &[invalid_ordering, sym::AcqRel]);
+            then {
+                cx.struct_span_lint(INVALID_ATOMIC_ORDERING, ordering_arg.span, |diag| {
+                    if method == sym::load {
+                        diag.build("atomic loads cannot have `Release` or `AcqRel` ordering")
+                            .help("consider using ordering modes `Acquire`, `SeqCst` or `Relaxed`")
+                            .emit()
+                    } else {
+                        debug_assert_eq!(method, sym::store);
+                        diag.build("atomic stores cannot have `Acquire` or `AcqRel` ordering")
+                            .help("consider using ordering modes `Release`, `SeqCst` or `Relaxed`")
+                            .emit();
+                    }
+                });
+            }
+        }
+    }
+
+    fn check_memory_fence(cx: &LateContext<'_>, expr: &Expr<'_>) {
+        if_chain! {
+            if let ExprKind::Call(ref func, ref args) = expr.kind;
+            if let ExprKind::Path(ref func_qpath) = func.kind;
+            if let Some(def_id) = cx.qpath_res(func_qpath, func.hir_id).opt_def_id();
+            if cx.tcx.is_diagnostic_item(sym::fence, def_id) ||
+                cx.tcx.is_diagnostic_item(sym::compiler_fence, def_id);
+            if let ExprKind::Path(ref ordering_qpath) = &args[0].kind;
+            if let Some(ordering_def_id) = cx.qpath_res(ordering_qpath, args[0].hir_id).opt_def_id();
+            if Self::matches_ordering(cx, ordering_def_id, &[sym::Relaxed]);
+            then {
+                cx.struct_span_lint(INVALID_ATOMIC_ORDERING, args[0].span, |diag| {
+                    diag.build("memory fences cannot have `Relaxed` ordering")
+                        .help("consider using ordering modes `Acquire`, `Release`, `AcqRel` or `SeqCst`")
+                        .emit();
+                });
+            }
+        }
+    }
+
+    fn check_atomic_compare_exchange(cx: &LateContext<'_>, expr: &Expr<'_>) {
+        if_chain! {
+            if let Some((method, args)) = Self::inherent_atomic_method_call(cx, expr);
+            if let Some((success_order_arg, failure_order_arg)) = match method {
+                sym::fetch_update => Some((&args[1], &args[2])),
+                sym::compare_exchange | sym::compare_exchange_weak => Some((&args[3], &args[4])),
+                _ => None,
+            };
+
+            if let Some(fail_ordering_def_id) = Self::opt_ordering_defid(cx, failure_order_arg);
+            then {
+                // Helper type holding on to some checking and error reporting data. Has
+                // - (success ordering,
+                // - list of failure orderings forbidden by the success order,
+                // - suggestion message)
+                type OrdLintInfo = (Symbol, &'static [Symbol], &'static str);
+                const RELAXED: OrdLintInfo = (sym::Relaxed, &[sym::SeqCst, sym::Acquire], "ordering mode `Relaxed`");
+                const ACQUIRE: OrdLintInfo = (sym::Acquire, &[sym::SeqCst], "ordering modes `Acquire` or `Relaxed`");
+                const SEQ_CST: OrdLintInfo = (sym::SeqCst, &[], "ordering modes `Acquire`, `SeqCst` or `Relaxed`");
+                const RELEASE: OrdLintInfo = (sym::Release, RELAXED.1, RELAXED.2);
+                const ACQREL: OrdLintInfo = (sym::AcqRel, ACQUIRE.1, ACQUIRE.2);
+                const SEARCH: [OrdLintInfo; 5] = [RELAXED, ACQUIRE, SEQ_CST, RELEASE, ACQREL];
+
+                let success_lint_info = Self::opt_ordering_defid(cx, success_order_arg)
+                    .and_then(|success_ord_def_id| -> Option<OrdLintInfo> {
+                        SEARCH
+                            .iter()
+                            .copied()
+                            .find(|(ordering, ..)| {
+                                Self::matches_ordering(cx, success_ord_def_id, &[*ordering])
+                            })
+                    });
+                if Self::matches_ordering(cx, fail_ordering_def_id, &[sym::Release, sym::AcqRel]) {
+                    // If we don't know the success order is, use what we'd suggest
+                    // if it were maximally permissive.
+                    let suggested = success_lint_info.unwrap_or(SEQ_CST).2;
+                    cx.struct_span_lint(INVALID_ATOMIC_ORDERING, failure_order_arg.span, |diag| {
+                        let msg = format!(
+                            "{}'s failure ordering may not be `Release` or `AcqRel`",
+                            method,
+                        );
+                        diag.build(&msg)
+                            .help(&format!("consider using {} instead", suggested))
+                            .emit();
+                    });
+                } else if let Some((success_ord, bad_ords_given_success, suggested)) = success_lint_info {
+                    if Self::matches_ordering(cx, fail_ordering_def_id, bad_ords_given_success) {
+                        cx.struct_span_lint(INVALID_ATOMIC_ORDERING, failure_order_arg.span, |diag| {
+                            let msg = format!(
+                                "{}'s failure ordering may not be stronger than the success ordering of `{}`",
+                                method,
+                                success_ord,
+                            );
+                            diag.build(&msg)
+                                .help(&format!("consider using {} instead", suggested))
+                                .emit();
+                        });
+                    }
+                }
+            }
+        }
+    }
+}
+
+impl<'tcx> LateLintPass<'tcx> for InvalidAtomicOrdering {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        Self::check_atomic_load_store(cx, expr);
+        Self::check_memory_fence(cx, expr);
+        Self::check_atomic_compare_exchange(cx, expr);
+    }
+}
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 1ac489f600a..3e458778a7f 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -121,6 +121,8 @@ symbols! {
     // There is currently no checking that all symbols are used; that would be
     // nice to have.
     Symbols {
+        AcqRel,
+        Acquire,
         Alignment,
         Any,
         Arc,
@@ -129,6 +131,20 @@ symbols! {
         Arguments,
         AsMut,
         AsRef,
+        AtomicBool,
+        AtomicI128,
+        AtomicI16,
+        AtomicI32,
+        AtomicI64,
+        AtomicI8,
+        AtomicIsize,
+        AtomicPtr,
+        AtomicU128,
+        AtomicU16,
+        AtomicU32,
+        AtomicU64,
+        AtomicU8,
+        AtomicUsize,
         BTreeEntry,
         BTreeMap,
         BTreeSet,
@@ -215,12 +231,15 @@ symbols! {
         Rc,
         Ready,
         Receiver,
+        Relaxed,
+        Release,
         Result,
         Return,
         Right,
         RustcDecodable,
         RustcEncodable,
         Send,
+        SeqCst,
         Some,
         StructuralEq,
         StructuralPartialEq,
@@ -311,6 +330,8 @@ symbols! {
         assume_init,
         async_await,
         async_closure,
+        atomic,
+        atomic_mod,
         atomics,
         att_syntax,
         attr,
@@ -390,8 +411,12 @@ symbols! {
         coerce_unsized,
         cold,
         column,
+        compare_and_swap,
+        compare_exchange,
+        compare_exchange_weak,
         compile_error,
         compiler_builtins,
+        compiler_fence,
         concat,
         concat_idents,
         conservative_impl_trait,
@@ -575,6 +600,8 @@ symbols! {
         fadd_fast,
         fdiv_fast,
         feature,
+        fence,
+        fetch_update,
         ffi,
         ffi_const,
         ffi_pure,
@@ -728,6 +755,7 @@ symbols! {
         lint_reasons,
         literal,
         llvm_asm,
+        load,
         local,
         local_inner_macros,
         log10f32,
@@ -1217,6 +1245,7 @@ symbols! {
         stmt,
         stmt_expr_attributes,
         stop_after_dataflow,
+        store,
         str,
         str_alloc,
         string_type,
diff --git a/library/core/src/sync/atomic.rs b/library/core/src/sync/atomic.rs
index 0194c58d339..d908b6ecda3 100644
--- a/library/core/src/sync/atomic.rs
+++ b/library/core/src/sync/atomic.rs
@@ -113,6 +113,7 @@
 #![stable(feature = "rust1", since = "1.0.0")]
 #![cfg_attr(not(target_has_atomic_load_store = "8"), allow(dead_code))]
 #![cfg_attr(not(target_has_atomic_load_store = "8"), allow(unused_imports))]
+#![rustc_diagnostic_item = "atomic_mod"]
 
 use self::Ordering::*;
 
@@ -198,6 +199,7 @@ unsafe impl<T> Sync for AtomicPtr<T> {}
 #[stable(feature = "rust1", since = "1.0.0")]
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
 #[non_exhaustive]
+#[rustc_diagnostic_item = "Ordering"]
 pub enum Ordering {
     /// No ordering constraints, only atomic operations.
     ///
@@ -2664,6 +2666,7 @@ unsafe fn atomic_umin<T: Copy>(dst: *mut T, val: T, order: Ordering) -> T {
 /// ```
 #[inline]
 #[stable(feature = "rust1", since = "1.0.0")]
+#[rustc_diagnostic_item = "fence"]
 pub fn fence(order: Ordering) {
     // SAFETY: using an atomic fence is safe.
     unsafe {
@@ -2745,6 +2748,7 @@ pub fn fence(order: Ordering) {
 /// [memory barriers]: https://www.kernel.org/doc/Documentation/memory-barriers.txt
 #[inline]
 #[stable(feature = "compiler_fences", since = "1.21.0")]
+#[rustc_diagnostic_item = "compiler_fence"]
 pub fn compiler_fence(order: Ordering) {
     // SAFETY: using an atomic fence is safe.
     unsafe {
diff --git a/src/tools/clippy/tests/ui/atomic_ordering_bool.rs b/src/test/ui/lint/lint-invalid-atomic-ordering-bool.rs
index cdbde79b19e..15ceb619571 100644
--- a/src/tools/clippy/tests/ui/atomic_ordering_bool.rs
+++ b/src/test/ui/lint/lint-invalid-atomic-ordering-bool.rs
@@ -1,5 +1,4 @@
-#![warn(clippy::invalid_atomic_ordering)]
-
+// only-x86_64
 use std::sync::atomic::{AtomicBool, Ordering};
 
 fn main() {
@@ -12,7 +11,9 @@ fn main() {
 
     // Disallowed load ordering modes
     let _ = x.load(Ordering::Release);
+    //~^ ERROR atomic loads cannot have `Release` or `AcqRel` ordering
     let _ = x.load(Ordering::AcqRel);
+    //~^ ERROR atomic loads cannot have `Release` or `AcqRel` ordering
 
     // Allowed store ordering modes
     x.store(false, Ordering::Release);
@@ -21,5 +22,7 @@ fn main() {
 
     // Disallowed store ordering modes
     x.store(false, Ordering::Acquire);
+    //~^ ERROR atomic stores cannot have `Acquire` or `AcqRel` ordering
     x.store(false, Ordering::AcqRel);
+    //~^ ERROR atomic stores cannot have `Acquire` or `AcqRel` ordering
 }
diff --git a/src/tools/clippy/tests/ui/atomic_ordering_bool.stderr b/src/test/ui/lint/lint-invalid-atomic-ordering-bool.stderr
index 397b893aed9..2a1847b9801 100644
--- a/src/tools/clippy/tests/ui/atomic_ordering_bool.stderr
+++ b/src/test/ui/lint/lint-invalid-atomic-ordering-bool.stderr
@@ -1,30 +1,30 @@
-error: atomic loads cannot have `Release` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_bool.rs:14:20
+error: atomic loads cannot have `Release` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-bool.rs:13:20
    |
 LL |     let _ = x.load(Ordering::Release);
    |                    ^^^^^^^^^^^^^^^^^
    |
-   = note: `-D clippy::invalid-atomic-ordering` implied by `-D warnings`
+   = note: `#[deny(invalid_atomic_ordering)]` on by default
    = help: consider using ordering modes `Acquire`, `SeqCst` or `Relaxed`
 
-error: atomic loads cannot have `Release` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_bool.rs:15:20
+error: atomic loads cannot have `Release` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-bool.rs:15:20
    |
 LL |     let _ = x.load(Ordering::AcqRel);
    |                    ^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Acquire`, `SeqCst` or `Relaxed`
 
-error: atomic stores cannot have `Acquire` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_bool.rs:23:20
+error: atomic stores cannot have `Acquire` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-bool.rs:24:20
    |
 LL |     x.store(false, Ordering::Acquire);
    |                    ^^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Release`, `SeqCst` or `Relaxed`
 
-error: atomic stores cannot have `Acquire` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_bool.rs:24:20
+error: atomic stores cannot have `Acquire` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-bool.rs:26:20
    |
 LL |     x.store(false, Ordering::AcqRel);
    |                    ^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/atomic_ordering_exchange_weak.rs b/src/test/ui/lint/lint-invalid-atomic-ordering-exchange-weak.rs
index 59069902507..c79c1daf774 100644
--- a/src/tools/clippy/tests/ui/atomic_ordering_exchange_weak.rs
+++ b/src/test/ui/lint/lint-invalid-atomic-ordering-exchange-weak.rs
@@ -1,5 +1,4 @@
-#![warn(clippy::invalid_atomic_ordering)]
-
+// only-x86_64
 use std::sync::atomic::{AtomicPtr, Ordering};
 
 fn main() {
@@ -21,27 +20,43 @@ fn main() {
 
     // AcqRel is always forbidden as a failure ordering
     let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::Relaxed, Ordering::AcqRel);
+    //~^ ERROR compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`
     let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::Acquire, Ordering::AcqRel);
+    //~^ ERROR compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`
     let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::Release, Ordering::AcqRel);
+    //~^ ERROR compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`
     let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::AcqRel, Ordering::AcqRel);
+    //~^ ERROR compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`
     let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::SeqCst, Ordering::AcqRel);
+    //~^ ERROR compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`
 
     // Release is always forbidden as a failure ordering
     let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::Relaxed, Ordering::Release);
+    //~^ ERROR compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`
     let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::Acquire, Ordering::Release);
+    //~^ ERROR compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`
     let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::Release, Ordering::Release);
+    //~^ ERROR compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`
     let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::AcqRel, Ordering::Release);
+    //~^ ERROR compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`
     let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::SeqCst, Ordering::Release);
+    //~^ ERROR compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`
 
     // Release success order forbids failure order of Acquire or SeqCst
     let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::Release, Ordering::Acquire);
+    //~^ ERROR compare_exchange_weak's failure ordering may not be stronger
     let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::Release, Ordering::SeqCst);
+    //~^ ERROR compare_exchange_weak's failure ordering may not be stronger
 
     // Relaxed success order also forbids failure order of Acquire or SeqCst
     let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::Relaxed, Ordering::SeqCst);
+    //~^ ERROR compare_exchange_weak's failure ordering may not be stronger
     let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::Relaxed, Ordering::Acquire);
+    //~^ ERROR compare_exchange_weak's failure ordering may not be stronger
 
     // Acquire/AcqRel forbids failure order of SeqCst
     let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::Acquire, Ordering::SeqCst);
+    //~^ ERROR compare_exchange_weak's failure ordering may not be stronger
     let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::AcqRel, Ordering::SeqCst);
+    //~^ ERROR compare_exchange_weak's failure ordering may not be stronger
 }
diff --git a/src/tools/clippy/tests/ui/atomic_ordering_exchange_weak.stderr b/src/test/ui/lint/lint-invalid-atomic-ordering-exchange-weak.stderr
index de7026f3ffa..13350ab0b9c 100644
--- a/src/tools/clippy/tests/ui/atomic_ordering_exchange_weak.stderr
+++ b/src/test/ui/lint/lint-invalid-atomic-ordering-exchange-weak.stderr
@@ -1,14 +1,14 @@
 error: compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`
-  --> $DIR/atomic_ordering_exchange_weak.rs:23:67
+  --> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:22:67
    |
 LL |     let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::Relaxed, Ordering::AcqRel);
    |                                                                   ^^^^^^^^^^^^^^^^
    |
-   = note: `-D clippy::invalid-atomic-ordering` implied by `-D warnings`
+   = note: `#[deny(invalid_atomic_ordering)]` on by default
    = help: consider using ordering mode `Relaxed` instead
 
 error: compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`
-  --> $DIR/atomic_ordering_exchange_weak.rs:24:67
+  --> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:24:67
    |
 LL |     let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::Acquire, Ordering::AcqRel);
    |                                                                   ^^^^^^^^^^^^^^^^
@@ -16,7 +16,7 @@ LL |     let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::Acquire, Ordering:
    = help: consider using ordering modes `Acquire` or `Relaxed` instead
 
 error: compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`
-  --> $DIR/atomic_ordering_exchange_weak.rs:25:67
+  --> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:26:67
    |
 LL |     let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::Release, Ordering::AcqRel);
    |                                                                   ^^^^^^^^^^^^^^^^
@@ -24,7 +24,7 @@ LL |     let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::Release, Ordering:
    = help: consider using ordering mode `Relaxed` instead
 
 error: compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`
-  --> $DIR/atomic_ordering_exchange_weak.rs:26:66
+  --> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:28:66
    |
 LL |     let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::AcqRel, Ordering::AcqRel);
    |                                                                  ^^^^^^^^^^^^^^^^
@@ -32,7 +32,7 @@ LL |     let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::AcqRel, Ordering::
    = help: consider using ordering modes `Acquire` or `Relaxed` instead
 
 error: compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`
-  --> $DIR/atomic_ordering_exchange_weak.rs:27:66
+  --> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:30:66
    |
 LL |     let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::SeqCst, Ordering::AcqRel);
    |                                                                  ^^^^^^^^^^^^^^^^
@@ -40,7 +40,7 @@ LL |     let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::SeqCst, Ordering::
    = help: consider using ordering modes `Acquire`, `SeqCst` or `Relaxed` instead
 
 error: compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`
-  --> $DIR/atomic_ordering_exchange_weak.rs:30:67
+  --> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:34:67
    |
 LL |     let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::Relaxed, Ordering::Release);
    |                                                                   ^^^^^^^^^^^^^^^^^
@@ -48,7 +48,7 @@ LL |     let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::Relaxed, Ordering:
    = help: consider using ordering mode `Relaxed` instead
 
 error: compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`
-  --> $DIR/atomic_ordering_exchange_weak.rs:31:67
+  --> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:36:67
    |
 LL |     let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::Acquire, Ordering::Release);
    |                                                                   ^^^^^^^^^^^^^^^^^
@@ -56,7 +56,7 @@ LL |     let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::Acquire, Ordering:
    = help: consider using ordering modes `Acquire` or `Relaxed` instead
 
 error: compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`
-  --> $DIR/atomic_ordering_exchange_weak.rs:32:67
+  --> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:38:67
    |
 LL |     let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::Release, Ordering::Release);
    |                                                                   ^^^^^^^^^^^^^^^^^
@@ -64,7 +64,7 @@ LL |     let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::Release, Ordering:
    = help: consider using ordering mode `Relaxed` instead
 
 error: compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`
-  --> $DIR/atomic_ordering_exchange_weak.rs:33:66
+  --> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:40:66
    |
 LL |     let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::AcqRel, Ordering::Release);
    |                                                                  ^^^^^^^^^^^^^^^^^
@@ -72,7 +72,7 @@ LL |     let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::AcqRel, Ordering::
    = help: consider using ordering modes `Acquire` or `Relaxed` instead
 
 error: compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`
-  --> $DIR/atomic_ordering_exchange_weak.rs:34:66
+  --> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:42:66
    |
 LL |     let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::SeqCst, Ordering::Release);
    |                                                                  ^^^^^^^^^^^^^^^^^
@@ -80,7 +80,7 @@ LL |     let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::SeqCst, Ordering::
    = help: consider using ordering modes `Acquire`, `SeqCst` or `Relaxed` instead
 
 error: compare_exchange_weak's failure ordering may not be stronger than the success ordering of `Release`
-  --> $DIR/atomic_ordering_exchange_weak.rs:37:67
+  --> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:46:67
    |
 LL |     let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::Release, Ordering::Acquire);
    |                                                                   ^^^^^^^^^^^^^^^^^
@@ -88,7 +88,7 @@ LL |     let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::Release, Ordering:
    = help: consider using ordering mode `Relaxed` instead
 
 error: compare_exchange_weak's failure ordering may not be stronger than the success ordering of `Release`
-  --> $DIR/atomic_ordering_exchange_weak.rs:38:67
+  --> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:48:67
    |
 LL |     let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::Release, Ordering::SeqCst);
    |                                                                   ^^^^^^^^^^^^^^^^
@@ -96,7 +96,7 @@ LL |     let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::Release, Ordering:
    = help: consider using ordering mode `Relaxed` instead
 
 error: compare_exchange_weak's failure ordering may not be stronger than the success ordering of `Relaxed`
-  --> $DIR/atomic_ordering_exchange_weak.rs:41:67
+  --> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:52:67
    |
 LL |     let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::Relaxed, Ordering::SeqCst);
    |                                                                   ^^^^^^^^^^^^^^^^
@@ -104,7 +104,7 @@ LL |     let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::Relaxed, Ordering:
    = help: consider using ordering mode `Relaxed` instead
 
 error: compare_exchange_weak's failure ordering may not be stronger than the success ordering of `Relaxed`
-  --> $DIR/atomic_ordering_exchange_weak.rs:42:67
+  --> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:54:67
    |
 LL |     let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::Relaxed, Ordering::Acquire);
    |                                                                   ^^^^^^^^^^^^^^^^^
@@ -112,7 +112,7 @@ LL |     let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::Relaxed, Ordering:
    = help: consider using ordering mode `Relaxed` instead
 
 error: compare_exchange_weak's failure ordering may not be stronger than the success ordering of `Acquire`
-  --> $DIR/atomic_ordering_exchange_weak.rs:45:67
+  --> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:58:67
    |
 LL |     let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::Acquire, Ordering::SeqCst);
    |                                                                   ^^^^^^^^^^^^^^^^
@@ -120,7 +120,7 @@ LL |     let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::Acquire, Ordering:
    = help: consider using ordering modes `Acquire` or `Relaxed` instead
 
 error: compare_exchange_weak's failure ordering may not be stronger than the success ordering of `AcqRel`
-  --> $DIR/atomic_ordering_exchange_weak.rs:46:66
+  --> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:60:66
    |
 LL |     let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::AcqRel, Ordering::SeqCst);
    |                                                                  ^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/atomic_ordering_exchange.rs b/src/test/ui/lint/lint-invalid-atomic-ordering-exchange.rs
index 1ddc12f9ab2..8ef3a400cf0 100644
--- a/src/tools/clippy/tests/ui/atomic_ordering_exchange.rs
+++ b/src/test/ui/lint/lint-invalid-atomic-ordering-exchange.rs
@@ -1,5 +1,4 @@
-#![warn(clippy::invalid_atomic_ordering)]
-
+// only-x86_64
 use std::sync::atomic::{AtomicUsize, Ordering};
 
 fn main() {
@@ -19,27 +18,43 @@ fn main() {
 
     // AcqRel is always forbidden as a failure ordering
     let _ = x.compare_exchange(0, 0, Ordering::Relaxed, Ordering::AcqRel);
+    //~^ ERROR compare_exchange's failure ordering may not be `Release` or `AcqRel`
     let _ = x.compare_exchange(0, 0, Ordering::Acquire, Ordering::AcqRel);
+    //~^ ERROR compare_exchange's failure ordering may not be `Release` or `AcqRel`
     let _ = x.compare_exchange(0, 0, Ordering::Release, Ordering::AcqRel);
+    //~^ ERROR compare_exchange's failure ordering may not be `Release` or `AcqRel`
     let _ = x.compare_exchange(0, 0, Ordering::AcqRel, Ordering::AcqRel);
+    //~^ ERROR compare_exchange's failure ordering may not be `Release` or `AcqRel`
     let _ = x.compare_exchange(0, 0, Ordering::SeqCst, Ordering::AcqRel);
+    //~^ ERROR compare_exchange's failure ordering may not be `Release` or `AcqRel`
 
     // Release is always forbidden as a failure ordering
     let _ = x.compare_exchange(0, 0, Ordering::Relaxed, Ordering::Release);
+    //~^ ERROR compare_exchange's failure ordering may not be `Release` or `AcqRel`
     let _ = x.compare_exchange(0, 0, Ordering::Acquire, Ordering::Release);
+    //~^ ERROR compare_exchange's failure ordering may not be `Release` or `AcqRel`
     let _ = x.compare_exchange(0, 0, Ordering::Release, Ordering::Release);
+    //~^ ERROR compare_exchange's failure ordering may not be `Release` or `AcqRel`
     let _ = x.compare_exchange(0, 0, Ordering::AcqRel, Ordering::Release);
+    //~^ ERROR compare_exchange's failure ordering may not be `Release` or `AcqRel`
     let _ = x.compare_exchange(0, 0, Ordering::SeqCst, Ordering::Release);
+    //~^ ERROR compare_exchange's failure ordering may not be `Release` or `AcqRel`
 
     // Release success order forbids failure order of Acquire or SeqCst
     let _ = x.compare_exchange(0, 0, Ordering::Release, Ordering::Acquire);
+    //~^ ERROR compare_exchange's failure ordering may not be stronger
     let _ = x.compare_exchange(0, 0, Ordering::Release, Ordering::SeqCst);
+    //~^ ERROR compare_exchange's failure ordering may not be stronger
 
     // Relaxed success order also forbids failure order of Acquire or SeqCst
     let _ = x.compare_exchange(0, 0, Ordering::Relaxed, Ordering::SeqCst);
+    //~^ ERROR compare_exchange's failure ordering may not be stronger
     let _ = x.compare_exchange(0, 0, Ordering::Relaxed, Ordering::Acquire);
+    //~^ ERROR compare_exchange's failure ordering may not be stronger
 
     // Acquire/AcqRel forbids failure order of SeqCst
     let _ = x.compare_exchange(0, 0, Ordering::Acquire, Ordering::SeqCst);
+    //~^ ERROR compare_exchange's failure ordering may not be stronger
     let _ = x.compare_exchange(0, 0, Ordering::AcqRel, Ordering::SeqCst);
+    //~^ ERROR compare_exchange's failure ordering may not be stronger
 }
diff --git a/src/tools/clippy/tests/ui/atomic_ordering_exchange.stderr b/src/test/ui/lint/lint-invalid-atomic-ordering-exchange.stderr
index 4b9bfef7974..daedfec7430 100644
--- a/src/tools/clippy/tests/ui/atomic_ordering_exchange.stderr
+++ b/src/test/ui/lint/lint-invalid-atomic-ordering-exchange.stderr
@@ -1,14 +1,14 @@
 error: compare_exchange's failure ordering may not be `Release` or `AcqRel`
-  --> $DIR/atomic_ordering_exchange.rs:21:57
+  --> $DIR/lint-invalid-atomic-ordering-exchange.rs:20:57
    |
 LL |     let _ = x.compare_exchange(0, 0, Ordering::Relaxed, Ordering::AcqRel);
    |                                                         ^^^^^^^^^^^^^^^^
    |
-   = note: `-D clippy::invalid-atomic-ordering` implied by `-D warnings`
+   = note: `#[deny(invalid_atomic_ordering)]` on by default
    = help: consider using ordering mode `Relaxed` instead
 
 error: compare_exchange's failure ordering may not be `Release` or `AcqRel`
-  --> $DIR/atomic_ordering_exchange.rs:22:57
+  --> $DIR/lint-invalid-atomic-ordering-exchange.rs:22:57
    |
 LL |     let _ = x.compare_exchange(0, 0, Ordering::Acquire, Ordering::AcqRel);
    |                                                         ^^^^^^^^^^^^^^^^
@@ -16,7 +16,7 @@ LL |     let _ = x.compare_exchange(0, 0, Ordering::Acquire, Ordering::AcqRel);
    = help: consider using ordering modes `Acquire` or `Relaxed` instead
 
 error: compare_exchange's failure ordering may not be `Release` or `AcqRel`
-  --> $DIR/atomic_ordering_exchange.rs:23:57
+  --> $DIR/lint-invalid-atomic-ordering-exchange.rs:24:57
    |
 LL |     let _ = x.compare_exchange(0, 0, Ordering::Release, Ordering::AcqRel);
    |                                                         ^^^^^^^^^^^^^^^^
@@ -24,7 +24,7 @@ LL |     let _ = x.compare_exchange(0, 0, Ordering::Release, Ordering::AcqRel);
    = help: consider using ordering mode `Relaxed` instead
 
 error: compare_exchange's failure ordering may not be `Release` or `AcqRel`
-  --> $DIR/atomic_ordering_exchange.rs:24:56
+  --> $DIR/lint-invalid-atomic-ordering-exchange.rs:26:56
    |
 LL |     let _ = x.compare_exchange(0, 0, Ordering::AcqRel, Ordering::AcqRel);
    |                                                        ^^^^^^^^^^^^^^^^
@@ -32,7 +32,7 @@ LL |     let _ = x.compare_exchange(0, 0, Ordering::AcqRel, Ordering::AcqRel);
    = help: consider using ordering modes `Acquire` or `Relaxed` instead
 
 error: compare_exchange's failure ordering may not be `Release` or `AcqRel`
-  --> $DIR/atomic_ordering_exchange.rs:25:56
+  --> $DIR/lint-invalid-atomic-ordering-exchange.rs:28:56
    |
 LL |     let _ = x.compare_exchange(0, 0, Ordering::SeqCst, Ordering::AcqRel);
    |                                                        ^^^^^^^^^^^^^^^^
@@ -40,7 +40,7 @@ LL |     let _ = x.compare_exchange(0, 0, Ordering::SeqCst, Ordering::AcqRel);
    = help: consider using ordering modes `Acquire`, `SeqCst` or `Relaxed` instead
 
 error: compare_exchange's failure ordering may not be `Release` or `AcqRel`
-  --> $DIR/atomic_ordering_exchange.rs:28:57
+  --> $DIR/lint-invalid-atomic-ordering-exchange.rs:32:57
    |
 LL |     let _ = x.compare_exchange(0, 0, Ordering::Relaxed, Ordering::Release);
    |                                                         ^^^^^^^^^^^^^^^^^
@@ -48,7 +48,7 @@ LL |     let _ = x.compare_exchange(0, 0, Ordering::Relaxed, Ordering::Release);
    = help: consider using ordering mode `Relaxed` instead
 
 error: compare_exchange's failure ordering may not be `Release` or `AcqRel`
-  --> $DIR/atomic_ordering_exchange.rs:29:57
+  --> $DIR/lint-invalid-atomic-ordering-exchange.rs:34:57
    |
 LL |     let _ = x.compare_exchange(0, 0, Ordering::Acquire, Ordering::Release);
    |                                                         ^^^^^^^^^^^^^^^^^
@@ -56,7 +56,7 @@ LL |     let _ = x.compare_exchange(0, 0, Ordering::Acquire, Ordering::Release);
    = help: consider using ordering modes `Acquire` or `Relaxed` instead
 
 error: compare_exchange's failure ordering may not be `Release` or `AcqRel`
-  --> $DIR/atomic_ordering_exchange.rs:30:57
+  --> $DIR/lint-invalid-atomic-ordering-exchange.rs:36:57
    |
 LL |     let _ = x.compare_exchange(0, 0, Ordering::Release, Ordering::Release);
    |                                                         ^^^^^^^^^^^^^^^^^
@@ -64,7 +64,7 @@ LL |     let _ = x.compare_exchange(0, 0, Ordering::Release, Ordering::Release);
    = help: consider using ordering mode `Relaxed` instead
 
 error: compare_exchange's failure ordering may not be `Release` or `AcqRel`
-  --> $DIR/atomic_ordering_exchange.rs:31:56
+  --> $DIR/lint-invalid-atomic-ordering-exchange.rs:38:56
    |
 LL |     let _ = x.compare_exchange(0, 0, Ordering::AcqRel, Ordering::Release);
    |                                                        ^^^^^^^^^^^^^^^^^
@@ -72,7 +72,7 @@ LL |     let _ = x.compare_exchange(0, 0, Ordering::AcqRel, Ordering::Release);
    = help: consider using ordering modes `Acquire` or `Relaxed` instead
 
 error: compare_exchange's failure ordering may not be `Release` or `AcqRel`
-  --> $DIR/atomic_ordering_exchange.rs:32:56
+  --> $DIR/lint-invalid-atomic-ordering-exchange.rs:40:56
    |
 LL |     let _ = x.compare_exchange(0, 0, Ordering::SeqCst, Ordering::Release);
    |                                                        ^^^^^^^^^^^^^^^^^
@@ -80,7 +80,7 @@ LL |     let _ = x.compare_exchange(0, 0, Ordering::SeqCst, Ordering::Release);
    = help: consider using ordering modes `Acquire`, `SeqCst` or `Relaxed` instead
 
 error: compare_exchange's failure ordering may not be stronger than the success ordering of `Release`
-  --> $DIR/atomic_ordering_exchange.rs:35:57
+  --> $DIR/lint-invalid-atomic-ordering-exchange.rs:44:57
    |
 LL |     let _ = x.compare_exchange(0, 0, Ordering::Release, Ordering::Acquire);
    |                                                         ^^^^^^^^^^^^^^^^^
@@ -88,7 +88,7 @@ LL |     let _ = x.compare_exchange(0, 0, Ordering::Release, Ordering::Acquire);
    = help: consider using ordering mode `Relaxed` instead
 
 error: compare_exchange's failure ordering may not be stronger than the success ordering of `Release`
-  --> $DIR/atomic_ordering_exchange.rs:36:57
+  --> $DIR/lint-invalid-atomic-ordering-exchange.rs:46:57
    |
 LL |     let _ = x.compare_exchange(0, 0, Ordering::Release, Ordering::SeqCst);
    |                                                         ^^^^^^^^^^^^^^^^
@@ -96,7 +96,7 @@ LL |     let _ = x.compare_exchange(0, 0, Ordering::Release, Ordering::SeqCst);
    = help: consider using ordering mode `Relaxed` instead
 
 error: compare_exchange's failure ordering may not be stronger than the success ordering of `Relaxed`
-  --> $DIR/atomic_ordering_exchange.rs:39:57
+  --> $DIR/lint-invalid-atomic-ordering-exchange.rs:50:57
    |
 LL |     let _ = x.compare_exchange(0, 0, Ordering::Relaxed, Ordering::SeqCst);
    |                                                         ^^^^^^^^^^^^^^^^
@@ -104,7 +104,7 @@ LL |     let _ = x.compare_exchange(0, 0, Ordering::Relaxed, Ordering::SeqCst);
    = help: consider using ordering mode `Relaxed` instead
 
 error: compare_exchange's failure ordering may not be stronger than the success ordering of `Relaxed`
-  --> $DIR/atomic_ordering_exchange.rs:40:57
+  --> $DIR/lint-invalid-atomic-ordering-exchange.rs:52:57
    |
 LL |     let _ = x.compare_exchange(0, 0, Ordering::Relaxed, Ordering::Acquire);
    |                                                         ^^^^^^^^^^^^^^^^^
@@ -112,7 +112,7 @@ LL |     let _ = x.compare_exchange(0, 0, Ordering::Relaxed, Ordering::Acquire);
    = help: consider using ordering mode `Relaxed` instead
 
 error: compare_exchange's failure ordering may not be stronger than the success ordering of `Acquire`
-  --> $DIR/atomic_ordering_exchange.rs:43:57
+  --> $DIR/lint-invalid-atomic-ordering-exchange.rs:56:57
    |
 LL |     let _ = x.compare_exchange(0, 0, Ordering::Acquire, Ordering::SeqCst);
    |                                                         ^^^^^^^^^^^^^^^^
@@ -120,7 +120,7 @@ LL |     let _ = x.compare_exchange(0, 0, Ordering::Acquire, Ordering::SeqCst);
    = help: consider using ordering modes `Acquire` or `Relaxed` instead
 
 error: compare_exchange's failure ordering may not be stronger than the success ordering of `AcqRel`
-  --> $DIR/atomic_ordering_exchange.rs:44:56
+  --> $DIR/lint-invalid-atomic-ordering-exchange.rs:58:56
    |
 LL |     let _ = x.compare_exchange(0, 0, Ordering::AcqRel, Ordering::SeqCst);
    |                                                        ^^^^^^^^^^^^^^^^
diff --git a/src/test/ui/lint/lint-invalid-atomic-ordering-false-positive.rs b/src/test/ui/lint/lint-invalid-atomic-ordering-false-positive.rs
new file mode 100644
index 00000000000..4fb8605b452
--- /dev/null
+++ b/src/test/ui/lint/lint-invalid-atomic-ordering-false-positive.rs
@@ -0,0 +1,18 @@
+// only-x86_64
+// check-pass
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+trait Foo {
+    fn store(self, ordering: Ordering);
+}
+
+impl Foo for AtomicUsize {
+    fn store(self, _ordering: Ordering) {
+        AtomicUsize::store(&self, 4, Ordering::SeqCst);
+    }
+}
+
+fn main() {
+    let x = AtomicUsize::new(3);
+    x.store(Ordering::Acquire);
+}
diff --git a/src/tools/clippy/tests/ui/atomic_ordering_fence.rs b/src/test/ui/lint/lint-invalid-atomic-ordering-fence.rs
index 5ee5182ca05..22034472c71 100644
--- a/src/tools/clippy/tests/ui/atomic_ordering_fence.rs
+++ b/src/test/ui/lint/lint-invalid-atomic-ordering-fence.rs
@@ -1,20 +1,21 @@
-#![warn(clippy::invalid_atomic_ordering)]
-
+// only-x86_64
 use std::sync::atomic::{compiler_fence, fence, Ordering};
 
 fn main() {
-    // Allowed fence ordering modes
+    // Allowed ordering modes
     fence(Ordering::Acquire);
     fence(Ordering::Release);
     fence(Ordering::AcqRel);
     fence(Ordering::SeqCst);
 
-    // Disallowed fence ordering modes
-    fence(Ordering::Relaxed);
-
     compiler_fence(Ordering::Acquire);
     compiler_fence(Ordering::Release);
     compiler_fence(Ordering::AcqRel);
     compiler_fence(Ordering::SeqCst);
+
+    // Disallowed ordering modes
+    fence(Ordering::Relaxed);
+    //~^ ERROR memory fences cannot have `Relaxed` ordering
     compiler_fence(Ordering::Relaxed);
+    //~^ ERROR memory fences cannot have `Relaxed` ordering
 }
diff --git a/src/tools/clippy/tests/ui/atomic_ordering_fence.stderr b/src/test/ui/lint/lint-invalid-atomic-ordering-fence.stderr
index 3ceff27d9ad..e0741ffedd9 100644
--- a/src/tools/clippy/tests/ui/atomic_ordering_fence.stderr
+++ b/src/test/ui/lint/lint-invalid-atomic-ordering-fence.stderr
@@ -1,14 +1,14 @@
 error: memory fences cannot have `Relaxed` ordering
-  --> $DIR/atomic_ordering_fence.rs:13:11
+  --> $DIR/lint-invalid-atomic-ordering-fence.rs:17:11
    |
 LL |     fence(Ordering::Relaxed);
    |           ^^^^^^^^^^^^^^^^^
    |
-   = note: `-D clippy::invalid-atomic-ordering` implied by `-D warnings`
+   = note: `#[deny(invalid_atomic_ordering)]` on by default
    = help: consider using ordering modes `Acquire`, `Release`, `AcqRel` or `SeqCst`
 
 error: memory fences cannot have `Relaxed` ordering
-  --> $DIR/atomic_ordering_fence.rs:19:20
+  --> $DIR/lint-invalid-atomic-ordering-fence.rs:19:20
    |
 LL |     compiler_fence(Ordering::Relaxed);
    |                    ^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/atomic_ordering_fetch_update.rs b/src/test/ui/lint/lint-invalid-atomic-ordering-fetch-update.rs
index 550bdb001e4..938ca0359f8 100644
--- a/src/tools/clippy/tests/ui/atomic_ordering_fetch_update.rs
+++ b/src/test/ui/lint/lint-invalid-atomic-ordering-fetch-update.rs
@@ -1,5 +1,4 @@
-#![warn(clippy::invalid_atomic_ordering)]
-
+// only-x86_64
 use std::sync::atomic::{AtomicIsize, Ordering};
 
 fn main() {
@@ -19,27 +18,43 @@ fn main() {
 
     // AcqRel is always forbidden as a failure ordering
     let _ = x.fetch_update(Ordering::Relaxed, Ordering::AcqRel, |old| Some(old + 1));
+    //~^ ERROR fetch_update's failure ordering may not be `Release` or `AcqRel`
     let _ = x.fetch_update(Ordering::Acquire, Ordering::AcqRel, |old| Some(old + 1));
+    //~^ ERROR fetch_update's failure ordering may not be `Release` or `AcqRel`
     let _ = x.fetch_update(Ordering::Release, Ordering::AcqRel, |old| Some(old + 1));
+    //~^ ERROR fetch_update's failure ordering may not be `Release` or `AcqRel`
     let _ = x.fetch_update(Ordering::AcqRel, Ordering::AcqRel, |old| Some(old + 1));
+    //~^ ERROR fetch_update's failure ordering may not be `Release` or `AcqRel`
     let _ = x.fetch_update(Ordering::SeqCst, Ordering::AcqRel, |old| Some(old + 1));
+    //~^ ERROR fetch_update's failure ordering may not be `Release` or `AcqRel`
 
     // Release is always forbidden as a failure ordering
     let _ = x.fetch_update(Ordering::Relaxed, Ordering::Release, |old| Some(old + 1));
+    //~^ ERROR fetch_update's failure ordering may not be `Release` or `AcqRel`
     let _ = x.fetch_update(Ordering::Acquire, Ordering::Release, |old| Some(old + 1));
+    //~^ ERROR fetch_update's failure ordering may not be `Release` or `AcqRel`
     let _ = x.fetch_update(Ordering::Release, Ordering::Release, |old| Some(old + 1));
+    //~^ ERROR fetch_update's failure ordering may not be `Release` or `AcqRel`
     let _ = x.fetch_update(Ordering::AcqRel, Ordering::Release, |old| Some(old + 1));
+    //~^ ERROR fetch_update's failure ordering may not be `Release` or `AcqRel`
     let _ = x.fetch_update(Ordering::SeqCst, Ordering::Release, |old| Some(old + 1));
+    //~^ ERROR fetch_update's failure ordering may not be `Release` or `AcqRel`
 
     // Release success order forbids failure order of Acquire or SeqCst
     let _ = x.fetch_update(Ordering::Release, Ordering::Acquire, |old| Some(old + 1));
+    //~^ ERROR fetch_update's failure ordering may not be stronger
     let _ = x.fetch_update(Ordering::Release, Ordering::SeqCst, |old| Some(old + 1));
+    //~^ ERROR fetch_update's failure ordering may not be stronger
 
     // Relaxed success order also forbids failure order of Acquire or SeqCst
     let _ = x.fetch_update(Ordering::Relaxed, Ordering::SeqCst, |old| Some(old + 1));
+    //~^ ERROR fetch_update's failure ordering may not be stronger
     let _ = x.fetch_update(Ordering::Relaxed, Ordering::Acquire, |old| Some(old + 1));
+    //~^ ERROR fetch_update's failure ordering may not be stronger
 
     // Acquire/AcqRel forbids failure order of SeqCst
     let _ = x.fetch_update(Ordering::Acquire, Ordering::SeqCst, |old| Some(old + 1));
+    //~^ ERROR fetch_update's failure ordering may not be stronger
     let _ = x.fetch_update(Ordering::AcqRel, Ordering::SeqCst, |old| Some(old + 1));
+    //~^ ERROR fetch_update's failure ordering may not be stronger
 }
diff --git a/src/tools/clippy/tests/ui/atomic_ordering_fetch_update.stderr b/src/test/ui/lint/lint-invalid-atomic-ordering-fetch-update.stderr
index 694548ece97..dabc1da7e55 100644
--- a/src/tools/clippy/tests/ui/atomic_ordering_fetch_update.stderr
+++ b/src/test/ui/lint/lint-invalid-atomic-ordering-fetch-update.stderr
@@ -1,14 +1,14 @@
 error: fetch_update's failure ordering may not be `Release` or `AcqRel`
-  --> $DIR/atomic_ordering_fetch_update.rs:21:47
+  --> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:20:47
    |
 LL |     let _ = x.fetch_update(Ordering::Relaxed, Ordering::AcqRel, |old| Some(old + 1));
    |                                               ^^^^^^^^^^^^^^^^
    |
-   = note: `-D clippy::invalid-atomic-ordering` implied by `-D warnings`
+   = note: `#[deny(invalid_atomic_ordering)]` on by default
    = help: consider using ordering mode `Relaxed` instead
 
 error: fetch_update's failure ordering may not be `Release` or `AcqRel`
-  --> $DIR/atomic_ordering_fetch_update.rs:22:47
+  --> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:22:47
    |
 LL |     let _ = x.fetch_update(Ordering::Acquire, Ordering::AcqRel, |old| Some(old + 1));
    |                                               ^^^^^^^^^^^^^^^^
@@ -16,7 +16,7 @@ LL |     let _ = x.fetch_update(Ordering::Acquire, Ordering::AcqRel, |old| Some(
    = help: consider using ordering modes `Acquire` or `Relaxed` instead
 
 error: fetch_update's failure ordering may not be `Release` or `AcqRel`
-  --> $DIR/atomic_ordering_fetch_update.rs:23:47
+  --> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:24:47
    |
 LL |     let _ = x.fetch_update(Ordering::Release, Ordering::AcqRel, |old| Some(old + 1));
    |                                               ^^^^^^^^^^^^^^^^
@@ -24,7 +24,7 @@ LL |     let _ = x.fetch_update(Ordering::Release, Ordering::AcqRel, |old| Some(
    = help: consider using ordering mode `Relaxed` instead
 
 error: fetch_update's failure ordering may not be `Release` or `AcqRel`
-  --> $DIR/atomic_ordering_fetch_update.rs:24:46
+  --> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:26:46
    |
 LL |     let _ = x.fetch_update(Ordering::AcqRel, Ordering::AcqRel, |old| Some(old + 1));
    |                                              ^^^^^^^^^^^^^^^^
@@ -32,7 +32,7 @@ LL |     let _ = x.fetch_update(Ordering::AcqRel, Ordering::AcqRel, |old| Some(o
    = help: consider using ordering modes `Acquire` or `Relaxed` instead
 
 error: fetch_update's failure ordering may not be `Release` or `AcqRel`
-  --> $DIR/atomic_ordering_fetch_update.rs:25:46
+  --> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:28:46
    |
 LL |     let _ = x.fetch_update(Ordering::SeqCst, Ordering::AcqRel, |old| Some(old + 1));
    |                                              ^^^^^^^^^^^^^^^^
@@ -40,7 +40,7 @@ LL |     let _ = x.fetch_update(Ordering::SeqCst, Ordering::AcqRel, |old| Some(o
    = help: consider using ordering modes `Acquire`, `SeqCst` or `Relaxed` instead
 
 error: fetch_update's failure ordering may not be `Release` or `AcqRel`
-  --> $DIR/atomic_ordering_fetch_update.rs:28:47
+  --> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:32:47
    |
 LL |     let _ = x.fetch_update(Ordering::Relaxed, Ordering::Release, |old| Some(old + 1));
    |                                               ^^^^^^^^^^^^^^^^^
@@ -48,7 +48,7 @@ LL |     let _ = x.fetch_update(Ordering::Relaxed, Ordering::Release, |old| Some
    = help: consider using ordering mode `Relaxed` instead
 
 error: fetch_update's failure ordering may not be `Release` or `AcqRel`
-  --> $DIR/atomic_ordering_fetch_update.rs:29:47
+  --> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:34:47
    |
 LL |     let _ = x.fetch_update(Ordering::Acquire, Ordering::Release, |old| Some(old + 1));
    |                                               ^^^^^^^^^^^^^^^^^
@@ -56,7 +56,7 @@ LL |     let _ = x.fetch_update(Ordering::Acquire, Ordering::Release, |old| Some
    = help: consider using ordering modes `Acquire` or `Relaxed` instead
 
 error: fetch_update's failure ordering may not be `Release` or `AcqRel`
-  --> $DIR/atomic_ordering_fetch_update.rs:30:47
+  --> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:36:47
    |
 LL |     let _ = x.fetch_update(Ordering::Release, Ordering::Release, |old| Some(old + 1));
    |                                               ^^^^^^^^^^^^^^^^^
@@ -64,7 +64,7 @@ LL |     let _ = x.fetch_update(Ordering::Release, Ordering::Release, |old| Some
    = help: consider using ordering mode `Relaxed` instead
 
 error: fetch_update's failure ordering may not be `Release` or `AcqRel`
-  --> $DIR/atomic_ordering_fetch_update.rs:31:46
+  --> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:38:46
    |
 LL |     let _ = x.fetch_update(Ordering::AcqRel, Ordering::Release, |old| Some(old + 1));
    |                                              ^^^^^^^^^^^^^^^^^
@@ -72,7 +72,7 @@ LL |     let _ = x.fetch_update(Ordering::AcqRel, Ordering::Release, |old| Some(
    = help: consider using ordering modes `Acquire` or `Relaxed` instead
 
 error: fetch_update's failure ordering may not be `Release` or `AcqRel`
-  --> $DIR/atomic_ordering_fetch_update.rs:32:46
+  --> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:40:46
    |
 LL |     let _ = x.fetch_update(Ordering::SeqCst, Ordering::Release, |old| Some(old + 1));
    |                                              ^^^^^^^^^^^^^^^^^
@@ -80,7 +80,7 @@ LL |     let _ = x.fetch_update(Ordering::SeqCst, Ordering::Release, |old| Some(
    = help: consider using ordering modes `Acquire`, `SeqCst` or `Relaxed` instead
 
 error: fetch_update's failure ordering may not be stronger than the success ordering of `Release`
-  --> $DIR/atomic_ordering_fetch_update.rs:35:47
+  --> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:44:47
    |
 LL |     let _ = x.fetch_update(Ordering::Release, Ordering::Acquire, |old| Some(old + 1));
    |                                               ^^^^^^^^^^^^^^^^^
@@ -88,7 +88,7 @@ LL |     let _ = x.fetch_update(Ordering::Release, Ordering::Acquire, |old| Some
    = help: consider using ordering mode `Relaxed` instead
 
 error: fetch_update's failure ordering may not be stronger than the success ordering of `Release`
-  --> $DIR/atomic_ordering_fetch_update.rs:36:47
+  --> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:46:47
    |
 LL |     let _ = x.fetch_update(Ordering::Release, Ordering::SeqCst, |old| Some(old + 1));
    |                                               ^^^^^^^^^^^^^^^^
@@ -96,7 +96,7 @@ LL |     let _ = x.fetch_update(Ordering::Release, Ordering::SeqCst, |old| Some(
    = help: consider using ordering mode `Relaxed` instead
 
 error: fetch_update's failure ordering may not be stronger than the success ordering of `Relaxed`
-  --> $DIR/atomic_ordering_fetch_update.rs:39:47
+  --> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:50:47
    |
 LL |     let _ = x.fetch_update(Ordering::Relaxed, Ordering::SeqCst, |old| Some(old + 1));
    |                                               ^^^^^^^^^^^^^^^^
@@ -104,7 +104,7 @@ LL |     let _ = x.fetch_update(Ordering::Relaxed, Ordering::SeqCst, |old| Some(
    = help: consider using ordering mode `Relaxed` instead
 
 error: fetch_update's failure ordering may not be stronger than the success ordering of `Relaxed`
-  --> $DIR/atomic_ordering_fetch_update.rs:40:47
+  --> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:52:47
    |
 LL |     let _ = x.fetch_update(Ordering::Relaxed, Ordering::Acquire, |old| Some(old + 1));
    |                                               ^^^^^^^^^^^^^^^^^
@@ -112,7 +112,7 @@ LL |     let _ = x.fetch_update(Ordering::Relaxed, Ordering::Acquire, |old| Some
    = help: consider using ordering mode `Relaxed` instead
 
 error: fetch_update's failure ordering may not be stronger than the success ordering of `Acquire`
-  --> $DIR/atomic_ordering_fetch_update.rs:43:47
+  --> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:56:47
    |
 LL |     let _ = x.fetch_update(Ordering::Acquire, Ordering::SeqCst, |old| Some(old + 1));
    |                                               ^^^^^^^^^^^^^^^^
@@ -120,7 +120,7 @@ LL |     let _ = x.fetch_update(Ordering::Acquire, Ordering::SeqCst, |old| Some(
    = help: consider using ordering modes `Acquire` or `Relaxed` instead
 
 error: fetch_update's failure ordering may not be stronger than the success ordering of `AcqRel`
-  --> $DIR/atomic_ordering_fetch_update.rs:44:46
+  --> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:58:46
    |
 LL |     let _ = x.fetch_update(Ordering::AcqRel, Ordering::SeqCst, |old| Some(old + 1));
    |                                              ^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/atomic_ordering_int.rs b/src/test/ui/lint/lint-invalid-atomic-ordering-int.rs
index 40a00ba3de3..462c9670f43 100644
--- a/src/tools/clippy/tests/ui/atomic_ordering_int.rs
+++ b/src/test/ui/lint/lint-invalid-atomic-ordering-int.rs
@@ -1,5 +1,5 @@
-#![warn(clippy::invalid_atomic_ordering)]
-
+// FIXME: add support for `// only-atomic` to compiletest/header.rs
+// only-x86_64
 use std::sync::atomic::{AtomicI16, AtomicI32, AtomicI64, AtomicI8, AtomicIsize, Ordering};
 
 fn main() {
@@ -11,76 +11,120 @@ fn main() {
     let _ = x.load(Ordering::SeqCst);
     let _ = x.load(Ordering::Relaxed);
 
-    // Disallowed load ordering modes
-    let _ = x.load(Ordering::Release);
-    let _ = x.load(Ordering::AcqRel);
-
     // Allowed store ordering modes
     x.store(1, Ordering::Release);
     x.store(1, Ordering::SeqCst);
     x.store(1, Ordering::Relaxed);
 
+    // Disallowed load ordering modes
+    let _ = x.load(Ordering::Release);
+    //~^ ERROR atomic loads cannot have `Release` or `AcqRel` ordering
+    let _ = x.load(Ordering::AcqRel);
+    //~^ ERROR atomic loads cannot have `Release` or `AcqRel` ordering
+
     // Disallowed store ordering modes
     x.store(1, Ordering::Acquire);
+    //~^ ERROR atomic stores cannot have `Acquire` or `AcqRel` ordering
     x.store(1, Ordering::AcqRel);
+    //~^ ERROR atomic stores cannot have `Acquire` or `AcqRel` ordering
 
     // `AtomicI16` test cases
     let x = AtomicI16::new(0);
 
+    // Allowed load ordering modes
     let _ = x.load(Ordering::Acquire);
     let _ = x.load(Ordering::SeqCst);
     let _ = x.load(Ordering::Relaxed);
-    let _ = x.load(Ordering::Release);
-    let _ = x.load(Ordering::AcqRel);
 
+    // Allowed store ordering modes
     x.store(1, Ordering::Release);
     x.store(1, Ordering::SeqCst);
     x.store(1, Ordering::Relaxed);
+
+    // Disallowed load ordering modes
+    let _ = x.load(Ordering::Release);
+    //~^ ERROR atomic loads cannot have `Release` or `AcqRel` ordering
+    let _ = x.load(Ordering::AcqRel);
+    //~^ ERROR atomic loads cannot have `Release` or `AcqRel` ordering
+
+    // Disallowed store ordering modes
     x.store(1, Ordering::Acquire);
+    //~^ ERROR atomic stores cannot have `Acquire` or `AcqRel` ordering
     x.store(1, Ordering::AcqRel);
+    //~^ ERROR atomic stores cannot have `Acquire` or `AcqRel` ordering
 
     // `AtomicI32` test cases
     let x = AtomicI32::new(0);
 
+    // Allowed load ordering modes
     let _ = x.load(Ordering::Acquire);
     let _ = x.load(Ordering::SeqCst);
     let _ = x.load(Ordering::Relaxed);
-    let _ = x.load(Ordering::Release);
-    let _ = x.load(Ordering::AcqRel);
 
+    // Allowed store ordering modes
     x.store(1, Ordering::Release);
     x.store(1, Ordering::SeqCst);
     x.store(1, Ordering::Relaxed);
+
+    // Disallowed load ordering modes
+    let _ = x.load(Ordering::Release);
+    //~^ ERROR atomic loads cannot have `Release` or `AcqRel` ordering
+    let _ = x.load(Ordering::AcqRel);
+    //~^ ERROR atomic loads cannot have `Release` or `AcqRel` ordering
+
+    // Disallowed store ordering modes
     x.store(1, Ordering::Acquire);
+    //~^ ERROR atomic stores cannot have `Acquire` or `AcqRel` ordering
     x.store(1, Ordering::AcqRel);
+    //~^ ERROR atomic stores cannot have `Acquire` or `AcqRel` ordering
 
     // `AtomicI64` test cases
     let x = AtomicI64::new(0);
 
+    // Allowed load ordering modes
     let _ = x.load(Ordering::Acquire);
     let _ = x.load(Ordering::SeqCst);
     let _ = x.load(Ordering::Relaxed);
-    let _ = x.load(Ordering::Release);
-    let _ = x.load(Ordering::AcqRel);
 
+    // Allowed store ordering modes
     x.store(1, Ordering::Release);
     x.store(1, Ordering::SeqCst);
     x.store(1, Ordering::Relaxed);
+
+    // Disallowed load ordering modes
+    let _ = x.load(Ordering::Release);
+    //~^ ERROR atomic loads cannot have `Release` or `AcqRel` ordering
+    let _ = x.load(Ordering::AcqRel);
+    //~^ ERROR atomic loads cannot have `Release` or `AcqRel` ordering
+
+    // Disallowed store ordering modes
     x.store(1, Ordering::Acquire);
+    //~^ ERROR atomic stores cannot have `Acquire` or `AcqRel` ordering
     x.store(1, Ordering::AcqRel);
+    //~^ ERROR atomic stores cannot have `Acquire` or `AcqRel` ordering
 
     // `AtomicIsize` test cases
     let x = AtomicIsize::new(0);
 
+    // Allowed load ordering modes
     let _ = x.load(Ordering::Acquire);
     let _ = x.load(Ordering::SeqCst);
     let _ = x.load(Ordering::Relaxed);
-    let _ = x.load(Ordering::Release);
-    let _ = x.load(Ordering::AcqRel);
 
+    // Allowed store ordering modes
     x.store(1, Ordering::Release);
     x.store(1, Ordering::SeqCst);
     x.store(1, Ordering::Relaxed);
+
+    // Disallowed load ordering modes
+    let _ = x.load(Ordering::Release);
+    //~^ ERROR atomic loads cannot have `Release` or `AcqRel` ordering
+    let _ = x.load(Ordering::AcqRel);
+    //~^ ERROR atomic loads cannot have `Release` or `AcqRel` ordering
+
+    // Disallowed store ordering modes
     x.store(1, Ordering::Acquire);
+    //~^ ERROR atomic stores cannot have `Acquire` or `AcqRel` ordering
     x.store(1, Ordering::AcqRel);
+    //~^ ERROR atomic stores cannot have `Acquire` or `AcqRel` ordering
 }
diff --git a/src/tools/clippy/tests/ui/atomic_ordering_int.stderr b/src/test/ui/lint/lint-invalid-atomic-ordering-int.stderr
index bbaf234d3c9..dfd9990455a 100644
--- a/src/tools/clippy/tests/ui/atomic_ordering_int.stderr
+++ b/src/test/ui/lint/lint-invalid-atomic-ordering-int.stderr
@@ -1,158 +1,158 @@
-error: atomic loads cannot have `Release` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_int.rs:15:20
+error: atomic loads cannot have `Release` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-int.rs:20:20
    |
 LL |     let _ = x.load(Ordering::Release);
    |                    ^^^^^^^^^^^^^^^^^
    |
-   = note: `-D clippy::invalid-atomic-ordering` implied by `-D warnings`
+   = note: `#[deny(invalid_atomic_ordering)]` on by default
    = help: consider using ordering modes `Acquire`, `SeqCst` or `Relaxed`
 
-error: atomic loads cannot have `Release` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_int.rs:16:20
+error: atomic loads cannot have `Release` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-int.rs:22:20
    |
 LL |     let _ = x.load(Ordering::AcqRel);
    |                    ^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Acquire`, `SeqCst` or `Relaxed`
 
-error: atomic stores cannot have `Acquire` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_int.rs:24:16
+error: atomic stores cannot have `Acquire` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-int.rs:26:16
    |
 LL |     x.store(1, Ordering::Acquire);
    |                ^^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Release`, `SeqCst` or `Relaxed`
 
-error: atomic stores cannot have `Acquire` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_int.rs:25:16
+error: atomic stores cannot have `Acquire` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-int.rs:28:16
    |
 LL |     x.store(1, Ordering::AcqRel);
    |                ^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Release`, `SeqCst` or `Relaxed`
 
-error: atomic loads cannot have `Release` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_int.rs:33:20
+error: atomic loads cannot have `Release` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-int.rs:45:20
    |
 LL |     let _ = x.load(Ordering::Release);
    |                    ^^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Acquire`, `SeqCst` or `Relaxed`
 
-error: atomic loads cannot have `Release` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_int.rs:34:20
+error: atomic loads cannot have `Release` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-int.rs:47:20
    |
 LL |     let _ = x.load(Ordering::AcqRel);
    |                    ^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Acquire`, `SeqCst` or `Relaxed`
 
-error: atomic stores cannot have `Acquire` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_int.rs:39:16
+error: atomic stores cannot have `Acquire` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-int.rs:51:16
    |
 LL |     x.store(1, Ordering::Acquire);
    |                ^^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Release`, `SeqCst` or `Relaxed`
 
-error: atomic stores cannot have `Acquire` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_int.rs:40:16
+error: atomic stores cannot have `Acquire` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-int.rs:53:16
    |
 LL |     x.store(1, Ordering::AcqRel);
    |                ^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Release`, `SeqCst` or `Relaxed`
 
-error: atomic loads cannot have `Release` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_int.rs:48:20
+error: atomic loads cannot have `Release` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-int.rs:70:20
    |
 LL |     let _ = x.load(Ordering::Release);
    |                    ^^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Acquire`, `SeqCst` or `Relaxed`
 
-error: atomic loads cannot have `Release` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_int.rs:49:20
+error: atomic loads cannot have `Release` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-int.rs:72:20
    |
 LL |     let _ = x.load(Ordering::AcqRel);
    |                    ^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Acquire`, `SeqCst` or `Relaxed`
 
-error: atomic stores cannot have `Acquire` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_int.rs:54:16
+error: atomic stores cannot have `Acquire` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-int.rs:76:16
    |
 LL |     x.store(1, Ordering::Acquire);
    |                ^^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Release`, `SeqCst` or `Relaxed`
 
-error: atomic stores cannot have `Acquire` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_int.rs:55:16
+error: atomic stores cannot have `Acquire` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-int.rs:78:16
    |
 LL |     x.store(1, Ordering::AcqRel);
    |                ^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Release`, `SeqCst` or `Relaxed`
 
-error: atomic loads cannot have `Release` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_int.rs:63:20
+error: atomic loads cannot have `Release` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-int.rs:95:20
    |
 LL |     let _ = x.load(Ordering::Release);
    |                    ^^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Acquire`, `SeqCst` or `Relaxed`
 
-error: atomic loads cannot have `Release` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_int.rs:64:20
+error: atomic loads cannot have `Release` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-int.rs:97:20
    |
 LL |     let _ = x.load(Ordering::AcqRel);
    |                    ^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Acquire`, `SeqCst` or `Relaxed`
 
-error: atomic stores cannot have `Acquire` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_int.rs:69:16
+error: atomic stores cannot have `Acquire` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-int.rs:101:16
    |
 LL |     x.store(1, Ordering::Acquire);
    |                ^^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Release`, `SeqCst` or `Relaxed`
 
-error: atomic stores cannot have `Acquire` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_int.rs:70:16
+error: atomic stores cannot have `Acquire` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-int.rs:103:16
    |
 LL |     x.store(1, Ordering::AcqRel);
    |                ^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Release`, `SeqCst` or `Relaxed`
 
-error: atomic loads cannot have `Release` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_int.rs:78:20
+error: atomic loads cannot have `Release` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-int.rs:120:20
    |
 LL |     let _ = x.load(Ordering::Release);
    |                    ^^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Acquire`, `SeqCst` or `Relaxed`
 
-error: atomic loads cannot have `Release` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_int.rs:79:20
+error: atomic loads cannot have `Release` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-int.rs:122:20
    |
 LL |     let _ = x.load(Ordering::AcqRel);
    |                    ^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Acquire`, `SeqCst` or `Relaxed`
 
-error: atomic stores cannot have `Acquire` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_int.rs:84:16
+error: atomic stores cannot have `Acquire` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-int.rs:126:16
    |
 LL |     x.store(1, Ordering::Acquire);
    |                ^^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Release`, `SeqCst` or `Relaxed`
 
-error: atomic stores cannot have `Acquire` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_int.rs:85:16
+error: atomic stores cannot have `Acquire` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-int.rs:128:16
    |
 LL |     x.store(1, Ordering::AcqRel);
    |                ^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/atomic_ordering_ptr.rs b/src/test/ui/lint/lint-invalid-atomic-ordering-ptr.rs
index ecbb05c7fbc..984f7edebd1 100644
--- a/src/tools/clippy/tests/ui/atomic_ordering_ptr.rs
+++ b/src/test/ui/lint/lint-invalid-atomic-ordering-ptr.rs
@@ -1,5 +1,4 @@
-#![warn(clippy::invalid_atomic_ordering)]
-
+// only-x86_64
 use std::sync::atomic::{AtomicPtr, Ordering};
 
 fn main() {
@@ -14,7 +13,9 @@ fn main() {
 
     // Disallowed load ordering modes
     let _ = x.load(Ordering::Release);
+    //~^ ERROR atomic loads cannot have `Release` or `AcqRel` ordering
     let _ = x.load(Ordering::AcqRel);
+    //~^ ERROR atomic loads cannot have `Release` or `AcqRel` ordering
 
     // Allowed store ordering modes
     x.store(other_ptr, Ordering::Release);
@@ -23,5 +24,7 @@ fn main() {
 
     // Disallowed store ordering modes
     x.store(other_ptr, Ordering::Acquire);
+    //~^ ERROR atomic stores cannot have `Acquire` or `AcqRel` ordering
     x.store(other_ptr, Ordering::AcqRel);
+    //~^ ERROR atomic stores cannot have `Acquire` or `AcqRel` ordering
 }
diff --git a/src/tools/clippy/tests/ui/atomic_ordering_ptr.stderr b/src/test/ui/lint/lint-invalid-atomic-ordering-ptr.stderr
index 558ae55518d..f00cb8e4082 100644
--- a/src/tools/clippy/tests/ui/atomic_ordering_ptr.stderr
+++ b/src/test/ui/lint/lint-invalid-atomic-ordering-ptr.stderr
@@ -1,30 +1,30 @@
-error: atomic loads cannot have `Release` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_ptr.rs:16:20
+error: atomic loads cannot have `Release` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-ptr.rs:15:20
    |
 LL |     let _ = x.load(Ordering::Release);
    |                    ^^^^^^^^^^^^^^^^^
    |
-   = note: `-D clippy::invalid-atomic-ordering` implied by `-D warnings`
+   = note: `#[deny(invalid_atomic_ordering)]` on by default
    = help: consider using ordering modes `Acquire`, `SeqCst` or `Relaxed`
 
-error: atomic loads cannot have `Release` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_ptr.rs:17:20
+error: atomic loads cannot have `Release` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-ptr.rs:17:20
    |
 LL |     let _ = x.load(Ordering::AcqRel);
    |                    ^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Acquire`, `SeqCst` or `Relaxed`
 
-error: atomic stores cannot have `Acquire` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_ptr.rs:25:24
+error: atomic stores cannot have `Acquire` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-ptr.rs:26:24
    |
 LL |     x.store(other_ptr, Ordering::Acquire);
    |                        ^^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Release`, `SeqCst` or `Relaxed`
 
-error: atomic stores cannot have `Acquire` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_ptr.rs:26:24
+error: atomic stores cannot have `Acquire` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-ptr.rs:28:24
    |
 LL |     x.store(other_ptr, Ordering::AcqRel);
    |                        ^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/atomic_ordering_uint.rs b/src/test/ui/lint/lint-invalid-atomic-ordering-uint.rs
index a0d5d7c4010..80ec3b9ee34 100644
--- a/src/tools/clippy/tests/ui/atomic_ordering_uint.rs
+++ b/src/test/ui/lint/lint-invalid-atomic-ordering-uint.rs
@@ -1,5 +1,4 @@
-#![warn(clippy::invalid_atomic_ordering)]
-
+// only-x86_64
 use std::sync::atomic::{AtomicU16, AtomicU32, AtomicU64, AtomicU8, AtomicUsize, Ordering};
 
 fn main() {
@@ -11,76 +10,120 @@ fn main() {
     let _ = x.load(Ordering::SeqCst);
     let _ = x.load(Ordering::Relaxed);
 
-    // Disallowed load ordering modes
-    let _ = x.load(Ordering::Release);
-    let _ = x.load(Ordering::AcqRel);
-
     // Allowed store ordering modes
     x.store(1, Ordering::Release);
     x.store(1, Ordering::SeqCst);
     x.store(1, Ordering::Relaxed);
 
+    // Disallowed load ordering modes
+    let _ = x.load(Ordering::Release);
+    //~^ ERROR atomic loads cannot have `Release` or `AcqRel` ordering
+    let _ = x.load(Ordering::AcqRel);
+    //~^ ERROR atomic loads cannot have `Release` or `AcqRel` ordering
+
     // Disallowed store ordering modes
     x.store(1, Ordering::Acquire);
+    //~^ ERROR atomic stores cannot have `Acquire` or `AcqRel` ordering
     x.store(1, Ordering::AcqRel);
+    //~^ ERROR atomic stores cannot have `Acquire` or `AcqRel` ordering
 
     // `AtomicU16` test cases
     let x = AtomicU16::new(0);
 
+    // Allowed load ordering modes
     let _ = x.load(Ordering::Acquire);
     let _ = x.load(Ordering::SeqCst);
     let _ = x.load(Ordering::Relaxed);
-    let _ = x.load(Ordering::Release);
-    let _ = x.load(Ordering::AcqRel);
 
+    // Allowed store ordering modes
     x.store(1, Ordering::Release);
     x.store(1, Ordering::SeqCst);
     x.store(1, Ordering::Relaxed);
+
+    // Disallowed load ordering modes
+    let _ = x.load(Ordering::Release);
+    //~^ ERROR atomic loads cannot have `Release` or `AcqRel` ordering
+    let _ = x.load(Ordering::AcqRel);
+    //~^ ERROR atomic loads cannot have `Release` or `AcqRel` ordering
+
+    // Disallowed store ordering modes
     x.store(1, Ordering::Acquire);
+    //~^ ERROR atomic stores cannot have `Acquire` or `AcqRel` ordering
     x.store(1, Ordering::AcqRel);
+    //~^ ERROR atomic stores cannot have `Acquire` or `AcqRel` ordering
 
     // `AtomicU32` test cases
     let x = AtomicU32::new(0);
 
+    // Allowed load ordering modes
     let _ = x.load(Ordering::Acquire);
     let _ = x.load(Ordering::SeqCst);
     let _ = x.load(Ordering::Relaxed);
-    let _ = x.load(Ordering::Release);
-    let _ = x.load(Ordering::AcqRel);
 
+    // Allowed store ordering modes
     x.store(1, Ordering::Release);
     x.store(1, Ordering::SeqCst);
     x.store(1, Ordering::Relaxed);
+
+    // Disallowed load ordering modes
+    let _ = x.load(Ordering::Release);
+    //~^ ERROR atomic loads cannot have `Release` or `AcqRel` ordering
+    let _ = x.load(Ordering::AcqRel);
+    //~^ ERROR atomic loads cannot have `Release` or `AcqRel` ordering
+
+    // Disallowed store ordering modes
     x.store(1, Ordering::Acquire);
+    //~^ ERROR atomic stores cannot have `Acquire` or `AcqRel` ordering
     x.store(1, Ordering::AcqRel);
+    //~^ ERROR atomic stores cannot have `Acquire` or `AcqRel` ordering
 
     // `AtomicU64` test cases
     let x = AtomicU64::new(0);
 
+    // Allowed load ordering modes
     let _ = x.load(Ordering::Acquire);
     let _ = x.load(Ordering::SeqCst);
     let _ = x.load(Ordering::Relaxed);
-    let _ = x.load(Ordering::Release);
-    let _ = x.load(Ordering::AcqRel);
 
+    // Allowed store ordering modes
     x.store(1, Ordering::Release);
     x.store(1, Ordering::SeqCst);
     x.store(1, Ordering::Relaxed);
+
+    // Disallowed load ordering modes
+    let _ = x.load(Ordering::Release);
+    //~^ ERROR atomic loads cannot have `Release` or `AcqRel` ordering
+    let _ = x.load(Ordering::AcqRel);
+    //~^ ERROR atomic loads cannot have `Release` or `AcqRel` ordering
+
+    // Disallowed store ordering modes
     x.store(1, Ordering::Acquire);
+    //~^ ERROR atomic stores cannot have `Acquire` or `AcqRel` ordering
     x.store(1, Ordering::AcqRel);
+    //~^ ERROR atomic stores cannot have `Acquire` or `AcqRel` ordering
 
     // `AtomicUsize` test cases
     let x = AtomicUsize::new(0);
 
+    // Allowed load ordering modes
     let _ = x.load(Ordering::Acquire);
     let _ = x.load(Ordering::SeqCst);
     let _ = x.load(Ordering::Relaxed);
-    let _ = x.load(Ordering::Release);
-    let _ = x.load(Ordering::AcqRel);
 
+    // Allowed store ordering modes
     x.store(1, Ordering::Release);
     x.store(1, Ordering::SeqCst);
     x.store(1, Ordering::Relaxed);
+
+    // Disallowed load ordering modes
+    let _ = x.load(Ordering::Release);
+    //~^ ERROR atomic loads cannot have `Release` or `AcqRel` ordering
+    let _ = x.load(Ordering::AcqRel);
+    //~^ ERROR atomic loads cannot have `Release` or `AcqRel` ordering
+
+    // Disallowed store ordering modes
     x.store(1, Ordering::Acquire);
+    //~^ ERROR atomic stores cannot have `Acquire` or `AcqRel` ordering
     x.store(1, Ordering::AcqRel);
+    //~^ ERROR atomic stores cannot have `Acquire` or `AcqRel` ordering
 }
diff --git a/src/tools/clippy/tests/ui/atomic_ordering_uint.stderr b/src/test/ui/lint/lint-invalid-atomic-ordering-uint.stderr
index 5703135bcf1..36672e434b9 100644
--- a/src/tools/clippy/tests/ui/atomic_ordering_uint.stderr
+++ b/src/test/ui/lint/lint-invalid-atomic-ordering-uint.stderr
@@ -1,158 +1,158 @@
-error: atomic loads cannot have `Release` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_uint.rs:15:20
+error: atomic loads cannot have `Release` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-uint.rs:19:20
    |
 LL |     let _ = x.load(Ordering::Release);
    |                    ^^^^^^^^^^^^^^^^^
    |
-   = note: `-D clippy::invalid-atomic-ordering` implied by `-D warnings`
+   = note: `#[deny(invalid_atomic_ordering)]` on by default
    = help: consider using ordering modes `Acquire`, `SeqCst` or `Relaxed`
 
-error: atomic loads cannot have `Release` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_uint.rs:16:20
+error: atomic loads cannot have `Release` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-uint.rs:21:20
    |
 LL |     let _ = x.load(Ordering::AcqRel);
    |                    ^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Acquire`, `SeqCst` or `Relaxed`
 
-error: atomic stores cannot have `Acquire` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_uint.rs:24:16
+error: atomic stores cannot have `Acquire` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-uint.rs:25:16
    |
 LL |     x.store(1, Ordering::Acquire);
    |                ^^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Release`, `SeqCst` or `Relaxed`
 
-error: atomic stores cannot have `Acquire` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_uint.rs:25:16
+error: atomic stores cannot have `Acquire` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-uint.rs:27:16
    |
 LL |     x.store(1, Ordering::AcqRel);
    |                ^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Release`, `SeqCst` or `Relaxed`
 
-error: atomic loads cannot have `Release` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_uint.rs:33:20
+error: atomic loads cannot have `Release` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-uint.rs:44:20
    |
 LL |     let _ = x.load(Ordering::Release);
    |                    ^^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Acquire`, `SeqCst` or `Relaxed`
 
-error: atomic loads cannot have `Release` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_uint.rs:34:20
+error: atomic loads cannot have `Release` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-uint.rs:46:20
    |
 LL |     let _ = x.load(Ordering::AcqRel);
    |                    ^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Acquire`, `SeqCst` or `Relaxed`
 
-error: atomic stores cannot have `Acquire` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_uint.rs:39:16
+error: atomic stores cannot have `Acquire` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-uint.rs:50:16
    |
 LL |     x.store(1, Ordering::Acquire);
    |                ^^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Release`, `SeqCst` or `Relaxed`
 
-error: atomic stores cannot have `Acquire` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_uint.rs:40:16
+error: atomic stores cannot have `Acquire` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-uint.rs:52:16
    |
 LL |     x.store(1, Ordering::AcqRel);
    |                ^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Release`, `SeqCst` or `Relaxed`
 
-error: atomic loads cannot have `Release` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_uint.rs:48:20
+error: atomic loads cannot have `Release` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-uint.rs:69:20
    |
 LL |     let _ = x.load(Ordering::Release);
    |                    ^^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Acquire`, `SeqCst` or `Relaxed`
 
-error: atomic loads cannot have `Release` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_uint.rs:49:20
+error: atomic loads cannot have `Release` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-uint.rs:71:20
    |
 LL |     let _ = x.load(Ordering::AcqRel);
    |                    ^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Acquire`, `SeqCst` or `Relaxed`
 
-error: atomic stores cannot have `Acquire` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_uint.rs:54:16
+error: atomic stores cannot have `Acquire` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-uint.rs:75:16
    |
 LL |     x.store(1, Ordering::Acquire);
    |                ^^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Release`, `SeqCst` or `Relaxed`
 
-error: atomic stores cannot have `Acquire` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_uint.rs:55:16
+error: atomic stores cannot have `Acquire` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-uint.rs:77:16
    |
 LL |     x.store(1, Ordering::AcqRel);
    |                ^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Release`, `SeqCst` or `Relaxed`
 
-error: atomic loads cannot have `Release` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_uint.rs:63:20
+error: atomic loads cannot have `Release` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-uint.rs:94:20
    |
 LL |     let _ = x.load(Ordering::Release);
    |                    ^^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Acquire`, `SeqCst` or `Relaxed`
 
-error: atomic loads cannot have `Release` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_uint.rs:64:20
+error: atomic loads cannot have `Release` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-uint.rs:96:20
    |
 LL |     let _ = x.load(Ordering::AcqRel);
    |                    ^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Acquire`, `SeqCst` or `Relaxed`
 
-error: atomic stores cannot have `Acquire` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_uint.rs:69:16
+error: atomic stores cannot have `Acquire` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-uint.rs:100:16
    |
 LL |     x.store(1, Ordering::Acquire);
    |                ^^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Release`, `SeqCst` or `Relaxed`
 
-error: atomic stores cannot have `Acquire` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_uint.rs:70:16
+error: atomic stores cannot have `Acquire` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-uint.rs:102:16
    |
 LL |     x.store(1, Ordering::AcqRel);
    |                ^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Release`, `SeqCst` or `Relaxed`
 
-error: atomic loads cannot have `Release` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_uint.rs:78:20
+error: atomic loads cannot have `Release` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-uint.rs:119:20
    |
 LL |     let _ = x.load(Ordering::Release);
    |                    ^^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Acquire`, `SeqCst` or `Relaxed`
 
-error: atomic loads cannot have `Release` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_uint.rs:79:20
+error: atomic loads cannot have `Release` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-uint.rs:121:20
    |
 LL |     let _ = x.load(Ordering::AcqRel);
    |                    ^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Acquire`, `SeqCst` or `Relaxed`
 
-error: atomic stores cannot have `Acquire` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_uint.rs:84:16
+error: atomic stores cannot have `Acquire` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-uint.rs:125:16
    |
 LL |     x.store(1, Ordering::Acquire);
    |                ^^^^^^^^^^^^^^^^^
    |
    = help: consider using ordering modes `Release`, `SeqCst` or `Relaxed`
 
-error: atomic stores cannot have `Acquire` and `AcqRel` ordering
-  --> $DIR/atomic_ordering_uint.rs:85:16
+error: atomic stores cannot have `Acquire` or `AcqRel` ordering
+  --> $DIR/lint-invalid-atomic-ordering-uint.rs:127:16
    |
 LL |     x.store(1, Ordering::AcqRel);
    |                ^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/clippy_lints/src/atomic_ordering.rs b/src/tools/clippy/clippy_lints/src/atomic_ordering.rs
deleted file mode 100644
index cece28e8b3c..00000000000
--- a/src/tools/clippy/clippy_lints/src/atomic_ordering.rs
+++ /dev/null
@@ -1,230 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::match_def_path;
-use if_chain::if_chain;
-use rustc_hir::def_id::DefId;
-use rustc_hir::{Expr, ExprKind};
-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 usage of invalid atomic
-    /// ordering in atomic loads/stores/exchanges/updates and
-    /// memory fences.
-    ///
-    /// ### Why is this bad?
-    /// Using an invalid atomic ordering
-    /// will cause a panic at run-time.
-    ///
-    /// ### Example
-    /// ```rust,no_run
-    /// # use std::sync::atomic::{self, AtomicU8, Ordering};
-    ///
-    /// let x = AtomicU8::new(0);
-    ///
-    /// // Bad: `Release` and `AcqRel` cannot be used for `load`.
-    /// let _ = x.load(Ordering::Release);
-    /// let _ = x.load(Ordering::AcqRel);
-    ///
-    /// // Bad: `Acquire` and `AcqRel` cannot be used for `store`.
-    /// x.store(1, Ordering::Acquire);
-    /// x.store(2, Ordering::AcqRel);
-    ///
-    /// // Bad: `Relaxed` cannot be used as a fence's ordering.
-    /// atomic::fence(Ordering::Relaxed);
-    /// atomic::compiler_fence(Ordering::Relaxed);
-    ///
-    /// // Bad: `Release` and `AcqRel` are both always invalid
-    /// // for the failure ordering (the last arg).
-    /// let _ = x.compare_exchange(1, 2, Ordering::SeqCst, Ordering::Release);
-    /// let _ = x.compare_exchange_weak(2, 3, Ordering::AcqRel, Ordering::AcqRel);
-    ///
-    /// // Bad: The failure ordering is not allowed to be
-    /// // stronger than the success order, and `SeqCst` is
-    /// // stronger than `Relaxed`.
-    /// let _ = x.fetch_update(Ordering::Relaxed, Ordering::SeqCst, |val| Some(val + val));
-    /// ```
-    pub INVALID_ATOMIC_ORDERING,
-    correctness,
-    "usage of invalid atomic ordering in atomic operations and memory fences"
-}
-
-declare_lint_pass!(AtomicOrdering => [INVALID_ATOMIC_ORDERING]);
-
-const ATOMIC_TYPES: [&str; 12] = [
-    "AtomicBool",
-    "AtomicI8",
-    "AtomicI16",
-    "AtomicI32",
-    "AtomicI64",
-    "AtomicIsize",
-    "AtomicPtr",
-    "AtomicU8",
-    "AtomicU16",
-    "AtomicU32",
-    "AtomicU64",
-    "AtomicUsize",
-];
-
-fn type_is_atomic(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    if let ty::Adt(&ty::AdtDef { did, .. }, _) = cx.typeck_results().expr_ty(expr).kind() {
-        ATOMIC_TYPES
-            .iter()
-            .any(|ty| match_def_path(cx, did, &["core", "sync", "atomic", ty]))
-    } else {
-        false
-    }
-}
-
-fn match_ordering_def_path(cx: &LateContext<'_>, did: DefId, orderings: &[&str]) -> bool {
-    orderings
-        .iter()
-        .any(|ordering| match_def_path(cx, did, &["core", "sync", "atomic", "Ordering", ordering]))
-}
-
-fn check_atomic_load_store(cx: &LateContext<'_>, expr: &Expr<'_>) {
-    if_chain! {
-        if let ExprKind::MethodCall(method_path, _, args, _) = &expr.kind;
-        let method = method_path.ident.name.as_str();
-        if type_is_atomic(cx, &args[0]);
-        if method == "load" || method == "store";
-        let ordering_arg = if method == "load" { &args[1] } else { &args[2] };
-        if let ExprKind::Path(ref ordering_qpath) = ordering_arg.kind;
-        if let Some(ordering_def_id) = cx.qpath_res(ordering_qpath, ordering_arg.hir_id).opt_def_id();
-        then {
-            if method == "load" &&
-                match_ordering_def_path(cx, ordering_def_id, &["Release", "AcqRel"]) {
-                span_lint_and_help(
-                    cx,
-                    INVALID_ATOMIC_ORDERING,
-                    ordering_arg.span,
-                    "atomic loads cannot have `Release` and `AcqRel` ordering",
-                    None,
-                    "consider using ordering modes `Acquire`, `SeqCst` or `Relaxed`"
-                );
-            } else if method == "store" &&
-                match_ordering_def_path(cx, ordering_def_id, &["Acquire", "AcqRel"]) {
-                span_lint_and_help(
-                    cx,
-                    INVALID_ATOMIC_ORDERING,
-                    ordering_arg.span,
-                    "atomic stores cannot have `Acquire` and `AcqRel` ordering",
-                    None,
-                    "consider using ordering modes `Release`, `SeqCst` or `Relaxed`"
-                );
-            }
-        }
-    }
-}
-
-fn check_memory_fence(cx: &LateContext<'_>, expr: &Expr<'_>) {
-    if_chain! {
-        if let ExprKind::Call(func, args) = expr.kind;
-        if let ExprKind::Path(ref func_qpath) = func.kind;
-        if let Some(def_id) = cx.qpath_res(func_qpath, func.hir_id).opt_def_id();
-        if ["fence", "compiler_fence"]
-            .iter()
-            .any(|func| match_def_path(cx, def_id, &["core", "sync", "atomic", func]));
-        if let ExprKind::Path(ref ordering_qpath) = &args[0].kind;
-        if let Some(ordering_def_id) = cx.qpath_res(ordering_qpath, args[0].hir_id).opt_def_id();
-        if match_ordering_def_path(cx, ordering_def_id, &["Relaxed"]);
-        then {
-            span_lint_and_help(
-                cx,
-                INVALID_ATOMIC_ORDERING,
-                args[0].span,
-                "memory fences cannot have `Relaxed` ordering",
-                None,
-                "consider using ordering modes `Acquire`, `Release`, `AcqRel` or `SeqCst`"
-            );
-        }
-    }
-}
-
-fn opt_ordering_defid(cx: &LateContext<'_>, ord_arg: &Expr<'_>) -> Option<DefId> {
-    if let ExprKind::Path(ref ord_qpath) = ord_arg.kind {
-        cx.qpath_res(ord_qpath, ord_arg.hir_id).opt_def_id()
-    } else {
-        None
-    }
-}
-
-fn check_atomic_compare_exchange(cx: &LateContext<'_>, expr: &Expr<'_>) {
-    if_chain! {
-        if let ExprKind::MethodCall(method_path, _, args, _) = &expr.kind;
-        let method = method_path.ident.name.as_str();
-        if type_is_atomic(cx, &args[0]);
-        if method == "compare_exchange" || method == "compare_exchange_weak" || method == "fetch_update";
-        let (success_order_arg, failure_order_arg) = if method == "fetch_update" {
-            (&args[1], &args[2])
-        } else {
-            (&args[3], &args[4])
-        };
-        if let Some(fail_ordering_def_id) = opt_ordering_defid(cx, failure_order_arg);
-        then {
-            // Helper type holding on to some checking and error reporting data. Has
-            // - (success ordering name,
-            // - list of failure orderings forbidden by the success order,
-            // - suggestion message)
-            type OrdLintInfo = (&'static str, &'static [&'static str], &'static str);
-            let relaxed: OrdLintInfo = ("Relaxed", &["SeqCst", "Acquire"], "ordering mode `Relaxed`");
-            let acquire: OrdLintInfo = ("Acquire", &["SeqCst"], "ordering modes `Acquire` or `Relaxed`");
-            let seq_cst: OrdLintInfo = ("SeqCst", &[], "ordering modes `Acquire`, `SeqCst` or `Relaxed`");
-            let release = ("Release", relaxed.1, relaxed.2);
-            let acqrel = ("AcqRel", acquire.1, acquire.2);
-            let search = [relaxed, acquire, seq_cst, release, acqrel];
-
-            let success_lint_info = opt_ordering_defid(cx, success_order_arg)
-                .and_then(|success_ord_def_id| -> Option<OrdLintInfo> {
-                    search
-                        .iter()
-                        .find(|(ordering, ..)| {
-                            match_def_path(cx, success_ord_def_id,
-                                &["core", "sync", "atomic", "Ordering", ordering])
-                        })
-                        .copied()
-                });
-
-            if match_ordering_def_path(cx, fail_ordering_def_id, &["Release", "AcqRel"]) {
-                // If we don't know the success order is, use what we'd suggest
-                // if it were maximally permissive.
-                let suggested = success_lint_info.unwrap_or(seq_cst).2;
-                span_lint_and_help(
-                    cx,
-                    INVALID_ATOMIC_ORDERING,
-                    failure_order_arg.span,
-                    &format!(
-                        "{}'s failure ordering may not be `Release` or `AcqRel`",
-                        method,
-                    ),
-                    None,
-                    &format!("consider using {} instead", suggested),
-                );
-            } else if let Some((success_ord_name, bad_ords_given_success, suggested)) = success_lint_info {
-                if match_ordering_def_path(cx, fail_ordering_def_id, bad_ords_given_success) {
-                    span_lint_and_help(
-                        cx,
-                        INVALID_ATOMIC_ORDERING,
-                        failure_order_arg.span,
-                        &format!(
-                            "{}'s failure ordering may not be stronger than the success ordering of `{}`",
-                            method,
-                            success_ord_name,
-                        ),
-                        None,
-                        &format!("consider using {} instead", suggested),
-                    );
-                }
-            }
-        }
-    }
-}
-
-impl<'tcx> LateLintPass<'tcx> for AtomicOrdering {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        check_atomic_load_store(cx, expr);
-        check_memory_fence(cx, expr);
-        check_atomic_compare_exchange(cx, expr);
-    }
-}
diff --git a/src/tools/clippy/clippy_lints/src/lib.rs b/src/tools/clippy/clippy_lints/src/lib.rs
index f49b382c5ea..e455c8db03f 100644
--- a/src/tools/clippy/clippy_lints/src/lib.rs
+++ b/src/tools/clippy/clippy_lints/src/lib.rs
@@ -165,7 +165,6 @@ mod asm_syntax;
 mod assertions_on_constants;
 mod assign_ops;
 mod async_yields_async;
-mod atomic_ordering;
 mod attrs;
 mod await_holding_invalid;
 mod bit_mask;
@@ -537,7 +536,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         assign_ops::ASSIGN_OP_PATTERN,
         assign_ops::MISREFACTORED_ASSIGN_OP,
         async_yields_async::ASYNC_YIELDS_ASYNC,
-        atomic_ordering::INVALID_ATOMIC_ORDERING,
         attrs::BLANKET_CLIPPY_RESTRICTION_LINTS,
         attrs::DEPRECATED_CFG_ATTR,
         attrs::DEPRECATED_SEMVER,
@@ -1174,7 +1172,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(assign_ops::ASSIGN_OP_PATTERN),
         LintId::of(assign_ops::MISREFACTORED_ASSIGN_OP),
         LintId::of(async_yields_async::ASYNC_YIELDS_ASYNC),
-        LintId::of(atomic_ordering::INVALID_ATOMIC_ORDERING),
         LintId::of(attrs::BLANKET_CLIPPY_RESTRICTION_LINTS),
         LintId::of(attrs::DEPRECATED_CFG_ATTR),
         LintId::of(attrs::DEPRECATED_SEMVER),
@@ -1670,7 +1667,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(absurd_extreme_comparisons::ABSURD_EXTREME_COMPARISONS),
         LintId::of(approx_const::APPROX_CONSTANT),
         LintId::of(async_yields_async::ASYNC_YIELDS_ASYNC),
-        LintId::of(atomic_ordering::INVALID_ATOMIC_ORDERING),
         LintId::of(attrs::DEPRECATED_SEMVER),
         LintId::of(attrs::MISMATCHED_TARGET_OS),
         LintId::of(attrs::USELESS_ATTRIBUTE),
@@ -2044,7 +2040,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box floating_point_arithmetic::FloatingPointArithmetic);
     store.register_early_pass(|| box as_conversions::AsConversions);
     store.register_late_pass(|| box let_underscore::LetUnderscore);
-    store.register_late_pass(|| box atomic_ordering::AtomicOrdering);
     store.register_early_pass(|| box single_component_path_imports::SingleComponentPathImports);
     let max_fn_params_bools = conf.max_fn_params_bools;
     let max_struct_bools = conf.max_struct_bools;
@@ -2183,6 +2178,7 @@ pub fn register_renamed(ls: &mut rustc_lint::LintStore) {
     ls.register_renamed("clippy::temporary_cstring_as_ptr", "temporary_cstring_as_ptr");
     ls.register_renamed("clippy::panic_params", "non_fmt_panics");
     ls.register_renamed("clippy::unknown_clippy_lints", "unknown_lints");
+    ls.register_renamed("clippy::invalid_atomic_ordering", "invalid_atomic_ordering");
 }
 
 // only exists to let the dogfood integration test works.
diff --git a/src/tools/clippy/tests/ui/deprecated.rs b/src/tools/clippy/tests/ui/deprecated.rs
index 4ba9f0c1fcf..1943d0092e6 100644
--- a/src/tools/clippy/tests/ui/deprecated.rs
+++ b/src/tools/clippy/tests/ui/deprecated.rs
@@ -14,5 +14,6 @@
 #[warn(clippy::filter_map)]
 #[warn(clippy::pub_enum_variant_names)]
 #[warn(clippy::wrong_pub_self_convention)]
+#[warn(clippy::invalid_atomic_ordering)]
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/deprecated.stderr b/src/tools/clippy/tests/ui/deprecated.stderr
index c0002e53543..51048e45c06 100644
--- a/src/tools/clippy/tests/ui/deprecated.stderr
+++ b/src/tools/clippy/tests/ui/deprecated.stderr
@@ -96,5 +96,11 @@ error: lint `clippy::wrong_pub_self_convention` has been removed: set the `avoid
 LL | #[warn(clippy::wrong_pub_self_convention)]
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 16 previous errors
+error: lint `clippy::invalid_atomic_ordering` has been renamed to `invalid_atomic_ordering`
+  --> $DIR/deprecated.rs:17:8
+   |
+LL | #[warn(clippy::invalid_atomic_ordering)]
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_atomic_ordering`
+
+error: aborting due to 17 previous errors
 
diff --git a/src/tools/tidy/src/deps.rs b/src/tools/tidy/src/deps.rs
index 32660ae2aee..5f1267fc3d2 100644
--- a/src/tools/tidy/src/deps.rs
+++ b/src/tools/tidy/src/deps.rs
@@ -121,6 +121,7 @@ const PERMITTED_DEPENDENCIES: &[&str] = &[
     "hashbrown",
     "hermit-abi",
     "humantime",
+    "if_chain",
     "indexmap",
     "instant",
     "itertools",