Is it okay to use 'static for references to Box in self referential structs?

Given the code snippet below:

use std::{io::BufWriter, pin::Pin};

pub struct SelfReferential {
    pub writer: BufWriter<&'static mut [u8]>, // borrowed from buffer
    pub buffer: Pin<Box<[u8]>>, 
}

#[cfg(test)]
mod tests {
    use std::io::Write;

    use super::*;
    fn init() -> SelfReferential {
        let mut buffer = Pin::new(vec![0; 12].into_boxed_slice());
        let writer = unsafe { buffer.as_mut().get_unchecked_mut() };
        let writer = unsafe { (writer as *mut [u8]).as_mut().unwrap() };
        let writer = BufWriter::new(writer);
        SelfReferential { writer, buffer }
    }

    #[test]
    fn move_works() {
        let mut sr = init();
        sr.writer.write(b"hello ").unwrap();
        sr.writer.flush().unwrap();
        let mut slice = &mut sr.buffer[6..];
        slice.write(b"world!").unwrap();
        assert_eq!(&sr.buffer[..], b"hello world!".as_ref());

        let mut sr_moved = sr;
        sr_moved.writer.write(b"W").unwrap();
        sr_moved.writer.flush().unwrap();
        assert_eq!(&sr_moved.buffer[..], b"hello World!".as_ref());
    }
}

The first question: is it OK to assign 'static lifetime to mutable slice reference in BufWriter? As technically speaking, it's bound to the lifetime of struct instances themselves, and AFAIK there's no safe way to invalidate it.

The second question: besides the fact that unsafe instantiation of this type, in test example, creates two mutable references into the underlying buffer, is there any other potential dangers associated with such an "unidiomatic" (for the lack of better word) type?

is it OK to assign 'static lifetime to mutable slice reference in BufWriter?

Sort of, but there's a bigger problem. The lifetime itself is not worse than any other choice, because there is no lifetime that you can use here which is really accurate. But it is not safe to expose that reference, because then it can be taken:

let w = BufWriter<&'static mut [u8]> = {
    let sr = init();
    sr.writer
};
// `sr.buffer` has now been dropped, so `w` has a dangling reference

is there any other potential dangers associated with such an "unidiomatic" (for the lack of better word) type?

Yes, it's undefined behavior. Box isn't just managing an allocation; it also (currently) signals a claim of unique, non-aliasing access to the contents. You violate that non-aliasing by creating the writer and then moving the buffer — even though the heap memory is not actually touched, the move of buffer is counted invalidating all references into it.

This is an area of Rust semantics which is not yet fully nailed down, but as far as the current compiler is concerned, this is UB. You can see this if you run your test code under the Miri interpreter.

The good news is, what you're trying to do is a very common desire and people have worked on the problem. I personally recommend using ouroboros — with the help of a macro, it allows you to create the struct you want without writing any new unsafe code. There will be some restrictions on how you use the writer, but nothing you can't tidy out of the way by writing an impl io::Write for SelfReferential. Another, newer library in this space is yoke; I haven't tried it.