🚧 WIP

semver: chore
Somfic · Oct 30, 2024 · 675a034 · 675a034
1 parent 811c453
commit 675a034
Show file tree

Hide file tree

Showing 5 changed files with 77 additions and 33 deletions.
diff --git a/src/main.rs b/src/main.rs
@@ -10,22 +10,15 @@ pub mod parser;
 
 fn main() {
     let input = "
-    let x = {1};
-    let a = \"hello\";
-    let b = 123;
-    let b = b if b <= 100 else 100;
-
-    struct Human: name, age;
-    enum Color: red, green, blue, orange;
-
-    fn add(a, b) { a + b }
-    fn sub(a, b) { a - b }
-    fn mul(a, b) { a * b }
-    fn div(a, b) { a / b }
+    fn main() {
+        fib(9999);
+    }
 
-    trait Add: 
-        fn add(a, b);
-    ";
+    fn fib(n ~ number) ~ number {
+        return if n < 2;
+        fib(n - 1) + fib(n - 2)
+    }
+        ";
 
     miette::set_hook(Box::new(|_| {
         Box::new(

diff --git a/src/parser/ast.rs b/src/parser/ast.rs
@@ -52,6 +52,10 @@ pub enum Expression<'de> {
         truthy: Box<Expression<'de>>,
         falsy: Option<Box<Expression<'de>>>,
     },
+    Call {
+        callee: Box<Expression<'de>>,
+        arguments: Vec<Expression<'de>>,
+    },
 }
 
 #[derive(Debug)]

diff --git a/src/parser/expression/mod.rs b/src/parser/expression/mod.rs
@@ -1,7 +1,7 @@
 use miette::Result;
 
 use super::{ast::Expression, Parser};
-use crate::parser::lookup::BindingPower;
+use crate::{lexer::TokenKind, parser::lookup::BindingPower};
 
 pub mod binary;
 pub mod primitive;
@@ -67,3 +67,35 @@ pub fn parse<'de>(
 
     Ok(lhs)
 }
+
+pub fn call<'de>(
+    parser: &mut Parser<'de>,
+    lhs: Expression<'de>,
+    binding_power: BindingPower,
+) -> Result<Expression<'de>> {
+    let mut arguments = Vec::new();
+
+    while parser.lexer.peek().map_or(false, |token| {
+        token
+            .as_ref()
+            .map_or(false, |token| token.kind != TokenKind::ParenClose)
+    }) {
+        if !arguments.is_empty() {
+            parser
+                .lexer
+                .expect(TokenKind::Comma, "expected a comma between arguments")?;
+        }
+
+        let argument = parse(parser, BindingPower::None)?;
+        arguments.push(argument);
+    }
+
+    parser
+        .lexer
+        .expect(TokenKind::ParenClose, "expected a closing parenthesis")?;
+
+    Ok(Expression::Call {
+        callee: Box::new(lhs),
+        arguments,
+    })
+}
diff --git a/src/parser/lookup.rs b/src/parser/lookup.rs
@@ -117,6 +117,7 @@ impl<'de> Default for Lookup<'de> {
         .add_expression_handler(TokenKind::Identifier, expression::primitive::identifier)
         .add_expression_handler(TokenKind::ParenOpen, group)
         .add_left_expression_handler(TokenKind::If, BindingPower::None, if_)
+        .add_left_expression_handler(TokenKind::ParenOpen, BindingPower::None, expression::call)
         .add_expression_handler(TokenKind::Not, expression::unary::negate)
         .add_expression_handler(TokenKind::Minus, expression::unary::negative)
         .add_expression_handler(TokenKind::CurlyOpen, block)

diff --git a/src/parser/statement.rs b/src/parser/statement.rs
@@ -48,7 +48,7 @@ pub fn let_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
         .expect(TokenKind::Let, "expected a let keyword")?;
     let identifier = parser
         .lexer
-        .expect(TokenKind::Identifier, "expected an identifier")?;
+        .expect(TokenKind::Identifier, "expected a variable name")?;
     let identifier = match identifier.value {
         TokenValue::Identifier(identifier) => identifier,
         _ => unreachable!(),
@@ -72,7 +72,7 @@ pub fn struct_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
 
     let identifier = parser
         .lexer
-        .expect(TokenKind::Identifier, "expected an identifier")?;
+        .expect(TokenKind::Identifier, "expected a struct name")?;
 
     let identifier = match identifier.value {
         TokenValue::Identifier(identifier) => identifier,
@@ -89,12 +89,14 @@ pub fn struct_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
             .map_or(false, |token| token.kind != TokenKind::Semicolon)
     }) {
         if !fields.is_empty() {
-            parser.lexer.expect(TokenKind::Comma, "expected a comma")?;
+            parser
+                .lexer
+                .expect(TokenKind::Comma, "expected a comma between fields")?;
         }
 
         let field = parser
             .lexer
-            .expect(TokenKind::Identifier, "expected an identifier")?;
+            .expect(TokenKind::Identifier, "expected a field name")?;
 
         let field = match field.value {
             TokenValue::Identifier(field) => field,
@@ -121,7 +123,7 @@ pub fn enum_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
 
     let identifier = parser
         .lexer
-        .expect(TokenKind::Identifier, "expected an identifier")?;
+        .expect(TokenKind::Identifier, "expected an enum name")?;
 
     let identifier = match identifier.value {
         TokenValue::Identifier(identifier) => identifier,
@@ -138,12 +140,14 @@ pub fn enum_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
             .map_or(false, |token| token.kind != TokenKind::Semicolon)
     }) {
         if !variants.is_empty() {
-            parser.lexer.expect(TokenKind::Comma, "expected a comma")?;
+            parser
+                .lexer
+                .expect(TokenKind::Comma, "expected a comma between enum members")?;
         }
 
         let variant = parser
             .lexer
-            .expect(TokenKind::Identifier, "expected an identifier")?;
+            .expect(TokenKind::Identifier, "expected an enum member name")?;
 
         let variant = match variant.value {
             TokenValue::Identifier(variant) => variant,
@@ -166,11 +170,11 @@ pub fn enum_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
 pub fn function_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
     parser
         .lexer
-        .expect(TokenKind::Function, "expected a fn keyword")?;
+        .expect(TokenKind::Function, "expected a function keyword")?;
 
     let identifier = parser
         .lexer
-        .expect(TokenKind::Identifier, "expected an identifier")?;
+        .expect(TokenKind::Identifier, "expected function name")?;
 
     let identifier = match identifier.value {
         TokenValue::Identifier(identifier) => identifier,
@@ -189,12 +193,14 @@ pub fn function_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
             .map_or(false, |token| token.kind != TokenKind::ParenClose)
     }) {
         if !parameters.is_empty() {
-            parser.lexer.expect(TokenKind::Comma, "expected a comma")?;
+            parser
+                .lexer
+                .expect(TokenKind::Comma, "expected a comma between parameters")?;
         }
 
         let parameter = parser
             .lexer
-            .expect(TokenKind::Identifier, "expected an identifier")?;
+            .expect(TokenKind::Identifier, "expected a parameter name")?;
 
         let parameter = match parameter.value {
             TokenValue::Identifier(parameter) => parameter,
@@ -224,7 +230,7 @@ pub fn trait_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
 
     let identifier = parser
         .lexer
-        .expect(TokenKind::Identifier, "expected an identifier")?;
+        .expect(TokenKind::Identifier, "expected a trait name")?;
 
     let identifier = match identifier.value {
         TokenValue::Identifier(identifier) => identifier,
@@ -241,16 +247,18 @@ pub fn trait_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
             .map_or(false, |token| token.kind != TokenKind::Semicolon)
     }) {
         if !functions.is_empty() {
-            parser.lexer.expect(TokenKind::Comma, "expected a comma")?;
+            parser
+                .lexer
+                .expect(TokenKind::Comma, "expected a comma between functions")?;
         }
 
         parser
             .lexer
-            .expect(TokenKind::Function, "expected a fn keyword")?;
+            .expect(TokenKind::Function, "expected a function keyword")?;
 
         let function = parser
             .lexer
-            .expect(TokenKind::Identifier, "expected an identifier")?;
+            .expect(TokenKind::Identifier, "expected a function name")?;
 
         let function = match function.value {
             TokenValue::Identifier(function) => function,
@@ -269,12 +277,14 @@ pub fn trait_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
                 .map_or(false, |token| token.kind != TokenKind::ParenClose)
         }) {
             if !parameters.is_empty() {
-                parser.lexer.expect(TokenKind::Comma, "expected a comma")?;
+                parser
+                    .lexer
+                    .expect(TokenKind::Comma, "expected a comma in between arguments")?;
             }
 
             let parameter = parser
                 .lexer
-                .expect(TokenKind::Identifier, "expected an identifier")?;
+                .expect(TokenKind::Identifier, "expected an argument name")?;
 
             let parameter = match parameter.value {
                 TokenValue::Identifier(parameter) => parameter,
@@ -284,6 +294,10 @@ pub fn trait_<'de>(parser: &mut Parser<'de>) -> Result<Statement<'de>> {
             parameters.push(parameter);
         }
 
+        parser
+            .lexer
+            .expect(TokenKind::ParenClose, "expected a close parenthesis")?;
+
         functions.push((function, parameters));
     }