iter_with_drain suggestion causes lifetime/ownership error

[BenjaminBrienen]

Summary

Due to a lifetime issue, the suggestion doesn't compile.

Reproducer

fn foo() {
    let mut current = vec![];
    while !current.is_empty() {
        current.drain(..).for_each(|_: ()| {});
    }
}

becomes

fn foo() {
    let mut current = vec![];
    while !current.is_empty() { // borrow of moved value: `current`
        current.into_iter().for_each(|_: ()| {});
    }
}

Version

rustc 1.87.0 (17067e9ac 2025-05-09)
binary: rustc
commit-hash: 17067e9ac6d7ecb70e50f92c1944e545188d2359
commit-date: 2025-05-09
host: x86_64-unknown-linux-gnu
release: 1.87.0
LLVM version: 20.1.1

Additional Labels

@rustbot I-suggestion-causes-error

[BenjaminBrienen]

I think the correct suggestion would be:

fn foo() {
    let mut current = vec![];
    while !current.is_empty() {
        current.iter().for_each(|_: &()| {});
    }
}

[BenjaminBrienen]

REAL code before:

fn bdfs(
    node: &SyntaxNode,
    mut function: impl FnMut(SyntaxNode) -> TreeOrder,
) {
    let mut curr_layer = vec![node.clone()];
    let mut next_layer = vec![];
    while !curr_layer.is_empty() {
        curr_layer.drain(..).for_each(|node| {
            let mut preorder = node.preorder();
            while let Some(event) = preorder.next() {
                match event {
                    syntax::WalkEvent::Enter(node) => {
                        if function(node.clone()) == TreeOrder::BreadthFirst {
                            next_layer.extend(node.children());
                            preorder.skip_subtree();
                        }
                    },
                    syntax::WalkEvent::Leave(_) => {},
                }
            }
        });
        std::mem::swap(&mut curr_layer, &mut next_layer);
    }
}

theoretical after:

fn bdfs(
    node: &SyntaxNode,
    mut function: impl FnMut(SyntaxNode) -> TreeOrder,
) {
    let mut curr_layer = vec![node.clone()];
    let mut next_layer = vec![];
    while !curr_layer.is_empty() {
        for node in &curr_layer {
            let mut preorder = node.preorder();
            while let Some(event) = preorder.next() {
                match event {
                    syntax::WalkEvent::Enter(node) => {
                        if function(node.clone()) == TreeOrder::BreadthFirst {
                            next_layer.extend(node.children());
                            preorder.skip_subtree();
                        }
                    },
                    syntax::WalkEvent::Leave(_) => {},
                }
            }
        }
        std::mem::swap(&mut curr_layer, &mut next_layer);
    }
}

[Jarcho]

The drain in your example is required. curr_layer needs to be empty when it's swapped with next_layer so the new value of next_layer at the start of the loop is empty.