启用NLL后Rust循环与递归仍出现双重可变借用错误

首先，我们来拆解你遇到的问题核心——这和你显式声明的'buf生命周期参数直接相关，NLL（非 lexical lifetimes）在这里帮不上忙，因为问题根源不是借用的作用域，而是生命周期参数的强制绑定。

先看你的原循环版本代码：

fn next<'buf>(&mut self, buffer: &'buf mut String) -> XmlEvent<'buf> {
    let result = loop {
        buffer.clear();
        let temp_event = self.parse_outside_tag(buffer);
        match temp_event {
            XmlEvent::Comment(_) if self.ignore_comments => {}
            _ => break temp_event,
        }
    };
    result
}

循环版本报错的原因 #

你的方法签名明确要求：返回的XmlEvent<'buf>必须持有和输入buffer完全相同的'buf生命周期。这意味着，只要方法还没返回，任何生成的XmlEvent<'buf>实例都会绑定buffer的长期借用——哪怕你在循环里只想丢弃这个temp_event（比如忽略注释时），编译器仍然会认为这个借用必须持续到方法结束（因为返回值也是XmlEvent<'buf>，生命周期绑定）。

当你进入下一次循环，尝试调用buffer.clear()或再次传递buffer给parse_outside_tag时，buffer已经被之前的temp_event以'buf的生命周期借用了，自然会触发双重可变借用错误。NLL能优化借用的作用域，但它无法打破你在方法签名里强制的生命周期绑定。

递归版本为什么也不行？ #

你尝试用代码块限制temp_event的作用域：

fn next<'buf>(&mut self, buffer: &'buf mut String) -> XmlEvent<'buf> {
    buffer.clear();
    {
        let temp_event = self.parse_outside_tag(buffer);
        match temp_event {
            XmlEvent::Comment(_) if self.ignore_comments => {}
            _ => return temp_event,
        }
    }
    self.next(buffer)
}

问题还是出在'buf生命周期的绑定上。虽然temp_event被放在了代码块里，但它的类型是XmlEvent<'buf>，这意味着它的引用生命周期必须和方法的buffer参数完全一致——编译器会认为这个借用必须持续到方法返回，而不是代码块结束。当你调用self.next(buffer)时，buffer仍然被之前的temp_event占用着，所以还是会报错。

如何修复？ #

核心是打破XmlEvent和方法级'buf生命周期的强制绑定，让每次迭代/递归调用中生成的XmlEvent只持有当前buffer借用的短期生命周期。

最简单的修复方式是去掉显式的'buf参数，让编译器自动推导生命周期：

struct Parser { ignore_comments: bool, }
enum XmlEvent<'buf> { Comment(&'buf str), Other(&'buf str), }
impl Parser {
    fn next(&mut self, buffer: &mut String) -> XmlEvent<'_> {
        loop {
            buffer.clear();
            let temp_event = self.parse_outside_tag(buffer);
            match temp_event {
                XmlEvent::Comment(_) if self.ignore_comments => {}
                _ => return temp_event,
            }
        }
    }

    fn parse_outside_tag(&mut self, buffer: &mut String) -> XmlEvent<'_> {
        // 示例实现，根据实际逻辑替换
        unimplemented!()
    }
}

这里的'_是生命周期占位符，让编译器自动推导返回的XmlEvent的生命周期等于当前buffer的借用生命周期。每次循环中，当你丢弃temp_event（忽略注释时），对应的buffer借用就会被释放，NLL可以正确识别这一点，允许下一次循环重新借用buffer。

如果你更喜欢显式声明生命周期，也可以这样写：

fn next<'a>(&mut self, buffer: &'a mut String) -> XmlEvent<'a> {
    loop {
        buffer.clear();
        let temp_event = self.parse_outside_tag(buffer);
        match temp_event {
            XmlEvent::Comment(_) if self.ignore_comments => {
                // temp_event在这里被销毁，对应的buffer借用也被释放
            }
            _ => return temp_event,
        }
    }
}

fn parse_outside_tag<'a>(&mut self, buffer: &'a mut String) -> XmlEvent<'a> {
    unimplemented!()
}

这个版本和上面的效果一致，因为'a是每次调用next时的新生命周期参数，而不是固定的方法级生命周期。每次循环迭代中，temp_event的生命周期'a只限于当前迭代，销毁后借用就释放了。

内容的提问来源于stack exchange，提问作者Vladimir Matveev