Apply suggestions from code review

Author: TimTheBig

library/alloc/src/bstr.rs

@@ -642,7 +642,7 @@ impl Clone for Box<ByteStr> {
 #[cfg(not(test))] // https://github.com/rust-lang/rust/issues/135100
 #[unstable(feature = "bstr", issue = "134915")]
 impl<'a> From<&'a ByteStr> for Cow<'a, ByteStr> {
-    /// Create a `Borrowed` cow from a `ByteStr`.
+    /// Wrap `ByteStr` in `Cow::Borrowed`.
     #[inline]
     fn from(s: &'a ByteStr) -> Self {
         Cow::Borrowed(s)
@@ -652,7 +652,7 @@ impl<'a> From<&'a ByteStr> for Cow<'a, ByteStr> {
 #[cfg(not(test))] // https://github.com/rust-lang/rust/issues/135100
 #[unstable(feature = "bstr", issue = "134915")]
 impl From<Box<[u8]>> for Box<ByteStr> {
-    /// Create a `Box<[u8]>` from `Box<ByteStr>`s raw.
+    /// Move the bytes from `Box<ByteStr>` to `Box<[u8]>`, this does not allocate new memory.
     #[inline]
     fn from(s: Box<[u8]>) -> Box<ByteStr> {
         // SAFETY: `ByteStr` is a transparent wrapper around `[u8]`.

library/core/src/array/mod.rs

@@ -178,24 +178,12 @@ impl Error for TryFromSliceError {
 
 #[stable(feature = "try_from_slice_error", since = "1.36.0")]
 impl From<Infallible> for TryFromSliceError {
-    /// Match `Infallible` into `TryFromSliceError`.
+    /// Convert `Infallible` into an error that can happen.
     fn from(x: Infallible) -> TryFromSliceError {
         match x {}
     }
 }
 
-#[unstable(feature = "never_type", issue = "35121")]
-impl From<!> for TryFromSliceError {
-    /// Match `!` into `TryFromSliceError`.
-    #[inline]
-    fn from(never: !) -> TryFromSliceError {
-        // Match rather than coerce to make sure that code like
-        // `From<Infallible> for TryFromSliceError` above will keep working
-        // when `Infallible` becomes an alias to `!`.
-        match never {}
-    }
-}
-
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T, const N: usize> AsRef<[T]> for [T; N] {
     #[inline]

library/core/src/fmt/mod.rs

@@ -36,7 +36,7 @@ pub enum Alignment {
 #[doc(hidden)]
 #[unstable(feature = "fmt_internals", reason = "internal to standard library", issue = "none")]
 impl From<rt::Alignment> for Option<Alignment> {
-    /// Match the `Alignment` to the `Some` equivalent, `Unknown` matches `None`.
+    /// Match the `rt::Alignment` to the `Some` equivalent, `Unknown` matches `None`.
     fn from(value: rt::Alignment) -> Self {
         match value {
             rt::Alignment::Left => Some(Alignment::Left),

library/core/src/num/error.rs

@@ -27,7 +27,7 @@ impl Error for TryFromIntError {
 
 #[stable(feature = "try_from", since = "1.34.0")]
 impl From<Infallible> for TryFromIntError {
-    /// Match `Infallible` into `TryFromIntError`.
+    /// Convert `Infallible` into an error that can happen.
     #[inline]
     fn from(x: Infallible) -> TryFromIntError {
         match x {}
@@ -36,7 +36,7 @@ impl From<Infallible> for TryFromIntError {
 
 #[unstable(feature = "never_type", issue = "35121")]
 impl From<!> for TryFromIntError {
-    /// Match `!` into `TryFromIntError`.
+    /// Convert `!` into an error that can happen.
     #[inline]
     fn from(never: !) -> TryFromIntError {
         // Match rather than coerce to make sure that code like

library/core/src/num/nonzero.rs

@@ -287,7 +287,7 @@ impl<T> From<NonZero<T>> for T
 where
     T: ZeroablePrimitive,
 {
-    /// Get the inner num of `NonZero`.
+    /// Returns the contained value as a primitive type.
     #[inline]
     fn from(nonzero: NonZero<T>) -> Self {
         // Call `get` method to keep range information.

library/core/src/ptr/alignment.rs

@@ -189,7 +189,7 @@ impl TryFrom<usize> for Alignment {
 
 #[unstable(feature = "ptr_alignment_type", issue = "102070")]
 impl From<Alignment> for NonZero<usize> {
-    /// `Alignment` is non zero so the inner enum value is returned
+    /// `Alignment` is non zero so the inner value is returned
     #[inline]
     fn from(align: Alignment) -> NonZero<usize> {
         align.as_nonzero()
@@ -198,7 +198,7 @@ impl From<Alignment> for NonZero<usize> {
 
 #[unstable(feature = "ptr_alignment_type", issue = "102070")]
 impl From<Alignment> for usize {
-    /// `Alignment` is unsined so the inner enum value is returned
+    /// `Alignment` is unsined so the inner value is returned
     #[inline]
     fn from(align: Alignment) -> usize {
         align.as_usize()

library/proc_macro/src/bridge/rpc.rs

@@ -269,7 +269,7 @@ impl From<PanicMessage> for Box<dyn Any + Send> {
     /// Return the inner wrapped in `Box`.
     ///
     /// ## Cost
-    /// Allocates a new `Box` on the heep
+    /// Allocates a new `Box` on the heap
     fn from(val: PanicMessage) -> Self {
         match val {
             PanicMessage::StaticStr(s) => Box::new(s),

library/std/src/sys/pal/windows/process.rs

@@ -140,7 +140,7 @@ impl From<&OsStr> for EnvKey {
     /// Uses `EnvKey::From<OsString>` to convert the `&OsStr`.
     ///
     /// ## Cost
-    /// Converts `&OsStr` to `OsString` which does a heep allocation
+    /// Converts `&OsStr` to `OsString` which does a heap allocation
     fn from(k: &OsStr) -> Self {
         Self::from(k.to_os_string())
     }

src/tools/clippy/clippy_lints/src/attrs/mixed_attributes_style.rs

@@ -19,7 +19,7 @@ impl From<&AttrKind> for SimpleAttrKind {
     /// if it's a `DocComment` then `Doc` is returned with no conversion.
     ///
     /// ## Cost
-    /// If `AttrKind` is `DocComment` it's free, however if it's `Normal` their is heep allocation
+    /// If `AttrKind` is `DocComment` it's free, however if it's `Normal` their is heap allocation
     fn from(value: &AttrKind) -> Self {
         match value {
             AttrKind::Normal(attr) => {

tests/ui/try-block/try-block-bad-type.stderr

@@ -7,9 +7,9 @@ LL |         Err("")?;
    |         this can't be annotated with `?` because it has type `Result<_, &str>`
    |
    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
-   = help: the following other types implement trait `From<T>`:
-             `TryFromSliceError` implements `From<!>`
-             `TryFromSliceError` implements `From<Infallible>`
+   = help: the trait `From<&str>` is not implemented for `TryFromSliceError`
+           but trait `From<Infallible>` is implemented for it
+   = help: for that trait implementation, expected `Infallible`, found `&str`
 
 error[E0271]: type mismatch resolving `<Result<i32, i32> as Try>::Output == &str`
   --> $DIR/try-block-bad-type.rs:12:9