Auto merge of rust-lang#89847 - JohnTitor:rollup-xfymeo4, r=JohnTitor

Rollup of 12 pull requests

Successful merges:

 - rust-lang#89768 (add some more testcases)
 - rust-lang#89777 (Edit explanation of test for nested type ascriptions)
 - rust-lang#89781 (Add missing words in `Infallible` docs)
 - rust-lang#89782 (Improve CJK font in rustdoc)
 - rust-lang#89794 (Add #[must_use] to to_value conversions)
 - rust-lang#89814 (Fix uppercase/lowercase error)
 - rust-lang#89816 (Fix invalid rules in .gitignore)
 - rust-lang#89817 (Add #[inline] to int log10 functions.)
 - rust-lang#89818 (Use Option::map_or instead of open coding it)
 - rust-lang#89828 (Fix config.toml overflow-checks options)
 - rust-lang#89840 (fix the stage0 tools config file path in `config.toml.example`)
 - rust-lang#89845 (Add davidtwco to the `.mailmap`)

Failed merges:

r? `@ghost`
`@rustbot` modify labels: rollup

Author: bors

.gitignore

@@ -69,8 +69,8 @@ __pycache__/
 *$py.class
 
 ## Node
-**node_modules
-**package-lock.json
+node_modules
+package-lock.json
 
 ## Rustdoc GUI tests
 src/test/rustdoc-gui/src/**.lock

.mailmap

@@ -72,6 +72,7 @@ Daniel Ramos <[email protected]>
 David Klein <[email protected]>
 David Manescu <[email protected]> <[email protected]>
 David Ross <[email protected]>
+David Wood <[email protected]> <[email protected]>
 Deadbeef <[email protected]> <[email protected]>
 Derek Chiang <[email protected]> Derek Chiang (Enchi Jiang) <[email protected]>
 Diggory Hardy <[email protected]> Diggory Hardy <[email protected]>

compiler/rustc_index/src/bit_set.rs

@@ -841,7 +841,7 @@ impl<T: Idx> GrowableBitSet<T> {
     #[inline]
     pub fn contains(&self, elem: T) -> bool {
         let (word_index, mask) = word_index_and_mask(elem);
-        if let Some(word) = self.bit_set.words.get(word_index) { (word & mask) != 0 } else { false }
+        self.bit_set.words.get(word_index).map_or(false, |word| (word & mask) != 0)
     }
 }
 

config.toml.example

@@ -202,15 +202,15 @@ changelog-seen = 2
 # You can use "$ROOT" to indicate the root of the git repository.
 #build-dir = "build"
 
-# Instead of downloading the src/stage0.txt version of Cargo specified, use
+# Instead of downloading the src/stage0.json version of Cargo specified, use
 # this Cargo binary instead to build all Rust code
 #cargo = "/path/to/cargo"
 
-# Instead of downloading the src/stage0.txt version of the compiler
+# Instead of downloading the src/stage0.json version of the compiler
 # specified, use this rustc binary instead as the stage0 snapshot compiler.
 #rustc = "/path/to/rustc"
 
-# Instead of download the src/stage0.txt version of rustfmt specified,
+# Instead of download the src/stage0.json version of rustfmt specified,
 # use this rustfmt binary instead as the stage0 snapshot rustfmt.
 #rustfmt = "/path/to/rustfmt"
 
@@ -423,6 +423,18 @@ changelog-seen = 2
 # set this value to `true`.
 #debug-logging = rust.debug-assertions (boolean)
 
+# Whether or not overflow checks are enabled for the compiler and standard
+# library.
+#
+# Defaults to rust.debug value
+#overflow-checks = rust.debug (boolean)
+
+# Whether or not overflow checks are enabled for the standard library.
+# Overrides the `overflow-checks` option, if defined.
+#
+# Defaults to rust.overflow-checks value
+#overflow-checks-std = rust.overflow-checks (boolean)
+
 # Debuginfo level for most of Rust code, corresponds to the `-C debuginfo=N` option of `rustc`.
 # `0` - no debug info
 # `1` - line tables only - sufficient to generate backtraces that include line

library/alloc/src/str.rs

@@ -538,7 +538,7 @@ impl str {
     /// [`make_ascii_uppercase`]: str::make_ascii_uppercase
     /// [`to_uppercase`]: #method.to_uppercase
     #[cfg(not(no_global_oom_handling))]
-    #[must_use = "to uppercase the value in-place, use `make_ascii_lowercase()`"]
+    #[must_use = "to uppercase the value in-place, use `make_ascii_uppercase()`"]
     #[stable(feature = "ascii_methods_on_intrinsics", since = "1.23.0")]
     #[inline]
     pub fn to_ascii_uppercase(&self) -> String {

library/core/src/char/methods.rs

@@ -328,9 +328,11 @@ impl char {
     ///
     /// ```should_panic
     /// // this panics
-    /// '1'.to_digit(37);
+    /// let _ = '1'.to_digit(37);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
+    #[must_use = "this returns the result of the operation, \
+                  without modifying the original"]
     #[inline]
     pub fn to_digit(self, radix: u32) -> Option<u32> {
         assert!(radix <= 36, "to_digit: radix is too high (maximum 36)");

library/core/src/convert/mod.rs

@@ -664,7 +664,7 @@ impl AsMut<str> for str {
 ///
 /// However there is one case where `!` syntax can be used
 /// before `!` is stabilized as a full-fledged type: in the position of a function’s return type.
-/// Specifically, it is possible implementations for two different function pointer types:
+/// Specifically, it is possible to have implementations for two different function pointer types:
 ///
 /// ```
 /// trait MyTrait {}

library/core/src/num/int_log10.rs

@@ -1,5 +1,6 @@
 mod unchecked {
     // 0 < val <= u8::MAX
+    #[inline]
     pub const fn u8(val: u8) -> u32 {
         let val = val as u32;
 
@@ -20,6 +21,7 @@ mod unchecked {
     }
 
     // 0 < val < 100_000
+    #[inline]
     const fn less_than_5(val: u32) -> u32 {
         // Similar to u8, when adding one of these constants to val,
         // we get two possible bit patterns above the low 17 bits,
@@ -40,11 +42,13 @@ mod unchecked {
     }
 
     // 0 < val <= u16::MAX
+    #[inline]
     pub const fn u16(val: u16) -> u32 {
         less_than_5(val as u32)
     }
 
     // 0 < val <= u32::MAX
+    #[inline]
     pub const fn u32(mut val: u32) -> u32 {
         let mut log = 0;
         if val >= 100_000 {
@@ -55,6 +59,7 @@ mod unchecked {
     }
 
     // 0 < val <= u64::MAX
+    #[inline]
     pub const fn u64(mut val: u64) -> u32 {
         let mut log = 0;
         if val >= 10_000_000_000 {
@@ -69,6 +74,7 @@ mod unchecked {
     }
 
     // 0 < val <= u128::MAX
+    #[inline]
     pub const fn u128(mut val: u128) -> u32 {
         let mut log = 0;
         if val >= 100_000_000_000_000_000_000_000_000_000_000 {
@@ -84,33 +90,39 @@ mod unchecked {
     }
 
     // 0 < val <= i8::MAX
+    #[inline]
     pub const fn i8(val: i8) -> u32 {
         u8(val as u8)
     }
 
     // 0 < val <= i16::MAX
+    #[inline]
     pub const fn i16(val: i16) -> u32 {
         u16(val as u16)
     }
 
     // 0 < val <= i32::MAX
+    #[inline]
     pub const fn i32(val: i32) -> u32 {
         u32(val as u32)
     }
 
     // 0 < val <= i64::MAX
+    #[inline]
     pub const fn i64(val: i64) -> u32 {
         u64(val as u64)
     }
 
     // 0 < val <= i128::MAX
+    #[inline]
     pub const fn i128(val: i128) -> u32 {
         u128(val as u128)
     }
 }
 
 macro_rules! impl_checked {
     ($T:ident) => {
+        #[inline]
         pub const fn $T(val: $T) -> Option<u32> {
             if val > 0 { Some(unchecked::$T(val)) } else { None }
         }

library/core/src/ptr/non_null.rs

@@ -242,6 +242,8 @@ impl<T: ?Sized> NonNull<T> {
     /// The pointer can be later reconstructed with [`NonNull::from_raw_parts`].
     #[unstable(feature = "ptr_metadata", issue = "81513")]
     #[rustc_const_unstable(feature = "ptr_metadata", issue = "81513")]
+    #[must_use = "this returns the result of the operation, \
+                  without modifying the original"]
     #[inline]
     pub const fn to_raw_parts(self) -> (NonNull<()>, <T as super::Pointee>::Metadata) {
         (self.cast(), super::metadata(self.as_ptr()))
@@ -386,6 +388,8 @@ impl<T: ?Sized> NonNull<T> {
     /// ```
     #[stable(feature = "nonnull_cast", since = "1.27.0")]
     #[rustc_const_stable(feature = "const_nonnull_cast", since = "1.36.0")]
+    #[must_use = "this returns the result of the operation, \
+                  without modifying the original"]
     #[inline]
     pub const fn cast<U>(self) -> NonNull<U> {
         // SAFETY: `self` is a `NonNull` pointer which is necessarily non-null

library/std/src/ffi/c_str.rs

@@ -1342,6 +1342,8 @@ impl CStr {
     /// assert_eq!(cstr.to_bytes(), b"foo");
     /// ```
     #[inline]
+    #[must_use = "this returns the result of the operation, \
+                  without modifying the original"]
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn to_bytes(&self) -> &[u8] {
         let bytes = self.to_bytes_with_nul();
@@ -1367,6 +1369,8 @@ impl CStr {
     /// assert_eq!(cstr.to_bytes_with_nul(), b"foo\0");
     /// ```
     #[inline]
+    #[must_use = "this returns the result of the operation, \
+                  without modifying the original"]
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn to_bytes_with_nul(&self) -> &[u8] {
         unsafe { &*(&self.inner as *const [c_char] as *const [u8]) }
@@ -1437,6 +1441,8 @@ impl CStr {
     ///     Cow::Owned(String::from("Hello �World")) as Cow<'_, str>
     /// );
     /// ```
+    #[must_use = "this returns the result of the operation, \
+                  without modifying the original"]
     #[stable(feature = "cstr_to_str", since = "1.4.0")]
     pub fn to_string_lossy(&self) -> Cow<'_, str> {
         String::from_utf8_lossy(self.to_bytes())