为什么借用检查器允许我进行两个可变借用？

Question

这是一个我遇到的某些行为的最小示例：

pub struct PrimeEngine {
    primes: Vec<uint>,
}

pub struct PrimeIterator<'a> {
    engine: &'a mut PrimeEngine,
    index: uint
}

impl PrimeEngine {
    pub fn new() -> PrimeEngine {
        PrimeEngine { primes: vec![] }
    }

    // Needs a &mut so it can call more_primes if needed
    pub fn is_prime(&mut self, x: uint) -> bool {
        true
    }

    pub fn iter<'a>(&'a mut self) -> PrimeIterator<'a> { // '
        PrimeIterator { engine: self, index: 0 }
    }

    fn more_primes(&mut self) {
        // Adds more primes to self.primes
    }
}

impl<'a> Iterator<uint> for PrimeIterator<'a> {
    fn next(&mut self) -> Option<uint> {
        if self.engine.primes.len() <= self.index {
            self.engine.more_primes();
        }
        let i = self.index;
        self.index += 1;
        Some(self.engine.primes[i])
    }
}

以下代码无法编译，因为它试图创建两个可变引用engine，一次是在创建闭包时，另一次是在创建迭代器时：

#[test]
fn test1() {
    let mut engine = PrimeEngine::new();
    engine.iter().take(5).inspect(|x| {
        assert!(engine.is_prime(*x))
    });
}

然而，这段代码可以编译：

#[test]
fn test2() {
    let mut engine = PrimeEngine::new();
    for x in engine.iter().take(5) {
        assert!(engine.is_prime(x))
    }
}

我不知道为什么。 它需要对engine进行可变借用以创建迭代器，这应该防止它进行必要的可变借用来调用is_prime。 由于某种原因允许吗？ 还是这是个bug？

- wingedsubmariner

Answer 1

这似乎是一个bug，我用更简单的代码成功地重现了这个问题：

fn main() {
    let mut vector = vec!(1u, 2u);
    for &x in vector.iter() {
        let cap = vector.capacity();
        println!("Capacity was: {}", cap);
        vector.grow(cap, &0u); // be sure to cause reallocation
        *vector.get_mut(1u) = 5u;
        println!("Value: {}", x);
    }
}

它输出的是：

Capacity was: 4
Value: 1
Capacity was: 8
Value: 2

我正在修改向量内容并进行重新分配，导致底层切片指向未分配的内存（vector.iter() 实际上是 vector.as_slice().iter()）。

最近有一个变化，由于双重借用，在 Rust 0.11 上不能编译。

我在这里打开了一个问题：https://github.com/rust-lang/rust/issues/16820 编辑（2014年9月10日）： 现在已经修复了这个错误：https://github.com/rust-lang/rust/pull/17101

- Levans