Attributes within patterns do not work if there is another attribute in the same pattern or above

[xinyufort]

This issue was originally discussed on https://users.rust-lang.org/t/cfg-attr-to-allow-unused-variables-doesnt-work-in-patterns/103511.

I noticed some weird behavior when it comes to attributes within destructuring patterns. For example, consider the following:

#![deny(unused_variables)]

// All `macro_use` attributes can be replaced with something else too,
// e.g., `#[allow()]`

// #[macro_use]
fn main() {
    #[derive(Default)]
    struct A {
        a: u8,
        b: u8
    }

    // #[macro_use]
    let A {
        // #[macro_use]
        a,
        #[allow(unused_variables)]
        b,
    } = Default::default();
    dbg!(a);
}

This code currently compiles fine. However, if I uncomment any of the commented-out #[macro_use] lines, I get an error from the compiler complaing about b being unused.

For example, if I uncomment the #[macro_use] line on top of the main function, I receive the following error when running it in Rust playground:

   Compiling playground v0.0.1 (/playground)
warning: `#[macro_use]` only has an effect on `extern crate` and modules
 --> src/main.rs:3:2
  |
3 |  #[macro_use]
  |  ^^^^^^^^^^^^
  |
  = note: `#[warn(unused_attributes)]` on by default

error: unused variable: `b`
  --> src/main.rs:16:9
   |
16 |         b,
   |         ^ help: try ignoring the field: `b: _`
   |
note: the lint level is defined here
  --> src/main.rs:1:9
   |
1  | #![deny(unused_variables)]
   |         ^^^^^^^^^^^^^^^^

warning: `playground` (bin "playground") generated 1 warning
error: could not compile `playground` (bin "playground") due to previous error; 1 warning emitted

I would have expected that the #[allow(unused_variables)] attribute on b would be honored by the compiler, and hence not using b anywhere in the code would not trigger a compiler error. However, that is not what seems to be happening.

I have been able to reproduce this in Rust Playground, using the Rust 2021 edition and the stable channel (1.74.0), and under both debug and release mode. I have attempted all seven possible combinations of uncommented #[macro_use] attributes; each one complains about the unused variable b.

[xinyufort]

Another observation: if the "enclosing item" is a module, and the #[macro_use] was placed on that item, then the code compiles. I tried compiling the following in Rust Playground (again, stable 2021 edition, in both debug + release modes):

#![deny(unused_variables)]

fn main() {
    hello::whatever()
}

#[macro_use]
mod hello {
    #[derive(Default)]
    struct A {
        a: u8,
        b: u8
    }
    
    pub fn whatever() {
        let A {
            a,
            #[allow(unused_variables)]
            b
        } = Default::default();
        dbg!(a);
    }
}

But, as implied in my previous message, something like this doesn't work:

#![deny(unused_variables)]

fn main() {
    hello::whatever()
}

mod hello {
    #[derive(Default)]
    struct A {
        a: u8,
        b: u8
    }
    
    #[allow()]
    pub fn whatever() {
        let A {
            a,
            #[allow(unused_variables)]
            b
        } = Default::default();
        dbg!(a);
    }
}

[kpreid]

I just hit what looks like this bug, but triggered by an unrelated attribute below the unused variable:

#![deny(unused_variables)]

#[allow(dead_code)]
struct S {
    foo: i32,
}

fn main() {
    let S {
        #[allow(unused_variables)] // has no effect, but should
        foo,
    } = S { foo: 1 };
    
    #[allow(unused_qualifications)] // can be whatever
    let _ = 1;
}

   Compiling playground v0.0.1 (/playground)
error: unused variable: `foo`
  --> src/main.rs:11:9
   |
11 |         foo,
   |         ^^^ help: try ignoring the field: `foo: _`

So, the issue title text "same pattern or above" is an understatement, regardless of whether that "above" is tree-wise or textually. Any sibling statement in the same block will also cause the problem.

[xinyufort]

A bit of a long-overdue reply...

Anyway, I tried a modification of @kpreid 's example:

#![deny(unused_variables)]

#[allow(dead_code)]
struct S {
    foo: i32,
}

fn main() {
    let S {
        #[allow(unused_variables)] // has no effect, but should
        foo,
    } = S { foo: 1 };
    
    #[allow(unused_qualifications)] // can be whatever
    dbg!(123);
}

(The only change is I replaced let _ = 1 with dbg!(123).)

This currently compiles on Rust playground (stable 1.84.1), under both debug + release modes.

However, Kevin's original example still does not work (again, same Rust playground version, on debug + release modes).

My original examples (back in #118682 (comment)) still don't work either.

At this stage, I'm having a hard time seeing what the exact pattern here is. It seems that attributes sometimes work, and sometimes don't, which is annoying.