diff --git a/library/alloc/src/collections/btree/map/tests.rs b/library/alloc/src/collections/btree/map/tests.rs
index 56620cf890d..ba1f38dcc3e 100644
--- a/library/alloc/src/collections/btree/map/tests.rs
+++ b/library/alloc/src/collections/btree/map/tests.rs
@@ -1796,18 +1796,18 @@ fn map<K>(mut map: BTreeMap<K, ()>) {
     }
 
     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());
         }
     }
 
diff --git a/library/alloc/src/collections/btree/set/tests.rs b/library/alloc/src/collections/btree/set/tests.rs
index 688ce57e9da..48bf7674138 100644
--- a/library/alloc/src/collections/btree/set/tests.rs
+++ b/library/alloc/src/collections/btree/set/tests.rs
@@ -705,9 +705,9 @@ fn set<K>(mut set: BTreeSet<K>) {
     }
 
     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>) {
diff --git a/library/alloc/src/fmt.rs b/library/alloc/src/fmt.rs
index ae44cab8131..c6bba619ae6 100644
--- a/library/alloc/src/fmt.rs
+++ b/library/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"
 //!
diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs
index 3237d8654c2..a7715740cbd 100644
--- a/library/alloc/src/lib.rs
+++ b/library/alloc/src/lib.rs
@@ -257,6 +257,7 @@ mod boxed {
 #[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)]
diff --git a/library/alloc/src/macros.rs b/library/alloc/src/macros.rs
index d5ca5c4ed27..8c6a367869c 100644
--- a/library/alloc/src/macros.rs
+++ b/library/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
+        })
+    }
 }
diff --git a/library/alloc/tests/fmt.rs b/library/alloc/tests/fmt.rs
index 379e09ab69a..ce24a40f4c0 100644
--- a/library/alloc/tests/fmt.rs
+++ b/library/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
diff --git a/library/core/tests/fmt/builders.rs b/library/core/tests/fmt/builders.rs
index 487ce46be28..2bdc334b7c0 100644
--- a/library/core/tests/fmt/builders.rs
+++ b/library/core/tests/fmt/builders.rs
@@ -441,7 +441,7 @@ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
             }
         }
 
-        format!("{Foo:?}");
+        let _ = format!("{Foo:?}");
     }
 
     #[test]
@@ -455,7 +455,7 @@ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
             }
         }
 
-        format!("{Foo:?}");
+        let _ = format!("{Foo:?}");
     }
 
     #[test]
@@ -469,7 +469,7 @@ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
             }
         }
 
-        format!("{Foo:?}");
+        let _ = format!("{Foo:?}");
     }
 }
 
diff --git a/src/bootstrap/src/core/build_steps/llvm.rs b/src/bootstrap/src/core/build_steps/llvm.rs
index bff731e13b0..872823506f8 100644
--- a/src/bootstrap/src/core/build_steps/llvm.rs
+++ b/src/bootstrap/src/core/build_steps/llvm.rs
@@ -753,7 +753,7 @@ fn configure_cmake(
     }
 
     if builder.config.llvm_clang_cl.is_some() {
-        cflags.push(&format!(" --target={target}"));
+        cflags.push(format!(" --target={target}"));
     }
     cfg.define("CMAKE_C_FLAGS", cflags);
     let mut cxxflags: OsString = builder
@@ -772,7 +772,7 @@ fn configure_cmake(
         cxxflags.push(s);
     }
     if builder.config.llvm_clang_cl.is_some() {
-        cxxflags.push(&format!(" --target={target}"));
+        cxxflags.push(format!(" --target={target}"));
     }
     cfg.define("CMAKE_CXX_FLAGS", cxxflags);
     if let Some(ar) = builder.ar(target) {
@@ -913,7 +913,7 @@ fn run(self, builder: &Builder<'_>) -> PathBuf {
                 // Find clang's runtime library directory and push that as a search path to the
                 // cmake linker flags.
                 let clang_rt_dir = get_clang_cl_resource_dir(clang_cl_path);
-                ldflags.push_all(&format!("/libpath:{}", clang_rt_dir.display()));
+                ldflags.push_all(format!("/libpath:{}", clang_rt_dir.display()));
             }
         }
 
