START OF COMPILER

src/parser/v1/body.rs

@@ -0,0 +1,131 @@
+use std::fmt::{Debug, Write};
+
+use super::{
+    token::{Keyword, Symbol, Token},
+    Node, Parsable, ParserErrors,
+};
+use crate::util::Padder;
+
+use super::{Expr, ParserError, TokenCursor};
+
+#[derive(Clone)]
+pub struct Body {
+    statements: Vec<Node<Statement>>,
+}
+
+#[derive(Clone)]
+pub enum Statement {
+    Let(String, Node<Expr>),
+    Return(Node<Expr>),
+    Expr(Node<Expr>),
+}
+
+impl Statement {
+    pub fn ended_with_error(&self) -> bool {
+        let expr = match self {
+            Statement::Let(_, e) => e,
+            Statement::Return(e) => e,
+            Statement::Expr(e) => e,
+        };
+        expr.is_err() || expr.as_ref().is_ok_and(|e| e.ended_with_error())
+    }
+}
+
+impl Parsable for Body {
+    fn parse(cursor: &mut TokenCursor, errors: &mut ParserErrors) -> Result<Self, ParserError> {
+        let mut statements = Vec::new();
+        let statement_end = &[Symbol::Semicolon, Symbol::CloseCurly];
+        cursor.expect_sym(Symbol::OpenCurly)?;
+        if cursor.expect_peek()?.is_symbol(Symbol::CloseCurly) {
+            cursor.next();
+            return Ok(Self { statements });
+        }
+        let mut expect_semi = false;
+        loop {
+            let next = cursor.expect_peek()?;
+            if next.is_symbol(Symbol::CloseCurly) {
+                cursor.next();
+                return Ok(Self { statements });
+            }
+            if next.is_symbol(Symbol::Semicolon) {
+                cursor.next();
+                expect_semi = false;
+                continue;
+            } else if expect_semi {
+                errors.add(ParserError {
+                    msg: "expected ';'".to_string(),
+                    spans: vec![cursor.next_pos().char_span()],
+                });
+            }
+            let statement: Node<Statement> = Node::parse(cursor, errors);
+            expect_semi = true;
+            if statement.is_err() || statement.as_ref().is_ok_and(|s| s.ended_with_error()) {
+                let res = cursor
+                    .seek(|t| t.is_symbol_and(|s| statement_end.contains(&s)))
+                    .ok_or(ParserError::unexpected_end())?;
+            }
+            statements.push(statement);
+        }
+    }
+}
+
+impl Parsable for Statement {
+    fn parse(cursor: &mut TokenCursor, errors: &mut ParserErrors) -> Result<Self, ParserError> {
+        let next = cursor.expect_peek()?;
+        Ok(match next.token {
+            Token::Keyword(Keyword::Let) => {
+                cursor.next();
+                let name = cursor.expect_ident()?;
+                cursor.expect_sym(Symbol::Equals)?;
+                let expr = Node::parse(cursor, errors);
+                Self::Let(name, expr)
+            }
+            Token::Keyword(Keyword::Return) => {
+                cursor.next();
+                Self::Return(Node::parse(cursor, errors))
+            }
+            _ => Self::Expr(Node::parse(cursor, errors)),
+        })
+    }
+}
+
+impl Debug for Statement {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Statement::Let(n, e) => {
+                f.write_str("let ")?;
+                f.write_str(n)?;
+                f.write_str(" = ")?;
+                e.fmt(f)?;
+                f.write_char(';')?;
+            }
+            Statement::Return(e) => {
+                f.write_str("return ")?;
+                e.fmt(f)?;
+                f.write_char(';')?;
+            }
+            Statement::Expr(e) => {
+                e.fmt(f)?;
+                f.write_char(';')?;
+            }
+        }
+        Ok(())
+    }
+}
+
+impl Debug for Body {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if self.statements.first().is_some() {
+            f.write_str("{\n    ")?;
+            let mut padder = Padder::new(f);
+            for s in &self.statements {
+                // they don't expose wrap_buf :grief:
+                padder.write_str(&format!("{s:?}\n"))?;
+            }
+            f.write_char('}')?;
+        } else {
+            f.write_str("{}")?;
+        }
+        Ok(())
+    }
+}