Cannot borrow as mutable in loop

Question

pub fn read_packet<'a>(buf: &'a mut [u8]) -> &'a [u8] {
    loop {
        read_exact(buf);

        if let Some(packet) = to_packet(buf) {
            return packet;
        }
    }
}

fn read_exact(_: &mut [u8]) {
    todo!()
}

fn to_packet<'a>(_: &'a [u8]) -> Option<&'a [u8]> {
    todo!()
}

I get the following error:

error[E0502]: cannot borrow `*buf` as mutable because it is also borrowed as immutable
 --> src/lib.rs:3:9
  |
1 | pub fn read_packet<'a>(buf: &'a mut [u8]) -> &'a [u8] {
  |                    -- lifetime `'a` defined here
2 |     loop {
3 |         read_exact(buf);
  |         ^^^^^^^^^^^^^^^ mutable borrow occurs here
4 | 
5 |         if let Some(packet) = to_packet(buf) {
  |                                         --- immutable borrow occurs here
6 |             return packet;
  |                    ------ returning this value requires that `*buf` is borrowed for `'a`

I think it should work because:

The mutable borrow in read_exact completes on line 3.
If to_packet returns Some then the value is returned to the caller.
If not, the immutable borrow of to_packet is over at the end of the loop. So it is free to be taken mutable borrow of in the next iteration.

Can somebody please let me know why this doesn't work?

EDIT:

It seems like a current borrow checker limitation. I tried using Polonius in the nightly and it works fine with

RUSTFLAGS=-Zpolonius cargo +nightly check

Netwave · Accepted Answer · 2021-11-05 08:52:19Z

2

It is a compiler limitation atm. You could refactor to something like:

pub fn read_packet<'a>(buf: &'a mut [u8]) {
    loop {
        if read_exact(buf) {
            break;
        }
    }
}


fn is_packet(a: &[u8]) -> bool {
    true
}
fn read_exact<'a>(a: &'a mut [u8]) -> bool {
    is_packet(a)
}

fn to_packet<'a>(_: &'a [u8]) -> Option<&'a [u8]> {
    todo!()
}

fn process_packet<'a>(buf: &'a mut [u8]) {
    read_packet(buf);
    let _packet = to_packet(buf);
}

Playground

answered Nov 5, 2021 at 8:52

Netwave

43.2k6 gold badges69 silver badges111 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Jerboas86 · Accepted Answer · 2021-11-05 13:25:20Z

pub fn read_packet<'a>(buffer: &'a mut [u8]) -> &'a [u8] {     |
    let buf = buffer;                                          |
    loop {                                                     |
        read_exact(buf);                                       \/
        if let Some(packet) = to_packet(buf) {              'a _
            return packet;                                     |
        }                                                      |
    }                                                          |
}                                                              
                                         
fn read_exact(_: &mut [u8]) {
    todo!()
}

fn to_packet<'b>(_from: &'b [u8]) -> Option<&'b [u8]> {
    todo!()
}

Compile error:

  |
1 | pub fn read_packet<'a>(buffer: &'a mut [u8]) -> &'a [u8] {     
  |                    -- lifetime `'a` defined here
...
4 |         read_exact(buf);                                       
  |         ^^^^^^^^^^^^^^^ mutable borrow occurs here
5 |         if let Some(packet) = to_packet(buf) {              
  |                                         --- immutable borrow occurs here
6 |             return packet;                                   
  |                    ------ returning this value requires that `*buf` is borrowed for `'a`

With Non Lexical Lifetime (NLL):

The return statement constrains the packet lifetime to be 'a.
If packet is 'a, so buf (to_packet) has to be also 'a.
'a is valid for the entire function. The loop makes the shared reference lifetime conflicts with the exclusive reference lifetime at the next iteration.

The conflict can be reproduced without the loop. This snippet doesn't compile for the same reason that buff is 'a. And we see that the root cause is the conditional return. Again 'a has to be valid for the entire function.

pub fn read_packet<'a>(buf: &'a mut [u8]) -> &'a [u8] {
    if let Some(packet) = to_packet(buf) {    'a _
        return packet;                           |
    }                                            |
    read_exact(buf);                             |
    return &[0];                                \/
}

fn read_exact(_: &mut [u8]) {
    todo!()
}

fn to_packet<'b>(_: &'b [u8]) -> Option<&'b [u8]> {
    todo!()
}

Compile error:

  |
1 | pub fn read_packet<'a>(buf: &'a mut [u8]) -> &'a [u8] {
  |                    -- lifetime `'a` defined here
2 |     if let Some(packet) = to_packet(buf) {
  |                                     --- immutable borrow occurs here
3 |         return packet;
  |                ------ returning this value requires that `*buf` is borrowed for `'a`
4 |     }
5 |     read_exact(buf);
  |     ^^^^^^^^^^^^^^^ mutable borrow occurs here

With NLL, the lifetime is infered like you thought it would be.

pub fn read_packet<'a>(buffer: &'a mut [u8]) -> &'a [u8] {     
    let buf = buffer;                                          
    loop {                                                     
        read_exact(buf);                                       
        if let Some(packet) = to_packet(buf) {              'x _
            return packet;                                     |
        }                                                     \/
    }                                                          
}                                                              
                                         
fn read_exact(_: &mut [u8]) {
    todo!()
}

fn to_packet<'b>(_from: &'b [u8]) -> Option<&'b [u8]> {
    todo!()
}

Collectives™ on Stack Overflow

Cannot borrow as mutable in loop

EDIT:

2 Answers 2

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

EDIT:

2 Answers 2

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related