nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-25 08:13:41 +00:00
Code Issues Packages Projects Releases Wiki Activity

Auto merge of #84039 - jyn514:uplift-atomic-ordering, r=wesleywiser

Browse Source 
Uplift the invalid_atomic_ordering lint from clippy to rustc

This is mostly just a rebase of https://github.com/rust-lang/rust/pull/79654; I've copy/pasted the text from that PR below.

r? `@lcnr` since you reviewed the last one, but feel free to reassign.

---

This is an implementation of https://github.com/rust-lang/compiler-team/issues/390.

As mentioned, in general this turns an unconditional runtime panic into a (compile time) lint failure. It has no false positives, and the only false negatives I'm aware of are if `Ordering` isn't specified directly and is comes from an argument/constant/whatever.

As a result of it having no false positives, and the alternative always being strictly wrong, it's on as deny by default. This seems right.

In the [zulip stream](https://rust-lang.zulipchat.com/#narrow/stream/233931-t-compiler.2Fmajor-changes/topic/Uplift.20the.20.60invalid_atomic_ordering.60.20lint.20from.20clippy/near/218483957) `@joshtriplett` suggested that lang team should FCP this before landing it. Perhaps libs team cares too?

---

Some notes on the code for reviewers / others below

## Changes from clippy

The code is changed from [the implementation in clippy](68cf94f6a6/clippy_lints/src/atomic_ordering.rs) in the following ways:

1. Uses `Symbols` and `rustc_diagnostic_item`s instead of string literals.
    - It's possible I should have just invoked Symbol::intern for some of these instead? Seems better to use symbol, but it did require adding several.
2. The functions are moved to static methods inside the lint struct, as a way to namespace them.
    - There's a lot of other code in that file — which I picked as the location for this lint because `@jyn514` told me that seemed reasonable.
3. Supports unstable AtomicU128/AtomicI128.
    - I did this because it was almost easier to support them than not — not supporting them would have (ideally) required finding a way not to give them a `rustc_diagnostic_item`, which would have complicated an already big macro.
    - These don't have tests since I wasn't sure if/how I should make tests conditional on whether or not the target has the atomic... This is to a certain extent an issue of 64bit atomics too, but 128-bit atomics are much less common. Regardless, the existing tests should be *more* than thorough enough here.
4. Minor changes like:
    - grammar tweaks ("loads cannot have `Release` **and** `AcqRel` ordering" => "loads cannot have `Release` **or** `AcqRel` ordering")
    - function renames (`match_ordering_def_path` => `matches_ordering_def_path`),
    - avoiding clippy-specific helper methods that don't exist in rustc_lint and didn't seem worth adding for this case (for example `cx.struct_span_lint` vs clippy's `span_lint_and_help` helper).

## Potential issues

(This is just about the code in this PR, not conceptual issues with the lint or anything)

1. I'm not sure if I should have used a diagnostic item for `Ordering` and its variants (I couldn't figure out how really, so if I should do this some pointers would be appreciated).
    - It seems possible that failing to do this might possibly mean there are more cases this lint would miss, but I don't really know how `match_def_path` works and if it has any pitfalls like that, so maybe not.

2. I *think* I deprecated the lint in clippy (CC `@flip1995` who asked to be notified about clippy changes in the future in [this comment](https://github.com/rust-lang/rust/pull/75671#issuecomment-718731659)) but I'm not sure if I need to do anything else there.
    - I'm kind of hoping CI will catch if I missed anything, since `x.py test src/tools/clippy` fails with a lot of errors with and without my changes (and is probably a nonsense command regardless). Running `cargo test` from src/tools/clippy also fails with unrelated errors that seem like refactorings that didnt update clippy? So, honestly no clue.

3. I wasn't sure if the description/example I gave good. Hopefully it is. The example is less thorough than the one from clippy here: https://rust-lang.github.io/rust-clippy/master/index.html#invalid_atomic_ordering. Let me know if/how I should change it if it needs changing.

4. It pulls in the `if_chain` crate. This crate was already used in clippy, and seems like it's used elsewhere in rustc, but I'm willing to rewrite it to not use this if needed (I'd prefer not to, all things being equal).
This commit is contained in:
bors 2021-08-16 06:36:13 +00:00
commit 92f3753b07
28 changed files with 657 additions and 455 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Cargo.lock
View File

@ -3924,6 +3924,7 @@ dependencies = [
name = "rustc_lint"
version = "0.0.0"
dependencies = [
"if_chain",
"rustc_ast",
"rustc_ast_pretty",
"rustc_attr",

1
compiler/rustc_lint/Cargo.toml
View File

@ -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" }

1
compiler/rustc_lint/src/lib.rs
View File

@ -170,6 +170,7 @@ macro_rules! late_lint_passes {
TemporaryCStringAsPtr: TemporaryCStringAsPtr,
NonPanicFmt: NonPanicFmt,
NoopMethodCall: NoopMethodCall,
InvalidAtomicOrdering: InvalidAtomicOrdering,
]
);
};

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

@ -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<DefId> {
if let ExprKind::Path(ref ord_qpath) = ord_arg.kind {
cx.qpath_res(ord_qpath, ord_arg.hir_id).opt_def_id()
} else {
None
}
}
fn check_atomic_load_store(cx: &LateContext<'_>, expr: &Expr<'_>) {
use rustc_hir::def::{DefKind, Res};
use rustc_hir::QPath;
if_chain! {
if let Some((method, args)) = Self::inherent_atomic_method_call(cx, expr, &[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<OrdLintInfo> {
SEARCH
.iter()
.copied()
.find(|(ordering, ..)| {
Self::matches_ordering(cx, success_ord_def_id, &[*ordering])
})
});
if Self::matches_ordering(cx, fail_ordering_def_id, &[sym::Release, sym::AcqRel]) {
// If we don't know the success order is, use what we'd suggest
// if it were maximally permissive.
let suggested = success_lint_info.unwrap_or(SEQ_CST).2;
cx.struct_span_lint(INVALID_ATOMIC_ORDERING, failure_order_arg.span, |diag| {
let msg = format!(
"{}'s failure ordering may not be `Release` or `AcqRel`",
method,
);
diag.build(&msg)
.help(&format!("consider using {} instead", suggested))
.emit();
});
} else if let Some((success_ord, bad_ords_given_success, suggested)) = success_lint_info {
if Self::matches_ordering(cx, fail_ordering_def_id, bad_ords_given_success) {
cx.struct_span_lint(INVALID_ATOMIC_ORDERING, failure_order_arg.span, |diag| {
let msg = format!(
"{}'s failure ordering may not be stronger than the success ordering of `{}`",
method,
success_ord,
);
diag.build(&msg)
.help(&format!("consider using {} instead", suggested))
.emit();
});
}
}
}
}
}
}
impl<'tcx> LateLintPass<'tcx> for InvalidAtomicOrdering {
fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
Self::check_atomic_load_store(cx, expr);
Self::check_memory_fence(cx, expr);
Self::check_atomic_compare_exchange(cx, expr);
}
}

29
compiler/rustc_span/src/symbol.rs
View File

@ -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,

4
library/core/src/sync/atomic.rs
View File

@ -113,6 +113,7 @@
#![stable(feature = "rust1", since = "1.0.0")]
#![cfg_attr(not(target_has_atomic_load_store = "8"), allow(dead_code))]
#![cfg_attr(not(target_has_atomic_load_store = "8"), allow(unused_imports))]
#![rustc_diagnostic_item = "atomic_mod"]
use self::Ordering::*;
@ -198,6 +199,7 @@ unsafe impl<T> Sync for AtomicPtr<T> {}
#[stable(feature = "rust1", since = "1.0.0")]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
#[non_exhaustive]
#[rustc_diagnostic_item = "Ordering"]
pub enum Ordering {
/// No ordering constraints, only atomic operations.
///
@ -2664,6 +2666,7 @@ unsafe fn atomic_umin<T: Copy>(dst: *mut T, val: T, order: Ordering) -> T {
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_diagnostic_item = "fence"]
pub fn fence(order: Ordering) {
// SAFETY: using an atomic fence is safe.
unsafe {
@ -2745,6 +2748,7 @@ pub fn fence(order: Ordering) {
/// [memory barriers]: https://www.kernel.org/doc/Documentation/memory-barriers.txt
#[inline]
#[stable(feature = "compiler_fences", since = "1.21.0")]
#[rustc_diagnostic_item = "compiler_fence"]
pub fn compiler_fence(order: Ordering) {
// SAFETY: using an atomic fence is safe.
unsafe {

7
src/tools/clippy/tests/ui/atomic_ordering_bool.rs → src/test/ui/lint/lint-invalid-atomic-ordering-bool.rs
View File

@ -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
}

18
src/tools/clippy/tests/ui/atomic_ordering_bool.stderr → src/test/ui/lint/lint-invalid-atomic-ordering-bool.stderr
View File

@ -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);
| ^^^^^^^^^^^^^^^^

19
src/tools/clippy/tests/ui/atomic_ordering_exchange_weak.rs → src/test/ui/lint/lint-invalid-atomic-ordering-exchange-weak.rs
View File

@ -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
}

34
src/tools/clippy/tests/ui/atomic_ordering_exchange_weak.stderr → src/test/ui/lint/lint-invalid-atomic-ordering-exchange-weak.stderr
View File

@ -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);
| ^^^^^^^^^^^^^^^^

19
src/tools/clippy/tests/ui/atomic_ordering_exchange.rs → src/test/ui/lint/lint-invalid-atomic-ordering-exchange.rs
View File

@ -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
}

34
src/tools/clippy/tests/ui/atomic_ordering_exchange.stderr → src/test/ui/lint/lint-invalid-atomic-ordering-exchange.stderr
View File

@ -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);
| ^^^^^^^^^^^^^^^^

18
src/test/ui/lint/lint-invalid-atomic-ordering-false-positive.rs Normal file
View File

@ -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);
}

