bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Slightly tweak invalid atomic ordering lint messages.

Browse source 
Co-authored-by: Esteban Kuber <estebank@users.noreply.github.com>
This commit is contained in:
Mara Bos 2022-06-22 20:03:39 +02:00
parent 1c1f221845
commit f107923cc0
7 changed files with 188 additions and 188 deletions
Download patch file Download diff file Expand all files Collapse all files

16
compiler/rustc_lint/src/types.rs
View file

@ -1554,11 +1554,11 @@ impl InvalidAtomicOrdering {
if matches!(fail_ordering, sym::Release | sym::AcqRel) { if matches!(fail_ordering, sym::Release | sym::AcqRel) {
cx.struct_span_lint(INVALID_ATOMIC_ORDERING, fail_order_arg.span, |diag| { cx.struct_span_lint(INVALID_ATOMIC_ORDERING, fail_order_arg.span, |diag| {
diag.build(&format!( diag.build(&format!(
"{method}'s failure ordering may not be `Release` or `AcqRel`, \ "`{method}`'s failure ordering may not be `Release` or `AcqRel`, \
since a failed {method} does not result in a write", since a failed `{method}` does not result in a write",
)) ))
.span_label(fail_order_arg.span, "invalid failure ordering") .span_label(fail_order_arg.span, "invalid failure ordering")
.help("consider using Acquire or Relaxed failure ordering instead") .help("consider using `Acquire` or `Relaxed` failure ordering instead")
.emit(); .emit();
}); });
} }
@ -1578,14 +1578,14 @@ impl InvalidAtomicOrdering {
}; };
cx.struct_span_lint(INVALID_ATOMIC_ORDERING, success_order_arg.span, |diag| { cx.struct_span_lint(INVALID_ATOMIC_ORDERING, success_order_arg.span, |diag| {
diag.build(&format!( diag.build(&format!(
"{method}'s success ordering must be at least as strong as its failure ordering" "`{method}`'s success ordering must be at least as strong as its failure ordering"
)) ))
.span_label(fail_order_arg.span, format!("{fail_ordering} failure ordering")) .span_label(fail_order_arg.span, format!("`{fail_ordering}` failure ordering"))
.span_label(success_order_arg.span, format!("{success_ordering} success ordering")) .span_label(success_order_arg.span, format!("`{success_ordering}` success ordering"))
.span_suggestion_short( .span_suggestion_short(
success_order_arg.span, success_order_arg.span,
format!("consider using {success_suggestion} success ordering instead"), format!("consider using `{success_suggestion}` success ordering instead"),
success_suggestion.to_string(), format!("std::sync::atomic::Ordering::{success_suggestion}"),
Applicability::MaybeIncorrect, Applicability::MaybeIncorrect,
) )
.emit(); .emit();

32
src/test/ui/lint/lint-invalid-atomic-ordering-exchange-weak.rs
View file

@ -20,43 +20,43 @@ fn main() {
// AcqRel is always forbidden as a failure ordering // AcqRel is always forbidden as a failure ordering
let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::Relaxed, Ordering::AcqRel); let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::Relaxed, Ordering::AcqRel);
//~^ ERROR compare_exchange_weak's failure ordering may not be `Release` or `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); let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::Acquire, Ordering::AcqRel);
//~^ ERROR compare_exchange_weak's failure ordering may not be `Release` or `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); let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::Release, Ordering::AcqRel);
//~^ ERROR compare_exchange_weak's failure ordering may not be `Release` or `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); let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::AcqRel, Ordering::AcqRel);
//~^ ERROR compare_exchange_weak's failure ordering may not be `Release` or `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); let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::SeqCst, Ordering::AcqRel);
//~^ ERROR compare_exchange_weak's failure ordering may not be `Release` or `AcqRel` //~^ ERROR `compare_exchange_weak`'s failure ordering may not be `Release` or `AcqRel`
// Release is always forbidden as a failure ordering // Release is always forbidden as a failure ordering
let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::Relaxed, Ordering::Release); let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::Relaxed, Ordering::Release);
//~^ ERROR compare_exchange_weak's failure ordering may not be `Release` or `AcqRel` //~^ ERROR `compare_exchange_weak`'s failure ordering may not be `Release` or `AcqRel`
let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::Acquire, Ordering::Release); let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::Acquire, Ordering::Release);
//~^ ERROR compare_exchange_weak's failure ordering may not be `Release` or `AcqRel` //~^ ERROR `compare_exchange_weak`'s failure ordering may not be `Release` or `AcqRel`
let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::Release, Ordering::Release); let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::Release, Ordering::Release);
//~^ ERROR compare_exchange_weak's failure ordering may not be `Release` or `AcqRel` //~^ ERROR `compare_exchange_weak`'s failure ordering may not be `Release` or `AcqRel`
let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::AcqRel, Ordering::Release); let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::AcqRel, Ordering::Release);
//~^ ERROR compare_exchange_weak's failure ordering may not be `Release` or `AcqRel` //~^ ERROR `compare_exchange_weak`'s failure ordering may not be `Release` or `AcqRel`
let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::SeqCst, Ordering::Release); let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::SeqCst, Ordering::Release);
//~^ ERROR compare_exchange_weak's failure ordering may not be `Release` or `AcqRel` //~^ ERROR `compare_exchange_weak`'s failure ordering may not be `Release` or `AcqRel`
// Release success order forbids failure order of Acquire or SeqCst // Release success order forbids failure order of Acquire or SeqCst
let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::Release, Ordering::Acquire); let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::Release, Ordering::Acquire);
//~^ ERROR compare_exchange_weak's success ordering must be at least as strong as //~^ ERROR `compare_exchange_weak`'s success ordering must be at least as strong as
let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::Release, Ordering::SeqCst); let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::Release, Ordering::SeqCst);
//~^ ERROR compare_exchange_weak's success ordering must be at least as strong as //~^ ERROR `compare_exchange_weak`'s success ordering must be at least as strong as
// Relaxed success order also forbids failure order of Acquire or SeqCst // Relaxed success order also forbids failure order of Acquire or SeqCst
let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::Relaxed, Ordering::SeqCst); let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::Relaxed, Ordering::SeqCst);
//~^ ERROR compare_exchange_weak's success ordering must be at least as strong as //~^ ERROR `compare_exchange_weak`'s success ordering must be at least as strong as
let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::Relaxed, Ordering::Acquire); let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::Relaxed, Ordering::Acquire);
//~^ ERROR compare_exchange_weak's success ordering must be at least as strong as //~^ ERROR `compare_exchange_weak`'s success ordering must be at least as strong as
// Acquire/AcqRel forbids failure order of SeqCst // Acquire/AcqRel forbids failure order of SeqCst
let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::Acquire, Ordering::SeqCst); let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::Acquire, Ordering::SeqCst);
//~^ ERROR compare_exchange_weak's success ordering must be at least as strong as //~^ ERROR `compare_exchange_weak`'s success ordering must be at least as strong as
let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::AcqRel, Ordering::SeqCst); let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::AcqRel, Ordering::SeqCst);
//~^ ERROR compare_exchange_weak's success ordering must be at least as strong as //~^ ERROR `compare_exchange_weak`'s success ordering must be at least as strong as
} }

