eval_order_dependence is unclear/hard to understand/too strict #5684
Description
See this error from CI:
https://github.com/djc/quinn/runs/739773792?check_suite_focus=true#step:5:144
For example, this function triggers the warning:
https://github.com/djc/quinn/blob/master/interop/src/main.rs#L251
But the error from CI is:
error: unsequenced read of a variable
##[error] --> interop/src/main.rs:261:17
|
261 | self.retry_hq().instrument(info_span!("retry")).await,
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
note: whether read occurs before this write depends on evaluation order
--> interop/src/main.rs:262:17
|
262 | / self.throughput_hq()
263 | | .instrument(info_span!("throughput"))
264 | | .await,
| |__________________________^
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#eval_order_dependenceIt's not clear what the "read" or the "write" here is (maybe due to the tokio::join!() expansion?). Even if I use cargo expand to expand all the macros, the warning span is super unclear:
warning: unsequenced read of a variable
--> interop/src/main.rs:414:17
|
414 | / self.rebind_hq()
415 | | .instrument({
416 | | if ::tracing::dispatcher::has_been_set()
417 | | && ::tracing::Level::INFO <= ::tracing::level_filters::STATIC_MAX_LEVEL
... |
492 | | })
493 | | .await,
| |__________________________^
|
note: whether read occurs before this write depends on evaluation order
--> interop/src/main.rs:574:17
|
574 | / self.throughput_hq()
575 | | .instrument({
576 | | if ::tracing::dispatcher::has_been_set()
577 | | && ::tracing::Level::INFO <= ::tracing::level_filters::STATIC_MAX_LEVEL
... |
652 | | })
653 | | .await,
| |__________________________^
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#eval_order_dependenceExpanded version of `run_hq()`
async fn run_hq(self) -> Result<InteropResult> {
let core =
self.core_hq()
.instrument({
if ::tracing::dispatcher::has_been_set()
&& ::tracing::Level::INFO <= ::tracing::level_filters::STATIC_MAX_LEVEL
{
use ::tracing::callsite;
use ::tracing::callsite::Callsite;
let callsite = {
use ::tracing::{
callsite, subscriber::Interest, Metadata, __macro_support::*,
};
struct MyCallsite;
static META: Metadata<'static> = {
::tracing_core::metadata::Metadata::new(
"core",
"main",
::tracing::Level::INFO,
Some("interop/src/main.rs"),
Some(253u32),
Some("main"),
::tracing_core::field::FieldSet::new(
&[],
::tracing_core::callsite::Identifier(&MyCallsite),
),
::tracing::metadata::Kind::SPAN,
)
};
static INTEREST: AtomicUsize = AtomicUsize::new(0);
static REGISTRATION: Once = Once::new();
impl MyCallsite {
#[inline]
fn interest(&self) -> Interest {
match INTEREST.load(Ordering::Relaxed) {
0 => Interest::never(),
2 => Interest::always(),
_ => Interest::sometimes(),
}
}
}
impl callsite::Callsite for MyCallsite {
fn set_interest(&self, interest: Interest) {
let interest = match () {
_ if interest.is_never() => 0,
_ if interest.is_always() => 2,
_ => 1,
};
INTEREST.store(interest, Ordering::SeqCst);
}
fn metadata(&self) -> &Metadata {
&META
}
}
REGISTRATION.call_once(|| {
callsite::register(&MyCallsite);
});
&MyCallsite
};
let meta = callsite.metadata();
if {
let interest = callsite.interest();
if interest.is_never() {
false
} else if interest.is_always() {
true
} else {
let meta = callsite.metadata();
::tracing::dispatcher::get_default(|current| current.enabled(meta))
}
} {
::tracing::Span::new(meta, &{ meta.fields().value_set(&[]) })
} else {
::tracing::Span::none()
}
} else {
::tracing::Span::none()
}
})
.await;
if self.peer.sequential {
Ok(build_result(
core,
self.key_update_hq()
.instrument({
if ::tracing::dispatcher::has_been_set()
&& ::tracing::Level::INFO <= ::tracing::level_filters::STATIC_MAX_LEVEL
{
use ::tracing::callsite;
use ::tracing::callsite::Callsite;
let callsite = {
use ::tracing::{
callsite, subscriber::Interest, Metadata, __macro_support::*,
};
struct MyCallsite;
static META: Metadata<'static> = {
::tracing_core::metadata::Metadata::new(
"key_update",
"main",
::tracing::Level::INFO,
Some("interop/src/main.rs"),
Some(258u32),
Some("main"),
::tracing_core::field::FieldSet::new(
&[],
::tracing_core::callsite::Identifier(&MyCallsite),
),
::tracing::metadata::Kind::SPAN,
)
};
static INTEREST: AtomicUsize = AtomicUsize::new(0);
static REGISTRATION: Once = Once::new();
impl MyCallsite {
#[inline]
fn interest(&self) -> Interest {
match INTEREST.load(Ordering::Relaxed) {
0 => Interest::never(),
2 => Interest::always(),
_ => Interest::sometimes(),
}
}
}
impl callsite::Callsite for MyCallsite {
fn set_interest(&self, interest: Interest) {
let interest = match () {
_ if interest.is_never() => 0,
_ if interest.is_always() => 2,
_ => 1,
};
INTEREST.store(interest, Ordering::SeqCst);
}
fn metadata(&self) -> &Metadata {
&META
}
}
REGISTRATION.call_once(|| {
callsite::register(&MyCallsite);
});
&MyCallsite
};
let meta = callsite.metadata();
if {
let interest = callsite.interest();
if interest.is_never() {
false
} else if interest.is_always() {
true
} else {
let meta = callsite.metadata();
::tracing::dispatcher::get_default(|current| {
current.enabled(meta)
})
}
} {
::tracing::Span::new(meta, &{ meta.fields().value_set(&[]) })
} else {
::tracing::Span::none()
}
} else {
::tracing::Span::none()
}
})
.await,
self.rebind_hq()
.instrument({
if ::tracing::dispatcher::has_been_set()
&& ::tracing::Level::INFO <= ::tracing::level_filters::STATIC_MAX_LEVEL
{
use ::tracing::callsite;
use ::tracing::callsite::Callsite;
let callsite = {
use ::tracing::{
callsite, subscriber::Interest, Metadata, __macro_support::*,
};
struct MyCallsite;
static META: Metadata<'static> = {
::tracing_core::metadata::Metadata::new(
"rebind",
"main",
::tracing::Level::INFO,
Some("interop/src/main.rs"),
Some(260u32),
Some("main"),
::tracing_core::field::FieldSet::new(
&[],
::tracing_core::callsite::Identifier(&MyCallsite),
),
::tracing::metadata::Kind::SPAN,
)
};
static INTEREST: AtomicUsize = AtomicUsize::new(0);
static REGISTRATION: Once = Once::new();
impl MyCallsite {
#[inline]
fn interest(&self) -> Interest {
match INTEREST.load(Ordering::Relaxed) {
0 => Interest::never(),
2 => Interest::always(),
_ => Interest::sometimes(),
}
}
}
impl callsite::Callsite for MyCallsite {
fn set_interest(&self, interest: Interest) {
let interest = match () {
_ if interest.is_never() => 0,
_ if interest.is_always() => 2,
_ => 1,
};
INTEREST.store(interest, Ordering::SeqCst);
}
fn metadata(&self) -> &Metadata {
&META
}
}
REGISTRATION.call_once(|| {
callsite::register(&MyCallsite);
});
&MyCallsite
};
let meta = callsite.metadata();
if {
let interest = callsite.interest();
if interest.is_never() {
false
} else if interest.is_always() {
true
} else {
let meta = callsite.metadata();
::tracing::dispatcher::get_default(|current| {
current.enabled(meta)
})
}
} {
::tracing::Span::new(meta, &{ meta.fields().value_set(&[]) })
} else {
::tracing::Span::none()
}
} else {
::tracing::Span::none()
}
})
.await,
self.retry_hq()
.instrument({
if ::tracing::dispatcher::has_been_set()
&& ::tracing::Level::INFO <= ::tracing::level_filters::STATIC_MAX_LEVEL
{
use ::tracing::callsite;
use ::tracing::callsite::Callsite;
let callsite = {
use ::tracing::{
callsite, subscriber::Interest, Metadata, __macro_support::*,
};
struct MyCallsite;
static META: Metadata<'static> = {
::tracing_core::metadata::Metadata::new(
"retry",
"main",
::tracing::Level::INFO,
Some("interop/src/main.rs"),
Some(261u32),
Some("main"),
::tracing_core::field::FieldSet::new(
&[],
::tracing_core::callsite::Identifier(&MyCallsite),
),
::tracing::metadata::Kind::SPAN,
)
};
static INTEREST: AtomicUsize = AtomicUsize::new(0);
static REGISTRATION: Once = Once::new();
impl MyCallsite {
#[inline]
fn interest(&self) -> Interest {
match INTEREST.load(Ordering::Relaxed) {
0 => Interest::never(),
2 => Interest::always(),
_ => Interest::sometimes(),
}
}
}
impl callsite::Callsite for MyCallsite {
fn set_interest(&self, interest: Interest) {
let interest = match () {
_ if interest.is_never() => 0,
_ if interest.is_always() => 2,
_ => 1,
};
INTEREST.store(interest, Ordering::SeqCst);
}
fn metadata(&self) -> &Metadata {
&META
}
}
REGISTRATION.call_once(|| {
callsite::register(&MyCallsite);
});
&MyCallsite
};
let meta = callsite.metadata();
if {
let interest = callsite.interest();
if interest.is_never() {
false
} else if interest.is_always() {
true
} else {
let meta = callsite.metadata();
::tracing::dispatcher::get_default(|current| {
current.enabled(meta)
})
}
} {
::tracing::Span::new(meta, &{ meta.fields().value_set(&[]) })
} else {
::tracing::Span::none()
}
} else {
::tracing::Span::none()
}
})
.await,
self.throughput_hq()
.instrument({
if ::tracing::dispatcher::has_been_set()
&& ::tracing::Level::INFO <= ::tracing::level_filters::STATIC_MAX_LEVEL
{
use ::tracing::callsite;
use ::tracing::callsite::Callsite;
let callsite = {
use ::tracing::{
callsite, subscriber::Interest, Metadata, __macro_support::*,
};
struct MyCallsite;
static META: Metadata<'static> = {
::tracing_core::metadata::Metadata::new(
"throughput",
"main",
::tracing::Level::INFO,
Some("interop/src/main.rs"),
Some(263u32),
Some("main"),
::tracing_core::field::FieldSet::new(
&[],
::tracing_core::callsite::Identifier(&MyCallsite),
),
::tracing::metadata::Kind::SPAN,
)
};
static INTEREST: AtomicUsize = AtomicUsize::new(0);
static REGISTRATION: Once = Once::new();
impl MyCallsite {
#[inline]
fn interest(&self) -> Interest {
match INTEREST.load(Ordering::Relaxed) {
0 => Interest::never(),
2 => Interest::always(),
_ => Interest::sometimes(),
}
}
}
impl callsite::Callsite for MyCallsite {
fn set_interest(&self, interest: Interest) {
let interest = match () {
_ if interest.is_never() => 0,
_ if interest.is_always() => 2,
_ => 1,
};
INTEREST.store(interest, Ordering::SeqCst);
}
fn metadata(&self) -> &Metadata {
&META
}
}
REGISTRATION.call_once(|| {
callsite::register(&MyCallsite);
});
&MyCallsite
};
let meta = callsite.metadata();
if {
let interest = callsite.interest();
if interest.is_never() {
false
} else if interest.is_always() {
true
} else {
let meta = callsite.metadata();
::tracing::dispatcher::get_default(|current| {
current.enabled(meta)
})
}
} {
::tracing::Span::new(meta, &{ meta.fields().value_set(&[]) })
} else {
::tracing::Span::none()
}
} else {
::tracing::Span::none()
}
})
.await,
None,
None,
))
} else {
let (key_update, rebind, retry, throughput) = {
use ::tokio::macros::support::{maybe_done, poll_fn, Future, Pin};
use ::tokio::macros::support::Poll::{Ready, Pending};
let mut futures = (
maybe_done(self.key_update_hq().instrument({
if ::tracing::dispatcher::has_been_set()
&& ::tracing::Level::INFO <= ::tracing::level_filters::STATIC_MAX_LEVEL
{
use ::tracing::callsite;
use ::tracing::callsite::Callsite;
let callsite = {
use ::tracing::{
callsite, subscriber::Interest, Metadata, __macro_support::*,
};
struct MyCallsite;
static META: Metadata<'static> = {
::tracing_core::metadata::Metadata::new(
"key_update",
"main",
::tracing::Level::INFO,
Some("interop/src/main.rs"),
Some(270u32),
Some("main"),
::tracing_core::field::FieldSet::new(
&[],
::tracing_core::callsite::Identifier(&MyCallsite),
),
::tracing::metadata::Kind::SPAN,
)
};
static INTEREST: AtomicUsize = AtomicUsize::new(0);
static REGISTRATION: Once = Once::new();
impl MyCallsite {
#[inline]
fn interest(&self) -> Interest {
match INTEREST.load(Ordering::Relaxed) {
0 => Interest::never(),
2 => Interest::always(),
_ => Interest::sometimes(),
}
}
}
impl callsite::Callsite for MyCallsite {
fn set_interest(&self, interest: Interest) {
let interest = match () {
_ if interest.is_never() => 0,
_ if interest.is_always() => 2,
_ => 1,
};
INTEREST.store(interest, Ordering::SeqCst);
}
fn metadata(&self) -> &Metadata {
&META
}
}
REGISTRATION.call_once(|| {
callsite::register(&MyCallsite);
});
&MyCallsite
};
let meta = callsite.metadata();
if {
let interest = callsite.interest();
if interest.is_never() {
false
} else if interest.is_always() {
true
} else {
let meta = callsite.metadata();
::tracing::dispatcher::get_default(|current| {
current.enabled(meta)
})
}
} {
::tracing::Span::new(meta, &{ meta.fields().value_set(&[]) })
} else {
::tracing::Span::none()
}
} else {
::tracing::Span::none()
}
})),
maybe_done(self.rebind_hq().instrument({
if ::tracing::dispatcher::has_been_set()
&& ::tracing::Level::INFO <= ::tracing::level_filters::STATIC_MAX_LEVEL
{
use ::tracing::callsite;
use ::tracing::callsite::Callsite;
let callsite = {
use ::tracing::{
callsite, subscriber::Interest, Metadata, __macro_support::*,
};
struct MyCallsite;
static META: Metadata<'static> = {
::tracing_core::metadata::Metadata::new(
"rebind",
"main",
::tracing::Level::INFO,
Some("interop/src/main.rs"),
Some(271u32),
Some("main"),
::tracing_core::field::FieldSet::new(
&[],
::tracing_core::callsite::Identifier(&MyCallsite),
),
::tracing::metadata::Kind::SPAN,
)
};
static INTEREST: AtomicUsize = AtomicUsize::new(0);
static REGISTRATION: Once = Once::new();
impl MyCallsite {
#[inline]
fn interest(&self) -> Interest {
match INTEREST.load(Ordering::Relaxed) {
0 => Interest::never(),
2 => Interest::always(),
_ => Interest::sometimes(),
}
}
}
impl callsite::Callsite for MyCallsite {
fn set_interest(&self, interest: Interest) {
let interest = match () {
_ if interest.is_never() => 0,
_ if interest.is_always() => 2,
_ => 1,
};
INTEREST.store(interest, Ordering::SeqCst);
}
fn metadata(&self) -> &Metadata {
&META
}
}
REGISTRATION.call_once(|| {
callsite::register(&MyCallsite);
});
&MyCallsite
};
let meta = callsite.metadata();
if {
let interest = callsite.interest();
if interest.is_never() {
false
} else if interest.is_always() {
true
} else {
let meta = callsite.metadata();
::tracing::dispatcher::get_default(|current| {
current.enabled(meta)
})
}
} {
::tracing::Span::new(meta, &{ meta.fields().value_set(&[]) })
} else {
::tracing::Span::none()
}
} else {
::tracing::Span::none()
}
})),
maybe_done(self.retry_hq().instrument({
if ::tracing::dispatcher::has_been_set()
&& ::tracing::Level::INFO <= ::tracing::level_filters::STATIC_MAX_LEVEL
{
use ::tracing::callsite;
use ::tracing::callsite::Callsite;
let callsite = {
use ::tracing::{
callsite, subscriber::Interest, Metadata, __macro_support::*,
};
struct MyCallsite;
static META: Metadata<'static> = {
::tracing_core::metadata::Metadata::new(
"retry",
"main",
::tracing::Level::INFO,
Some("interop/src/main.rs"),
Some(272u32),
Some("main"),
::tracing_core::field::FieldSet::new(
&[],
::tracing_core::callsite::Identifier(&MyCallsite),
),
::tracing::metadata::Kind::SPAN,
)
};
static INTEREST: AtomicUsize = AtomicUsize::new(0);
static REGISTRATION: Once = Once::new();
impl MyCallsite {
#[inline]
fn interest(&self) -> Interest {
match INTEREST.load(Ordering::Relaxed) {
0 => Interest::never(),
2 => Interest::always(),
_ => Interest::sometimes(),
}
}
}
impl callsite::Callsite for MyCallsite {
fn set_interest(&self, interest: Interest) {
let interest = match () {
_ if interest.is_never() => 0,
_ if interest.is_always() => 2,
_ => 1,
};
INTEREST.store(interest, Ordering::SeqCst);
}
fn metadata(&self) -> &Metadata {
&META
}
}
REGISTRATION.call_once(|| {
callsite::register(&MyCallsite);
});
&MyCallsite
};
let meta = callsite.metadata();
if {
let interest = callsite.interest();
if interest.is_never() {
false
} else if interest.is_always() {
true
} else {
let meta = callsite.metadata();
::tracing::dispatcher::get_default(|current| {
current.enabled(meta)
})
}
} {
::tracing::Span::new(meta, &{ meta.fields().value_set(&[]) })
} else {
::tracing::Span::none()
}
} else {
::tracing::Span::none()
}
})),
maybe_done(self.throughput_hq().instrument({
if ::tracing::dispatcher::has_been_set()
&& ::tracing::Level::INFO <= ::tracing::level_filters::STATIC_MAX_LEVEL
{
use ::tracing::callsite;
use ::tracing::callsite::Callsite;
let callsite = {
use ::tracing::{
callsite, subscriber::Interest, Metadata, __macro_support::*,
};
struct MyCallsite;
static META: Metadata<'static> = {
::tracing_core::metadata::Metadata::new(
"throughput",
"main",
::tracing::Level::INFO,
Some("interop/src/main.rs"),
Some(273u32),
Some("main"),
::tracing_core::field::FieldSet::new(
&[],
::tracing_core::callsite::Identifier(&MyCallsite),
),
::tracing::metadata::Kind::SPAN,
)
};
static INTEREST: AtomicUsize = AtomicUsize::new(0);
static REGISTRATION: Once = Once::new();
impl MyCallsite {
#[inline]
fn interest(&self) -> Interest {
match INTEREST.load(Ordering::Relaxed) {
0 => Interest::never(),
2 => Interest::always(),
_ => Interest::sometimes(),
}
}
}
impl callsite::Callsite for MyCallsite {
fn set_interest(&self, interest: Interest) {
let interest = match () {
_ if interest.is_never() => 0,
_ if interest.is_always() => 2,
_ => 1,
};
INTEREST.store(interest, Ordering::SeqCst);
}
fn metadata(&self) -> &Metadata {
&META
}
}
REGISTRATION.call_once(|| {
callsite::register(&MyCallsite);
});
&MyCallsite
};
let meta = callsite.metadata();
if {
let interest = callsite.interest();
if interest.is_never() {
false
} else if interest.is_always() {
true
} else {
let meta = callsite.metadata();
::tracing::dispatcher::get_default(|current| {
current.enabled(meta)
})
}
} {
::tracing::Span::new(meta, &{ meta.fields().value_set(&[]) })
} else {
::tracing::Span::none()
}
} else {
::tracing::Span::none()
}
})),
);
poll_fn(move |cx| {
let mut is_pending = false;
let (fut, ..) = &mut futures;
let mut fut = unsafe { Pin::new_unchecked(fut) };
if fut.poll(cx).is_pending() {
is_pending = true;
}
let (_, fut, ..) = &mut futures;
let mut fut = unsafe { Pin::new_unchecked(fut) };
if fut.poll(cx).is_pending() {
is_pending = true;
}
let (_, _, fut, ..) = &mut futures;
let mut fut = unsafe { Pin::new_unchecked(fut) };
if fut.poll(cx).is_pending() {
is_pending = true;
}
let (_, _, _, fut, ..) = &mut futures;
let mut fut = unsafe { Pin::new_unchecked(fut) };
if fut.poll(cx).is_pending() {
is_pending = true;
}
if is_pending {
Pending
} else {
Ready((
{
let (fut, ..) = &mut futures;
let mut fut = unsafe { Pin::new_unchecked(fut) };
fut.take_output().expect("expected completed future")
},
{
let (_, fut, ..) = &mut futures;
let mut fut = unsafe { Pin::new_unchecked(fut) };
fut.take_output().expect("expected completed future")
},
{
let (_, _, fut, ..) = &mut futures;
let mut fut = unsafe { Pin::new_unchecked(fut) };
fut.take_output().expect("expected completed future")
},
{
let (_, _, _, fut, ..) = &mut futures;
let mut fut = unsafe { Pin::new_unchecked(fut) };
fut.take_output().expect("expected completed future")
},
))
}
})
.await
};
Ok(build_result(
core, key_update, rebind, retry, throughput, None, None,
))
}
}