Merge subtree update for toolchain nightly-2025-04-23 (model-checking#340)

github-actions[bot] · matthiaskrgr · frank-king · web-flow · commit 75bf5cefb801 · 2025-04-24T08:02:45.000Z
This is an automated PR to merge library subtree updates from 2025-04-21 (rust-lang/rust@b8c54d6) to 2025-04-23 (rust-lang/rust@6bc57c6), inclusive. This is a clean merge, no conflicts were detected. **Do not remove or edit the following annotations:** git-subtree-dir: library git-subtree-split: 54a7b4f --------- Signed-off-by: xizheyin <xizheyin@smail.nju.edu.cn> Signed-off-by: Petros Angelatos <petrosagg@gmail.com> Signed-off-by: Huang Qi <huangqi3@xiaomi.com> Signed-off-by: Ayush Singh <ayush@beagleboard.org> Signed-off-by: Alice Ryhl <aliceryhl@google.com> Co-authored-by: Matthias Krüger <476013+matthiaskrgr@users.noreply.github.com> Co-authored-by: Frank King <frankking1729@gmail.com> Co-authored-by: Mara Bos <m-ou.se@m-ou.se> Co-authored-by: Daniel Henry-Mantilla <daniel.henry.mantilla@gmail.com> Co-authored-by: Scott McMurray <scottmcm@users.noreply.github.com> Co-authored-by: joboet <jonasboettiger@icloud.com> Co-authored-by: Chris Denton <chris@chrisdenton.dev> Co-authored-by: bors <bors@rust-lang.org> Co-authored-by: mejrs <59372212+mejrs@users.noreply.github.com> Co-authored-by: okaneco <47607823+okaneco@users.noreply.github.com> Co-authored-by: Jacob Pratt <jacob@jhpratt.dev> Co-authored-by: xizheyin <xizheyin@smail.nju.edu.cn> Co-authored-by: Benoît du Garreau <benoit@dugarreau.fr> Co-authored-by: clubby789 <jamie@hill-daniel.co.uk> Co-authored-by: Takayuki Maeda <takoyaki0316@gmail.com> Co-authored-by: Daniel Bloom <daniel@wormholelabs.xyz> Co-authored-by: Trevor Gross <tmgross@umich.edu> Co-authored-by: Jake Wharton <jw@squareup.com> Co-authored-by: bjorn3 <17426603+bjorn3@users.noreply.github.com> Co-authored-by: Ralf Jung <post@ralfj.de> Co-authored-by: Guillaume Gomez <guillaume1.gomez@gmail.com> Co-authored-by: Kornel <kornel@geekhood.net> Co-authored-by: Calder Coalson <caldercoalson@gmail.com> Co-authored-by: Stuart Cook <Zalathar@users.noreply.github.com> Co-authored-by: Thalia Archibald <thalia@archibald.dev> Co-authored-by: github-actions <github-actions@github.com> Co-authored-by: izarma <phuckuhh@gmail.com> Co-authored-by: Bennet Bleßmann <bb-github@t-online.de> Co-authored-by: Celina G. Val <celinval@amazon.com> Co-authored-by: Jonathan Gruner <jogru0@gmail.com> Co-authored-by: Stan Manilov <stanislav.manilov@gmail.com> Co-authored-by: Gabriel Bjørnager Jensen <gabriel@achernar.io> Co-authored-by: lincot <lincot@disroot.org> Co-authored-by: timesince <seekseat@icloud.com> Co-authored-by: Boxy <rust@boxyuwu.dev> Co-authored-by: oyvindln <oyvindln@users.noreply.github.com> Co-authored-by: Alice Ryhl <aliceryhl@google.com> Co-authored-by: Folkert de Vries <folkert@folkertdev.nl> Co-authored-by: Bastian Kersting <bkersting@google.com> Co-authored-by: Petros Angelatos <petrosagg@gmail.com> Co-authored-by: Jesus Checa Hidalgo <jchecahi@redhat.com> Co-authored-by: Michael Howell <michael@notriddle.com> Co-authored-by: Ricardo Fernández Serrata <76864299+Rudxain@users.noreply.github.com> Co-authored-by: GenYuLi <witherslin@synology.com> Co-authored-by: Chris Denton <christophersdenton@gmail.com> Co-authored-by: Amanieu d'Antras <amanieu@gmail.com> Co-authored-by: Sky <sky@sky9.dev> Co-authored-by: Huang Qi <huangqi3@xiaomi.com> Co-authored-by: Ayush Singh <ayush@beagleboard.org> Co-authored-by: Jethro Beekman <jethro@fortanix.com> Co-authored-by: 0x79de <0x79de@gmail.com> Co-authored-by: binarycat <binarycat@envs.net> Co-authored-by: Glyn Normington <glyn.normington@gmail.com> Co-authored-by: Tamir Duberstein <tamird@gmail.com> Co-authored-by: Josh Triplett <josh@joshtriplett.org> Co-authored-by: Bastian Kersting <bastian@cmbt.de> Co-authored-by: Lyndon Brown <jnqnfe@gmail.com> Co-authored-by: Kent Ross <k@mad.cash> Co-authored-by: Noa <coolreader18@gmail.com> Co-authored-by: Lieselotte <52315535+she3py@users.noreply.github.com> Co-authored-by: Patrick Mooney <pmooney@pfmooney.com> Co-authored-by: Onè <43485962+c-git@users.noreply.github.com> Co-authored-by: 王宇逸 <Strawberry_Str@hotmail.com> Co-authored-by: gitbot <git@bot>
diff --git a/library/Cargo.lock b/library/Cargo.lock
diff --git a/library/alloc/src/ffi/c_str.rs b/library/alloc/src/ffi/c_str.rs
@@ -574,7 +574,7 @@ impl CString {
     #[stable(feature = "as_c_str", since = "1.20.0")]
     #[rustc_diagnostic_item = "cstring_as_c_str"]
     pub fn as_c_str(&self) -> &CStr {
-        &*self
+        unsafe { CStr::from_bytes_with_nul_unchecked(self.as_bytes_with_nul()) }
     }
 
     /// Converts this `CString` into a boxed [`CStr`].
@@ -705,14 +705,14 @@ impl ops::Deref for CString {
 
     #[inline]
     fn deref(&self) -> &CStr {
-        unsafe { CStr::from_bytes_with_nul_unchecked(self.as_bytes_with_nul()) }
+        self.as_c_str()
     }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl fmt::Debug for CString {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Debug::fmt(&**self, f)
+        fmt::Debug::fmt(self.as_c_str(), f)
     }
 }
 
diff --git a/library/alloctests/tests/c_str2.rs b/library/alloctests/tests/c_str2.rs
@@ -33,12 +33,6 @@ fn build_with_zero2() {
     assert!(CString::new(vec![0]).is_err());
 }
 
-#[test]
-fn formatted() {
-    let s = CString::new(&b"abc\x01\x02\n\xE2\x80\xA6\xFF"[..]).unwrap();
-    assert_eq!(format!("{s:?}"), r#""abc\x01\x02\n\xe2\x80\xa6\xff""#);
-}
-
 #[test]
 fn borrowed() {
     unsafe {
diff --git a/library/core/src/any.rs b/library/core/src/any.rs
@@ -772,8 +772,8 @@ impl hash::Hash for TypeId {
         //   (especially given the previous point about the lower 64 bits being
         //   high quality on their own).
         // - It is correct to do so -- only hashing a subset of `self` is still
-        //   with an `Eq` implementation that considers the entire value, as
-        //   ours does.
+        //   compatible with an `Eq` implementation that considers the entire
+        //   value, as ours does.
         self.t.1.hash(state);
     }
 }
diff --git a/library/core/src/arch.rs b/library/core/src/arch.rs
@@ -32,7 +32,7 @@ pub macro asm("assembly template", $(operands,)* $(options($(option),*))?) {
 ///
 /// [Rust By Example]: https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html
 /// [reference]: https://doc.rust-lang.org/nightly/reference/inline-assembly.html
-#[unstable(feature = "naked_functions", issue = "90957")]
+#[stable(feature = "naked_functions", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_builtin_macro]
 pub macro naked_asm("assembly template", $(operands,)* $(options($(option),*))?) {
     /* compiler built-in */
diff --git a/library/core/src/bstr/mod.rs b/library/core/src/bstr/mod.rs
@@ -36,8 +36,7 @@ use crate::ops::{Deref, DerefMut, DerefPure};
 /// presented as hex escape sequences.
 ///
 /// The `Display` implementation behaves as if the `ByteStr` were first lossily converted to a
-/// `str`, with invalid UTF-8 presented as the Unicode replacement character: �
-///
+/// `str`, with invalid UTF-8 presented as the Unicode replacement character (�).
 #[unstable(feature = "bstr", issue = "134915")]
 #[repr(transparent)]
 #[doc(alias = "BStr")]
diff --git a/library/core/src/ffi/c_str.rs b/library/core/src/ffi/c_str.rs
@@ -157,7 +157,6 @@ impl Error for FromBytesWithNulError {
 /// within the slice.
 ///
 /// This error is created by the [`CStr::from_bytes_until_nul`] method.
-///
 #[derive(Clone, PartialEq, Eq, Debug)]
 #[stable(feature = "cstr_from_bytes_until_nul", since = "1.69.0")]
 pub struct FromBytesUntilNulError(());
diff --git a/library/core/src/intrinsics/simd.rs b/library/core/src/intrinsics/simd.rs
@@ -304,7 +304,7 @@ pub unsafe fn simd_shuffle<T, U, V>(x: T, y: T, idx: U) -> V;
 ///
 /// `U` must be a vector of pointers to the element type of `T`, with the same length as `T`.
 ///
-/// `V` must be a vector of signed integers with the same length as `T` (but any element size).
+/// `V` must be a vector of integers with the same length as `T` (but any element size).
 ///
 /// For each pointer in `ptr`, if the corresponding value in `mask` is `!0`, read the pointer.
 /// Otherwise if the corresponding value in `mask` is `0`, return the corresponding value from
@@ -325,7 +325,7 @@ pub unsafe fn simd_gather<T, U, V>(val: T, ptr: U, mask: V) -> T;
 ///
 /// `U` must be a vector of pointers to the element type of `T`, with the same length as `T`.
 ///
-/// `V` must be a vector of signed integers with the same length as `T` (but any element size).
+/// `V` must be a vector of integers with the same length as `T` (but any element size).
 ///
 /// For each pointer in `ptr`, if the corresponding value in `mask` is `!0`, write the
 /// corresponding value in `val` to the pointer.
@@ -349,7 +349,7 @@ pub unsafe fn simd_scatter<T, U, V>(val: T, ptr: U, mask: V);
 ///
 /// `U` must be a pointer to the element type of `T`
 ///
-/// `V` must be a vector of signed integers with the same length as `T` (but any element size).
+/// `V` must be a vector of integers with the same length as `T` (but any element size).
 ///
 /// For each element, if the corresponding value in `mask` is `!0`, read the corresponding
 /// pointer offset from `ptr`.
@@ -372,7 +372,7 @@ pub unsafe fn simd_masked_load<V, U, T>(mask: V, ptr: U, val: T) -> T;
 ///
 /// `U` must be a pointer to the element type of `T`
 ///
-/// `V` must be a vector of signed integers with the same length as `T` (but any element size).
+/// `V` must be a vector of integers with the same length as `T` (but any element size).
 ///
 /// For each element, if the corresponding value in `mask` is `!0`, write the corresponding
 /// value in `val` to the pointer offset from `ptr`.
@@ -556,7 +556,7 @@ pub unsafe fn simd_bitmask<T, U>(x: T) -> U;
 ///
 /// `T` must be a vector.
 ///
-/// `M` must be a signed integer vector with the same length as `T` (but any element size).
+/// `M` must be an integer vector with the same length as `T` (but any element size).
 ///
 /// For each element, if the corresponding value in `mask` is `!0`, select the element from
 /// `if_true`.  If the corresponding value in `mask` is `0`, select the element from
diff --git a/library/core/src/slice/mod.rs b/library/core/src/slice/mod.rs
@@ -2814,7 +2814,7 @@ impl<T> [T] {
             let half = size / 2;
             let mid = base + half;
 
-            // SAFETY: the call is made safe by the following inconstants:
+            // SAFETY: the call is made safe by the following invariants:
             // - `mid >= 0`: by definition
             // - `mid < size`: `mid = size / 2 + size / 4 + size / 8 ...`
             let cmp = f(unsafe { self.get_unchecked(mid) });
diff --git a/library/coretests/tests/ffi/cstr.rs b/library/coretests/tests/ffi/cstr.rs
@@ -13,3 +13,9 @@ fn compares_as_u8s() {
     assert_eq!(Ord::cmp(a, b), Ord::cmp(a_bytes, b_bytes));
     assert_eq!(PartialOrd::partial_cmp(a, b), PartialOrd::partial_cmp(a_bytes, b_bytes));
 }
+
+#[test]
+fn debug() {
+    let s = c"abc\x01\x02\n\xE2\x80\xA6\xFF";
+    assert_eq!(format!("{s:?}"), r#""abc\x01\x02\n\xe2\x80\xa6\xff""#);
+}
diff --git a/library/std/Cargo.toml b/library/std/Cargo.toml
@@ -36,7 +36,7 @@ miniz_oxide = { version = "0.8.0", optional = true, default-features = false }
 addr2line = { version = "0.24.0", optional = true, default-features = false }
 
 [target.'cfg(not(all(windows, target_env = "msvc")))'.dependencies]
-libc = { version = "0.2.171", default-features = false, features = [
+libc = { version = "0.2.172", default-features = false, features = [
     'rustc-dep-of-std',
 ], public = true }
 
diff --git a/library/std/src/path.rs b/library/std/src/path.rs
@@ -3265,7 +3265,7 @@ impl Hash for Path {
                 if !verbatim {
                     component_start += match tail {
                         [b'.'] => 1,
-                        [b'.', sep @ _, ..] if is_sep_byte(*sep) => 1,
+                        [b'.', sep, ..] if is_sep_byte(*sep) => 1,
                         _ => 0,
                     };
                 }
diff --git a/library/std/src/rt.rs b/library/std/src/rt.rs
@@ -46,7 +46,7 @@ macro_rules! rtprintpanic {
 macro_rules! rtabort {
     ($($t:tt)*) => {
         {
-            rtprintpanic!("fatal runtime error: {}\n", format_args!($($t)*));
+            rtprintpanic!("fatal runtime error: {}, aborting\n", format_args!($($t)*));
             crate::sys::abort_internal();
         }
     }
diff --git a/library/std/src/sys/alloc/sgx.rs b/library/std/src/sys/alloc/sgx.rs
@@ -10,8 +10,10 @@ use crate::sys::pal::waitqueue::SpinMutex;
 // The current allocator here is the `dlmalloc` crate which we've got included
 // in the rust-lang/rust repository as a submodule. The crate is a port of
 // dlmalloc.c from C to Rust.
+//
+// Specifying linkage/symbol name is solely to ensure a single instance between this crate and its unit tests
 #[cfg_attr(test, linkage = "available_externally")]
-#[unsafe(export_name = "_ZN16__rust_internals3std3sys3sgx5alloc8DLMALLOCE")]
+#[unsafe(export_name = "_ZN16__rust_internals3std3sys5alloc3sgx8DLMALLOCE")]
 static DLMALLOC: SpinMutex<dlmalloc::Dlmalloc<Sgx>> =
     SpinMutex::new(dlmalloc::Dlmalloc::new_with_allocator(Sgx {}));
 
diff --git a/library/std/src/sys/args/hermit.rs b/library/std/src/sys/args/hermit.rs
diff --git a/library/std/src/sys/args/mod.rs b/library/std/src/sys/args/mod.rs
@@ -3,15 +3,15 @@
 #![forbid(unsafe_op_in_unsafe_fn)]
 
 cfg_if::cfg_if! {
-    if #[cfg(all(target_family = "unix", not(any(target_os = "espidf", target_os = "vita"))))] {
+    if #[cfg(any(
+        all(target_family = "unix", not(any(target_os = "espidf", target_os = "vita"))),
+        target_os = "hermit",
+    ))] {
         mod unix;
         pub use unix::*;
     } else if #[cfg(target_family = "windows")] {
         mod windows;
         pub use windows::*;
-    } else if #[cfg(target_os = "hermit")] {
-        mod hermit;
-        pub use hermit::*;
     } else if #[cfg(all(target_vendor = "fortanix", target_env = "sgx"))] {
         mod sgx;
         pub use sgx::*;
diff --git a/library/std/src/sys/args/sgx.rs b/library/std/src/sys/args/sgx.rs
@@ -8,6 +8,7 @@ use crate::sys::pal::abi::usercalls::raw::ByteBuffer;
 use crate::sys_common::FromInner;
 use crate::{fmt, slice};
 
+// Specifying linkage/symbol name is solely to ensure a single instance between this crate and its unit tests
 #[cfg_attr(test, linkage = "available_externally")]
 #[unsafe(export_name = "_ZN16__rust_internals3std3sys3sgx4args4ARGSE")]
 static ARGS: AtomicUsize = AtomicUsize::new(0);
diff --git a/library/std/src/sys/args/unix.rs b/library/std/src/sys/args/unix.rs
@@ -6,6 +6,9 @@
 #![allow(dead_code)] // runtime init functions not used during testing
 
 use crate::ffi::CStr;
+#[cfg(target_os = "hermit")]
+use crate::os::hermit::ffi::OsStringExt;
+#[cfg(not(target_os = "hermit"))]
 use crate::os::unix::ffi::OsStringExt;
 
 #[path = "common.rs"]
@@ -73,6 +76,7 @@ pub fn args() -> Args {
     target_os = "illumos",
     target_os = "emscripten",
     target_os = "haiku",
+    target_os = "hermit",
     target_os = "l4re",
     target_os = "fuchsia",
     target_os = "redox",
@@ -100,7 +104,7 @@ mod imp {
 
     unsafe fn really_init(argc: isize, argv: *const *const u8) {
         // These don't need to be ordered with each other or other stores,
-        // because they only hold the unmodified system-provide argv/argc.
+        // because they only hold the unmodified system-provided argv/argc.
         ARGC.store(argc, Ordering::Relaxed);
         ARGV.store(argv as *mut _, Ordering::Relaxed);
     }
diff --git a/library/std/src/sys/pal/sgx/abi/tls/mod.rs b/library/std/src/sys/pal/sgx/abi/tls/mod.rs
@@ -11,15 +11,17 @@ const USIZE_BITS: usize = 64;
 const TLS_KEYS: usize = 128; // Same as POSIX minimum
 const TLS_KEYS_BITSET_SIZE: usize = (TLS_KEYS + (USIZE_BITS - 1)) / USIZE_BITS;
 
+// Specifying linkage/symbol name is solely to ensure a single instance between this crate and its unit tests
 #[cfg_attr(test, linkage = "available_externally")]
-#[unsafe(export_name = "_ZN16__rust_internals3std3sys3sgx3abi3tls14TLS_KEY_IN_USEE")]
+#[unsafe(export_name = "_ZN16__rust_internals3std3sys3pal3sgx3abi3tls14TLS_KEY_IN_USEE")]
 static TLS_KEY_IN_USE: SyncBitset = SYNC_BITSET_INIT;
 macro_rules! dup {
     ((* $($exp:tt)*) $($val:tt)*) => (dup!( ($($exp)*) $($val)* $($val)* ));
     (() $($val:tt)*) => ([$($val),*])
 }
+// Specifying linkage/symbol name is solely to ensure a single instance between this crate and its unit tests
 #[cfg_attr(test, linkage = "available_externally")]
-#[unsafe(export_name = "_ZN16__rust_internals3std3sys3sgx3abi3tls14TLS_DESTRUCTORE")]
+#[unsafe(export_name = "_ZN16__rust_internals3std3sys3pal3sgx3abi3tls14TLS_DESTRUCTORE")]
 static TLS_DESTRUCTOR: [AtomicUsize; TLS_KEYS] = dup!((* * * * * * *) (AtomicUsize::new(0)));
 
 unsafe extern "C" {
diff --git a/library/std/src/sys/pal/sgx/os.rs b/library/std/src/sys/pal/sgx/os.rs
@@ -73,11 +73,13 @@ pub fn current_exe() -> io::Result<PathBuf> {
     unsupported()
 }
 
+// Specifying linkage/symbol name is solely to ensure a single instance between this crate and its unit tests
 #[cfg_attr(test, linkage = "available_externally")]
-#[unsafe(export_name = "_ZN16__rust_internals3std3sys3sgx2os3ENVE")]
+#[unsafe(export_name = "_ZN16__rust_internals3std3sys3pal3sgx2os3ENVE")]
 static ENV: AtomicUsize = AtomicUsize::new(0);
+// Specifying linkage/symbol name is solely to ensure a single instance between this crate and its unit tests
 #[cfg_attr(test, linkage = "available_externally")]
-#[unsafe(export_name = "_ZN16__rust_internals3std3sys3sgx2os8ENV_INITE")]
+#[unsafe(export_name = "_ZN16__rust_internals3std3sys3pal3sgx2os8ENV_INITE")]
 static ENV_INIT: Once = Once::new();
 type EnvStore = Mutex<HashMap<OsString, OsString>>;
 
diff --git a/library/std/src/sys/pal/sgx/thread.rs b/library/std/src/sys/pal/sgx/thread.rs
@@ -45,8 +45,9 @@ mod task_queue {
         }
     }
 
+    // Specifying linkage/symbol name is solely to ensure a single instance between this crate and its unit tests
     #[cfg_attr(test, linkage = "available_externally")]
-    #[unsafe(export_name = "_ZN16__rust_internals3std3sys3sgx6thread10TASK_QUEUEE")]
+    #[unsafe(export_name = "_ZN16__rust_internals3std3sys3pal3sgx6thread10TASK_QUEUEE")]
     static TASK_QUEUE: Mutex<Vec<Task>> = Mutex::new(Vec::new());
 
     pub(super) fn lock() -> MutexGuard<'static, Vec<Task>> {
diff --git a/library/std/src/thread/local.rs b/library/std/src/thread/local.rs
@@ -22,12 +22,16 @@ use crate::fmt;
 ///
 /// Initialization is dynamically performed on the first call to a setter (e.g.
 /// [`with`]) within a thread, and values that implement [`Drop`] get
-/// destructed when a thread exits. Some caveats apply, which are explained below.
+/// destructed when a thread exits. Some platform-specific caveats apply, which
+/// are explained below.
+/// Note that, should the destructor panics, the whole process will be [aborted].
 ///
 /// A `LocalKey`'s initializer cannot recursively depend on itself. Using a
 /// `LocalKey` in this way may cause panics, aborts or infinite recursion on
 /// the first call to `with`.
 ///
+/// [aborted]: crate::process::abort
+///
 /// # Single-thread Synchronization
 ///
 /// Though there is no potential race with other threads, it is still possible to
diff --git a/library/std/src/time.rs b/library/std/src/time.rs
@@ -205,8 +205,8 @@ pub struct Instant(time::Instant);
 ///            println!("{}", elapsed.as_secs());
 ///        }
 ///        Err(e) => {
-///            // an error occurred!
-///            println!("Error: {e:?}");
+///            // the system clock went backwards!
+///            println!("Great Scott! {e:?}");
 ///        }
 ///    }
 /// }
@@ -245,6 +245,7 @@ pub struct Instant(time::Instant);
 /// > structure cannot represent the new point in time.
 ///
 /// [`add`]: SystemTime::add
+/// [`UNIX_EPOCH`]: SystemTime::UNIX_EPOCH
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[stable(feature = "time2", since = "1.8.0")]
 pub struct SystemTime(time::SystemTime);
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
@@ -2,5 +2,5 @@
 # standard library we currently track.
 
 [toolchain]
-channel = "nightly-2025-04-21"
+channel = "nightly-2025-04-23"
 components = ["llvm-tools-preview", "rustc-dev", "rust-src", "rustfmt"]
diff --git a/tool_config/kani-version.toml b/tool_config/kani-version.toml
@@ -2,4 +2,4 @@
 # incompatible with the verify-std repo.
 
 [kani]
-commit = "228c5a5f078ff7b46d67724ed8362865266d709f"
+commit = "2879207097a875f22768aec1e972c9b87b01b1b6"

Original file line number	Diff line number	Diff line change
`@@ -574,7 +574,7 @@ impl CString {`
`574`	`574`	`#[stable(feature = "as_c_str", since = "1.20.0")]`
`575`	`575`	`#[rustc_diagnostic_item = "cstring_as_c_str"]`
`576`	`576`	`pub fn as_c_str(&self) -> &CStr {`
`577`		`- &*self`
	`577`	`+ unsafe { CStr::from_bytes_with_nul_unchecked(self.as_bytes_with_nul()) }`
`578`	`578`	`}`
`579`	`579`
`580`	`580`	/// Converts this `CString` into a boxed [`CStr`].
`@@ -705,14 +705,14 @@ impl ops::Deref for CString {`
`705`	`705`
`706`	`706`	`#[inline]`
`707`	`707`	`fn deref(&self) -> &CStr {`
`708`		`- unsafe { CStr::from_bytes_with_nul_unchecked(self.as_bytes_with_nul()) }`
	`708`	`+ self.as_c_str()`
`709`	`709`	`}`
`710`	`710`	`}`
`711`	`711`
`712`	`712`	`#[stable(feature = "rust1", since = "1.0.0")]`
`713`	`713`	`impl fmt::Debug for CString {`
`714`	`714`	`fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
`715`		`- fmt::Debug::fmt(&**self, f)`
	`715`	`+ fmt::Debug::fmt(self.as_c_str(), f)`
`716`	`716`	`}`
`717`	`717`	`}`
`718`	`718`
Original file line number	Diff line number	Diff line change
`@@ -772,8 +772,8 @@ impl hash::Hash for TypeId {`
`772`	`772`	`// (especially given the previous point about the lower 64 bits being`
`773`	`773`	`// high quality on their own).`
`774`	`774`	// - It is correct to do so -- only hashing a subset of `self` is still
`775`		- // with an `Eq` implementation that considers the entire value, as
`776`		`- // ours does.`
	`775`	+ // compatible with an `Eq` implementation that considers the entire
	`776`	`+ // value, as ours does.`
`777`	`777`	`self.t.1.hash(state);`
`778`	`778`	`}`
`779`	`779`	`}`