diff --git a/Cargo.lock b/Cargo.lock index 940608975c5..60485273fa9 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3924,6 +3924,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 ad10db64302..75a031a86b6 100644 --- a/compiler/rustc_lint/Cargo.toml +++ b/compiler/rustc_lint/Cargo.toml @@ -4,6 +4,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 55961636f32..34d342e6694 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,236 @@ 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>, + recognized_names: &[Symbol], // used for fast path calculation + ) -> 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 recognized_names.contains(&method_path.ident.name); + 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 { + 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, &[sym::load, sym::store]); + 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, &[sym::fetch_update, sym::compare_exchange, sym::compare_exchange_weak]); + 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 { + 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 1d91b327901..62719ab1ab6 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, @@ -392,8 +413,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, @@ -578,6 +603,8 @@ symbols! { fadd_fast, fdiv_fast, feature, + fence, + fetch_update, ffi, ffi_const, ffi_pure, @@ -731,6 +758,7 @@ symbols! { lint_reasons, literal, llvm_asm, + load, local, local_inner_macros, log10f32, @@ -1220,6 +1248,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 Sync for AtomicPtr {} #[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(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 similarity index 67% rename from src/tools/clippy/tests/ui/atomic_ordering_bool.rs rename to 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 similarity index 57% rename from src/tools/clippy/tests/ui/atomic_ordering_bool.stderr rename to 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 similarity index 66% rename from src/tools/clippy/tests/ui/atomic_ordering_exchange_weak.rs rename to 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 similarity index 83% rename from src/tools/clippy/tests/ui/atomic_ordering_exchange_weak.stderr rename to 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 similarity index 64% rename from src/tools/clippy/tests/ui/atomic_ordering_exchange.rs rename to 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 similarity index 83% rename from src/tools/clippy/tests/ui/atomic_ordering_exchange.stderr rename to 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 similarity index 67% rename from src/tools/clippy/tests/ui/atomic_ordering_fence.rs rename to 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 similarity index 74% rename from src/tools/clippy/tests/ui/atomic_ordering_fence.stderr rename to 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 similarity index 68% rename from src/tools/clippy/tests/ui/atomic_ordering_fetch_update.rs rename to 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 similarity index 82% rename from src/tools/clippy/tests/ui/atomic_ordering_fetch_update.stderr rename to 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 similarity index 53% rename from src/tools/clippy/tests/ui/atomic_ordering_int.rs rename to 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); + // 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); // 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); - - // `AtomicI16` test cases - let x = AtomicI16::new(0); - - 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); - - x.store(1, Ordering::Release); - x.store(1, Ordering::SeqCst); - x.store(1, Ordering::Relaxed); - x.store(1, Ordering::Acquire); - 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 similarity index 58% rename from src/tools/clippy/tests/ui/atomic_ordering_int.stderr rename to 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 similarity index 70% rename from src/tools/clippy/tests/ui/atomic_ordering_ptr.rs rename to 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 similarity index 58% rename from src/tools/clippy/tests/ui/atomic_ordering_ptr.stderr rename to 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 similarity index 54% rename from src/tools/clippy/tests/ui/atomic_ordering_uint.rs rename to 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); + // 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); // 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); - - // `AtomicU16` test cases - let x = AtomicU16::new(0); - - 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); - - x.store(1, Ordering::Release); - x.store(1, Ordering::SeqCst); - x.store(1, Ordering::Relaxed); - x.store(1, Ordering::Acquire); - 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 similarity index 58% rename from src/tools/clippy/tests/ui/atomic_ordering_uint.stderr rename to 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 { - 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 { - 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 dbdb4251b3b..6f73a00d1f7 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, @@ -1175,7 +1173,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), @@ -1673,7 +1670,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), @@ -2047,7 +2043,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; @@ -2186,6 +2181,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",