Most dead code warnings don't work inside `const _`

[RReverser]

Given the following code:

const _: () = {
    let a: ();

    struct B {}

    enum C {}

    fn d() {}

    const E: () = {};
};

The current output is:

warning: unused variable: `a`
 --> <source>:2:9
  |
2 |     let a: ();
  |         ^ help: if this is intentional, prefix it with an underscore: `_a`
  |
  = note: `#[warn(unused_variables)]` on by default

Ideally the output should look like:

warning: unused variable: `a`
 --> <source>:2:9
  |
2 |     let a: ();
  |         ^ help: if this is intentional, prefix it with an underscore: `_a`
  |
  = note: `#[warn(unused_variables)]` on by default

warning: struct `B` is never constructed
 --> <source>:4:12
  |
4 |     struct B {}
  |            ^
  |
  = note: `#[warn(dead_code)]` on by default

warning: enum `C` is never used
 --> <source>:6:10
  |
6 |     enum C {}
  |          ^

warning: function `d` is never used
 --> <source>:8:8
  |
8 |     fn d() {}
  |        ^

warning: constant `E` is never used
  --> <source>:10:5
   |
10 |     const E: () = {};
   |     ^^^^^^^^^^^^^^^^^

warning: 5 warnings emitted

What's surprising is that adding pub changes the output to the expected one, even though pub doesn't make any meaning on const _: ():

pub const _: () = {
    let a: ();

    struct B {}

    enum C {}

    fn d() {}

    const E: () = {};
};

It's also interesting that the logic matches what happens with functions. For example, in:

fn foo() {
    let a: ();

    struct B {}

    enum C {}

    fn d() {}

    const E: () = {};
}

the function foo itself and also only the variable a are reported as unused, while the rest of the items don't get a warning:

warning: unused variable: `a`
 --> <source>:2:9
  |
2 |     let a: ();
  |         ^ help: if this is intentional, prefix it with an underscore: `_a`
  |
  = note: `#[warn(unused_variables)]` on by default

warning: function `foo` is never used
 --> <source>:1:4
  |