13
src/tools/clippy/tests/ui/atomic_ordering_fence.rs → src/test/ui/lint/lint-invalid-atomic-ordering-fence.rs
View File

@ -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
}

6
src/tools/clippy/tests/ui/atomic_ordering_fence.stderr → src/test/ui/lint/lint-invalid-atomic-ordering-fence.stderr
View File

@ -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);
| ^^^^^^^^^^^^^^^^^

19
src/tools/clippy/tests/ui/atomic_ordering_fetch_update.rs → src/test/ui/lint/lint-invalid-atomic-ordering-fetch-update.rs
View File

@ -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
}

34
src/tools/clippy/tests/ui/atomic_ordering_fetch_update.stderr → src/test/ui/lint/lint-invalid-atomic-ordering-fetch-update.stderr
View File

@ -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));
| ^^^^^^^^^^^^^^^^

90
src/tools/clippy/tests/ui/atomic_ordering_int.rs → src/test/ui/lint/lint-invalid-atomic-ordering-int.rs
View File

@ -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
}

82
src/tools/clippy/tests/ui/atomic_ordering_int.stderr → src/test/ui/lint/lint-invalid-atomic-ordering-int.stderr
View File

@ -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);
| ^^^^^^^^^^^^^^^^

7
src/tools/clippy/tests/ui/atomic_ordering_ptr.rs → src/test/ui/lint/lint-invalid-atomic-ordering-ptr.rs
View File

