I AM NORMAL AND CAN BE TRUSTED WITH PARSER STATE AND LIFETIMES

parser/src/parser.rs

@@ -1,11 +1,11 @@
-use std::{ops::Range, path::PathBuf};
+use std::{cell::Cell, ops::Range, path::PathBuf};
 
 use chumsky::{prelude::*, Stream};
 
 use crate::{
     ast::{
         Assignment, BinOp, BinOpKind, Call, ElsePart, Expr, ExprKind, File, FnDecl, IfStmt, Item,
-        Literal, NameTyPair, Stmt, StructDecl, Ty, TyKind, UnaryOp, UnaryOpKind, VarDecl,
+        Literal, NameTyPair, NodeId, Stmt, StructDecl, Ty, TyKind, UnaryOp, UnaryOpKind, VarDecl,
         WhileStmt,
     },
     lexer::Token,
@@ -14,6 +14,19 @@ use crate::{
 type Error<'src> = Simple<Token<'src>>;
 type Span = Range<usize>;
 
+#[derive(Default)]
+pub struct ParserState {
+    next_id: Cell<u32>,
+}
+
+impl ParserState {
+    pub fn next_id(&self) -> NodeId {
+        let next = self.next_id.get();
+        self.next_id.set(next + 1);
+        NodeId::new(next)
+    }
+}
+
 fn ident_parser<'src>() -> impl Parser<Token<'src>, String, Error = Error<'src>> + Clone {
     let ident = select! {
         Token::Ident(ident) => ident.to_owned(),
@@ -51,7 +64,9 @@ fn ty_parser<'src>() -> impl Parser<Token<'src>, Ty, Error = Error<'src>> + Clon
     })
 }
 
-fn expr_parser<'src>() -> impl Parser<Token<'src>, Expr, Error = Error<'src>> + Clone {
+fn expr_parser<'src>(
+    state: &'src ParserState,
+) -> impl Parser<Token<'src>, Expr, Error = Error<'src>> + Clone + 'src {
     recursive(|expr| {
         let literal = filter_map(|span: Span, token| match token {
             Token::String(str) => Ok(Expr {
@@ -59,11 +74,13 @@ fn expr_parser<'src>() -> impl Parser<Token<'src>, Expr, Error = Error<'src>> +
                     str[1..str.len() - 2].to_owned(),
                     span.clone(),
                 )),
+                id: state.next_id(),
                 span,
             }),
             // todo lol unwrap
             Token::Integer(int) => Ok(Expr {
                 kind: ExprKind::Literal(Literal::Integer(int.parse().unwrap(), span.clone())),
+                id: state.next_id(),
                 span,
             }),
             _ => Err(Simple::expected_input_found(span, Vec::new(), Some(token))),
@@ -83,12 +100,14 @@ fn expr_parser<'src>() -> impl Parser<Token<'src>, Expr, Error = Error<'src>> +
             .delimited_by(just(Token::BracketO), just(Token::BracketC))
             .map_with_span(|exprs: Vec<Expr>, span| Expr {
                 kind: ExprKind::Array(exprs),
+                id: state.next_id(),
                 span,
             });
 
         let atom = literal
             .or(ident_parser().map_with_span(|name, span| Expr {
                 kind: ExprKind::Name(name),
+                id: state.next_id(),
                 span,
             }))
             .or(array)
@@ -112,6 +131,7 @@ fn expr_parser<'src>() -> impl Parser<Token<'src>, Expr, Error = Error<'src>> +
                         callee: Box::new(callee),
                         args,
                     }),
+                    id: state.next_id(),
                     span,
                 }
             })
@@ -134,6 +154,7 @@ fn expr_parser<'src>() -> impl Parser<Token<'src>, Expr, Error = Error<'src>> +
                     kind,
                     span: span.clone(),
                 }),
+                id: state.next_id(),
                 span,
             }
         })
@@ -156,6 +177,7 @@ fn expr_parser<'src>() -> impl Parser<Token<'src>, Expr, Error = Error<'src>> +
                         rhs: Box::new(b),
                         span: span.clone(),
                     }),
+                    id: state.next_id(),
                     span,
                 }
             });
@@ -176,6 +198,7 @@ fn expr_parser<'src>() -> impl Parser<Token<'src>, Expr, Error = Error<'src>> +
                         rhs: Box::new(b),
                         span: span.clone(),
                     }),
+                    id: state.next_id(),
                     span,
                 }
             })
@@ -198,6 +221,7 @@ fn expr_parser<'src>() -> impl Parser<Token<'src>, Expr, Error = Error<'src>> +
                         rhs: Box::new(b),
                         span: span.clone(),
                     }),
+                    id: state.next_id(),
                     span,
                 }
             });
@@ -205,12 +229,14 @@ fn expr_parser<'src>() -> impl Parser<Token<'src>, Expr, Error = Error<'src>> +
     })
 }
 