1 | fn foo() {
  |    ^^^
  |
  = note: `#[warn(dead_code)]` on by default

warning: 2 warnings emitted

However, once foo is made public, all the items get warnings:

warning: unused variable: `a`
 --> <source>:2:9
  |
2 |     let a: ();
  |         ^ help: if this is intentional, prefix it with an underscore: `_a`
  |
  = note: `#[warn(unused_variables)]` on by default

warning: struct `B` is never constructed
 --> <source>:4:12
  |
4 |     struct B {}
  |            ^
  |
  = note: `#[warn(dead_code)]` on by default

warning: enum `C` is never used
 --> <source>:6:10
  |
6 |     enum C {}
  |          ^

warning: function `d` is never used
 --> <source>:8:8
  |
8 |     fn d() {}
  |        ^

warning: constant `E` is never used
  --> <source>:10:5
   |
10 |     const E: () = {};
   |     ^^^^^^^^^^^^^^^^^

warning: 5 warnings emitted

Either way, const _ should have different treatment due to being anonymous, but it's still a bit surprising that only let variables get inside both const _ and fn foo.

[Noratrieb]

Trying a few more and see whether it warns for the unused S

fn main() {
    let x = { struct S; }; // WARN
    let _ = { struct S; }; // WARN
    const CX: () = { struct S; }; // NO WARN
    const _: () = { struct S; }; // NO WARN
    static SX: () = { struct S; }; // NO WARN
    static _SX: () = { struct S; }; // NO WARN
}

[estebank]

Current output:

warning: unused variable: `a`
 --> src/lib.rs:2:9
  |
2 |     let a: ();
  |         ^
  |
  = note: `#[warn(unused_variables)]` (part of `#[warn(unused)]`) on by default
help: you might have meant to pattern match on the similarly named constant `_`
  |
2 -     let a: ();
2 +     let _: ();
  |
help: if this is intentional, prefix it with an underscore
  |
2 |     let _a: ();
  |         +

warning: struct `B` is never constructed
 --> src/lib.rs:4:12
  |
4 |     struct B {}
  |            ^
  |
  = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default

warning: enum `C` is never used
 --> src/lib.rs:6:10
  |
6 |     enum C {}
  |          ^

warning: function `d` is never used
 --> src/lib.rs:8:8
  |
8 |     fn d() {}
  |        ^

warning: constant `E` is never used
  --> src/lib.rs:10:11
   |
10 |     const E: () = {};
   |           ^

pub const

warning: visibility qualifiers have no effect on `const _` declarations
 --> src/lib.rs:1:1
  |
1 | pub const _: () = {
  | ^^^ help: remove the qualifier
  |
  = note: `const _` does not declare a name, so there is nothing for the qualifier to apply to
  = note: `#[warn(unused_visibilities)]` (part of `#[warn(unused)]`) on by default

warning: unused variable: `a`
 --> src/lib.rs:2:9
  |
2 |     let a: ();
  |         ^
  |
  = note: `#[warn(unused_variables)]` (part of `#[warn(unused)]`) on by default
help: you might have meant to pattern match on the similarly named constant `_`
  |
2 -     let a: ();
2 +     let _: ();
  |
help: if this is intentional, prefix it with an underscore
  |
2 |     let _a: ();
  |         +

warning: struct `B` is never constructed
 --> src/lib.rs:4:12
  |
4 |     struct B {}
  |            ^
  |
  = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default

warning: enum `C` is never used
 --> src/lib.rs:6:10
  |
6 |     enum C {}
  |          ^

warning: function `d` is never used
 --> src/lib.rs:8:8
  |
8 |     fn d() {}
  |        ^

warning: constant `E` is never used
  --> src/lib.rs:10:11
   |
10 |     const E: () = {};
   |           ^

fn

warning: unused variable: `a`
 --> src/lib.rs:2:9
  |
2 |     let a: ();
  |         ^
  |
  = note: `#[warn(unused_variables)]` (part of `#[warn(unused)]`) on by default
help: you might have meant to pattern match on the similarly named constant `E`
  |
2 -     let a: ();
2 +     let foo::E: ();
  |
help: if this is intentional, prefix it with an underscore
  |
2 |     let _a: ();
  |         +

warning: function `foo` is never used
 --> src/lib.rs:1:4
  |
1 | fn foo() {
  |    ^^^
  |
  = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default

pub fn

warning: unused variable: `a`
 --> src/lib.rs:2:9
  |
2 |     let a: ();
  |         ^
  |
  = note: `#[warn(unused_variables)]` (part of `#[warn(unused)]`) on by default
help: you might have meant to pattern match on the similarly named constant `E`
  |
2 -     let a: ();
2 +     let foo::E: ();
  |
help: if this is intentional, prefix it with an underscore
  |
2 |     let _a: ();
  |         +

warning: struct `B` is never constructed
 --> src/lib.rs:4:12
  |
4 |     struct B {}
  |            ^
  |
  = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default

warning: enum `C` is never used
 --> src/lib.rs:6:10
  |
6 |     enum C {}
  |          ^

warning: function `d` is never used
 --> src/lib.rs:8:8
  |
8 |     fn d() {}
  |        ^

warning: constant `E` is never used
  --> src/lib.rs:10:11
   |
10 |     const E: () = {};
   |           ^

warning: unused variable: `x`
 --> src/main.rs:2:9
  |
2 |     let x = { struct S; }; // WARN
  |         ^
  |
  = note: `#[warn(unused_variables)]` (part of `#[warn(unused)]`) on by default
help: you might have meant to pattern match on the similarly named constant `_`
  |
2 -     let x = { struct S; }; // WARN
2 +     let main::_ = { struct S; }; // WARN
  |
help: if this is intentional, prefix it with an underscore
  |
2 |     let _x = { struct S; }; // WARN
  |         +

warning: struct `S` is never constructed
 --> src/main.rs:2:22
  |
2 |     let x = { struct S; }; // WARN
  |                      ^
  |
  = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default

warning: struct `S` is never constructed
 --> src/main.rs:3:22
  |
3 |     let _ = { struct S; }; // WARN
  |                      ^

warning: constant `CX` is never used
 --> src/main.rs:4:11
  |
4 |     const CX: () = { struct S; }; // NO WARN
  |           ^^

warning: struct `S` is never constructed
 --> src/main.rs:5:28
  |
5 |     const _: () = { struct S; }; // NO WARN
  |                            ^

warning: static `SX` is never used
 --> src/main.rs:6:12
  |
6 |     static SX: () = { struct S; }; // NO WARN
  |            ^^

I don't think there's anything left here to do?

[RReverser]

Nice, yeah, looks like the original motivating const _ example has been fixed.

I don't think there's anything left here to do?

Looks like the non-pub fn scenario still doesn't report unused items B, C, d, E? Unless it's intentional to report only parent foo as unused to reduce noise, but then it's inconsistent with let a that is reported as unused regardless.

[JumpiiX]

Hi, I’m starting to work on this issue. @rustbot claim