Document From::from impls

library/alloc/src/bstr.rs

@@ -180,6 +180,7 @@ impl Default for ByteString {
 //
 // #[unstable(feature = "bstr", issue = "134915")]
 // impl<'a, const N: usize> From<&'a [u8; N]> for ByteString {
+//     /// Allocate a new `ByteString` with a copy of the bytes in the array.
 //     #[inline]
 //     fn from(s: &'a [u8; N]) -> Self {
 //         ByteString(s.as_slice().to_vec())
@@ -188,6 +189,7 @@ impl Default for ByteString {
 //
 // #[unstable(feature = "bstr", issue = "134915")]
 // impl<const N: usize> From<[u8; N]> for ByteString {
+//     /// Allocate a new `ByteString` with a copy of the bytes in the array.
 //     #[inline]
 //     fn from(s: [u8; N]) -> Self {
 //         ByteString(s.as_slice().to_vec())
@@ -196,6 +198,7 @@ impl Default for ByteString {
 //
 // #[unstable(feature = "bstr", issue = "134915")]
 // impl<'a> From<&'a [u8]> for ByteString {
+//     /// Allocate a new `ByteString` with a copy of the bytes in the array.
 //     #[inline]
 //     fn from(s: &'a [u8]) -> Self {
 //         ByteString(s.to_vec())
@@ -204,6 +207,7 @@ impl Default for ByteString {
 //
 // #[unstable(feature = "bstr", issue = "134915")]
 // impl From<Vec<u8>> for ByteString {
+//     /// Make a `ByteString` with `Vec<u8>` as inner
 //     #[inline]
 //     fn from(s: Vec<u8>) -> Self {
 //         ByteString(s)
@@ -212,6 +216,7 @@ impl Default for ByteString {
 
 #[unstable(feature = "bstr", issue = "134915")]
 impl From<ByteString> for Vec<u8> {
+    /// Return the inner `Vec` of the byte string.
     #[inline]
     fn from(s: ByteString) -> Self {
         s.0
@@ -222,6 +227,7 @@ impl From<ByteString> for Vec<u8> {
 //
 // #[unstable(feature = "bstr", issue = "134915")]
 // impl<'a> From<&'a str> for ByteString {
+//     /// Allocate a new `ByteString` with a copy of the bytes in the slice.
 //     #[inline]
 //     fn from(s: &'a str) -> Self {
 //         ByteString(s.as_bytes().to_vec())
@@ -230,6 +236,7 @@ impl From<ByteString> for Vec<u8> {
 //
 // #[unstable(feature = "bstr", issue = "134915")]
 // impl From<String> for ByteString {
+//     /// Create a `ByteString` from a `String`s bytes
 //     #[inline]
 //     fn from(s: String) -> Self {
 //         ByteString(s.into_bytes())
@@ -238,6 +245,7 @@ impl From<ByteString> for Vec<u8> {
 
 #[unstable(feature = "bstr", issue = "134915")]
 impl<'a> From<&'a ByteStr> for ByteString {
+    /// Allocates a `ByteString` containing the bytes of `ByteStr`.
     #[inline]
     fn from(s: &'a ByteStr) -> Self {
         ByteString(s.0.to_vec())
@@ -246,6 +254,7 @@ impl<'a> From<&'a ByteStr> for ByteString {
 
 #[unstable(feature = "bstr", issue = "134915")]
 impl<'a> From<ByteString> for Cow<'a, ByteStr> {
+    /// Wrap `ByteString` in `Cow::Owned`.
     #[inline]
     fn from(s: ByteString) -> Self {
         Cow::Owned(s)
@@ -254,6 +263,7 @@ impl<'a> From<ByteString> for Cow<'a, ByteStr> {
 
 #[unstable(feature = "bstr", issue = "134915")]
 impl<'a> From<&'a ByteString> for Cow<'a, ByteStr> {
+    /// Wrap `ByteString` as byte str in `Cow::Borrowed`.
     #[inline]
     fn from(s: &'a ByteString) -> Self {
         Cow::Borrowed(s.as_bytestr())
@@ -599,6 +609,7 @@ impl Clone for Box<ByteStr> {
 
 #[unstable(feature = "bstr", issue = "134915")]
 impl<'a> From<&'a ByteStr> for Cow<'a, ByteStr> {
+    /// Wrap `ByteStr` in `Cow::Borrowed`.
     #[inline]
     fn from(s: &'a ByteStr) -> Self {
         Cow::Borrowed(s)
@@ -607,6 +618,7 @@ impl<'a> From<&'a ByteStr> for Cow<'a, ByteStr> {
 
 #[unstable(feature = "bstr", issue = "134915")]
 impl From<Box<[u8]>> for Box<ByteStr> {
+    /// 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]`.
@@ -616,6 +628,7 @@ impl From<Box<[u8]>> for Box<ByteStr> {
 
 #[unstable(feature = "bstr", issue = "134915")]
 impl From<Box<ByteStr>> for Box<[u8]> {
+    /// Convert the inner bytes of `Box<[u8]>` to `ByteStr`.
     #[inline]
     fn from(s: Box<ByteStr>) -> Box<[u8]> {
         // SAFETY: `ByteStr` is a transparent wrapper around `[u8]`.
@@ -626,6 +639,7 @@ impl From<Box<ByteStr>> for Box<[u8]> {
 #[unstable(feature = "bstr", issue = "134915")]
 #[cfg(not(no_rc))]
 impl From<Rc<[u8]>> for Rc<ByteStr> {
+    /// Create an `Rc<[u8]>` from the inner bytes of `Rc<ByteStr>`.
     #[inline]
     fn from(s: Rc<[u8]>) -> Rc<ByteStr> {
         // SAFETY: `ByteStr` is a transparent wrapper around `[u8]`.
@@ -636,6 +650,7 @@ impl From<Rc<[u8]>> for Rc<ByteStr> {
 #[unstable(feature = "bstr", issue = "134915")]
 #[cfg(not(no_rc))]
 impl From<Rc<ByteStr>> for Rc<[u8]> {
+    /// Create a `Rc<ByteStr>` from the bytes of `Rc<[u8]>`.
     #[inline]
     fn from(s: Rc<ByteStr>) -> Rc<[u8]> {
         // SAFETY: `ByteStr` is a transparent wrapper around `[u8]`.
@@ -646,6 +661,7 @@ impl From<Rc<ByteStr>> for Rc<[u8]> {
 #[unstable(feature = "bstr", issue = "134915")]
 #[cfg(all(not(no_rc), not(no_sync), target_has_atomic = "ptr"))]
 impl From<Arc<[u8]>> for Arc<ByteStr> {
+    /// Create an `Arc<ByteStr>` from the bytes of `Arc<[u8]>`.
     #[inline]
     fn from(s: Arc<[u8]>) -> Arc<ByteStr> {
         // SAFETY: `ByteStr` is a transparent wrapper around `[u8]`.
@@ -656,6 +672,7 @@ impl From<Arc<[u8]>> for Arc<ByteStr> {
 #[unstable(feature = "bstr", issue = "134915")]
 #[cfg(all(not(no_rc), not(no_sync), target_has_atomic = "ptr"))]
 impl From<Arc<ByteStr>> for Arc<[u8]> {
+    /// Create a `Arc<[u8]>` from the inner bytes of `Arc<ByteStr>`.
     #[inline]
     fn from(s: Arc<ByteStr>) -> Arc<[u8]> {
         // SAFETY: `ByteStr` is a transparent wrapper around `[u8]`.
@@ -675,6 +692,10 @@ impl_partial_eq_ord_cow!(&'a ByteStr, Cow<'a, [u8]>);
 impl<'a> TryFrom<&'a ByteStr> for String {
     type Error = core::str::Utf8Error;
 
+    /// Try to allocate a `ByteStr`s bytes as a UTF-8 `String`.
+    ///
+    /// # Errors
+    /// If `ByteStr` is not valid UTF-8
     #[inline]
     fn try_from(s: &'a ByteStr) -> Result<Self, Self::Error> {
         Ok(core::str::from_utf8(&s.0)?.into())

library/alloc/src/collections/vec_deque/mod.rs

@@ -3045,6 +3045,7 @@ impl<T, A: Allocator> From<Vec<T, A>> for VecDeque<T, A> {
     /// [`Vec<T>`]: crate::vec::Vec
     /// [`VecDeque<T>`]: crate::collections::VecDeque
     ///
+    /// ## Cost
     /// This conversion is guaranteed to run in *O*(1) time
     /// and to not re-allocate the `Vec`'s buffer or allocate
     /// any additional memory.

library/alloc/src/task.rs

@@ -107,9 +107,7 @@ pub trait Wake {
 #[cfg(target_has_atomic = "ptr")]
 #[stable(feature = "wake_trait", since = "1.51.0")]
 impl<W: Wake + Send + Sync + 'static> From<Arc<W>> for Waker {
-    /// Use a [`Wake`]-able type as a `Waker`.
-    ///
-    /// No heap allocations or atomic operations are used for this conversion.
+    /// Use a [`Wake`]-able type as a `Waker`. Without any heap allocations or atomic operations.
     fn from(waker: Arc<W>) -> Waker {
         // SAFETY: This is safe because raw_waker safely constructs
         // a RawWaker from Arc<W>.
@@ -119,9 +117,7 @@ impl<W: Wake + Send + Sync + 'static> From<Arc<W>> for Waker {
 #[cfg(target_has_atomic = "ptr")]
 #[stable(feature = "wake_trait", since = "1.51.0")]
 impl<W: Wake + Send + Sync + 'static> From<Arc<W>> for RawWaker {
-    /// Use a `Wake`-able type as a `RawWaker`.
-    ///
-    /// No heap allocations or atomic operations are used for this conversion.
+    /// Use a `Wake`-able type as a `RawWaker`. Without any heap allocations or atomic operations.
     fn from(waker: Arc<W>) -> RawWaker {
         raw_waker(waker)
     }
@@ -286,9 +282,7 @@ pub trait LocalWake {
 
 #[unstable(feature = "local_waker", issue = "118959")]
 impl<W: LocalWake + 'static> From<Rc<W>> for LocalWaker {
-    /// Use a `Wake`-able type as a `LocalWaker`.
-    ///
-    /// No heap allocations or atomic operations are used for this conversion.
+    /// Use a `Wake`-able type as a `LocalWaker`. Without any heap allocations or atomic operations.
     fn from(waker: Rc<W>) -> LocalWaker {
         // SAFETY: This is safe because raw_waker safely constructs
         // a RawWaker from Rc<W>.
@@ -298,9 +292,7 @@ impl<W: LocalWake + 'static> From<Rc<W>> for LocalWaker {
 #[allow(ineffective_unstable_trait_impl)]
 #[unstable(feature = "local_waker", issue = "118959")]
 impl<W: LocalWake + 'static> From<Rc<W>> for RawWaker {
-    /// Use a `Wake`-able type as a `RawWaker`.
-    ///
-    /// No heap allocations or atomic operations are used for this conversion.
+    /// Use a `Wake`-able type as a `RawWaker`. Without any heap allocations or atomic operations.
     fn from(waker: Rc<W>) -> RawWaker {
         local_raw_waker(waker)
     }

library/core/src/array/mod.rs

@@ -178,6 +178,7 @@ impl Error for TryFromSliceError {
 
 #[stable(feature = "try_from_slice_error", since = "1.36.0")]
 impl From<Infallible> for TryFromSliceError {
+    /// Convert `Infallible` into an error that can happen.
     fn from(x: Infallible) -> TryFromSliceError {
         match x {}
     }

library/core/src/ascii/ascii_char.rs

@@ -546,6 +546,7 @@ macro_rules! into_int_impl {
         $(
             #[unstable(feature = "ascii_char", issue = "110998")]
             impl From<AsciiChar> for $ty {
+                #[doc = concat!("Convert `AsciiChar` as `u8` into `", stringify!($ty), "`")]
                 #[inline]
                 fn from(chr: AsciiChar) -> $ty {
                     chr as u8 as $ty

library/core/src/num/nonzero.rs

@@ -290,6 +290,7 @@ impl<T> From<NonZero<T>> for T
 where
     T: ZeroablePrimitive,
 {
+    /// 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,6 +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 value is returned
     #[inline]
     fn from(align: Alignment) -> NonZero<usize> {
         align.as_nonzero()
@@ -197,6 +198,7 @@ impl From<Alignment> for NonZero<usize> {
 
 #[unstable(feature = "ptr_alignment_type", issue = "102070")]
 impl From<Alignment> for usize {
+    /// Return the inner value of `Alignment` as a `usize`.
     #[inline]
     fn from(align: Alignment) -> usize {
         align.as_usize()

library/core/src/ptr/non_null.rs

@@ -1648,6 +1648,7 @@ impl<T: ?Sized> hash::Hash for NonNull<T> {
 
 #[unstable(feature = "ptr_internals", issue = "none")]
 impl<T: ?Sized> From<Unique<T>> for NonNull<T> {
+    /// Return `Unique` cast to a `NonNull`.
     #[inline]
     fn from(unique: Unique<T>) -> Self {
         unique.as_non_null_ptr()

library/core/src/range.rs

@@ -187,13 +187,15 @@ impl<T> IntoBounds<T> for Range<T> {
 
 #[unstable(feature = "new_range_api", issue = "125687")]
 impl<T> From<Range<T>> for legacy::Range<T> {
+    /// Make a new `legacy::Range` with the same start and end as `Range`
     #[inline]
     fn from(value: Range<T>) -> Self {
         Self { start: value.start, end: value.end }
     }
 }
 #[unstable(feature = "new_range_api", issue = "125687")]
 impl<T> From<legacy::Range<T>> for Range<T> {
+    /// Make a new `Range` with the same start and end as `legacy::Range`
     #[inline]
     fn from(value: legacy::Range<T>) -> Self {
         Self { start: value.start, end: value.end }
@@ -363,13 +365,15 @@ impl<T> IntoBounds<T> for RangeInclusive<T> {
 
 #[unstable(feature = "new_range_api", issue = "125687")]
 impl<T> From<RangeInclusive<T>> for legacy::RangeInclusive<T> {
+    /// Make a new `legacy::RangeInclusive` with the same start and end as `RangeInclusive`
     #[inline]
     fn from(value: RangeInclusive<T>) -> Self {
         Self::new(value.start, value.end)
     }
 }
 #[unstable(feature = "new_range_api", issue = "125687")]
 impl<T> From<legacy::RangeInclusive<T>> for RangeInclusive<T> {
+    /// Make a new `RangeInclusive` with the same start and end as `legacy::RangeInclusive`
     #[inline]
     fn from(value: legacy::RangeInclusive<T>) -> Self {
         assert!(
@@ -507,13 +511,15 @@ impl<T> IntoBounds<T> for RangeFrom<T> {
 
 #[unstable(feature = "new_range_api", issue = "125687")]
 impl<T> From<RangeFrom<T>> for legacy::RangeFrom<T> {
+    /// Make a new `legacy::RangeFrom` with the same start as `RangeFrom`
     #[inline]
     fn from(value: RangeFrom<T>) -> Self {
         Self { start: value.start }
     }
 }
 #[unstable(feature = "new_range_api", issue = "125687")]
 impl<T> From<legacy::RangeFrom<T>> for RangeFrom<T> {
+    /// Make a new `RangeFrom` with the same start as `legacy::RangeFrom`
     #[inline]
     fn from(value: legacy::RangeFrom<T>) -> Self {
         Self { start: value.start }

library/core/src/sync/exclusive.rs

@@ -164,6 +164,7 @@ impl<T: ?Sized> Exclusive<T> {
 
 #[unstable(feature = "exclusive_wrapper", issue = "98407")]
 impl<T> From<T> for Exclusive<T> {
+    /// Creates a new `Exclusive` wrapping `T`.
     #[inline]
     fn from(t: T) -> Self {
         Self::new(t)

library/portable-simd/crates/core_simd/src/masks.rs

@@ -378,6 +378,7 @@ where
     T: MaskElement,
     LaneCount<N>: SupportedLaneCount,
 {
+    /// Uses `from_array` to create a new `Mask`
     #[inline]
     fn from(array: [bool; N]) -> Self {
         Self::from_array(array)
@@ -389,6 +390,7 @@ where
     T: MaskElement,
     LaneCount<N>: SupportedLaneCount,
 {
+    /// Converts a SIMD mask to an array of bools.
     #[inline]
     fn from(vector: Mask<T, N>) -> Self {
         vector.to_array()
@@ -634,6 +636,7 @@ macro_rules! impl_from {
         where
             LaneCount<N>: SupportedLaneCount,
         {
+            /// Casts the value into the other `Mask`
             #[inline]
             fn from(value: Mask<$from, N>) -> Self {
                 value.cast()

library/portable-simd/crates/core_simd/src/vector.rs

@@ -1047,6 +1047,7 @@ where
     LaneCount<N>: SupportedLaneCount,
     T: SimdElement,
 {
+    /// Load the array into a new `Simd`
     #[inline]
     fn from(array: [T; N]) -> Self {
         Self::from_array(array)
@@ -1058,6 +1059,7 @@ where
     LaneCount<N>: SupportedLaneCount,
     T: SimdElement,
 {
+    /// Use `to_array` to store the `Simd` into a new array
     #[inline]
     fn from(vector: Simd<T, N>) -> Self {
         vector.to_array()

library/portable-simd/crates/core_simd/src/vendor.rs

@@ -7,6 +7,7 @@ macro_rules! from_transmute {
     };
     { @impl $from:ty => $to:ty } => {
         impl core::convert::From<$from> for $to {
+            #[doc = concat!("Transmute a `", stringify!($from), "` into a `", stringify!($to), "`")]
             #[inline]
             fn from(value: $from) -> $to {
                 // Safety: transmuting between vectors is safe, but the caller of this macro

library/proc_macro/src/bridge/buffer.rs

@@ -127,6 +127,8 @@ impl Drop for Buffer {
 }
 
 impl From<Vec<u8>> for Buffer {
+    /// Create a `Buffer` without allocation.\
+    /// By moving data, len, and capacity from `Vec`, then create custom reserve and drop fns.
     fn from(v: Vec<u8>) -> Self {
         let mut v = ManuallyDrop::new(v);
         let (data, len, capacity) = (v.as_mut_ptr(), v.len(), v.capacity());

library/proc_macro/src/bridge/closure.rs

@@ -17,6 +17,7 @@ pub(super) struct Closure<'a, A, R> {
 struct Env;
 
 impl<'a, A, R, F: FnMut(A) -> R> From<&'a mut F> for Closure<'a, A, R> {
+    /// Create a `Closure` from an `FnMut` eg.(function, `||` closure)
     fn from(f: &'a mut F) -> Self {
         unsafe extern "C" fn call<A, R, F: FnMut(A) -> R>(env: *mut Env, arg: A) -> R {
             unsafe { (*(env as *mut _ as *mut F))(arg) }

library/proc_macro/src/bridge/rpc.rs

@@ -253,6 +253,7 @@ pub enum PanicMessage {
 }
 
 impl From<Box<dyn Any + Send>> for PanicMessage {
+    /// Extract `String` or `&'static str` payloads if available or default to `Unknown`
     fn from(payload: Box<dyn Any + Send + 'static>) -> Self {
         if let Some(s) = payload.downcast_ref::<&'static str>() {
             return PanicMessage::StaticStr(s);
@@ -265,6 +266,7 @@ impl From<Box<dyn Any + Send>> for PanicMessage {
 }
 
 impl From<PanicMessage> for Box<dyn Any + Send> {
+    /// Wrap the inner message in a newly allocated `Box`.
     fn from(val: PanicMessage) -> Self {
         match val {
             PanicMessage::StaticStr(s) => Box::new(s),

library/proc_macro/src/lib.rs

@@ -238,6 +238,7 @@ fn tree_to_bridge_tree(
 /// Creates a token stream containing a single token tree.
 #[stable(feature = "proc_macro_lib2", since = "1.29.0")]
 impl From<TokenTree> for TokenStream {
+    /// Convert the tree to a `TokenStream`
     fn from(tree: TokenTree) -> TokenStream {
         TokenStream(Some(bridge::client::TokenStream::from_token_tree(tree_to_bridge_tree(tree))))
     }

library/std/src/error.rs

@@ -511,6 +511,7 @@ impl<E> From<E> for Report<E>
 where
     E: Error,
 {
+    /// Create a `Report` with error of `E`, with all other parameters `false`
     fn from(error: E) -> Self {
         Report { error, show_backtrace: false, pretty: false }
     }