-fn statement_parser<'src>() -> impl Parser<Token<'src>, Stmt, Error = Error<'src>> + Clone {
+fn statement_parser<'src>(
+    state: &'src ParserState,
+) -> impl Parser<Token<'src>, Stmt, Error = Error<'src>> + Clone {
     recursive(|stmt| {
         let var_decl = ty_parser()
             .then(ident_parser())
             .then_ignore(just(Token::Eq))
-            .then(expr_parser())
+            .then(expr_parser(state))
             .then_ignore(just(Token::Semi))
             .map(|((ty, name), rhs)| {
                 Stmt::VarDecl(VarDecl {
@@ -222,9 +248,9 @@ fn statement_parser<'src>() -> impl Parser<Token<'src>, Stmt, Error = Error<'src
             })
             .boxed();
 
-        let assignment = expr_parser()
+        let assignment = expr_parser(state)
             .then_ignore(just(Token::Eq))
-            .then(expr_parser())
+            .then(expr_parser(state))
             .then_ignore(just(Token::Semi))
             .map(|(place, rhs)| {
                 Stmt::Assignment(Assignment {
@@ -240,14 +266,14 @@ fn statement_parser<'src>() -> impl Parser<Token<'src>, Stmt, Error = Error<'src
             .delimited_by(just(Token::BraceO), just(Token::BraceC));
 
         let while_loop = just(Token::While)
-            .ignore_then(expr_parser())
+            .ignore_then(expr_parser(state))
             .then(block.clone())
             .map_with_span(|(cond, body), span| Stmt::WhileStmt(WhileStmt { cond, body, span }))
             .labelled("while loop");
 
         let if_stmt = recursive(|if_stmt| {
             just(Token::If)
-                .ignore_then(expr_parser())
+                .ignore_then(expr_parser(state))
                 .then(block.clone())
                 .then(
                     just(Token::Else)
@@ -270,7 +296,9 @@ fn statement_parser<'src>() -> impl Parser<Token<'src>, Stmt, Error = Error<'src
 
         var_decl
             .or(assignment)
-            .or(expr_parser().then_ignore(just(Token::Semi)).map(Stmt::Expr))
+            .or(expr_parser(state)
+                .then_ignore(just(Token::Semi))
+                .map(Stmt::Expr))
             .or(if_stmt)
             .or(while_loop)
     })
@@ -278,18 +306,26 @@ fn statement_parser<'src>() -> impl Parser<Token<'src>, Stmt, Error = Error<'src
     .boxed()
 }
 
-fn name_ty_pair_parser<'src>() -> impl Parser<Token<'src>, NameTyPair, Error = Error<'src>> + Clone
-{
+fn name_ty_pair_parser<'src>(
+    state: &'src ParserState,
+) -> impl Parser<Token<'src>, NameTyPair, Error = Error<'src>> + Clone {
     ident_parser()
         .then_ignore(just(Token::Colon))
         .then(ty_parser())
-        .map_with_span(|(name, ty), span| NameTyPair { name, ty, span })
+        .map_with_span(|(name, ty), span| NameTyPair {
+            name,
+            ty,
+            id: state.next_id(),
+            span,
+        })
 }
 
-fn struct_parser<'src>() -> impl Parser<Token<'src>, StructDecl, Error = Error<'src>> + Clone {
+fn struct_parser<'src>(
+    state: &'src ParserState,
+) -> impl Parser<Token<'src>, StructDecl, Error = Error<'src>> + Clone {
     let name = just(Token::Struct).ignore_then(ident_parser());
 
-    let fields = name_ty_pair_parser()
+    let fields = name_ty_pair_parser(state)
         .separated_by(just(Token::Comma))
         .delimited_by(just(Token::BraceO), just(Token::BraceC));
 
@@ -297,17 +333,20 @@ fn struct_parser<'src>() -> impl Parser<Token<'src>, StructDecl, Error = Error<'
         .map(|(name, fields)| StructDecl {
             name,
             fields,
+            id: state.next_id(),
             span: Default::default(),
         })
         .labelled("struct")
 }
 
-fn item_parser<'src>() -> impl Parser<Token<'src>, Item, Error = Error<'src>> + Clone {
+fn item_parser<'src>(
+    state: &'src ParserState,
+) -> impl Parser<Token<'src>, Item, Error = Error<'src>> + Clone {
     // ---- function
 
     let name = ident_parser();
 
-    let params = name_ty_pair_parser()
+    let params = name_ty_pair_parser(state)
         .separated_by(just(Token::Comma))
         .allow_trailing()
         .delimited_by(just(Token::ParenO), just(Token::ParenC))
@@ -319,7 +358,7 @@ fn item_parser<'src>() -> impl Parser<Token<'src>, Item, Error = Error<'src>> +
         .then(params)
         .then(ret_ty)
         .then(
-            statement_parser()
+            statement_parser(state)
                 .repeated()
                 .delimited_by(just(Token::BraceO), just(Token::BraceC)),
         )
@@ -327,6 +366,7 @@ fn item_parser<'src>() -> impl Parser<Token<'src>, Item, Error = Error<'src>> +
             name,
             params,
             ret_ty,
+            id: state.next_id(),
             span,
             body,
         })
@@ -336,14 +376,15 @@ fn item_parser<'src>() -> impl Parser<Token<'src>, Item, Error = Error<'src>> +
 
     function
         .map(Item::FnDecl)
-        .or(struct_parser().map(Item::StructDecl))
+        .or(struct_parser(state).map(Item::StructDecl))
         .labelled("item")
 }
 
 fn file_parser<'src>(
     file_name: PathBuf,
+    state: &'src ParserState,
 ) -> impl Parser<Token<'src>, File, Error = Error<'src>> + Clone {
-    item_parser()
+    item_parser(state)
         .repeated()
         .then_ignore(end())
         .map(move |items| File {
@@ -353,12 +394,17 @@ fn file_parser<'src>(
         .labelled("file")
 }
 
-pub fn parse<'src, I>(lexer: I, len: usize, file_name: PathBuf) -> (Option<File>, Vec<Error<'src>>)
+pub fn parse<'src, I>(
+    lexer: I,
+    state: &'src ParserState,
+    len: usize,
+    file_name: PathBuf,
+) -> (Option<File>, Vec<Error<'src>>)
 where
     I: 'src,
     I: Iterator<Item = (Token<'src>, Span)>,
 {
-    file_parser(file_name).parse_recovery_verbose(Stream::from_iter(len..len + 1, lexer))
+    file_parser(file_name, state).parse_recovery_verbose(Stream::from_iter(len..len + 1, lexer))
 }
 
 #[cfg(test)]
@@ -367,14 +413,16 @@ mod tests {
 
     use logos::Logos;
 
+    use super::ParserState;
     use crate::lexer::Token;
 
-    fn parse(src: &str) -> impl Debug + '_ {
+    fn parse<'src>(src: &'src str, state: &'src ParserState) -> impl Debug + 'src {
         let lexer = Token::lexer(src);
         let len = lexer.source().len();
 
         super::parse(
             lexer.spanned(),
+            state,
             len,
             PathBuf::from(module_path!().replace("::", "__")),
         )
@@ -382,18 +430,21 @@ mod tests {
 
     #[test]
     fn addition() {
-        let r = parse("fn main() { 1 + 4; }");
+        let state = ParserState::default();
+        let r = parse("fn main() { 1 + 4; }", &state);
         insta::assert_debug_snapshot!(r);
     }
 
     #[test]
     fn expression() {
-        let r = parse("fn main() { (4 / hallo()) + 5; }");
+        let state = ParserState::default();
+        let r = parse("fn main() { (4 / hallo()) + 5; }", &state);
         insta::assert_debug_snapshot!(r);
     }
 
     #[test]
     fn unary() {
+        let state = ParserState::default();
         let r = parse(
             "fn main() {
     -(*5);
@@ -401,49 +452,66 @@ mod tests {
     2 + &8;
     *6 * *8; // :)
 }",
+            &state,
         );
         insta::assert_debug_snapshot!(r);
     }
 
     #[test]
     fn function() {
-        let r = parse("fn foo() -> u64 { 1 + 5; }");
+        let state = ParserState::default();
+        let r = parse("fn foo() -> u64 { 1 + 5; }", &state);
         insta::assert_debug_snapshot!(r);
     }
 
     #[test]
     fn if_no_else() {
-        let r = parse("fn foo() -> u64 { if false {} }");
+        let state = ParserState::default();
+
+        let r = parse("fn foo() -> u64 { if false {} }", &state);
         insta::assert_debug_snapshot!(r);
     }
 
     #[test]
     fn if_else() {
-        let r = parse("fn foo() -> u64 { if false {} else {} }");
+        let state = ParserState::default();
+
+        let r = parse("fn foo() -> u64 { if false {} else {} }", &state);
         insta::assert_debug_snapshot!(r);
     }
 
     #[test]
     fn while_loop() {
-        let r = parse("fn foo() -> u64 { while false {} }");
+        let state = ParserState::default();
+
+        let r = parse("fn foo() -> u64 { while false {} }", &state);
         insta::assert_debug_snapshot!(r);
     }
 
     #[test]
     fn var_decl() {
-        let r = parse("fn foo() -> u64 { u64 hello = 5; }");
+        let state = ParserState::default();
+
+        let r = parse("fn foo() -> u64 { u64 hello = 5; }", &state);
         insta::assert_debug_snapshot!(r);
     }
 
     #[test]
     fn struct_() {
-        let r = parse("struct X { y: u64, x: u64 }");
+        let state = ParserState::default();
+
+        let r = parse("struct X { y: u64, x: u64 }", &state);
         insta::assert_debug_snapshot!(r);
     }
 
     #[test]
     fn types() {
-        let r = parse("fn types() -> ptr u64 { Test test = 2; ptr u64 int = 25; }");
+        let state = ParserState::default();
+
+        let r = parse(
+            "fn types() -> ptr u64 { Test test = 2; ptr u64 int = 25; }",
+            &state,
+        );
         insta::assert_debug_snapshot!(r);
     }
 }