88
src/test/ui/lint/lint-invalid-atomic-ordering-exchange-weak.stderr
View file

@ -1,137 +1,137 @@
error: compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`, since a failed compare_exchange_weak does not result in a write error: `compare_exchange_weak`'s failure ordering may not be `Release` or `AcqRel`, since a failed `compare_exchange_weak` does not result in a write
--> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:22:67 --> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:22:67
| |
LL | let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::Relaxed, Ordering::AcqRel); LL | let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::Relaxed, Ordering::AcqRel);
| ^^^^^^^^^^^^^^^^ invalid failure ordering | ^^^^^^^^^^^^^^^^ invalid failure ordering
| |
= note: `#[deny(invalid_atomic_ordering)]` on by default = note: `#[deny(invalid_atomic_ordering)]` on by default
= help: consider using Acquire or Relaxed failure ordering instead = help: consider using `Acquire` or `Relaxed` failure ordering instead
error: compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`, since a failed compare_exchange_weak does not result in a write error: `compare_exchange_weak`'s failure ordering may not be `Release` or `AcqRel`, since a failed `compare_exchange_weak` does not result in a write
--> $DIR/lint-invalid-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); LL | let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::Acquire, Ordering::AcqRel);
| ^^^^^^^^^^^^^^^^ invalid failure ordering | ^^^^^^^^^^^^^^^^ invalid failure ordering
| |
= help: consider using Acquire or Relaxed failure ordering instead = help: consider using `Acquire` or `Relaxed` failure ordering instead
error: compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`, since a failed compare_exchange_weak does not result in a write error: `compare_exchange_weak`'s failure ordering may not be `Release` or `AcqRel`, since a failed `compare_exchange_weak` does not result in a write
--> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:26:67 --> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:26:67
| |
LL | let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::Release, Ordering::AcqRel); LL | let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::Release, Ordering::AcqRel);
| ^^^^^^^^^^^^^^^^ invalid failure ordering | ^^^^^^^^^^^^^^^^ invalid failure ordering
| |
= help: consider using Acquire or Relaxed failure ordering instead = help: consider using `Acquire` or `Relaxed` failure ordering instead
error: compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`, since a failed compare_exchange_weak does not result in a write error: `compare_exchange_weak`'s failure ordering may not be `Release` or `AcqRel`, since a failed `compare_exchange_weak` does not result in a write
--> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:28:66 --> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:28:66
| |
LL | let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::AcqRel, Ordering::AcqRel); LL | let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::AcqRel, Ordering::AcqRel);
| ^^^^^^^^^^^^^^^^ invalid failure ordering | ^^^^^^^^^^^^^^^^ invalid failure ordering
| |
= help: consider using Acquire or Relaxed failure ordering instead = help: consider using `Acquire` or `Relaxed` failure ordering instead
error: compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`, since a failed compare_exchange_weak does not result in a write error: `compare_exchange_weak`'s failure ordering may not be `Release` or `AcqRel`, since a failed `compare_exchange_weak` does not result in a write
--> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:30:66 --> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:30:66
| |
LL | let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::SeqCst, Ordering::AcqRel); LL | let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::SeqCst, Ordering::AcqRel);
| ^^^^^^^^^^^^^^^^ invalid failure ordering | ^^^^^^^^^^^^^^^^ invalid failure ordering
| |
= help: consider using Acquire or Relaxed failure ordering instead = help: consider using `Acquire` or `Relaxed` failure ordering instead
error: compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`, since a failed compare_exchange_weak does not result in a write error: `compare_exchange_weak`'s failure ordering may not be `Release` or `AcqRel`, since a failed `compare_exchange_weak` does not result in a write
--> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:34:67 --> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:34:67
| |
LL | let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::Relaxed, Ordering::Release); LL | let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::Relaxed, Ordering::Release);
| ^^^^^^^^^^^^^^^^^ invalid failure ordering | ^^^^^^^^^^^^^^^^^ invalid failure ordering
| |
= help: consider using Acquire or Relaxed failure ordering instead = help: consider using `Acquire` or `Relaxed` failure ordering instead
error: compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`, since a failed compare_exchange_weak does not result in a write error: `compare_exchange_weak`'s failure ordering may not be `Release` or `AcqRel`, since a failed `compare_exchange_weak` does not result in a write
--> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:36:67 --> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:36:67
| |
LL | let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::Acquire, Ordering::Release); LL | let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::Acquire, Ordering::Release);
| ^^^^^^^^^^^^^^^^^ invalid failure ordering | ^^^^^^^^^^^^^^^^^ invalid failure ordering
| |
= help: consider using Acquire or Relaxed failure ordering instead = help: consider using `Acquire` or `Relaxed` failure ordering instead
error: compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`, since a failed compare_exchange_weak does not result in a write error: `compare_exchange_weak`'s failure ordering may not be `Release` or `AcqRel`, since a failed `compare_exchange_weak` does not result in a write
--> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:38:67 --> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:38:67
| |
LL | let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::Release, Ordering::Release); LL | let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::Release, Ordering::Release);
| ^^^^^^^^^^^^^^^^^ invalid failure ordering | ^^^^^^^^^^^^^^^^^ invalid failure ordering
| |
= help: consider using Acquire or Relaxed failure ordering instead = help: consider using `Acquire` or `Relaxed` failure ordering instead
error: compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`, since a failed compare_exchange_weak does not result in a write error: `compare_exchange_weak`'s failure ordering may not be `Release` or `AcqRel`, since a failed `compare_exchange_weak` does not result in a write
--> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:40:66 --> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:40:66
| |
LL | let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::AcqRel, Ordering::Release); LL | let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::AcqRel, Ordering::Release);
| ^^^^^^^^^^^^^^^^^ invalid failure ordering | ^^^^^^^^^^^^^^^^^ invalid failure ordering
| |
= help: consider using Acquire or Relaxed failure ordering instead = help: consider using `Acquire` or `Relaxed` failure ordering instead
error: compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`, since a failed compare_exchange_weak does not result in a write error: `compare_exchange_weak`'s failure ordering may not be `Release` or `AcqRel`, since a failed `compare_exchange_weak` does not result in a write
--> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:42:66 --> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:42:66
| |
LL | let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::SeqCst, Ordering::Release); LL | let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::SeqCst, Ordering::Release);
| ^^^^^^^^^^^^^^^^^ invalid failure ordering | ^^^^^^^^^^^^^^^^^ invalid failure ordering
| |
= help: consider using Acquire or Relaxed failure ordering instead = help: consider using `Acquire` or `Relaxed` failure ordering instead
error: compare_exchange_weak's success ordering must be at least as strong as its failure ordering error: `compare_exchange_weak`'s success ordering must be at least as strong as its failure ordering
--> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:46:48 --> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:46:48
| |
LL | let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::Release, Ordering::Acquire); LL | let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::Release, Ordering::Acquire);
| ^^^^^^^^^^^^^^^^^ ----------------- Acquire failure ordering | ^^^^^^^^^^^^^^^^^ ----------------- `Acquire` failure ordering
| | | |
| Release success ordering | `Release` success ordering
| help: consider using AcqRel success ordering instead | help: consider using `AcqRel` success ordering instead
error: compare_exchange_weak's success ordering must be at least as strong as its failure ordering error: `compare_exchange_weak`'s success ordering must be at least as strong as its failure ordering
--> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:48:48 --> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:48:48
| |
LL | let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::Release, Ordering::SeqCst); LL | let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::Release, Ordering::SeqCst);
| ^^^^^^^^^^^^^^^^^ ---------------- SeqCst failure ordering | ^^^^^^^^^^^^^^^^^ ---------------- `SeqCst` failure ordering
| | | |
| Release success ordering | `Release` success ordering
| help: consider using SeqCst success ordering instead | help: consider using `SeqCst` success ordering instead
error: compare_exchange_weak's success ordering must be at least as strong as its failure ordering error: `compare_exchange_weak`'s success ordering must be at least as strong as its failure ordering
--> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:52:48 --> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:52:48
| |
LL | let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::Relaxed, Ordering::SeqCst); LL | let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::Relaxed, Ordering::SeqCst);
| ^^^^^^^^^^^^^^^^^ ---------------- SeqCst failure ordering | ^^^^^^^^^^^^^^^^^ ---------------- `SeqCst` failure ordering
| | | |
| Relaxed success ordering | `Relaxed` success ordering
| help: consider using SeqCst success ordering instead | help: consider using `SeqCst` success ordering instead
error: compare_exchange_weak's success ordering must be at least as strong as its failure ordering error: `compare_exchange_weak`'s success ordering must be at least as strong as its failure ordering
--> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:54:48 --> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:54:48
| |
LL | let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::Relaxed, Ordering::Acquire); LL | let _ = x.compare_exchange_weak(ptr, ptr2, Ordering::Relaxed, Ordering::Acquire);
| ^^^^^^^^^^^^^^^^^ ----------------- Acquire failure ordering | ^^^^^^^^^^^^^^^^^ ----------------- `Acquire` failure ordering
| | | |
| Relaxed success ordering | `Relaxed` success ordering
| help: consider using Acquire success ordering instead | help: consider using `Acquire` success ordering instead
error: compare_exchange_weak's success ordering must be at least as strong as its failure ordering error: `compare_exchange_weak`'s success ordering must be at least as strong as its failure ordering
--> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:58:48 --> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:58:48
| |
LL | let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::Acquire, Ordering::SeqCst); LL | let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::Acquire, Ordering::SeqCst);
| ^^^^^^^^^^^^^^^^^ ---------------- SeqCst failure ordering | ^^^^^^^^^^^^^^^^^ ---------------- `SeqCst` failure ordering
| | | |
| Acquire success ordering | `Acquire` success ordering
| help: consider using SeqCst success ordering instead | help: consider using `SeqCst` success ordering instead
error: compare_exchange_weak's success ordering must be at least as strong as its failure ordering error: `compare_exchange_weak`'s success ordering must be at least as strong as its failure ordering
--> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:60:48 --> $DIR/lint-invalid-atomic-ordering-exchange-weak.rs:60:48
| |
LL | let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::AcqRel, Ordering::SeqCst); LL | let _ = x.compare_exchange_weak(ptr2, ptr, Ordering::AcqRel, Ordering::SeqCst);
| ^^^^^^^^^^^^^^^^ ---------------- SeqCst failure ordering | ^^^^^^^^^^^^^^^^ ---------------- `SeqCst` failure ordering
| | | |
| AcqRel success ordering | `AcqRel` success ordering
| help: consider using SeqCst success ordering instead | help: consider using `SeqCst` success ordering instead
error: aborting due to 16 previous errors error: aborting due to 16 previous errors

32
src/test/ui/lint/lint-invalid-atomic-ordering-exchange.rs
View file

@ -18,43 +18,43 @@ fn main() {
// AcqRel is always forbidden as a failure ordering // AcqRel is always forbidden as a failure ordering
let _ = x.compare_exchange(0, 0, Ordering::Relaxed, Ordering::AcqRel); let _ = x.compare_exchange(0, 0, Ordering::Relaxed, Ordering::AcqRel);
//~^ ERROR compare_exchange's failure ordering may not be `Release` or `AcqRel` //~^ ERROR `compare_exchange`'s failure ordering may not be `Release` or `AcqRel`
let _ = x.compare_exchange(0, 0, Ordering::Acquire, Ordering::AcqRel); let _ = x.compare_exchange(0, 0, Ordering::Acquire, Ordering::AcqRel);
//~^ ERROR compare_exchange's failure ordering may not be `Release` or `AcqRel` //~^ ERROR `compare_exchange`'s failure ordering may not be `Release` or `AcqRel`
let _ = x.compare_exchange(0, 0, Ordering::Release, Ordering::AcqRel); let _ = x.compare_exchange(0, 0, Ordering::Release, Ordering::AcqRel);
//~^ ERROR compare_exchange's failure ordering may not be `Release` or `AcqRel` //~^ ERROR `compare_exchange`'s failure ordering may not be `Release` or `AcqRel`
let _ = x.compare_exchange(0, 0, Ordering::AcqRel, Ordering::AcqRel); let _ = x.compare_exchange(0, 0, Ordering::AcqRel, Ordering::AcqRel);
//~^ ERROR compare_exchange's failure ordering may not be `Release` or `AcqRel` //~^ ERROR `compare_exchange`'s failure ordering may not be `Release` or `AcqRel`
let _ = x.compare_exchange(0, 0, Ordering::SeqCst, Ordering::AcqRel); let _ = x.compare_exchange(0, 0, Ordering::SeqCst, Ordering::AcqRel);
//~^ ERROR compare_exchange's failure ordering may not be `Release` or `AcqRel` //~^ ERROR `compare_exchange`'s failure ordering may not be `Release` or `AcqRel`
// Release is always forbidden as a failure ordering // Release is always forbidden as a failure ordering
let _ = x.compare_exchange(0, 0, Ordering::Relaxed, Ordering::Release); let _ = x.compare_exchange(0, 0, Ordering::Relaxed, Ordering::Release);
//~^ ERROR compare_exchange's failure ordering may not be `Release` or `AcqRel` //~^ ERROR `compare_exchange`'s failure ordering may not be `Release` or `AcqRel`
let _ = x.compare_exchange(0, 0, Ordering::Acquire, Ordering::Release); let _ = x.compare_exchange(0, 0, Ordering::Acquire, Ordering::Release);
//~^ ERROR compare_exchange's failure ordering may not be `Release` or `AcqRel` //~^ ERROR `compare_exchange`'s failure ordering may not be `Release` or `AcqRel`
let _ = x.compare_exchange(0, 0, Ordering::Release, Ordering::Release); let _ = x.compare_exchange(0, 0, Ordering::Release, Ordering::Release);
//~^ ERROR compare_exchange's failure ordering may not be `Release` or `AcqRel` //~^ ERROR `compare_exchange`'s failure ordering may not be `Release` or `AcqRel`
let _ = x.compare_exchange(0, 0, Ordering::AcqRel, Ordering::Release); let _ = x.compare_exchange(0, 0, Ordering::AcqRel, Ordering::Release);
//~^ ERROR compare_exchange's failure ordering may not be `Release` or `AcqRel` //~^ ERROR `compare_exchange`'s failure ordering may not be `Release` or `AcqRel`
let _ = x.compare_exchange(0, 0, Ordering::SeqCst, Ordering::Release); let _ = x.compare_exchange(0, 0, Ordering::SeqCst, Ordering::Release);
//~^ ERROR compare_exchange's failure ordering may not be `Release` or `AcqRel` //~^ ERROR `compare_exchange`'s failure ordering may not be `Release` or `AcqRel`
// Release success order forbids failure order of Acquire or SeqCst // Release success order forbids failure order of Acquire or SeqCst
let _ = x.compare_exchange(0, 0, Ordering::Release, Ordering::Acquire); let _ = x.compare_exchange(0, 0, Ordering::Release, Ordering::Acquire);
//~^ ERROR compare_exchange's success ordering must be at least as strong as //~^ ERROR `compare_exchange`'s success ordering must be at least as strong as
let _ = x.compare_exchange(0, 0, Ordering::Release, Ordering::SeqCst); let _ = x.compare_exchange(0, 0, Ordering::Release, Ordering::SeqCst);
//~^ ERROR compare_exchange's success ordering must be at least as strong as //~^ ERROR `compare_exchange`'s success ordering must be at least as strong as
// Relaxed success order also forbids failure order of Acquire or SeqCst // Relaxed success order also forbids failure order of Acquire or SeqCst
let _ = x.compare_exchange(0, 0, Ordering::Relaxed, Ordering::SeqCst); let _ = x.compare_exchange(0, 0, Ordering::Relaxed, Ordering::SeqCst);
//~^ ERROR compare_exchange's success ordering must be at least as strong as //~^ ERROR `compare_exchange`'s success ordering must be at least as strong as
let _ = x.compare_exchange(0, 0, Ordering::Relaxed, Ordering::Acquire); let _ = x.compare_exchange(0, 0, Ordering::Relaxed, Ordering::Acquire);
//~^ ERROR compare_exchange's success ordering must be at least as strong as //~^ ERROR `compare_exchange`'s success ordering must be at least as strong as
// Acquire/AcqRel forbids failure order of SeqCst // Acquire/AcqRel forbids failure order of SeqCst
let _ = x.compare_exchange(0, 0, Ordering::Acquire, Ordering::SeqCst); let _ = x.compare_exchange(0, 0, Ordering::Acquire, Ordering::SeqCst);
//~^ ERROR compare_exchange's success ordering must be at least as strong as //~^ ERROR `compare_exchange`'s success ordering must be at least as strong as
let _ = x.compare_exchange(0, 0, Ordering::AcqRel, Ordering::SeqCst); let _ = x.compare_exchange(0, 0, Ordering::AcqRel, Ordering::SeqCst);
//~^ ERROR compare_exchange's success ordering must be at least as strong as //~^ ERROR `compare_exchange`'s success ordering must be at least as strong as
} }

88
src/test/ui/lint/lint-invalid-atomic-ordering-exchange.stderr
View file

@ -1,137 +1,137 @@
error: compare_exchange's failure ordering may not be `Release` or `AcqRel`, since a failed compare_exchange does not result in a write error: `compare_exchange`'s failure ordering may not be `Release` or `AcqRel`, since a failed `compare_exchange` does not result in a write
--> $DIR/lint-invalid-atomic-ordering-exchange.rs:20:57 --> $DIR/lint-invalid-atomic-ordering-exchange.rs:20:57
| |
LL | let _ = x.compare_exchange(0, 0, Ordering::Relaxed, Ordering::AcqRel); LL | let _ = x.compare_exchange(0, 0, Ordering::Relaxed, Ordering::AcqRel);
| ^^^^^^^^^^^^^^^^ invalid failure ordering | ^^^^^^^^^^^^^^^^ invalid failure ordering
| |
= note: `#[deny(invalid_atomic_ordering)]` on by default = note: `#[deny(invalid_atomic_ordering)]` on by default
= help: consider using Acquire or Relaxed failure ordering instead = help: consider using `Acquire` or `Relaxed` failure ordering instead
error: compare_exchange's failure ordering may not be `Release` or `AcqRel`, since a failed compare_exchange does not result in a write error: `compare_exchange`'s failure ordering may not be `Release` or `AcqRel`, since a failed `compare_exchange` does not result in a write
--> $DIR/lint-invalid-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); LL | let _ = x.compare_exchange(0, 0, Ordering::Acquire, Ordering::AcqRel);
| ^^^^^^^^^^^^^^^^ invalid failure ordering | ^^^^^^^^^^^^^^^^ invalid failure ordering
| |
= help: consider using Acquire or Relaxed failure ordering instead = help: consider using `Acquire` or `Relaxed` failure ordering instead
error: compare_exchange's failure ordering may not be `Release` or `AcqRel`, since a failed compare_exchange does not result in a write error: `compare_exchange`'s failure ordering may not be `Release` or `AcqRel`, since a failed `compare_exchange` does not result in a write
--> $DIR/lint-invalid-atomic-ordering-exchange.rs:24:57 --> $DIR/lint-invalid-atomic-ordering-exchange.rs:24:57
| |
LL | let _ = x.compare_exchange(0, 0, Ordering::Release, Ordering::AcqRel); LL | let _ = x.compare_exchange(0, 0, Ordering::Release, Ordering::AcqRel);
| ^^^^^^^^^^^^^^^^ invalid failure ordering | ^^^^^^^^^^^^^^^^ invalid failure ordering
| |
= help: consider using Acquire or Relaxed failure ordering instead = help: consider using `Acquire` or `Relaxed` failure ordering instead
error: compare_exchange's failure ordering may not be `Release` or `AcqRel`, since a failed compare_exchange does not result in a write error: `compare_exchange`'s failure ordering may not be `Release` or `AcqRel`, since a failed `compare_exchange` does not result in a write
--> $DIR/lint-invalid-atomic-ordering-exchange.rs:26:56 --> $DIR/lint-invalid-atomic-ordering-exchange.rs:26:56
| |
LL | let _ = x.compare_exchange(0, 0, Ordering::AcqRel, Ordering::AcqRel); LL | let _ = x.compare_exchange(0, 0, Ordering::AcqRel, Ordering::AcqRel);
| ^^^^^^^^^^^^^^^^ invalid failure ordering | ^^^^^^^^^^^^^^^^ invalid failure ordering
| |
= help: consider using Acquire or Relaxed failure ordering instead = help: consider using `Acquire` or `Relaxed` failure ordering instead
error: compare_exchange's failure ordering may not be `Release` or `AcqRel`, since a failed compare_exchange does not result in a write error: `compare_exchange`'s failure ordering may not be `Release` or `AcqRel`, since a failed `compare_exchange` does not result in a write
--> $DIR/lint-invalid-atomic-ordering-exchange.rs:28:56 --> $DIR/lint-invalid-atomic-ordering-exchange.rs:28:56
| |
LL | let _ = x.compare_exchange(0, 0, Ordering::SeqCst, Ordering::AcqRel); LL | let _ = x.compare_exchange(0, 0, Ordering::SeqCst, Ordering::AcqRel);
| ^^^^^^^^^^^^^^^^ invalid failure ordering | ^^^^^^^^^^^^^^^^ invalid failure ordering
| |
= help: consider using Acquire or Relaxed failure ordering instead = help: consider using `Acquire` or `Relaxed` failure ordering instead
error: compare_exchange's failure ordering may not be `Release` or `AcqRel`, since a failed compare_exchange does not result in a write error: `compare_exchange`'s failure ordering may not be `Release` or `AcqRel`, since a failed `compare_exchange` does not result in a write
--> $DIR/lint-invalid-atomic-ordering-exchange.rs:32:57 --> $DIR/lint-invalid-atomic-ordering-exchange.rs:32:57
| |
LL | let _ = x.compare_exchange(0, 0, Ordering::Relaxed, Ordering::Release); LL | let _ = x.compare_exchange(0, 0, Ordering::Relaxed, Ordering::Release);
| ^^^^^^^^^^^^^^^^^ invalid failure ordering | ^^^^^^^^^^^^^^^^^ invalid failure ordering
| |
= help: consider using Acquire or Relaxed failure ordering instead = help: consider using `Acquire` or `Relaxed` failure ordering instead
error: compare_exchange's failure ordering may not be `Release` or `AcqRel`, since a failed compare_exchange does not result in a write error: `compare_exchange`'s failure ordering may not be `Release` or `AcqRel`, since a failed `compare_exchange` does not result in a write
--> $DIR/lint-invalid-atomic-ordering-exchange.rs:34:57 --> $DIR/lint-invalid-atomic-ordering-exchange.rs:34:57
| |
LL | let _ = x.compare_exchange(0, 0, Ordering::Acquire, Ordering::Release); LL | let _ = x.compare_exchange(0, 0, Ordering::Acquire, Ordering::Release);
| ^^^^^^^^^^^^^^^^^ invalid failure ordering | ^^^^^^^^^^^^^^^^^ invalid failure ordering
| |
= help: consider using Acquire or Relaxed failure ordering instead = help: consider using `Acquire` or `Relaxed` failure ordering instead
error: compare_exchange's failure ordering may not be `Release` or `AcqRel`, since a failed compare_exchange does not result in a write error: `compare_exchange`'s failure ordering may not be `Release` or `AcqRel`, since a failed `compare_exchange` does not result in a write
--> $DIR/lint-invalid-atomic-ordering-exchange.rs:36:57 --> $DIR/lint-invalid-atomic-ordering-exchange.rs:36:57
| |
LL | let _ = x.compare_exchange(0, 0, Ordering::Release, Ordering::Release); LL | let _ = x.compare_exchange(0, 0, Ordering::Release, Ordering::Release);
| ^^^^^^^^^^^^^^^^^ invalid failure ordering | ^^^^^^^^^^^^^^^^^ invalid failure ordering
| |
= help: consider using Acquire or Relaxed failure ordering instead = help: consider using `Acquire` or `Relaxed` failure ordering instead
error: compare_exchange's failure ordering may not be `Release` or `AcqRel`, since a failed compare_exchange does not result in a write error: `compare_exchange`'s failure ordering may not be `Release` or `AcqRel`, since a failed `compare_exchange` does not result in a write
--> $DIR/lint-invalid-atomic-ordering-exchange.rs:38:56 --> $DIR/lint-invalid-atomic-ordering-exchange.rs:38:56
| |
LL | let _ = x.compare_exchange(0, 0, Ordering::AcqRel, Ordering::Release); LL | let _ = x.compare_exchange(0, 0, Ordering::AcqRel, Ordering::Release);
| ^^^^^^^^^^^^^^^^^ invalid failure ordering | ^^^^^^^^^^^^^^^^^ invalid failure ordering
| |
= help: consider using Acquire or Relaxed failure ordering instead = help: consider using `Acquire` or `Relaxed` failure ordering instead
error: compare_exchange's failure ordering may not be `Release` or `AcqRel`, since a failed compare_exchange does not result in a write error: `compare_exchange`'s failure ordering may not be `Release` or `AcqRel`, since a failed `compare_exchange` does not result in a write
--> $DIR/lint-invalid-atomic-ordering-exchange.rs:40:56 --> $DIR/lint-invalid-atomic-ordering-exchange.rs:40:56
| |
LL | let _ = x.compare_exchange(0, 0, Ordering::SeqCst, Ordering::Release); LL | let _ = x.compare_exchange(0, 0, Ordering::SeqCst, Ordering::Release);
| ^^^^^^^^^^^^^^^^^ invalid failure ordering | ^^^^^^^^^^^^^^^^^ invalid failure ordering
| |
= help: consider using Acquire or Relaxed failure ordering instead = help: consider using `Acquire` or `Relaxed` failure ordering instead
error: compare_exchange's success ordering must be at least as strong as its failure ordering error: `compare_exchange`'s success ordering must be at least as strong as its failure ordering
--> $DIR/lint-invalid-atomic-ordering-exchange.rs:44:38 --> $DIR/lint-invalid-atomic-ordering-exchange.rs:44:38
| |
LL | let _ = x.compare_exchange(0, 0, Ordering::Release, Ordering::Acquire); LL | let _ = x.compare_exchange(0, 0, Ordering::Release, Ordering::Acquire);
| ^^^^^^^^^^^^^^^^^ ----------------- Acquire failure ordering | ^^^^^^^^^^^^^^^^^ ----------------- `Acquire` failure ordering
| | | |
| Release success ordering | `Release` success ordering
| help: consider using AcqRel success ordering instead | help: consider using `AcqRel` success ordering instead
error: compare_exchange's success ordering must be at least as strong as its failure ordering error: `compare_exchange`'s success ordering must be at least as strong as its failure ordering
--> $DIR/lint-invalid-atomic-ordering-exchange.rs:46:38 --> $DIR/lint-invalid-atomic-ordering-exchange.rs:46:38
| |
LL | let _ = x.compare_exchange(0, 0, Ordering::Release, Ordering::SeqCst); LL | let _ = x.compare_exchange(0, 0, Ordering::Release, Ordering::SeqCst);
| ^^^^^^^^^^^^^^^^^ ---------------- SeqCst failure ordering | ^^^^^^^^^^^^^^^^^ ---------------- `SeqCst` failure ordering
| | | |
| Release success ordering | `Release` success ordering
| help: consider using SeqCst success ordering instead | help: consider using `SeqCst` success ordering instead
error: compare_exchange's success ordering must be at least as strong as its failure ordering error: `compare_exchange`'s success ordering must be at least as strong as its failure ordering
--> $DIR/lint-invalid-atomic-ordering-exchange.rs:50:38 --> $DIR/lint-invalid-atomic-ordering-exchange.rs:50:38
| |
LL | let _ = x.compare_exchange(0, 0, Ordering::Relaxed, Ordering::SeqCst); LL | let _ = x.compare_exchange(0, 0, Ordering::Relaxed, Ordering::SeqCst);
| ^^^^^^^^^^^^^^^^^ ---------------- SeqCst failure ordering | ^^^^^^^^^^^^^^^^^ ---------------- `SeqCst` failure ordering
| | | |
| Relaxed success ordering | `Relaxed` success ordering
| help: consider using SeqCst success ordering instead | help: consider using `SeqCst` success ordering instead
error: compare_exchange's success ordering must be at least as strong as its failure ordering error: `compare_exchange`'s success ordering must be at least as strong as its failure ordering
--> $DIR/lint-invalid-atomic-ordering-exchange.rs:52:38 --> $DIR/lint-invalid-atomic-ordering-exchange.rs:52:38
| |
LL | let _ = x.compare_exchange(0, 0, Ordering::Relaxed, Ordering::Acquire); LL | let _ = x.compare_exchange(0, 0, Ordering::Relaxed, Ordering::Acquire);
| ^^^^^^^^^^^^^^^^^ ----------------- Acquire failure ordering | ^^^^^^^^^^^^^^^^^ ----------------- `Acquire` failure ordering
| | | |
| Relaxed success ordering | `Relaxed` success ordering
| help: consider using Acquire success ordering instead | help: consider using `Acquire` success ordering instead
error: compare_exchange's success ordering must be at least as strong as its failure ordering error: `compare_exchange`'s success ordering must be at least as strong as its failure ordering
--> $DIR/lint-invalid-atomic-ordering-exchange.rs:56:38 --> $DIR/lint-invalid-atomic-ordering-exchange.rs:56:38
| |
LL | let _ = x.compare_exchange(0, 0, Ordering::Acquire, Ordering::SeqCst); LL | let _ = x.compare_exchange(0, 0, Ordering::Acquire, Ordering::SeqCst);
| ^^^^^^^^^^^^^^^^^ ---------------- SeqCst failure ordering | ^^^^^^^^^^^^^^^^^ ---------------- `SeqCst` failure ordering
| | | |
| Acquire success ordering | `Acquire` success ordering
| help: consider using SeqCst success ordering instead | help: consider using `SeqCst` success ordering instead
error: compare_exchange's success ordering must be at least as strong as its failure ordering error: `compare_exchange`'s success ordering must be at least as strong as its failure ordering
--> $DIR/lint-invalid-atomic-ordering-exchange.rs:58:38 --> $DIR/lint-invalid-atomic-ordering-exchange.rs:58:38
| |
LL | let _ = x.compare_exchange(0, 0, Ordering::AcqRel, Ordering::SeqCst); LL | let _ = x.compare_exchange(0, 0, Ordering::AcqRel, Ordering::SeqCst);
| ^^^^^^^^^^^^^^^^ ---------------- SeqCst failure ordering | ^^^^^^^^^^^^^^^^ ---------------- `SeqCst` failure ordering
| | | |
| AcqRel success ordering | `AcqRel` success ordering
| help: consider using SeqCst success ordering instead | help: consider using `SeqCst` success ordering instead
error: aborting due to 16 previous errors error: aborting due to 16 previous errors

