Implement Deref<Target=ByteStr> for CStr

This produces a deref chain of `CStr` -> `BStr` -> `[u8]` which is
present in the Rust-for-Linux analogues of these types.

Add `AsRef<ByteStr>` as well.

Link: rust-lang#134915
Link: Rust-for-Linux/linux#1075
Link: https://lore.kernel.org/all/20250221142816.0c015e9f@eugeo/
Link: Rust-for-Linux/linux#1146

Author: tamird

library/core/src/ffi/c_str.rs

@@ -25,6 +25,10 @@ use crate::{fmt, ops, slice, str};
 /// The `CStr` can then be converted to a Rust <code>&[str]</code> by performing
 /// UTF-8 validation, or into an owned `CString`.
 ///
+/// The `CStr` [`Deref`] implementation has the same semantics as
+/// [`CStr::to_bytes`]; the trailing nul terminator is **omitted** from
+/// [`Deref::Target`].
+///
 /// `&CStr` is to `CString` as <code>&[str]</code> is to `String`: the former
 /// in each pair are borrowed references; the latter are owned
 /// strings.
@@ -87,6 +91,8 @@ use crate::{fmt, ops, slice, str};
 /// ```
 ///
 /// [str]: prim@str "str"
+/// [`Deref`]: crate::ops::Deref
+/// [`Deref::Target`]: crate::ops::Deref::Target
 #[derive(PartialEq, Eq, Hash)]
 #[stable(feature = "core_c_str", since = "1.64.0")]
 #[rustc_diagnostic_item = "cstr_type"]
@@ -710,6 +716,22 @@ impl AsRef<CStr> for CStr {
     }
 }
 
+#[unstable(feature = "bstr", issue = "134915")]
+impl AsRef<crate::bstr::ByteStr> for CStr {
+    #[inline]
+    fn as_ref(&self) -> &crate::bstr::ByteStr {
+        crate::bstr::ByteStr::from_bytes(self.to_bytes())
+    }
+}
+
+impl ops::Deref for CStr {
+    type Target = crate::bstr::ByteStr;
+
+    fn deref(&self) -> &Self::Target {
+        self.as_ref()
+    }
+}
+
 /// Calculate the length of a nul-terminated string. Defers to C's `strlen` when possible.
 ///
 /// # Safety

src/tools/linkchecker/main.rs

@@ -46,6 +46,8 @@ const LINKCHECK_EXCEPTIONS: &[(&str, &[&str])] = &[
     // The docs in std::primitive use proper intra-doc links, so these seem fine to special-case.
     // Most these are broken because liballoc uses `#[lang_item]` magic to define things on
     // primitives that aren't available in core.
+    ("alloc/ffi/c_str/struct.CString.html", &["#method.sort_by_key"]),
+    ("alloc/ffi/struct.CString.html", &["#method.sort_by_key"]),
     ("alloc/slice/trait.Join.html", &["#method.join"]),
     ("alloc/slice/trait.Concat.html", &["#method.concat"]),
     ("alloc/slice/index.html", &["#method.concat", "#method.join"]),
@@ -73,6 +75,16 @@ const LINKCHECK_EXCEPTIONS: &[(&str, &[&str])] = &[
         "core\\bstr\\slice::sort_by_key",
         "#method.sort_by_cached_key"
     ]),
+    ("core/ffi/c_str/struct.CStr.html", &[
+        "#method.to_ascii_uppercase",
+        "#method.to_ascii_lowercase",
+        "core/ffi/c_str/slice::sort_by_key",
+    ]),
+    ("core/ffi/struct.CStr.html", &[
+        "#method.to_ascii_uppercase",
+        "#method.to_ascii_lowercase",
+        "core/ffi/slice::sort_by_key",
+    ]),
     ("core/primitive.str.html", &["#method.to_ascii_uppercase", "#method.to_ascii_lowercase"]),
     ("core/primitive.slice.html", &["#method.to_ascii_uppercase", "#method.to_ascii_lowercase",
                                     "core/slice::sort_by_key", "core\\slice::sort_by_key",

tests/ui/associated-types/associated-types-in-ambiguous-context.stderr

@@ -49,10 +49,10 @@ LL - type X = std::ops::Deref::Target;
 LL + type X = <ByteString as Deref>::Target;
    |
 LL - type X = std::ops::Deref::Target;
-LL + type X = <CString as Deref>::Target;
+LL + type X = <CStr as Deref>::Target;
    |
 LL - type X = std::ops::Deref::Target;
-LL + type X = <IoSlice<'_> as Deref>::Target;
+LL + type X = <CString as Deref>::Target;
    |
      and N other candidates