false positive dead_code "never constructed" warning on 1.80.0 for a struct where the constructor takes &'static self

[chrisnc]

Code

/* XXX: changing Foo::init to take self: &'static Foo instead of
 * &'static self silences the dead_code warning. */
pub struct Foo {
    x: i32,
}

impl Foo {
    #[must_use]
    //pub const fn init(self: &'static Foo, x: i32) -> Foo {
    pub const fn init(&'static self, x: i32) -> Foo {
        Foo { x }
    }

    pub fn foo(&self) -> i32 {
        self.x
    }
}

#[cfg(test)]
mod test {
    use crate::Foo;

    #[test]
    fn test() {
        static FOO: Foo = FOO.init(7);
        assert_eq!(FOO.foo(), FOO.x);
    }
}

Current output

warning: struct `Foo` is never constructed
 --> src/lib.rs:3:12
  |
3 | pub struct Foo {
  |            ^^^
  |
  = note: `#[warn(dead_code)]` on by default

warning: `playground` (lib) generated 1 warning

Desired output

No output.

Rationale and extra context

This problem does not occur with 1.79.0. https://play.rust-lang.org/?version=beta&mode=debug&edition=2021&gist=ad761b02ac5d86f28629e7fa2d6a1936

This is a reduced example from real code where objects are constructed in such a way that they need static references to fields within the same object (and those objects themselves will be static). It's clearly possible to construct such an object, so the dead_code warning is not accurate.

Other cases

Changing the parameter to be self: &'static Foo instead silences the warning.

Rust Version

$ rustc --version --verbose
rustc 1.80.0 (051478957 2024-07-21)
binary: rustc
commit-hash: 051478957371ee0084a7c0913941d2a8c4757bb9
commit-date: 2024-07-21
host: aarch64-apple-darwin
release: 1.80.0
LLVM version: 18.1.7

[tgross35]

How do you wind up with the &'static self in the original code, is it via FFI? If so, #126169 / #127104 may be relevant. (If this was 1.80 then it happend before that, similar code though).

[chrisnc]

The example I pasted shows how the &'static self is obtained: static FOO: Foo = FOO.init(7);
This part matches exactly what the original code was doing. I'm not using any repr attribute in this example so I'm not sure it's related to those issues (I did notice those while searching for dups). The warning should fire for Foo if the init function didn't exist, but init constructs Foo.

[tgross35]

Completely missed the example, thanks. This is a pretty weird case considering self is the parameter that doesn't get used.

[chrisnc]

In the real code the &'static self does get used of course, but as I was minimizing it I found that it wasn't necessary to see the warning. The 'static itself is not necessary to see the warning either, but in this case I think the only way to call init in safe rust is with a static, so I included it for clarity.

[chrisnc]

Some bisecting shows that this is caused by #125572 just like the others, but this is a distinct case. I see there's some discussion about whether the FFI-constructed cases should be using some other annotation to avoid the warning which is otherwise accurate for safe Rust code, but in this instance, the liveness analysis for safe Rust is not accurate.

[theemathas]

Minimal reproduction: a library crate containing the following code

pub struct Foo(&'static Foo);  // The field is included for demonstration of how this could be useful

impl Foo {
    pub const fn chain(&'static self) -> Foo {
        Foo(self)
    }
}

// An external crate could construct Foo by writing:
// static X: Foo = X.chain();

Compiler output on nightly 2024-07-12

   Compiling playground v0.0.1 (/playground)
warning: struct `Foo` is never constructed
 --> src/lib.rs:1:12
  |
1 | pub struct Foo(&'static Foo);  // The field is included for demonstration of how this could be useful
  |            ^^^
  |
  = note: `#[warn(dead_code)]` on by default

warning: `playground` (lib) generated 1 warning
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.47s

[gurry]

A self-contained reproducer:

pub struct Foo(&'static Foo);  // The field is included for demonstration of how this could be useful
    
impl Foo {
    pub const fn chain(&'static self) -> Foo {
        Foo(self)
    }
}

fn main() {
    static _X: Foo = _X.chain();
}

[gurry]

@rustbot claim

[mu001999]

In the real code the &'static self does get used of course

@chrisnc Hi, I'm curious about what do you need an uninitialized self (&'static self) for?

[chrisnc]

@mu001999 the original comment gives some explanation:

This is a reduced example from real code where objects are constructed in such a way that they need static references to fields within the same object (and those objects themselves will be static).

The reference is not uninitialized (nor is the object, it's statically initialized, self-referentially).

[mu001999]

@chrisnc oh sorry, I missed it. i think i understand ;)