Rollup merge of rust-lang#127355 - aceArt-GmbH:126475, r=oli-obk

Mark format! with must_use hint Uses unstable feature rust-lang#94745 Part of rust-lang#126475 First contribution to rust, please let me know if the blessing of tests is correct Thanks `@bjorn3` for the help

Author: matthiaskrgr

alloc/src/collections/btree/map/tests.rs

@@ -1796,18 +1796,18 @@ fn test_ord_absence() {
  }
 
  fn map_debug<K: Debug>(mut map: BTreeMap<K, ()>) {
- format!("{map:?}");
- format!("{:?}", map.iter());
- format!("{:?}", map.iter_mut());
- format!("{:?}", map.keys());
- format!("{:?}", map.values());
- format!("{:?}", map.values_mut());
+ let _ = format!("{map:?}");
+ let _ = format!("{:?}", map.iter());
+ let _ = format!("{:?}", map.iter_mut());
+ let _ = format!("{:?}", map.keys());
+ let _ = format!("{:?}", map.values());
+ let _ = format!("{:?}", map.values_mut());
  if true {
- format!("{:?}", map.into_iter());
+ let _ = format!("{:?}", map.into_iter());
  } else if true {
- format!("{:?}", map.into_keys());
+ let _ = format!("{:?}", map.into_keys());
  } else {
- format!("{:?}", map.into_values());
+ let _ = format!("{:?}", map.into_values());
  }
  }
 

alloc/src/collections/btree/set/tests.rs

@@ -705,9 +705,9 @@ fn test_ord_absence() {
  }
 
  fn set_debug<K: Debug>(set: BTreeSet<K>) {
- format!("{set:?}");
- format!("{:?}", set.iter());
- format!("{:?}", set.into_iter());
+ let _ = format!("{set:?}");
+ let _ = format!("{:?}", set.iter());
+ let _ = format!("{:?}", set.into_iter());
  }
 
  fn set_clone<K: Clone>(mut set: BTreeSet<K>) {

alloc/src/fmt.rs

@@ -12,6 +12,7 @@
 //! Some examples of the [`format!`] extension are:
 //!
 //! ```
+//! # #![allow(unused_must_use)]
 //! format!("Hello"); // => "Hello"
 //! format!("Hello, {}!", "world"); // => "Hello, world!"
 //! format!("The number is {}", 1); // => "The number is 1"
@@ -50,6 +51,7 @@
 //! the iterator advances. This leads to behavior like this:
 //!
 //! ```
+//! # #![allow(unused_must_use)]
 //! format!("{1} {} {0} {}", 1, 2); // => "2 1 1 2"
 //! ```
 //!
@@ -77,6 +79,7 @@
 //! For example, the following [`format!`] expressions all use named arguments:
 //!
 //! ```
+//! # #![allow(unused_must_use)]
 //! format!("{argument}", argument = "test"); // => "test"
 //! format!("{name} {}", 1, name = 2); // => "2 1"
 //! format!("{a} {c} {b}", a="a", b='b', c=3); // => "a 3 b"
@@ -86,6 +89,7 @@
 //! reference a variable with that name in the current scope.
 //!
 //! ```
+//! # #![allow(unused_must_use)]
 //! let argument = 2 + 2;
 //! format!("{argument}"); // => "4"
 //!

alloc/src/lib.rs

@@ -257,6 +257,7 @@ pub mod vec;
 #[unstable(feature = "liballoc_internals", issue = "none", reason = "implementation detail")]
 pub mod __export {
  pub use core::format_args;
+ pub use core::hint::must_use;
 }
 
 #[cfg(test)]

alloc/src/macros.rs

@@ -111,6 +111,7 @@ macro_rules! vec {
 /// # Examples
 ///
 /// ```
+/// # #![allow(unused_must_use)]
 /// format!("test"); // => "test"
 /// format!("hello {}", "world!"); // => "hello world!"
 /// format!("x = {}, y = {val}", 10, val = 30); // => "x = 10, y = 30"
@@ -119,10 +120,13 @@ macro_rules! vec {
 /// ```
 #[macro_export]
 #[stable(feature = "rust1", since = "1.0.0")]
+#[allow_internal_unstable(hint_must_use, liballoc_internals)]
 #[cfg_attr(not(test), rustc_diagnostic_item = "format_macro")]
 macro_rules! format {
- ($($arg:tt)*) => {{
- let res = $crate::fmt::format($crate::__export::format_args!($($arg)*));
- res
- }}
+ ($($arg:tt)*) => {
+ $crate::__export::must_use({
+ let res = $crate::fmt::format($crate::__export::format_args!($($arg)*));
+ res
+ })
+ }
 }

alloc/tests/fmt.rs

@@ -217,19 +217,19 @@ fn test_format_macro_interface() {
 
  // make sure that format! doesn't move out of local variables
  let a = Box::new(3);
- format!("{a}");
- format!("{a}");
+ let _ = format!("{a}");
+ let _ = format!("{a}");
 
  // make sure that format! doesn't cause spurious unused-unsafe warnings when
  // it's inside of an outer unsafe block
  unsafe {
  let a: isize = ::std::mem::transmute(3_usize);
- format!("{a}");
+ let _ = format!("{a}");
  }
 
  // test that trailing commas are acceptable
- format!("{}", "test",);
- format!("{foo}", foo = "test",);
+ let _ = format!("{}", "test",);
+ let _ = format!("{foo}", foo = "test",);
 }
 
 // Basic test to make sure that we can invoke the `write!` macro with an

core/tests/fmt/builders.rs

@@ -441,7 +441,7 @@ mod debug_map {
  }
  }
 
- format!("{Foo:?}");
+ let _ = format!("{Foo:?}");
  }
 
  #[test]
@@ -455,7 +455,7 @@ mod debug_map {
  }
  }
 
- format!("{Foo:?}");
+ let _ = format!("{Foo:?}");
  }
 
  #[test]
@@ -469,7 +469,7 @@ mod debug_map {
  }
  }
 
- format!("{Foo:?}");
+ let _ = format!("{Foo:?}");
  }
 }