Borrow checking with loops, safe uninitailized variables, and conditional breaks.

[Ericson2314]

I have some code that compiles like this:

pub struct ViewIter<'a> {
  expected_seq: u32,
  tagged_iter:  Peekable<&'a Tagged, dlist::Items<'a, Tagged>>,
}

impl<'a> Iterator<u8> for ViewIter<'a>
{
  #[inline]
  fn next(&mut self) -> Option<u8>
  {
    loop {
      {
        let next = match self.tagged_iter.peek() {
          None    => return None,
          Some(s) => s,
        };

        let cond = self.expected_seq == next.tail() ||
          next.tail().is_clockwise(&self.expected_seq, &next.head());

        if cond
        {
          let tagged = next;

          let ret = Some(tagged.as_slice()[(self.expected_seq - tagged.tail()) as uint]);
          self.expected_seq += 1;

          return ret;
        }
      };

      self.tagged_iter.next();
    }
  }
}

I would like to change the method so it is instead

impl<'a> Iterator<u8> for ViewIter<'a>
{
  #[inline]
  fn next(&mut self) -> Option<u8>
  {
    let tagged;
    loop {
      {
        let next = match self.tagged_iter.peek() {
          None    => return None,
          Some(s) => s,
        };

        let cond = self.expected_seq == next.tail() ||
          next.tail().is_clockwise(&self.expected_seq, &next.head());

        if cond
        {
          tagged = next;
          break;
        }
      };

      self.tagged_iter.next();
    }

    let ret = Some(tagged.as_slice()[(self.expected_seq - tagged.tail()) as uint]);
    self.expected_seq += 1;

    ret
  }
}

But the borrow checker rejects this. Not that if if cond is commented, it is accepted.

I understand that the borrow checker is already doing a lot of magic regarding loops, conditional breaks, and uninitialized variables, but thought I'd report this in case I am hitting an unintended restriction.

head, tail, is_clockwise, are invariant with respect to lifetimes. Everything else is I believe from the standard library or countravariant.

[huonw]

I suspect this is a dupe of #12147 and hence of #6393 transitively. cc @nikomatsakis

[Ericson2314]

Since I reported this, I have been allowed to open source the code: https://github.com/RustOS-Fork-Holding-Ground/rust-net/blob/master/transport/tcp/src/connection/packet_buf/vec_queue.rs#L191-L219

[nikomatsakis]

It's hard to be sure without digging in more deeply, but I don't believe this is a dup of #6393. I suspect it is a dup of #10520 though.

[nwin]

I might be wrong but I think my current problem (more minimal example) falls under the same class:

struct Foo;

impl Foo {
    fn borrow_mut(&mut self) -> Option<&str> {
        Some("Hello World")
    }
}

fn main() {
    let mut foo = Foo;
    let mut retval = None;
    while retval.is_none() {
        retval = foo.borrow_mut()
    };
}

It should pass the borrow checker because the loop will be terminated after the assignment. Same issue occurs on early returns in the loop. I don’t think that it is a dupe of #10520 but indeed a dupe of #12147.

[steveklabnik]

Triage: it seems that this issue boils down to non-lexiacal lifetimes, so I'm going to give it a close in favor of that. Thanks all!

[Ericson2314]

Heh, I got about 1/3 through getting my net stack to compile this summer. I'll make a definitive report on this someday!