32
src/test/ui/lint/lint-invalid-atomic-ordering-fetch-update.rs
View file

@ -18,43 +18,43 @@ fn main() {
// AcqRel is always forbidden as a failure ordering // AcqRel is always forbidden as a failure ordering
let _ = x.fetch_update(Ordering::Relaxed, Ordering::AcqRel, |old| Some(old + 1)); let _ = x.fetch_update(Ordering::Relaxed, Ordering::AcqRel, |old| Some(old + 1));
//~^ ERROR fetch_update's failure ordering may not be `Release` or `AcqRel` //~^ ERROR `fetch_update`'s failure ordering may not be `Release` or `AcqRel`
let _ = x.fetch_update(Ordering::Acquire, Ordering::AcqRel, |old| Some(old + 1)); let _ = x.fetch_update(Ordering::Acquire, Ordering::AcqRel, |old| Some(old + 1));
//~^ ERROR fetch_update's failure ordering may not be `Release` or `AcqRel` //~^ ERROR `fetch_update`'s failure ordering may not be `Release` or `AcqRel`
let _ = x.fetch_update(Ordering::Release, Ordering::AcqRel, |old| Some(old + 1)); let _ = x.fetch_update(Ordering::Release, Ordering::AcqRel, |old| Some(old + 1));
//~^ ERROR fetch_update's failure ordering may not be `Release` or `AcqRel` //~^ ERROR `fetch_update`'s failure ordering may not be `Release` or `AcqRel`
let _ = x.fetch_update(Ordering::AcqRel, Ordering::AcqRel, |old| Some(old + 1)); let _ = x.fetch_update(Ordering::AcqRel, Ordering::AcqRel, |old| Some(old + 1));
//~^ ERROR fetch_update's failure ordering may not be `Release` or `AcqRel` //~^ ERROR `fetch_update`'s failure ordering may not be `Release` or `AcqRel`
let _ = x.fetch_update(Ordering::SeqCst, Ordering::AcqRel, |old| Some(old + 1)); let _ = x.fetch_update(Ordering::SeqCst, Ordering::AcqRel, |old| Some(old + 1));
//~^ ERROR fetch_update's failure ordering may not be `Release` or `AcqRel` //~^ ERROR `fetch_update`'s failure ordering may not be `Release` or `AcqRel`
// Release is always forbidden as a failure ordering // Release is always forbidden as a failure ordering
let _ = x.fetch_update(Ordering::Relaxed, Ordering::Release, |old| Some(old + 1)); let _ = x.fetch_update(Ordering::Relaxed, Ordering::Release, |old| Some(old + 1));
//~^ ERROR fetch_update's failure ordering may not be `Release` or `AcqRel` //~^ ERROR `fetch_update`'s failure ordering may not be `Release` or `AcqRel`
let _ = x.fetch_update(Ordering::Acquire, Ordering::Release, |old| Some(old + 1)); let _ = x.fetch_update(Ordering::Acquire, Ordering::Release, |old| Some(old + 1));
//~^ ERROR fetch_update's failure ordering may not be `Release` or `AcqRel` //~^ ERROR `fetch_update`'s failure ordering may not be `Release` or `AcqRel`
let _ = x.fetch_update(Ordering::Release, Ordering::Release, |old| Some(old + 1)); let _ = x.fetch_update(Ordering::Release, Ordering::Release, |old| Some(old + 1));
//~^ ERROR fetch_update's failure ordering may not be `Release` or `AcqRel` //~^ ERROR `fetch_update`'s failure ordering may not be `Release` or `AcqRel`
let _ = x.fetch_update(Ordering::AcqRel, Ordering::Release, |old| Some(old + 1)); let _ = x.fetch_update(Ordering::AcqRel, Ordering::Release, |old| Some(old + 1));
//~^ ERROR fetch_update's failure ordering may not be `Release` or `AcqRel` //~^ ERROR `fetch_update`'s failure ordering may not be `Release` or `AcqRel`
let _ = x.fetch_update(Ordering::SeqCst, Ordering::Release, |old| Some(old + 1)); let _ = x.fetch_update(Ordering::SeqCst, Ordering::Release, |old| Some(old + 1));
//~^ ERROR fetch_update's failure ordering may not be `Release` or `AcqRel` //~^ ERROR `fetch_update`'s failure ordering may not be `Release` or `AcqRel`
// Release success order forbids failure order of Acquire or SeqCst // Release success order forbids failure order of Acquire or SeqCst
let _ = x.fetch_update(Ordering::Release, Ordering::Acquire, |old| Some(old + 1)); let _ = x.fetch_update(Ordering::Release, Ordering::Acquire, |old| Some(old + 1));
//~^ ERROR fetch_update's success ordering must be at least as strong as //~^ ERROR `fetch_update`'s success ordering must be at least as strong as
let _ = x.fetch_update(Ordering::Release, Ordering::SeqCst, |old| Some(old + 1)); let _ = x.fetch_update(Ordering::Release, Ordering::SeqCst, |old| Some(old + 1));
//~^ ERROR fetch_update's success ordering must be at least as strong as //~^ ERROR `fetch_update`'s success ordering must be at least as strong as
// Relaxed success order also forbids failure order of Acquire or SeqCst // Relaxed success order also forbids failure order of Acquire or SeqCst
let _ = x.fetch_update(Ordering::Relaxed, Ordering::SeqCst, |old| Some(old + 1)); let _ = x.fetch_update(Ordering::Relaxed, Ordering::SeqCst, |old| Some(old + 1));
//~^ ERROR fetch_update's success ordering must be at least as strong as //~^ ERROR `fetch_update`'s success ordering must be at least as strong as
let _ = x.fetch_update(Ordering::Relaxed, Ordering::Acquire, |old| Some(old + 1)); let _ = x.fetch_update(Ordering::Relaxed, Ordering::Acquire, |old| Some(old + 1));
//~^ ERROR fetch_update's success ordering must be at least as strong as //~^ ERROR `fetch_update`'s success ordering must be at least as strong as
// Acquire/AcqRel forbids failure order of SeqCst // Acquire/AcqRel forbids failure order of SeqCst
let _ = x.fetch_update(Ordering::Acquire, Ordering::SeqCst, |old| Some(old + 1)); let _ = x.fetch_update(Ordering::Acquire, Ordering::SeqCst, |old| Some(old + 1));
//~^ ERROR fetch_update's success ordering must be at least as strong as //~^ ERROR `fetch_update`'s success ordering must be at least as strong as
let _ = x.fetch_update(Ordering::AcqRel, Ordering::SeqCst, |old| Some(old + 1)); let _ = x.fetch_update(Ordering::AcqRel, Ordering::SeqCst, |old| Some(old + 1));
//~^ ERROR fetch_update's success ordering must be at least as strong as //~^ ERROR `fetch_update`'s success ordering must be at least as strong as
} }

