Auto merge of #147359 - Zalathar:rollup-x1pnbjz, r=Zalathar

Rollup of 8 pull requests

Successful merges:

 - #143900 ([rustdoc] Correctly handle `should_panic` doctest attribute and fix `--no-run` test flag on the 2024 edition)
 - #147288 (compiletest: Make `DirectiveLine` responsible for name/value splitting)
 - #147309 (Add documentation about unwinding to wasm targets)
 - #147310 (Mark `PatternTypo` suggestion as maybe incorrect)
 - #147320 (Avoid to suggest pattern match on the similarly named in fn signature)
 - #147328 (Implement non-poisoning `Mutex::with_mut`, `RwLock::with` and `RwLock::with_mut`)
 - #147337 (Make `fmt::Write` a diagnostic item)
 - #147349 (Improve the advice given by panic_immediate_abort)

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

Author: bors

compiler/rustc_passes/src/errors.rs

@@ -1365,7 +1365,7 @@ pub(crate) struct UnusedVarAssignedOnly {
 #[multipart_suggestion(
     passes_unused_var_typo,
     style = "verbose",
-    applicability = "machine-applicable"
+    applicability = "maybe-incorrect"
 )]
 pub(crate) struct PatternTypo {
     #[suggestion_part(code = "{code}")]

compiler/rustc_passes/src/liveness.rs

@@ -1691,7 +1691,10 @@ impl<'tcx> Liveness<'_, 'tcx> {
                 if ln == self.exit_ln { false } else { self.assigned_on_exit(ln, var) };
 
             let mut typo = None;
-            for (hir_id, _, span) in &hir_ids_and_spans {
+            let filtered_hir_ids_and_spans = hir_ids_and_spans.iter().filter(|(hir_id, ..)| {
+                !matches!(self.ir.tcx.parent_hir_node(*hir_id), hir::Node::Param(_))
+            });
+            for (hir_id, _, span) in filtered_hir_ids_and_spans.clone() {
                 let ty = self.typeck_results.node_type(*hir_id);
                 if let ty::Adt(adt, _) = ty.peel_refs().kind() {
                     let name = Symbol::intern(&name);
@@ -1717,7 +1720,7 @@ impl<'tcx> Liveness<'_, 'tcx> {
                 }
             }
             if typo.is_none() {
-                for (hir_id, _, span) in &hir_ids_and_spans {
+                for (hir_id, _, span) in filtered_hir_ids_and_spans {
                     let ty = self.typeck_results.node_type(*hir_id);
                     // Look for consts of the same type with similar names as well, not just unit
                     // structs and variants.

compiler/rustc_span/src/symbol.rs

@@ -236,6 +236,7 @@ symbols! {
         File,
         FileType,
         FmtArgumentsNew,
+        FmtWrite,
         Fn,
         FnMut,
         FnOnce,

library/core/src/fmt/mod.rs

@@ -115,6 +115,7 @@ pub struct Error;
 /// [`std::io::Write`]: ../../std/io/trait.Write.html
 /// [flushable]: ../../std/io/trait.Write.html#tymethod.flush
 #[stable(feature = "rust1", since = "1.0.0")]
+#[rustc_diagnostic_item = "FmtWrite"]
 pub trait Write {
     /// Writes a string slice into this writer, returning whether the write
     /// succeeded.

library/core/src/panicking.rs

@@ -35,7 +35,8 @@ use crate::panic::{Location, PanicInfo};
 #[cfg(feature = "panic_immediate_abort")]
 compile_error!(
     "panic_immediate_abort is now a real panic strategy! \
-    Enable it with the compiler flags `-Zunstable-options -Cpanic=immediate-abort`"
+    Enable it with `panic = \"immediate-abort\"` in Cargo.toml, \
+    or with the compiler flags `-Zunstable-options -Cpanic=immediate-abort`"
 );
 
 // First we define the two main entry points that all panics go through.

library/std/src/error.rs

@@ -123,7 +123,7 @@ use crate::fmt::{self, Write};
 /// the `Debug` output means `Report` is an ideal starting place for formatting errors returned
 /// from `main`.
 ///
-/// ```should_panic
+/// ```
 /// #![feature(error_reporter)]
 /// use std::error::Report;
 /// # use std::error::Error;
@@ -154,10 +154,14 @@ use crate::fmt::{self, Write};
 /// #     Err(SuperError { source: SuperErrorSideKick })
 /// # }
 ///
-/// fn main() -> Result<(), Report<SuperError>> {
+/// fn run() -> Result<(), Report<SuperError>> {
 ///     get_super_error()?;
 ///     Ok(())
 /// }
+///
+/// fn main() {
+///     assert!(run().is_err());
+/// }
 /// ```
 ///
 /// This example produces the following output:
@@ -170,7 +174,7 @@ use crate::fmt::{self, Write};
 /// output format. If you want to make sure your `Report`s are pretty printed and include backtrace
 /// you will need to manually convert and enable those flags.
 ///
-/// ```should_panic
+/// ```
 /// #![feature(error_reporter)]
 /// use std::error::Report;
 /// # use std::error::Error;
@@ -201,12 +205,16 @@ use crate::fmt::{self, Write};
 /// #     Err(SuperError { source: SuperErrorSideKick })
 /// # }
 ///
-/// fn main() -> Result<(), Report<SuperError>> {
+/// fn run() -> Result<(), Report<SuperError>> {
 ///     get_super_error()
 ///         .map_err(Report::from)
 ///         .map_err(|r| r.pretty(true).show_backtrace(true))?;
 ///     Ok(())
 /// }
+///
+/// fn main() {
+///     assert!(run().is_err());
+/// }
 /// ```
 ///
 /// This example produces the following output:

library/std/src/sync/nonpoison/mutex.rs

@@ -376,6 +376,40 @@ impl<T: ?Sized> Mutex<T> {
     pub const fn data_ptr(&self) -> *mut T {
         self.data.get()
     }
+
+    /// Acquires the mutex and provides mutable access to the underlying data by passing
+    /// a mutable reference to the given closure.
+    ///
+    /// This method acquires the lock, calls the provided closure with a mutable reference
+    /// to the data, and returns the result of the closure. The lock is released after
+    /// the closure completes, even if it panics.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(lock_value_accessors, nonpoison_mutex)]
+    ///
+    /// use std::sync::nonpoison::Mutex;
+    ///
+    /// let mutex = Mutex::new(2);
+    ///
+    /// let result = mutex.with_mut(|data| {
+    ///     *data += 3;
+    ///
+    ///     *data + 5
+    /// });
+    ///
+    /// assert_eq!(*mutex.lock(), 5);
+    /// assert_eq!(result, 10);
+    /// ```
+    #[unstable(feature = "lock_value_accessors", issue = "133407")]
+    // #[unstable(feature = "nonpoison_mutex", issue = "134645")]
+    pub fn with_mut<F, R>(&self, f: F) -> R
+    where
+        F: FnOnce(&mut T) -> R,
+    {
+        f(&mut self.lock())
+    }
 }
 
 #[unstable(feature = "nonpoison_mutex", issue = "134645")]

library/std/src/sync/nonpoison/rwlock.rs

@@ -498,6 +498,68 @@ impl<T: ?Sized> RwLock<T> {
     pub const fn data_ptr(&self) -> *mut T {
         self.data.get()
     }
+
+    /// Locks this `RwLock` with shared read access to the underlying data by passing
+    /// a reference to the given closure.
+    ///
+    /// This method acquires the lock, calls the provided closure with a reference
+    /// to the data, and returns the result of the closure. The lock is released after
+    /// the closure completes, even if it panics.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(lock_value_accessors, nonpoison_rwlock)]
+    ///
+    /// use std::sync::nonpoison::RwLock;
+    ///
+    /// let rwlock = RwLock::new(2);
+    /// let result = rwlock.with(|data| *data + 3);
+    ///
+    /// assert_eq!(result, 5);
+    /// ```
+    #[unstable(feature = "lock_value_accessors", issue = "133407")]
+    // #[unstable(feature = "nonpoison_rwlock", issue = "134645")]
+    pub fn with<F, R>(&self, f: F) -> R
+    where
+        F: FnOnce(&T) -> R,
+    {
+        f(&self.read())
+    }
+
+    /// Locks this `RwLock` with exclusive write access to the underlying data by passing
+    /// a mutable reference to the given closure.
+    ///
+    /// This method acquires the lock, calls the provided closure with a mutable reference
+    /// to the data, and returns the result of the closure. The lock is released after
+    /// the closure completes, even if it panics.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(lock_value_accessors, nonpoison_rwlock)]
+    ///
+    /// use std::sync::nonpoison::RwLock;
+    ///
+    /// let rwlock = RwLock::new(2);
+    ///
+    /// let result = rwlock.with_mut(|data| {
+    ///     *data += 3;
+    ///
+    ///     *data + 5
+    /// });
+    ///
+    /// assert_eq!(*rwlock.read(), 5);
+    /// assert_eq!(result, 10);
+    /// ```
+    #[unstable(feature = "lock_value_accessors", issue = "133407")]
+    // #[unstable(feature = "nonpoison_rwlock", issue = "134645")]
+    pub fn with_mut<F, R>(&self, f: F) -> R
+    where
+        F: FnOnce(&mut T) -> R,
+    {
+        f(&mut self.write())
+    }
 }
 
 #[unstable(feature = "nonpoison_rwlock", issue = "134645")]

library/std/tests/sync/mutex.rs

@@ -549,3 +549,17 @@ fn panic_while_mapping_unlocked_poison() {
 
     drop(lock);
 }
+
+#[test]
+fn test_mutex_with_mut() {
+    let mutex = std::sync::nonpoison::Mutex::new(2);
+
+    let result = mutex.with_mut(|value| {
+        *value += 3;
+
+        *value + 5
+    });
+
+    assert_eq!(*mutex.lock(), 5);
+    assert_eq!(result, 10);
+}

library/std/tests/sync/rwlock.rs

@@ -861,3 +861,25 @@ fn panic_while_mapping_write_unlocked_poison() {
 
     drop(lock);
 }
+
+#[test]
+fn test_rwlock_with() {
+    let rwlock = std::sync::nonpoison::RwLock::new(2);
+    let result = rwlock.with(|value| *value + 3);
+
+    assert_eq!(result, 5);
+}
+
+#[test]
+fn test_rwlock_with_mut() {
+    let rwlock = std::sync::nonpoison::RwLock::new(2);
+
+    let result = rwlock.with_mut(|value| {
+        *value += 3;
+
+        *value + 5
+    });
+
+    assert_eq!(*rwlock.read(), 5);
+    assert_eq!(result, 10);
+}