Question about "lifetime mismatch"

[piggynl]

Here is my simplified code. A lexer produces Tokens and they are collected into a LexerResult. A Token may contain a reference to the raw input.

use peg::{Parse, ParseElem, RuleResult};

enum Token<'lex> {
    Keyword,
    Name(Vec<&'lex str>),
}

struct LexerResult<'lex>(Vec<Token<'lex>>);

impl<'lex> Parse for LexerResult<'lex> {
    type PositionRepr = usize;

    fn start(&self) -> usize { 0 }

    fn is_eof(&self, p: usize) -> bool { p >= self.0.len() }

    fn position_repr(&self, p: usize) -> Self::PositionRepr { p }
}

impl<'parse: 'lex, 'lex> ParseElem<'parse> for LexerResult<'lex>
{
    type Element = &'lex Token<'lex>;

    fn parse_elem(&'parse self, pos: usize) -> RuleResult<Self::Element> {
        match self.0.get(pos) {
            Some(t) => RuleResult::Matched(pos + 1, t),
            None => RuleResult::Failed,
        }
    }
}

peg::parser! {
    grammar parser<'lex>() for LexerResult<'lex> {
        rule keyword() = [&Token::Keyword]

        rule name() -> Vec<&'lex str> = [&Token::Name(s)] { s }

        rule syntax() = keyword() name()
    }
}

But Rust complains about lifetime mismatch:

error[E0623]: lifetime mismatch
  --> src/lib.rs:36:59
   |
32 | / peg::parser! {
33 | |     grammar parser<'lex>() for LexerResult<'lex> {
34 | |         rule keyword() = [&Token::Keyword]
35 | |
36 | |         rule name() -> Vec<&'lex str> = [&Token::Name(s)] { s }
   | |         ----                                              ^^^^^ ...but data from `__input` is returned here
...  |
39 | |     }
40 | | }
   | |_- this parameter and the return type are declared with different lifetimes...
   |
   = note: this error originates in the macro `peg::parser` (in Nightly builds, run with -Z macro-backtrace for more info)

Is there a workaround for this? Or is this the same problem as #291 (comment) described? Thank you!

[kevinmehall]

This is pretty similar to #291.

You can make it compile if you get the lifetimes just right:

--- a/src/main.rs
+++ b/src/main.rs
@@ -17,9 +17,9 @@
     fn position_repr(&self, p: usize) -> Self::PositionRepr { p }
 }
 
-impl<'parse: 'lex, 'lex> ParseElem<'parse> for LexerResult<'lex>
+impl<'parse, 'lex: 'parse> ParseElem<'parse> for LexerResult<'lex>
 {
-    type Element = &'lex Token<'lex>;
+    type Element = &'parse Token<'lex>;
 
     fn parse_elem(&'parse self, pos: usize) -> RuleResult<Self::Element> {
         match self.0.get(pos) {
@@ -33,7 +33,7 @@
     grammar parser<'lex>() for LexerResult<'lex> {
         rule keyword() = [&Token::Keyword]
 
-        rule name() -> Vec<&'lex str> = [&Token::Name(s)] { s }
+        rule name() -> &'input Vec<&'lex str> = [&Token::Name(ref s)] { s }
 
         rule syntax() = keyword() name()
     }

'lex: 'parse rather than the other way around because this means 'lex outlives 'parse. You could have a 'lex result from the lexer, and parse it multiple times each with a separate 'parse lifetime within 'lex.

This is harder than it needs to be -- realistically, you probably don't need the flexibility offered by using two lifetimes here to be able to discard the Vec but continue to hold the &str inside. It could be a single lifetime, but rust-peg always introduces and forces you to use a new &'input lifetime for the parser input.

I'd like to make that input reference and associated lifetime explicit instead of implicit in an upcoming release to let you write grammar parser<'a>() for &'a LexerResult<'a> {.

[piggynl]

Thank you for your kindly responding! Everything works fine after this change.