Dangling pointer example in "FFI Idioms/Passing Strings" - is it actually correct?

[ImplOfAnImpl]

Hi everyone.

I'm relatively new to Rust, so I may be missing something, but the example at the end of "FFI Idioms/Passing Strings" doesn't seem correct to me:

...
A common mistake (so common it's in the documentation) is to not use the variable in the first block:

pub mod unsafe_module {

    // other module content

    fn report_error<S: Into<String>>(err: S) -> Result<(), std::ffi::NulError> {
        unsafe {
            // SAFETY: whoops, this contains a dangling pointer!
            seterr(std::ffi::CString::new(err.into())?.as_ptr());
        }
        Ok(())
    }
}

This code will result in a dangling pointer, because the lifetime of the CString is not extended by the pointer creation, unlike if a reference were created.

As I see it, assuming that seterr doesn't store the pointer anywhere, it won't dangle, because the scope of the corresponding temporary should be the whole statement containing the call.

Btw, the example in the documentation for CString::as_ptr is slightly different; there the creation and the usage of the pointer are in different statements and the pointer is dangling indeed:

let ptr = CString::new("Hello").expect("CString::new failed").as_ptr();
unsafe {
    // `ptr` is dangling
    *ptr;
}

Perhaps the example in "Passing Strings" should be formulated in the same way?