Why `std::mem::forget` cannot be used for creating static references?

pub trait Forget {
    fn forget_me_as_ptr(self) -> *const Self
    where
        Self: Sized,
    {
        let p = addr_of!(self);
        forget(self);
        p
    }

    fn forget_me_as_mut_ptr(self) -> *mut Self
    where
        Self: Sized,
    {
        self.forget_me_as_ptr() as *mut Self
    }

    fn forget_me_as_ref(self) -> &'static Self
    where
        Self: Sized,
    {
        self.forget_me_as_mut_ref()
    }

    fn forget_me_as_mut_ref(mut self) -> &'static mut Self
    where
        Self: Sized,
    {
        let p = addr_of_mut!(self);
        forget(self);
        unsafe { p.as_mut().unwrap() }
    }
}

pub fn default<T: Forget + Default>() -> &'static T {
    T::default().forget_me_as_ref()
}

#[derive(Debug)]
struct Player {
    health: u8,
    name: String,
    aliases: Vec<String>,
}

impl Drop for Player {
    fn drop(&mut self) {
        println!("Dropping [{}, {self:p}]", type_name::<Self>());
    }
}

impl Display for Player {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "[{}, {self:p}] = name: {}, health: {}, aliases: {:#?}",
            type_name::<Self>(),
            self.name,
            self.health,
            self.aliases
        )
    }
}

impl Forget for Player {}

impl Default for Player {
    fn default() -> Self {
        Self {
            health: 100,
            name: "default".into(),
            aliases: vec!["default".to_string()],
        }
    }
}

fn main() {
    let p = default::<Player>();
    println!("{p}");
}

output:

$ cargo r
    Finished dev [unoptimized + debuginfo] target(s) in 0.00s
     Running `target/debug/static_factory`
Segmentation fault (core dumped)

In the above code snippet why is it segfaulting ?
std::mem::forget just takes ownership and does not run the destructor/drop which can exactly be used to create references whose lifetime is static ? Where is the flaw in this logic ? Am new to rust and kind of wanted to understand what is the relation between references, instances of struct T, pointers. The code above looks logically correct from a naive thought. Please explain and correct.

Using std::mem::forget avoids running the Drop implementation but since self is a local variable, the memory for it will still be reclaimed and used for other things.

To get the desired behavior, you would need to move it to a stable address that won't be reused. You can do this by putting it in a Box, getting the pointer to it, and forgetting the box. Fortunately there is already a function for that: Box::leak. Something like:

pub trait Forget {
    // ... the rest ...

    fn forget_me_as_mut_ref(mut self) -> &'static mut Self
    where
        Self: Sized,
    {
        Box::leak(Box::new(self))
    }

Local variables, like the parameters of a function live on the stack, whether drop is called on it's memory doesn't make a difference in that any pointer to it becomes dangling as soon as you leave the function. Therefore unsafe { p.as_mut().unwrap() } is unsound when p points to local memory (such as the argument self) and you return the result.

My suspect is with the line:

pub fn default<T: Forget + Default>() -> &'static T {
    T::default().forget_me_as_ref()
}

T::default() creates a temporary object on stack for which we create a reference. Once the function call ends the memory corresponding to the stack allocated object is lets say garbled. Had the object been created on heap i think this would go away.