WIP

Author: JonathanBrouwer

prism_compiler/src/parser/eat.rs

@@ -19,7 +19,7 @@ impl<'a> ParserPrismEnv<'a> {
     }
 
     pub fn eat_keyword(&mut self, expected_str: &str) -> PResult<Span> {
-        let token = self.eat_token(Expected::Literal(expected_str.to_string()), |token, env| {
+        self.eat_token(Expected::Literal(expected_str.to_string()), |token, env| {
             if let Token::Identifier { span, .. } = token
                 && env.db.input.inner().slice(span) == expected_str
             {
@@ -28,8 +28,8 @@ impl<'a> ParserPrismEnv<'a> {
             } else {
                 false
             }
-        })?;
-        Ok(token.span())
+        })
+        .map(|tok| tok.span())
     }
 
     pub fn eat_paren_open(&mut self, open: &str) -> PResult<()> {
@@ -57,4 +57,27 @@ impl<'a> ParserPrismEnv<'a> {
         })
         .map(|_| ())
     }
+
+    pub fn eat_identifier(&mut self) -> PResult<Span> {
+        self.eat_token(Expected::Rule("identifier".to_string()), |token, _env| {
+            matches!(token, Token::Identifier { .. })
+        })
+        .map(|tok| tok.span())
+    }
+
+    pub fn eat_symbol(&mut self, expected_symbol: char) -> PResult<Span> {
+        self.eat_token(
+            Expected::Literal(expected_symbol.to_string()),
+            |token, env| {
+                if let Token::Symbol(span) = token
+                    && env.db.input.inner().slice(span) == String::from_iter([expected_symbol])
+                {
+                    true
+                } else {
+                    false
+                }
+            },
+        )
+        .map(|tok| tok.span())
+    }
 }

prism_compiler/src/parser/expect.rs

@@ -10,12 +10,14 @@ pub type PResult<T> = Result<T, ExpectedGuaranteed>;
 
 pub enum Expected {
     Literal(String),
+    Rule(String),
 }
 
 impl Display for Expected {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
             Expected::Literal(exp) => write!(f, "`{exp}`"),
+            Expected::Rule(rule) => write!(f, "{rule}"),
         }
     }
 }

prism_compiler/src/parser/mod.rs

@@ -70,18 +70,22 @@ impl<'a> ParserPrismEnv<'a> {
     }
 
     fn parse_expr(&mut self) -> PResult<CoreIndex> {
-        self.parse_base()
+        self.parse_statement()
     }
 
-    // fn parse_statement(&mut self) -> PResult<()> {
-    //     if self.eat_lit("let").is_ok() {
-    //         return Ok(())
-    //     } else if self.eat_lit("adapt").is_ok() {
-    //         return Ok(())
-    //     } else {
-    //         return Err(self.fail())
-    //     }
-    // }
+    fn parse_statement(&mut self) -> PResult<CoreIndex> {
+        if let Ok(kw) = self.eat_keyword("let") {
+            let name = self.eat_identifier()?;
+            let _ = self.eat_symbol('=')?;
+            let value = self.parse_base()?;
+            let _ = self.eat_symbol(';')?;
+            let body = self.parse_statement()?;
+            // let span = kw.start_pos().span_to(self)
+            Ok(self.store(CorePrismExpr::Let(), span))
+        } else {
+            self.parse_base()
+        }
+    }
 
     fn parse_base(&mut self) -> PResult<CoreIndex> {
         if let Ok(span) = self.eat_keyword("Type") {
@@ -90,19 +94,11 @@ impl<'a> ParserPrismEnv<'a> {
             let expr = self.parse_expr()?;
             self.eat_paren_close(")")?;
             Ok(expr)
+        } else if let Ok(ident) = self.eat_identifier() {
+            Ok(self.store(CorePrismExpr::DeBruijnIndex(0), ident))
         } else {
             Err(self.fail())
         }
-
-        // if let Ok(span) = self.eat_lit("Type") {
-        //     Ok(self.store(CorePrismExpr::Type, span))
-        // } else if let Ok(paren_ctx) = self.eat_open_paren("(", ")") {
-        //     let expr = self.parse_expr()?;
-        //     self.eat_close_paren(paren_ctx)?;
-        //     Ok(expr)
-        // } else {
-        //     Err(self.fail())
-        // }
     }
 
     pub fn store(&mut self, e: CorePrismExpr, span: Span) -> CoreIndex {