`#[instrument]` on a fn returning `Pin<Box<dyn Future>>` leads to bogus `unused_braces` lint

[Swatinem]

Bug Report

Version

0.1.29

Description

When using a fn that returns a Pin<Box<dyn Future>> and uses an async move block, I get a bogus unused_braces lint.

use std::future::Future;
use std::pin::Pin;

#[tracing::instrument]
pub fn instumented_fn() -> Pin<Box<dyn Future<Output = ()>>> {
    Box::pin(async move { () })
}

The lint is bogus and the suggestion would yield invalid code:

warning: unnecessary braces around block return value
  --> src/main.rs:50:25
   |
50 |     Box::pin(async move { () })
   |                         ^^  ^^
   |
   = note: `#[warn(unused_braces)]` on by default
help: remove these braces
   |
50 -     Box::pin(async move { () })
50 +     Box::pin(async move ())
   | 

In our original code we had something along the lines of Box::pin(async move { foo.await.map_err(…)? }).

[hawkw]

Huh, that's weird! I wonder what it is about the #[instrument] codegen that's incorrectly triggering that lint --- it should still always be generating an async move block...

[Swatinem]

Looking at the expanded source, I highlighted the redundant braces that I think rustc is pointing at:

Mind you, the expanded output might be super hard to read.

pub fn instumented_fn() -> Pin<Box<dyn Future<Output = ()>>> {
    Box::pin(async move {
        let __tracing_attr_span = {
            use ::tracing::__macro_support::Callsite as _;
            static CALLSITE: ::tracing::__macro_support::MacroCallsite = {
                use ::tracing::__macro_support::MacroCallsite;
                static META: ::tracing::Metadata<'static> = {
                    ::tracing_core::metadata::Metadata::new(
                        "instumented_fn",
                        "instrument_repro",
                        tracing::Level::INFO,
                        Some("src/main.rs"),
                        Some(4u32),
                        Some("instrument_repro"),
                        ::tracing_core::field::FieldSet::new(
                            &[],
                            ::tracing_core::callsite::Identifier(&CALLSITE),
                        ),
                        ::tracing::metadata::Kind::SPAN,
                    )
                };
                MacroCallsite::new(&META)
            };
            let mut interest = ::tracing::subscriber::Interest::never();
            if tracing::Level::INFO <= ::tracing::level_filters::STATIC_MAX_LEVEL
                && tracing::Level::INFO <= ::tracing::level_filters::LevelFilter::current()
                && {
                    interest = CALLSITE.interest();
                    !interest.is_never()
                }
                && CALLSITE.is_enabled(interest)
            {
                let meta = CALLSITE.metadata();
                ::tracing::Span::new(meta, &{ meta.fields().value_set(&[]) })
            } else {
                let span = CALLSITE.disabled_span();
                {};
                span
            }
        };
        let __tracing_instrument_future = async move {
            { // <--
                ()
            } // <--
        };
        if !__tracing_attr_span.is_disabled() {
            tracing::Instrument::instrument(__tracing_instrument_future, __tracing_attr_span).await
        } else {
            __tracing_instrument_future.await
        }
    })
}