perf(semantic): use split_at_mut instead of iterator in current_and_parent_mut

[camc314]

Before:

impl Stack {
    #[inline]
    pub fn current_and_parent_iter(&mut self) -> (&mut Map, &mut Map) {
        // Assert invariants
        if self.depth == 0 {
            unsafe { unreachable_unchecked() };
        }
        if self.stack.len() <= self.depth {
            unsafe { unreachable_unchecked() };
        }
        let mut iter = self.stack.iter_mut();
        let parent = iter.nth(self.depth - 1).unwrap();
        let current = iter.next().unwrap();
        (current, parent)
    }
}

pub fn use_iter(s: &mut Stack) -> (&mut Map, &mut Map) {
    s.current_and_parent_iter()
}

use_iter:
        mov     rax, qword ptr [rdi + 24]
        movabs  rcx, 1152921504606846975
        and     rcx, rax
        cmp     rcx, qword ptr [rdi + 16]
        je      .LBB0_2
        lea     rcx, [rax + 2*rax]
        shl     rcx, 4
        mov     rdx, qword ptr [rdi + 8]
        lea     rax, [rdx + rcx]
        add     rdx, rcx
        add     rdx, -48
        ret
.LBB0_2:
        push    rax
        lea     rdi, [rip + .Lanon.f6daf3c64be0965473887c7779875594.1]
        call    qword ptr [rip + core::option::unwrap_failed::hc7ed8ec7fd6c106d@GOTPCREL]

.Lanon.f6daf3c64be0965473887c7779875594.0:
        .asciz  "/app/example.rs"

.Lanon.f6daf3c64be0965473887c7779875594.1:
        .quad   .Lanon.f6daf3c64be0965473887c7779875594.0
        .asciz  "\017\000\000\000\000\000\000\000\025\000\000\000#\000\000"

After:

impl Stack {
    #[inline]
    pub fn current_and_parent_split(&mut self) -> (&mut Map, &mut Map) {
        // Assert invariants
        if self.depth == 0 {
            unsafe { unreachable_unchecked() };
        }
        if self.stack.len() <= self.depth {
            unsafe { unreachable_unchecked() };
        }
        let (head, tail) = self.stack.split_at_mut(self.depth);
        let parent = &mut head[self.depth - 1] ;
        let current = &mut tail[0];
        (current, parent)
    }
}

pub fn use_split(s: &mut Stack) -> (&mut Map, &mut Map) {
    s.current_and_parent_split()
}

use_split:
        mov     rcx, qword ptr [rdi + 8]
        mov     rax, qword ptr [rdi + 24]
        lea     rdx, [rax + 2*rax]
        shl     rdx, 4
        lea     rax, [rcx + rdx]
        add     rdx, rcx
        add     rdx, -48
        ret

[camc314]

• perf(semantic): use match_module_declaration! macro instead of match guard #17184
• perf(semantic): use swap_remove instead of into_iter().next() in into_root #17183
• perf(semantic): use split_at_mut instead of iterator in current_and_parent_mut #17182 👈 (View in Graphite)
• main

---

How to use the Graphite Merge Queue

Add either label to this PR to merge it via the merge queue:

• 0-merge - adds this PR to the back of the merge queue
• hotfix - for urgent hot fixes, skip the queue and merge this PR next

You must have a Graphite account in order to use the merge queue. Sign up using this link.

An organization admin has enabled the Graphite Merge Queue in this repository.

Please do not merge from GitHub as this will restart CI on PRs being processed by the merge queue.

This stack of pull requests is managed by Graphite. Learn more about stacking.

[codspeed-hq]

CodSpeed Performance Report

Merging #17182 will not alter performance

_{Comparing c/12-20-perf_semantic_use_split_at_mut_instead_of_iterator_in_current_and_parent_mut (18ed7de) with main (0f63e75)}

Summary

✅ 42 untouched
⏩ 3 skipped¹

Footnotes

1. 3 benchmarks were skipped, so the baseline results were used instead. If they were deleted from the codebase, click here and archive them to remove them from the performance reports. ↩

[camc314]

😞 I was more optimistic that there'd be a more concrete perf improvement.

[Copilot]

Pull request overview

This PR optimizes the current_and_parent_mut method in the unresolved references stack by replacing an iterator-based approach with split_at_mut, resulting in cleaner assembly code with fewer instructions and no panic paths.

Key Changes

• Replaced iter_mut().nth().next() pattern with split_at_mut() for better code generation
• Removed outdated godbolt.org link comment since the optimization approach has changed
• Maintained the same safety guarantees through existing assert_unchecked! calls

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[overlookmotel]

Weird. It's regressed in since Rust 1.79. Used not to have a panicking branch.

You got a Godbolt link for new vs old? (just checking this isn't Claude inventing assembly again)

It's also useful to put a Godbolt link in a comment above code like this, which we can use to verify the assembly is still what it should be.

[camc314]

Yep i did verify these as claude can hallicinate here:

https://godbolt.org/z/r55YzaoPq

[camc314]

I made an issue here rust-lang/rust#150235 it's a regression in 1.82

[graphite-app]

Merge activity

• Dec 22, 1:44 PM UTC: Boshen added this pull request to the Graphite merge queue.
• Dec 22, 1:56 PM UTC: Merged by the Graphite merge queue.