Method sort_by_lt

compiler/src/modules/vm/builtins/sequence.rs:173–194

In-place sort dispatching `__lt__`; roots items since a comparison can run user code that GCs. */

(&mut self, items: &mut [Val], chunk: &SSAChunk, slots: &mut [Val])

    /* In-place sort dispatching `__lt__`; roots items since a comparison can run user code that GCs. */
    pub(crate) fn sort_by_lt(&mut self, items: &mut [Val], chunk: &SSAChunk, slots: &mut [Val]) -> Result<(), VmErr> {
        let snapshot = items.to_vec();
        let roots_base = self.temp_roots.len();
        for &v in &snapshot { self.temp_roots.push(v); }
        let mut sort_err: Option<VmErr> = None;
        let order = Self::stable_sort_indices(snapshot.len(), |a, b| {
            if sort_err.is_some() { return core::cmp::Ordering::Equal; }
            match self.sort_lt(snapshot[a], snapshot[b], chunk, slots) {
                Ok(true) => core::cmp::Ordering::Less,
                Ok(false) => match self.sort_lt(snapshot[b], snapshot[a], chunk, slots) {
                    Ok(true) => core::cmp::Ordering::Greater,
                    Ok(false) => core::cmp::Ordering::Equal,
                    Err(e) => { sort_err = Some(e); core::cmp::Ordering::Equal }
                },
                Err(e) => { sort_err = Some(e); core::cmp::Ordering::Equal }
            }
        });
        self.temp_roots.truncate(roots_base);
        if let Some(e) = sort_err { return Err(e); }
        for (dst, &src) in order.iter().enumerate() { items[dst] = snapshot[src]; }
        Ok(())
    }

    /* Stable merge sort over `0..n`; unlike `slice::sort_by` it tolerates a non-total `cmp` (NaN keys) without aborting. */
    fn stable_sort_indices<F>(n: usize, mut cmp: F) -> Vec<usize>