diff --git a/src/bootstrap/src/core/builder.rs b/src/bootstrap/src/core/builder.rs
index 24bb96c6b88..22629b38187 100644
--- a/src/bootstrap/src/core/builder.rs
+++ b/src/bootstrap/src/core/builder.rs
@@ -2526,7 +2526,7 @@ fn configure_linker(&mut self, builder: &Builder<'_>) -> &mut Cargo {
 
         if let Some(target_linker) = builder.linker(target) {
             let target = crate::envify(&target.triple);
-            self.command.env(&format!("CARGO_TARGET_{target}_LINKER"), target_linker);
+            self.command.env(format!("CARGO_TARGET_{target}_LINKER"), target_linker);
         }
         // We want to set -Clinker using Cargo, therefore we only call `linker_flags` and not
         // `linker_args` here.
diff --git a/src/tools/clippy/tests/ui/or_fun_call.fixed b/src/tools/clippy/tests/ui/or_fun_call.fixed
index 7657ef470c5..c76f7a81843 100644
--- a/src/tools/clippy/tests/ui/or_fun_call.fixed
+++ b/src/tools/clippy/tests/ui/or_fun_call.fixed
@@ -98,7 +98,7 @@ fn or_fun_call() {
 
     let opt = Some(1);
     let hello = "Hello";
-    let _ = opt.ok_or(format!("{} world.", hello));
+    let _ = opt.ok_or_else(|| format!("{} world.", hello));
 
     // index
     let map = HashMap::<u64, u64>::new();
diff --git a/src/tools/clippy/tests/ui/or_fun_call.stderr b/src/tools/clippy/tests/ui/or_fun_call.stderr
index b5a30f29923..3070db22fc5 100644
--- a/src/tools/clippy/tests/ui/or_fun_call.stderr
+++ b/src/tools/clippy/tests/ui/or_fun_call.stderr
@@ -100,6 +100,12 @@ error: use of `unwrap_or` to construct default value
 LL |     let _ = stringy.unwrap_or(String::new());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
+error: use of `ok_or` followed by a function call
+  --> tests/ui/or_fun_call.rs:101:17
+   |
+LL |     let _ = opt.ok_or(format!("{} world.", hello));
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `ok_or_else(|| format!("{} world.", hello))`
+
 error: use of `unwrap_or` followed by a function call
   --> tests/ui/or_fun_call.rs:105:21
    |
@@ -190,5 +196,5 @@ error: use of `unwrap_or_else` to construct default value
 LL |         let _ = stringy.unwrap_or_else(String::new);
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
-error: aborting due to 31 previous errors
+error: aborting due to 32 previous errors
 
diff --git a/src/tools/miri/tests/pass/intptrcast.rs b/src/tools/miri/tests/pass/intptrcast.rs
index 4e9fa12c181..fb1a1dfae5d 100644
--- a/src/tools/miri/tests/pass/intptrcast.rs
+++ b/src/tools/miri/tests/pass/intptrcast.rs
@@ -35,7 +35,7 @@ fn cast_dangling() {
 fn format() {
     // Pointer string formatting! We can't check the output as it changes when libstd changes,
     // but we can make sure Miri does not error.
-    format!("{:?}", &mut 13 as *mut _);
+    let _ = format!("{:?}", &mut 13 as *mut _);
 }
 
 fn transmute() {
@@ -52,7 +52,7 @@ fn ptr_bitops1() {
     let one = bytes.as_ptr().wrapping_offset(1);
     let three = bytes.as_ptr().wrapping_offset(3);
     let res = (one as usize) | (three as usize);
-    format!("{}", res);
+    let _ = format!("{}", res);
 }
 
 fn ptr_bitops2() {
diff --git a/src/tools/miri/tests/pass/packed_struct.rs b/src/tools/miri/tests/pass/packed_struct.rs
index b86235e0c67..039eb5adef0 100644
--- a/src/tools/miri/tests/pass/packed_struct.rs
+++ b/src/tools/miri/tests/pass/packed_struct.rs
@@ -138,7 +138,7 @@ struct P {
     assert_eq!(x.partial_cmp(&y).unwrap(), x.cmp(&y));
     x.hash(&mut DefaultHasher::new());
     P::default();
-    format!("{:?}", x);
+    let _ = format!("{:?}", x);
 }
 
 fn main() {
diff --git a/src/tools/miri/tests/pass/shims/fs.rs b/src/tools/miri/tests/pass/shims/fs.rs
index 35980fad15d..16d3e8cab30 100644
--- a/src/tools/miri/tests/pass/shims/fs.rs
+++ b/src/tools/miri/tests/pass/shims/fs.rs
@@ -202,7 +202,7 @@ fn test_errors() {
     // Opening a non-existing file should fail with a "not found" error.
     assert_eq!(ErrorKind::NotFound, File::open(&path).unwrap_err().kind());
     // Make sure we can also format this.
-    format!("{0}: {0:?}", File::open(&path).unwrap_err());
+    let _ = format!("{0}: {0:?}", File::open(&path).unwrap_err());
     // Removing a non-existing file should fail with a "not found" error.
     assert_eq!(ErrorKind::NotFound, remove_file(&path).unwrap_err().kind());
     // Reading the metadata of a non-existing file should fail with a "not found" error.
@@ -301,5 +301,5 @@ fn test_from_raw_os_error() {
     let error = Error::from_raw_os_error(code);
     assert!(matches!(error.kind(), ErrorKind::Uncategorized));
     // Make sure we can also format this.
-    format!("{error:?}");
+    let _ = format!("{error:?}");
 }
diff --git a/src/tools/miri/tests/pass/shims/io.rs b/src/tools/miri/tests/pass/shims/io.rs
index d20fc75b793..420ef95a0cb 100644
--- a/src/tools/miri/tests/pass/shims/io.rs
+++ b/src/tools/miri/tests/pass/shims/io.rs
@@ -15,5 +15,5 @@ fn main() {
         panic!("unsupported OS")
     };
     let err = io::Error::from_raw_os_error(raw_os_error);
-    format!("{err}: {err:?}");
+    let _ = format!("{err}: {err:?}");
 }
diff --git a/src/tools/miri/tests/pass/vecdeque.rs b/src/tools/miri/tests/pass/vecdeque.rs
index 77c4ca5a04e..9153c428e18 100644
--- a/src/tools/miri/tests/pass/vecdeque.rs
+++ b/src/tools/miri/tests/pass/vecdeque.rs
@@ -31,8 +31,8 @@ fn main() {
     }
 
     // Regression test for Debug impl's
-    format!("{:?} {:?}", dst, dst.iter());
-    format!("{:?}", VecDeque::<u32>::new().iter());
+    let _ = format!("{:?} {:?}", dst, dst.iter());
+    let _ = format!("{:?}", VecDeque::<u32>::new().iter());
 
     for a in dst {
         assert_eq!(*a, 2);
diff --git a/tests/pretty/issue-4264.pp b/tests/pretty/issue-4264.pp
index 018ccf82dae..fa958d9f1e8 100644
--- a/tests/pretty/issue-4264.pp
+++ b/tests/pretty/issue-4264.pp
@@ -29,16 +29,17 @@ fn bar() ({
 
 
 
-    ({
-        let res =
-            ((::alloc::fmt::format as
-                    for<'a> fn(Arguments<'a>) -> String {format})(((format_arguments::new_const
-                        as
-                        fn(&[&'static str; 1]) -> Arguments<'_> {Arguments::<'_>::new_const::<1>})((&([("test"
-                                    as &str)] as [&str; 1]) as &[&str; 1])) as Arguments<'_>))
-                as String);
-        (res as String)
-    } as String);
+    ((::alloc::__export::must_use as
+            fn(String) -> String {must_use::<String>})(({
+            let res =
+                ((::alloc::fmt::format as
+                        for<'a> fn(Arguments<'a>) -> String {format})(((format_arguments::new_const
+                            as
+                            fn(&[&'static str; 1]) -> Arguments<'_> {Arguments::<'_>::new_const::<1>})((&([("test"
+                                        as &str)] as [&str; 1]) as &[&str; 1])) as Arguments<'_>))
+                    as String);
+            (res as String)
+        } as String)) as String);
 } as ())
 type Foo = [i32; (3 as usize)];
 struct Bar {
diff --git a/tests/ui/deriving/deriving-in-fn.rs b/tests/ui/deriving/deriving-in-fn.rs
index 72da2148350..13f3d39597c 100644
--- a/tests/ui/deriving/deriving-in-fn.rs
+++ b/tests/ui/deriving/deriving-in-fn.rs
@@ -9,5 +9,5 @@ struct Foo {
     }
 
     let f = Foo { foo: 10 };
-    format!("{:?}", f);
+    let _ = format!("{:?}", f);
 }
diff --git a/tests/ui/fmt/struct-field-as-captured-argument.fixed b/tests/ui/fmt/struct-field-as-captured-argument.fixed
index e13af744ec8..0da40737354 100644
--- a/tests/ui/fmt/struct-field-as-captured-argument.fixed
+++ b/tests/ui/fmt/struct-field-as-captured-argument.fixed
@@ -8,11 +8,11 @@ struct Foo {
 fn main() {
     let foo = Foo { field: 0 };
     let bar = 3;
-    format!("{0}", foo.field); //~ ERROR invalid format string: field access isn't supported
-    format!("{1} {} {bar}", "aa", foo.field); //~ ERROR invalid format string: field access isn't supported
-    format!("{2} {} {1} {bar}", "aa", "bb", foo.field); //~ ERROR invalid format string: field access isn't supported
-    format!("{1} {} {baz}", "aa", foo.field, baz = 3); //~ ERROR invalid format string: field access isn't supported
-    format!("{1:?} {} {baz}", "aa", foo.field, baz = 3); //~ ERROR invalid format string: field access isn't supported
-    format!("{1:#?} {} {baz}", "aa", foo.field, baz = 3); //~ ERROR invalid format string: field access isn't supported
-    format!("{1:.3} {} {baz}", "aa", foo.field, baz = 3); //~ ERROR invalid format string: field access isn't supported
+    let _ = format!("{0}", foo.field); //~ ERROR invalid format string: field access isn't supported
+    let _ = format!("{1} {} {bar}", "aa", foo.field); //~ ERROR invalid format string: field access isn't supported
+    let _ = format!("{2} {} {1} {bar}", "aa", "bb", foo.field); //~ ERROR invalid format string: field access isn't supported
+    let _ = format!("{1} {} {baz}", "aa", foo.field, baz = 3); //~ ERROR invalid format string: field access isn't supported
+    let _ = format!("{1:?} {} {baz}", "aa", foo.field, baz = 3); //~ ERROR invalid format string: field access isn't supported
+    let _ = format!("{1:#?} {} {baz}", "aa", foo.field, baz = 3); //~ ERROR invalid format string: field access isn't supported
+    let _ = format!("{1:.3} {} {baz}", "aa", foo.field, baz = 3); //~ ERROR invalid format string: field access isn't supported
 }
diff --git a/tests/ui/fmt/struct-field-as-captured-argument.rs b/tests/ui/fmt/struct-field-as-captured-argument.rs
index 6a875a85848..325b4e3a218 100644
--- a/tests/ui/fmt/struct-field-as-captured-argument.rs
+++ b/tests/ui/fmt/struct-field-as-captured-argument.rs
@@ -8,11 +8,11 @@ struct Foo {
 fn main() {
     let foo = Foo { field: 0 };
     let bar = 3;
-    format!("{foo.field}"); //~ ERROR invalid format string: field access isn't supported
-    format!("{foo.field} {} {bar}", "aa"); //~ ERROR invalid format string: field access isn't supported
-    format!("{foo.field} {} {1} {bar}", "aa", "bb"); //~ ERROR invalid format string: field access isn't supported
-    format!("{foo.field} {} {baz}", "aa", baz = 3); //~ ERROR invalid format string: field access isn't supported
-    format!("{foo.field:?} {} {baz}", "aa", baz = 3); //~ ERROR invalid format string: field access isn't supported
-    format!("{foo.field:#?} {} {baz}", "aa", baz = 3); //~ ERROR invalid format string: field access isn't supported
-    format!("{foo.field:.3} {} {baz}", "aa", baz = 3); //~ ERROR invalid format string: field access isn't supported
+    let _ = format!("{foo.field}"); //~ ERROR invalid format string: field access isn't supported
+    let _ = format!("{foo.field} {} {bar}", "aa"); //~ ERROR invalid format string: field access isn't supported
+    let _ = format!("{foo.field} {} {1} {bar}", "aa", "bb"); //~ ERROR invalid format string: field access isn't supported
+    let _ = format!("{foo.field} {} {baz}", "aa", baz = 3); //~ ERROR invalid format string: field access isn't supported
+    let _ = format!("{foo.field:?} {} {baz}", "aa", baz = 3); //~ ERROR invalid format string: field access isn't supported
+    let _ = format!("{foo.field:#?} {} {baz}", "aa", baz = 3); //~ ERROR invalid format string: field access isn't supported
+    let _ = format!("{foo.field:.3} {} {baz}", "aa", baz = 3); //~ ERROR invalid format string: field access isn't supported
 }
diff --git a/tests/ui/fmt/struct-field-as-captured-argument.stderr b/tests/ui/fmt/struct-field-as-captured-argument.stderr
index 7ea8b4068f2..4ef022cecb0 100644
--- a/tests/ui/fmt/struct-field-as-captured-argument.stderr
+++ b/tests/ui/fmt/struct-field-as-captured-argument.stderr
@@ -1,79 +1,79 @@
 error: invalid format string: field access isn't supported
-  --> $DIR/struct-field-as-captured-argument.rs:11:15
+  --> $DIR/struct-field-as-captured-argument.rs:11:23
    |
-LL |     format!("{foo.field}");
-   |               ^^^^^^^^^ not supported in format string
+LL |     let _ = format!("{foo.field}");
+   |                       ^^^^^^^^^ not supported in format string
    |
 help: consider using a positional formatting argument instead
    |
-LL |     format!("{0}", foo.field);
-   |               ~  +++++++++++
+LL |     let _ = format!("{0}", foo.field);
+   |                       ~  +++++++++++
 
 error: invalid format string: field access isn't supported
-  --> $DIR/struct-field-as-captured-argument.rs:12:15
+  --> $DIR/struct-field-as-captured-argument.rs:12:23
    |
-LL |     format!("{foo.field} {} {bar}", "aa");
-   |               ^^^^^^^^^ not supported in format string
+LL |     let _ = format!("{foo.field} {} {bar}", "aa");
+   |                       ^^^^^^^^^ not supported in format string
    |
 help: consider using a positional formatting argument instead
    |
-LL |     format!("{1} {} {bar}", "aa", foo.field);
-   |               ~                 +++++++++++
+LL |     let _ = format!("{1} {} {bar}", "aa", foo.field);
+   |                       ~                 +++++++++++
 
 error: invalid format string: field access isn't supported
-  --> $DIR/struct-field-as-captured-argument.rs:13:15
+  --> $DIR/struct-field-as-captured-argument.rs:13:23
    |
-LL |     format!("{foo.field} {} {1} {bar}", "aa", "bb");
-   |               ^^^^^^^^^ not supported in format string
+LL |     let _ = format!("{foo.field} {} {1} {bar}", "aa", "bb");
+   |                       ^^^^^^^^^ not supported in format string
    |
 help: consider using a positional formatting argument instead
    |
-LL |     format!("{2} {} {1} {bar}", "aa", "bb", foo.field);
-   |               ~                           +++++++++++
+LL |     let _ = format!("{2} {} {1} {bar}", "aa", "bb", foo.field);
+   |                       ~                           +++++++++++
 
 error: invalid format string: field access isn't supported
-  --> $DIR/struct-field-as-captured-argument.rs:14:15
+  --> $DIR/struct-field-as-captured-argument.rs:14:23
    |
-LL |     format!("{foo.field} {} {baz}", "aa", baz = 3);
-   |               ^^^^^^^^^ not supported in format string
+LL |     let _ = format!("{foo.field} {} {baz}", "aa", baz = 3);
+   |                       ^^^^^^^^^ not supported in format string
    |
 help: consider using a positional formatting argument instead
    |
-LL |     format!("{1} {} {baz}", "aa", foo.field, baz = 3);
-   |               ~                 +++++++++++
+LL |     let _ = format!("{1} {} {baz}", "aa", foo.field, baz = 3);
+   |                       ~                 +++++++++++
 
 error: invalid format string: field access isn't supported
-  --> $DIR/struct-field-as-captured-argument.rs:15:15
+  --> $DIR/struct-field-as-captured-argument.rs:15:23
    |
-LL |     format!("{foo.field:?} {} {baz}", "aa", baz = 3);
-   |               ^^^^^^^^^ not supported in format string
+LL |     let _ = format!("{foo.field:?} {} {baz}", "aa", baz = 3);
+   |                       ^^^^^^^^^ not supported in format string
    |
 help: consider using a positional formatting argument instead
    |
-LL |     format!("{1:?} {} {baz}", "aa", foo.field, baz = 3);
-   |               ~                   +++++++++++
+LL |     let _ = format!("{1:?} {} {baz}", "aa", foo.field, baz = 3);
+   |                       ~                   +++++++++++
 
 error: invalid format string: field access isn't supported
-  --> $DIR/struct-field-as-captured-argument.rs:16:15
+  --> $DIR/struct-field-as-captured-argument.rs:16:23
    |
-LL |     format!("{foo.field:#?} {} {baz}", "aa", baz = 3);
-   |               ^^^^^^^^^ not supported in format string
+LL |     let _ = format!("{foo.field:#?} {} {baz}", "aa", baz = 3);
+   |                       ^^^^^^^^^ not supported in format string
    |
 help: consider using a positional formatting argument instead
    |
-LL |     format!("{1:#?} {} {baz}", "aa", foo.field, baz = 3);
-   |               ~                    +++++++++++
+LL |     let _ = format!("{1:#?} {} {baz}", "aa", foo.field, baz = 3);
+   |                       ~                    +++++++++++
 
 error: invalid format string: field access isn't supported
-  --> $DIR/struct-field-as-captured-argument.rs:17:15
+  --> $DIR/struct-field-as-captured-argument.rs:17:23
    |
-LL |     format!("{foo.field:.3} {} {baz}", "aa", baz = 3);
-   |               ^^^^^^^^^ not supported in format string
+LL |     let _ = format!("{foo.field:.3} {} {baz}", "aa", baz = 3);
+   |                       ^^^^^^^^^ not supported in format string
    |
 help: consider using a positional formatting argument instead
    |
-LL |     format!("{1:.3} {} {baz}", "aa", foo.field, baz = 3);
-   |               ~                    +++++++++++
+LL |     let _ = format!("{1:.3} {} {baz}", "aa", foo.field, baz = 3);
+   |                       ~                    +++++++++++
 
 error: aborting due to 7 previous errors
 
diff --git a/tests/ui/issues/issue-20676.rs b/tests/ui/issues/issue-20676.rs
index b3319950b42..2059365c7d6 100644
--- a/tests/ui/issues/issue-20676.rs
+++ b/tests/ui/issues/issue-20676.rs
@@ -8,5 +8,5 @@
 
 fn main() {
     let a: &dyn fmt::Debug = &1;
-    format!("{:?}", a);
+    let _ = format!("{:?}", a);
 }