     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56

    use core::iter::TrustedLen;
    use core::ptr::{self};

    use super::{SpecExtend, Vec};

    /// Another specialization trait for Vec::from_iter
    /// necessary to manually prioritize overlapping specializations
    /// see [`SpecFromIter`](super::SpecFromIter) for details.
    pub(super) trait SpecFromIterNested<T, I> {
        fn from_iter(iter: I) -> Self;
    }

    impl<T, I> SpecFromIterNested<T, I> for Vec<T>
    where
        I: Iterator<Item = T>,
    {
        default fn from_iter(mut iterator: I) -> Self {
            // Unroll the first iteration, as the vector is going to be
            // expanded on this iteration in every case when the iterable is not
            // empty, but the loop in extend_desugared() is not going to see the
            // vector being full in the few subsequent loop iterations.
            // So we get better branch prediction.
            let mut vector = match iterator.next() {
                None => return Vec::new(),
                Some(element) => {
                    let (lower, _) = iterator.size_hint();
                    let mut vector = Vec::with_capacity(lower.saturating_add(1));
                    unsafe {
                        ptr::write(vector.as_mut_ptr(), element);
                        vector.set_len(1);
                    }
                    vector
                }
            };
            // must delegate to spec_extend() since extend() itself delegates
            // to spec_from for empty Vecs
            <Vec<T> as SpecExtend<T, I>>::spec_extend(&mut vector, iterator);
            vector
        }
    }

    impl<T, I> SpecFromIterNested<T, I> for Vec<T>
    where
        I: TrustedLen<Item = T>,
    {
        fn from_iter(iterator: I) -> Self {
            let mut vector = match iterator.size_hint() {
                (_, Some(upper)) => Vec::with_capacity(upper),
                _ => Vec::new(),
            };
            // must delegate to spec_extend() since extend() itself delegates
            // to spec_from for empty Vecs
            vector.spec_extend(iterator);
            vector
        }
    }