Double mutable borrow error in a loop happens even with NLL on

by

This is a limitation of the current implementation of non-lexical lifetimes This can be shown with this reduced case:

fn next<'buf>(buffer: &'buf mut String) -> &'buf str {
    loop {
        let event = parse(buffer);

        if true {
            return event;
        }
    }
}

fn parse<'buf>(_buffer: &'buf mut String) -> &'buf str {
    unimplemented!()
}

fn main() {}

This limitation prevents NLL case #3: conditional control flow across functions

In compiler developer terms, the current implementation of non-lexical lifetimes is “location insensitive”. Location sensitivity was originally available but it was disabled in the name of performance.

I asked Niko Matsakis about this code:

In the context of your example: the value event only has to have the lifetime 'buf conditionally — at the return point which may or may not execute. But when we are “location insensitive”, we just track the lifetime that event must have anywhere, without considering where that lifetime must hold. In this case, that means we make it hold everywhere, which is why you get a compilation failure.

One subtle thing is that the current analysis is location sensitive in one respect — where the borrow takes place. The length of the borrow is not.

The good news is that adding this concept of location sensitivity back is seen as an enhancement to the implementation of non-lexical lifetimes. The bad news:

That may or may not be before the [Rust 2018] edition.

(Note: it did not make it into the initial release of Rust 2018)

This hinges on a (even newer!) underlying implementation of non-lexical lifetimes that improves the performance. You can opt-in to this half-implemented version using -Z polonius:

rustc +nightly -Zpolonius --edition=2018 example.rs

RUSTFLAGS="-Zpolonius" cargo +nightly build

Because this is across functions, you can sometimes work around this by inlining the function.

More Related Contents:

  1. Why can’t I store a value and a reference to that value in the same struct?
  2. Cannot move out of value which is behind a shared reference when unwrapping
  3. Why does refactoring by extracting a method trigger a borrow checker error?
  4. Temporarily move out of borrowed content
  5. Returning a reference from a HashMap or Vec causes a borrow to last beyond the scope it’s in?
  6. Passing mutable self reference to method of owned object
  7. Mutably borrow one struct field while borrowing another in a closure
  8. Do mutable references have move semantics?
  9. Cannot borrow as immutable because it is also borrowed as mutable in function arguments
  10. What are the options to end a mutable borrow in Rust?
  11. How to update-or-insert on a Vec?
  12. “borrowed value does not live long enough” when using the builder pattern
  13. How to use struct self in member method closure
  14. Can’t borrow mutably within two different closures in the same scope
  15. Temporary value is freed at the end of this statement [duplicate]
  16. How to use a struct’s member as its own key when inserting the struct into a map without duplicating it?
  17. How can I modify self in a closure called from a member function?
  18. How do I move out of a struct field that is an Option?
  19. Why does this mutable borrow live beyond its scope?
  20. Why can’t I reuse a &mut reference after passing it to a function that accepts a generic type?
  21. Return local String as a slice (&str)
  22. How can I swap in a new value for a field in a mutable reference to a structure?
  23. How to convert a String into a &’static str
  24. How do I match enum values with an integer?
  25. How to transform fields during serialization using Serde?
  26. Is it possible to conditionally enable an attribute like `derive`?
  27. Thread ” has overflowed its stack when allocating a large array using Box
  28. How do you enable a Rust “crate feature”?
  29. How to implement Iterator yielding mutable references [duplicate]
  30. How to swap two variables?

Leave a Comment