@ -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
}

18
src/tools/clippy/tests/ui/atomic_ordering_ptr.stderr → src/test/ui/lint/lint-invalid-atomic-ordering-ptr.stderr
View File

@ -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);
| ^^^^^^^^^^^^^^^^

89
src/tools/clippy/tests/ui/atomic_ordering_uint.rs → src/test/ui/lint/lint-invalid-atomic-ordering-uint.rs
View File

@ -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
}

82
src/tools/clippy/tests/ui/atomic_ordering_uint.stderr → src/test/ui/lint/lint-invalid-atomic-ordering-uint.stderr
View File

@ -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);
| ^^^^^^^^^^^^^^^^

230
src/tools/clippy/clippy_lints/src/atomic_ordering.rs
View File

@ -1,230 +0,0 @@
use clippy_utils::diagnostics::span_lint_and_help;
use clippy_utils::match_def_path;
use if_chain::if_chain;
use rustc_hir::def_id::DefId;
use rustc_hir::{Expr, ExprKind};
use rustc_lint::{LateContext, LateLintPass};
use rustc_middle::ty;
use rustc_session::{declare_lint_pass, declare_tool_lint};
declare_clippy_lint! {
/// ### What it does
/// Checks for usage of invalid atomic
/// ordering in atomic loads/stores/exchanges/updates and
/// memory fences.
///
/// ### Why is this bad?
/// Using an invalid atomic ordering
/// will cause a panic at run-time.
///
/// ### Example
/// ```rust,no_run
/// # use std::sync::atomic::{self, AtomicU8, Ordering};
///
/// let x = AtomicU8::new(0);
///
/// // Bad: `Release` and `AcqRel` cannot be used for `load`.
/// let _ = x.load(Ordering::Release);
/// let _ = x.load(Ordering::AcqRel);
///
/// // Bad: `Acquire` and `AcqRel` cannot be used for `store`.
/// x.store(1, Ordering::Acquire);
/// x.store(2, Ordering::AcqRel);
///
/// // Bad: `Relaxed` cannot be used as a fence's ordering.
/// atomic::fence(Ordering::Relaxed);
/// atomic::compiler_fence(Ordering::Relaxed);
///
/// // Bad: `Release` and `AcqRel` are both always invalid
/// // for the failure ordering (the last arg).
/// let _ = x.compare_exchange(1, 2, Ordering::SeqCst, Ordering::Release);
/// let _ = x.compare_exchange_weak(2, 3, Ordering::AcqRel, Ordering::AcqRel);
///
/// // Bad: The failure ordering is not allowed to be
/// // stronger than the success order, and `SeqCst` is
/// // stronger than `Relaxed`.
/// let _ = x.fetch_update(Ordering::Relaxed, Ordering::SeqCst, |val| Some(val + val));
/// ```
pub INVALID_ATOMIC_ORDERING,
correctness,
"usage of invalid atomic ordering in atomic operations and memory fences"
}
declare_lint_pass!(AtomicOrdering => [INVALID_ATOMIC_ORDERING]);
const ATOMIC_TYPES: [&str; 12] = [
"AtomicBool",
"AtomicI8",
"AtomicI16",
"AtomicI32",
"AtomicI64",
"AtomicIsize",
"AtomicPtr",
"AtomicU8",
"AtomicU16",
"AtomicU32",
"AtomicU64",
"AtomicUsize",
];
fn type_is_atomic(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
if let ty::Adt(&ty::AdtDef { did, .. }, _) = cx.typeck_results().expr_ty(expr).kind() {
ATOMIC_TYPES
.iter()
.any(|ty| match_def_path(cx, did, &["core", "sync", "atomic", ty]))
} else {
false
}
}
fn match_ordering_def_path(cx: &LateContext<'_>, did: DefId, orderings: &[&str]) -> bool {
orderings
.iter()
.any(|ordering| match_def_path(cx, did, &["core", "sync", "atomic", "Ordering", ordering]))
}
fn check_atomic_load_store(cx: &LateContext<'_>, expr: &Expr<'_>) {
if_chain! {
if let ExprKind::MethodCall(method_path, _, args, _) = &expr.kind;
let method = method_path.ident.name.as_str();
if type_is_atomic(cx, &args[0]);
if method == "load" || method == "store";
let ordering_arg = if method == "load" { &args[1] } else { &args[2] };
if let ExprKind::Path(ref ordering_qpath) = ordering_arg.kind;
if let Some(ordering_def_id) = cx.qpath_res(ordering_qpath, ordering_arg.hir_id).opt_def_id();
then {
if method == "load" &&
match_ordering_def_path(cx, ordering_def_id, &["Release", "AcqRel"]) {
span_lint_and_help(
cx,
INVALID_ATOMIC_ORDERING,
ordering_arg.span,
"atomic loads cannot have `Release` and `AcqRel` ordering",
None,
"consider using ordering modes `Acquire`, `SeqCst` or `Relaxed`"
);
} else if method == "store" &&
match_ordering_def_path(cx, ordering_def_id, &["Acquire", "AcqRel"]) {
span_lint_and_help(
cx,
INVALID_ATOMIC_ORDERING,
ordering_arg.span,
"atomic stores cannot have `Acquire` and `AcqRel` ordering",
None,
"consider using ordering modes `Release`, `SeqCst` or `Relaxed`"
);
}
}
}
}
fn check_memory_fence(cx: &LateContext<'_>, expr: &Expr<'_>) {
if_chain! {
if let ExprKind::Call(func, args) = expr.kind;
if let ExprKind::Path(ref func_qpath) = func.kind;
if let Some(def_id) = cx.qpath_res(func_qpath, func.hir_id).opt_def_id();
if ["fence", "compiler_fence"]
.iter()
.any(|func| match_def_path(cx, def_id, &["core", "sync", "atomic", func]));
if let ExprKind::Path(ref ordering_qpath) = &args[0].kind;
if let Some(ordering_def_id) = cx.qpath_res(ordering_qpath, args[0].hir_id).opt_def_id();
if match_ordering_def_path(cx, ordering_def_id, &["Relaxed"]);
then {
span_lint_and_help(
cx,
INVALID_ATOMIC_ORDERING,
args[0].span,
"memory fences cannot have `Relaxed` ordering",
None,
"consider using ordering modes `Acquire`, `Release`, `AcqRel` or `SeqCst`"
);
}
}
}
fn opt_ordering_defid(cx: &LateContext<'_>, ord_arg: &Expr<'_>) -> Option<DefId> {
if let ExprKind::Path(ref ord_qpath) = ord_arg.kind {
cx.qpath_res(ord_qpath, ord_arg.hir_id).opt_def_id()
} else {
None
}
}
fn check_atomic_compare_exchange(cx: &LateContext<'_>, expr: &Expr<'_>) {
if_chain! {
if let ExprKind::MethodCall(method_path, _, args, _) = &expr.kind;
let method = method_path.ident.name.as_str();
if type_is_atomic(cx, &args[0]);
if method == "compare_exchange" || method == "compare_exchange_weak" || method == "fetch_update";
let (success_order_arg, failure_order_arg) = if method == "fetch_update" {
(&args[1], &args[2])
} else {
(&args[3], &args[4])
};
if let Some(fail_ordering_def_id) = opt_ordering_defid(cx, failure_order_arg);
then {
// Helper type holding on to some checking and error reporting data. Has
// - (success ordering name,
// - list of failure orderings forbidden by the success order,
// - suggestion message)
type OrdLintInfo = (&'static str, &'static [&'static str], &'static str);
let relaxed: OrdLintInfo = ("Relaxed", &["SeqCst", "Acquire"], "ordering mode `Relaxed`");
let acquire: OrdLintInfo = ("Acquire", &["SeqCst"], "ordering modes `Acquire` or `Relaxed`");
let seq_cst: OrdLintInfo = ("SeqCst", &[], "ordering modes `Acquire`, `SeqCst` or `Relaxed`");
let release = ("Release", relaxed.1, relaxed.2);
let acqrel = ("AcqRel", acquire.1, acquire.2);
let search = [relaxed, acquire, seq_cst, release, acqrel];
let success_lint_info = opt_ordering_defid(cx, success_order_arg)
.and_then(|success_ord_def_id| -> Option<OrdLintInfo> {
search
.iter()
.find(|(ordering, ..)| {
match_def_path(cx, success_ord_def_id,
&["core", "sync", "atomic", "Ordering", ordering])
})
.copied()
});
if match_ordering_def_path(cx, fail_ordering_def_id, &["Release", "AcqRel"]) {
// If we don't know the success order is, use what we'd suggest
// if it were maximally permissive.
let suggested = success_lint_info.unwrap_or(seq_cst).2;
span_lint_and_help(
cx,
INVALID_ATOMIC_ORDERING,
failure_order_arg.span,
&format!(
"{}'s failure ordering may not be `Release` or `AcqRel`",
method,
),
None,
&format!("consider using {} instead", suggested),
);
} else if let Some((success_ord_name, bad_ords_given_success, suggested)) = success_lint_info {
if match_ordering_def_path(cx, fail_ordering_def_id, bad_ords_given_success) {
span_lint_and_help(
cx,
INVALID_ATOMIC_ORDERING,
failure_order_arg.span,
&format!(
"{}'s failure ordering may not be stronger than the success ordering of `{}`",
method,
success_ord_name,
),
None,
&format!("consider using {} instead", suggested),
);
}
}
}
}
}
impl<'tcx> LateLintPass<'tcx> for AtomicOrdering {
fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
check_atomic_load_store(cx, expr);
check_memory_fence(cx, expr);
check_atomic_compare_exchange(cx, expr);
}
}

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

@ -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.

1
src/tools/clippy/tests/ui/deprecated.rs
View File

@ -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() {}

8
src/tools/clippy/tests/ui/deprecated.stderr
View File

@ -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

1
src/tools/tidy/src/deps.rs
View File

@ -121,6 +121,7 @@ const PERMITTED_DEPENDENCIES: &[&str] = &[
"hashbrown",
"hermit-abi",
"humantime",
"if_chain",
"indexmap",
"instant",
"itertools",