88
src/test/ui/lint/lint-invalid-atomic-ordering-fetch-update.stderr
View file

@ -1,137 +1,137 @@
error: fetch_update's failure ordering may not be `Release` or `AcqRel`, since a failed fetch_update does not result in a write error: `fetch_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `fetch_update` does not result in a write
--> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:20:47 --> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:20:47
| |
LL | let _ = x.fetch_update(Ordering::Relaxed, Ordering::AcqRel, |old| Some(old + 1)); LL | let _ = x.fetch_update(Ordering::Relaxed, Ordering::AcqRel, |old| Some(old + 1));
| ^^^^^^^^^^^^^^^^ invalid failure ordering | ^^^^^^^^^^^^^^^^ invalid failure ordering
| |
= note: `#[deny(invalid_atomic_ordering)]` on by default = note: `#[deny(invalid_atomic_ordering)]` on by default
= help: consider using Acquire or Relaxed failure ordering instead = help: consider using `Acquire` or `Relaxed` failure ordering instead
error: fetch_update's failure ordering may not be `Release` or `AcqRel`, since a failed fetch_update does not result in a write error: `fetch_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `fetch_update` does not result in a write
--> $DIR/lint-invalid-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)); LL | let _ = x.fetch_update(Ordering::Acquire, Ordering::AcqRel, |old| Some(old + 1));
| ^^^^^^^^^^^^^^^^ invalid failure ordering | ^^^^^^^^^^^^^^^^ invalid failure ordering
| |
= help: consider using Acquire or Relaxed failure ordering instead = help: consider using `Acquire` or `Relaxed` failure ordering instead
error: fetch_update's failure ordering may not be `Release` or `AcqRel`, since a failed fetch_update does not result in a write error: `fetch_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `fetch_update` does not result in a write
--> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:24:47 --> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:24:47
| |
LL | let _ = x.fetch_update(Ordering::Release, Ordering::AcqRel, |old| Some(old + 1)); LL | let _ = x.fetch_update(Ordering::Release, Ordering::AcqRel, |old| Some(old + 1));
| ^^^^^^^^^^^^^^^^ invalid failure ordering | ^^^^^^^^^^^^^^^^ invalid failure ordering
| |
= help: consider using Acquire or Relaxed failure ordering instead = help: consider using `Acquire` or `Relaxed` failure ordering instead
error: fetch_update's failure ordering may not be `Release` or `AcqRel`, since a failed fetch_update does not result in a write error: `fetch_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `fetch_update` does not result in a write
--> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:26:46 --> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:26:46
| |
LL | let _ = x.fetch_update(Ordering::AcqRel, Ordering::AcqRel, |old| Some(old + 1)); LL | let _ = x.fetch_update(Ordering::AcqRel, Ordering::AcqRel, |old| Some(old + 1));
| ^^^^^^^^^^^^^^^^ invalid failure ordering | ^^^^^^^^^^^^^^^^ invalid failure ordering
| |
= help: consider using Acquire or Relaxed failure ordering instead = help: consider using `Acquire` or `Relaxed` failure ordering instead
error: fetch_update's failure ordering may not be `Release` or `AcqRel`, since a failed fetch_update does not result in a write error: `fetch_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `fetch_update` does not result in a write
--> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:28:46 --> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:28:46
| |
LL | let _ = x.fetch_update(Ordering::SeqCst, Ordering::AcqRel, |old| Some(old + 1)); LL | let _ = x.fetch_update(Ordering::SeqCst, Ordering::AcqRel, |old| Some(old + 1));
| ^^^^^^^^^^^^^^^^ invalid failure ordering | ^^^^^^^^^^^^^^^^ invalid failure ordering
| |
= help: consider using Acquire or Relaxed failure ordering instead = help: consider using `Acquire` or `Relaxed` failure ordering instead
error: fetch_update's failure ordering may not be `Release` or `AcqRel`, since a failed fetch_update does not result in a write error: `fetch_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `fetch_update` does not result in a write
--> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:32:47 --> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:32:47
| |
LL | let _ = x.fetch_update(Ordering::Relaxed, Ordering::Release, |old| Some(old + 1)); LL | let _ = x.fetch_update(Ordering::Relaxed, Ordering::Release, |old| Some(old + 1));
| ^^^^^^^^^^^^^^^^^ invalid failure ordering | ^^^^^^^^^^^^^^^^^ invalid failure ordering
| |
= help: consider using Acquire or Relaxed failure ordering instead = help: consider using `Acquire` or `Relaxed` failure ordering instead
error: fetch_update's failure ordering may not be `Release` or `AcqRel`, since a failed fetch_update does not result in a write error: `fetch_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `fetch_update` does not result in a write
--> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:34:47 --> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:34:47
| |
LL | let _ = x.fetch_update(Ordering::Acquire, Ordering::Release, |old| Some(old + 1)); LL | let _ = x.fetch_update(Ordering::Acquire, Ordering::Release, |old| Some(old + 1));
| ^^^^^^^^^^^^^^^^^ invalid failure ordering | ^^^^^^^^^^^^^^^^^ invalid failure ordering
| |
= help: consider using Acquire or Relaxed failure ordering instead = help: consider using `Acquire` or `Relaxed` failure ordering instead
error: fetch_update's failure ordering may not be `Release` or `AcqRel`, since a failed fetch_update does not result in a write error: `fetch_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `fetch_update` does not result in a write
--> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:36:47 --> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:36:47
| |
LL | let _ = x.fetch_update(Ordering::Release, Ordering::Release, |old| Some(old + 1)); LL | let _ = x.fetch_update(Ordering::Release, Ordering::Release, |old| Some(old + 1));
| ^^^^^^^^^^^^^^^^^ invalid failure ordering | ^^^^^^^^^^^^^^^^^ invalid failure ordering
| |
= help: consider using Acquire or Relaxed failure ordering instead = help: consider using `Acquire` or `Relaxed` failure ordering instead
error: fetch_update's failure ordering may not be `Release` or `AcqRel`, since a failed fetch_update does not result in a write error: `fetch_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `fetch_update` does not result in a write
--> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:38:46 --> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:38:46
| |
LL | let _ = x.fetch_update(Ordering::AcqRel, Ordering::Release, |old| Some(old + 1)); LL | let _ = x.fetch_update(Ordering::AcqRel, Ordering::Release, |old| Some(old + 1));
| ^^^^^^^^^^^^^^^^^ invalid failure ordering | ^^^^^^^^^^^^^^^^^ invalid failure ordering
| |
= help: consider using Acquire or Relaxed failure ordering instead = help: consider using `Acquire` or `Relaxed` failure ordering instead
error: fetch_update's failure ordering may not be `Release` or `AcqRel`, since a failed fetch_update does not result in a write error: `fetch_update`'s failure ordering may not be `Release` or `AcqRel`, since a failed `fetch_update` does not result in a write
--> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:40:46 --> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:40:46
| |
LL | let _ = x.fetch_update(Ordering::SeqCst, Ordering::Release, |old| Some(old + 1)); LL | let _ = x.fetch_update(Ordering::SeqCst, Ordering::Release, |old| Some(old + 1));
| ^^^^^^^^^^^^^^^^^ invalid failure ordering | ^^^^^^^^^^^^^^^^^ invalid failure ordering
| |
= help: consider using Acquire or Relaxed failure ordering instead = help: consider using `Acquire` or `Relaxed` failure ordering instead
error: fetch_update's success ordering must be at least as strong as its failure ordering error: `fetch_update`'s success ordering must be at least as strong as its failure ordering
--> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:44:28 --> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:44:28
| |
LL | let _ = x.fetch_update(Ordering::Release, Ordering::Acquire, |old| Some(old + 1)); LL | let _ = x.fetch_update(Ordering::Release, Ordering::Acquire, |old| Some(old + 1));
| ^^^^^^^^^^^^^^^^^ ----------------- Acquire failure ordering | ^^^^^^^^^^^^^^^^^ ----------------- `Acquire` failure ordering
| | | |
| Release success ordering | `Release` success ordering
| help: consider using AcqRel success ordering instead | help: consider using `AcqRel` success ordering instead
error: fetch_update's success ordering must be at least as strong as its failure ordering error: `fetch_update`'s success ordering must be at least as strong as its failure ordering
--> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:46:28 --> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:46:28
| |
LL | let _ = x.fetch_update(Ordering::Release, Ordering::SeqCst, |old| Some(old + 1)); LL | let _ = x.fetch_update(Ordering::Release, Ordering::SeqCst, |old| Some(old + 1));
| ^^^^^^^^^^^^^^^^^ ---------------- SeqCst failure ordering | ^^^^^^^^^^^^^^^^^ ---------------- `SeqCst` failure ordering
| | | |
| Release success ordering | `Release` success ordering
| help: consider using SeqCst success ordering instead | help: consider using `SeqCst` success ordering instead
error: fetch_update's success ordering must be at least as strong as its failure ordering error: `fetch_update`'s success ordering must be at least as strong as its failure ordering
--> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:50:28 --> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:50:28
| |
LL | let _ = x.fetch_update(Ordering::Relaxed, Ordering::SeqCst, |old| Some(old + 1)); LL | let _ = x.fetch_update(Ordering::Relaxed, Ordering::SeqCst, |old| Some(old + 1));
| ^^^^^^^^^^^^^^^^^ ---------------- SeqCst failure ordering | ^^^^^^^^^^^^^^^^^ ---------------- `SeqCst` failure ordering
| | | |
| Relaxed success ordering | `Relaxed` success ordering
| help: consider using SeqCst success ordering instead | help: consider using `SeqCst` success ordering instead
error: fetch_update's success ordering must be at least as strong as its failure ordering error: `fetch_update`'s success ordering must be at least as strong as its failure ordering
--> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:52:28 --> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:52:28
| |
LL | let _ = x.fetch_update(Ordering::Relaxed, Ordering::Acquire, |old| Some(old + 1)); LL | let _ = x.fetch_update(Ordering::Relaxed, Ordering::Acquire, |old| Some(old + 1));
| ^^^^^^^^^^^^^^^^^ ----------------- Acquire failure ordering | ^^^^^^^^^^^^^^^^^ ----------------- `Acquire` failure ordering
| | | |
| Relaxed success ordering | `Relaxed` success ordering
| help: consider using Acquire success ordering instead | help: consider using `Acquire` success ordering instead
error: fetch_update's success ordering must be at least as strong as its failure ordering error: `fetch_update`'s success ordering must be at least as strong as its failure ordering
--> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:56:28 --> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:56:28
| |
LL | let _ = x.fetch_update(Ordering::Acquire, Ordering::SeqCst, |old| Some(old + 1)); LL | let _ = x.fetch_update(Ordering::Acquire, Ordering::SeqCst, |old| Some(old + 1));
| ^^^^^^^^^^^^^^^^^ ---------------- SeqCst failure ordering | ^^^^^^^^^^^^^^^^^ ---------------- `SeqCst` failure ordering
| | | |
| Acquire success ordering | `Acquire` success ordering
| help: consider using SeqCst success ordering instead | help: consider using `SeqCst` success ordering instead
error: fetch_update's success ordering must be at least as strong as its failure ordering error: `fetch_update`'s success ordering must be at least as strong as its failure ordering
--> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:58:28 --> $DIR/lint-invalid-atomic-ordering-fetch-update.rs:58:28
| |
LL | let _ = x.fetch_update(Ordering::AcqRel, Ordering::SeqCst, |old| Some(old + 1)); LL | let _ = x.fetch_update(Ordering::AcqRel, Ordering::SeqCst, |old| Some(old + 1));
| ^^^^^^^^^^^^^^^^ ---------------- SeqCst failure ordering | ^^^^^^^^^^^^^^^^ ---------------- `SeqCst` failure ordering
| | | |
| AcqRel success ordering | `AcqRel` success ordering
| help: consider using SeqCst success ordering instead | help: consider using `SeqCst` success ordering instead
error: aborting due to 16 previous errors error: aborting due to 16 previous errors