Rust 分配的匿名vs结构生存期

对于这段代码（删减了一些，抱歉没有更多），我遇到了一个终生的问题：

fn main() {
    println!("Hello, world!");
}

#[derive(Debug)]
pub struct Token<'a> {
    pub line: usize,
    // Col in code points.
    pub col: usize,
    // Index in bytes.
    pub index: usize,
    pub state: TokenState,
    pub text: &'a str,
}

#[derive(Clone, Copy, Debug, PartialEq)]
pub enum TokenState {
    VSpace,
}

#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ParseState {
    Expr,
}

pub struct Node<'a> {
    kids: Vec<Node<'a>>,
    state: ParseState,
    token: Option<&'a Token<'a>>,
}

impl<'a> Node<'a> {
    fn new(state: ParseState) -> Node<'a> {
        Node {
            kids: vec![],
            state,
            token: None,
        }
    }

    fn new_token(token: &'a Token<'a>) -> Node<'a> {
        // TODO Control state? Some token state?
        Node {
            kids: vec![],
            state: ParseState::Expr,
            token: Some(&token),
        }
    }

    fn push_if(&mut self, node: Node<'a>) {
        if !node.kids.is_empty() {
            self.kids.push(node);
        }
    }
}

pub fn parse<'a>(tokens: &'a Vec<Token<'a>>) -> Node<'a> {
    let mut root = Node::new(ParseState::Expr);
    let mut parser = Parser {
        index: 0,
        tokens: tokens,
    };
    parser.parse_block(&mut root);
    root
}

struct Parser<'a> {
    index: usize,
    tokens: &'a Vec<Token<'a>>,
}

impl<'a> Parser<'a> {
    fn parse_block(&mut self, parent: &mut Node) {
        loop {
            let mut row = Node::new(ParseState::Expr);
            match self.peek() {
                Some(_) => {
                    self.parse_row(&mut row);
                }
                None => {
                    break;
                }
            }
            parent.push_if(row);
        }
    }

    fn parse_row(&mut self, parent: &mut Node) {
        loop {
            match self.next() {
                Some(ref token) => match token.state {
                    TokenState::VSpace => break,
                    _ => {
                        parent.kids.push(Node::new_token(&token));
                    }
                },
                None => break,
            }
        }
    }

    fn next(&mut self) -> Option<&Token> {
        let index = self.index;
        if index < self.tokens.len() {
            self.index += 1;
        }
        self.tokens.get(index)
    }

    fn peek(&mut self) -> Option<&Token> {
        self.tokens.get(self.index)
    }
}

fn main（）{
println！（“你好，世界！”）；
}
#[导出（调试）]
发布结构令牌>，
州:州,，
令牌：选项>，
}
恳求{
fn新建（状态：ParseState）->节点{
//TODO控制状态？某些令牌状态？
节点{
孩子们：vec！[]，
状态：ParseState:：Expr，
令牌：一些（&令牌），
}
}
fn push_if和mut self，节点：节点（令牌：&'a Vec{
让mut root=Node:：new（ParseState:：Expr）；
让mut parser=parser{
索引：0，
代币：代币，
};
parser.parse_块（&mut root）；
根
}
结构分析器src/main.rs:72:1
|
72 |/impl{
73 | | fn parse_块（&mut self，parent:&mut Node）{
74 | |环{
75 | |让mut row=Node:：new（ParseState:：Expr）；
...  |
112| |     }
113| | }
| |_^
注意：…因此类型`Parser，found Node让我们看看
Parser:：next的签名：

fn next(&mut self) -> Option<&Token>

我们这里又有一些省略的生命周期。让我们把它们拼出来：

fn parse_row<'b, 'c, 'd>(&'b mut self, parent: &'c mut Node<'d>)

现在，一个匿名生存期被标识为
'd
。另一个仍然是匿名生存期，这是编译器如何操作生存期的产物，但我们可以将其视为
'b

现在问题应该更清楚了：我们正在尝试推送一个
节点
对象。重要的是类型必须是
节点
fn parse_row(&mut self, parent: &mut Node)

fn parse_row<'b, 'c, 'd>(&'b mut self, parent: &'c mut Node<'d>)

fn next(&mut self) -> Option<&'a Token<'a>>

fn parse_row(&mut self, parent: &mut Node<'a>)

fn parse_block(&mut self, parent: &mut Node)

fn parse_block<'b, 'c, 'd>(&'b mut self, parent: &'c mut Node<'d>)

fn parse_block(&mut self, parent: &mut Node<'a>)