Chaining member accesses and calling closures inside of lists and objects

Author: Muhtasim-Rasheed

docs/crust-language.md

@@ -27,6 +27,10 @@ Inline statements are single-line statements that perform a specific action. The
 - `nop`: Does absolutely nothing.
 - `assert condition`: Checks if the condition is true, and if not, it throws an error. Example: `assert x > 0`
 - `function_name(arguments)`: Calls a function or a closure with the given arguments. Example: `goto("mouse")`
+
+!!! note
+    Closures can be put inside of lists, and calling them looks like this: `list[0](1, 2)`. This calls the closure at index 0 of the list with the arguments 1 and 2. Another example is `object.key(1, 2)`, which calls the closure at the key `key` of the object with the arguments 1 and 2.
+
 - `import "file.crst"`: Imports a Crust file. The file can contain functions and variables. Import statements are defined at the head of the program. Example: `import "utils.crst"`
 
 To assign a list's or object's value, you can use the following syntax:

src/utils/helpers.rs

@@ -170,32 +170,26 @@ pub fn resolve_expression(expr: &Expression, state: &mut State) -> Value {
             }
         }
         Expression::Call { function, args } => {
+            // evaluate the function expression
+            let func_val = resolve_expression(function, state);
+
+            // evaluate args
             let args = args
                 .iter()
                 .map(|arg| resolve_expression(arg, state))
                 .collect::<Vec<_>>();
-            if let Some(function_struct) = state.sprite.functions.get(function).cloned() {
-                function_struct.call(state, &args).unwrap_or_else(|e| {
-                    println!("Error calling function {}(): {}", function, e);
-                    Value::Null
-                })
-            } else if let Some(function_struct) = state.project.builtins.get(function).cloned() {
-                function_struct.call(state, &args).unwrap_or_else(|e| {
-                    println!("Error calling builtin function {}(): {}", function, e);
-                    Value::Null
-                })
-            } else if let Some(variable) = state.sprite.variables.get(function).cloned() {
-                let Value::Closure(closure) = variable else {
-                    println!("Variable '{}' is not a function", function);
-                    return Value::Null;
-                };
-                let function_struct = &*closure;
-                function_struct.call(state, &args).unwrap_or_else(|e| {
-                    println!("Error calling function '{}': {}", function, e);
+
+            match func_val {
+                Value::Closure(callable) => {
+                    callable.call(state, &args).unwrap_or_else(|e| {
+                        println!("Error calling function: {}", e);
+                        Value::Null
+                    })
+                }
+                _ => {
+                    println!("Attempted to call non-function: {:?}", func_val);
                     Value::Null
-                })
-            } else {
-                return Value::Null;
+                }
             }
         }
     }

src/utils/language/parser.rs

@@ -30,7 +30,7 @@ pub enum Expression {
         operand: Box<Expression>,
     },
     Call {
-        function: String,
+        function: Box<Expression>,
         args: Vec<Expression>,
     },
 }
@@ -599,7 +599,7 @@ impl Parser {
         })
     }
 
-    fn parse_function_call(&mut self, name: String) -> Result<Expression, String> {
+    fn parse_function_call(&mut self, base: Expression) -> Result<Expression, String> {
         let mut args = vec![];
         while self.peek().token_type != TokenType::Symbol(")".to_string()) {
             if self.eat(&TokenType::Newline) {
@@ -618,12 +618,12 @@ impl Parser {
             ));
         }
         Ok(Expression::Call {
-            function: name,
+            function: Box::new(base),
             args,
         })
     }
 
-    fn parse_bracket_access(&mut self, name: String) -> Result<Expression, String> {
+    fn parse_bracket_access(&mut self, base: Expression) -> Result<Expression, String> {
         let index = self.parse_binary(0)?;
         if !self.eat(&TokenType::Symbol("]".to_string())) {
             return Err(format!(
@@ -632,20 +632,20 @@ impl Parser {
             ));
         }
         Ok(Expression::ListMemberAccess {
-            list: Box::new(Expression::Identifier(name)),
+            list: Box::new(base),
             index: Box::new(index),
         })
     }
 
-    fn parse_dot_access(&mut self, name: String) -> Result<Expression, String> {
+    fn parse_dot_access(&mut self, base: Expression) -> Result<Expression, String> {
         let index = self.parse_primary()?;
         match index {
             Expression::Identifier(index_name) => Ok(Expression::ListMemberAccess {
-                list: Box::new(Expression::Identifier(name)),
+                list: Box::new(base),
                 index: Box::new(Expression::Value(Value::String(index_name))),
             }),
             Expression::Value(Value::Number(num)) => Ok(Expression::ListMemberAccess {
-                list: Box::new(Expression::Identifier(name)),
+                list: Box::new(base),
                 index: Box::new(Expression::Value(Value::Number(num))),
             }),
             _ => Err(format!(
@@ -656,15 +656,21 @@ impl Parser {
     }
 
     fn parse_identifier_expr(&mut self, name: String) -> Result<Expression, String> {
-        if self.eat(&TokenType::Symbol("(".to_string())) {
-            self.parse_function_call(name)
-        } else if self.eat(&TokenType::Symbol("[".to_string())) {
-            self.parse_bracket_access(name)
-        } else if self.eat(&TokenType::Symbol(".".to_string())) {
-            self.parse_dot_access(name)
-        } else {
-            Ok(Expression::Identifier(name))
+        let mut expr = Expression::Identifier(name);
+
+        loop {
+            if self.eat(&TokenType::Symbol("(".to_string())) {
+                expr = self.parse_function_call(expr)?;
+            } else if self.eat(&TokenType::Symbol("[".to_string())) {
+                expr = self.parse_bracket_access(expr)?;
+            } else if self.eat(&TokenType::Symbol(".".to_string())) {
+                expr = self.parse_dot_access(expr)?;
+            } else {
+                break;
+            }
         }
+
+        Ok(expr)
     }
 
     fn parse_pre_incdec(&mut self, op: &str) -> Result<Expression, String> {

src/utils/sprite/sprite.rs

@@ -543,7 +543,9 @@ impl Sprite {
                 value,
             } => {
                 let value = crate::utils::resolve_expression(value, state);
-                crate::utils::assign_expression(identifier, value, state, *is_global);
+                crate::utils::assign_expression(identifier, value, state, *is_global).unwrap_or_else(|e| {
+                    println!("Error assigning variable '{}': {}", identifier, e);
+                });
             }
             Statement::Nop => {}
             Statement::Assert { condition } => {
@@ -637,32 +639,25 @@ impl Sprite {
             }
             Statement::Call(c) => {
                 if let Expression::Call { function, args } = c {
+                    // evaluate the function expression
+                    let func_val = resolve_expression(function, state);
+
+                    // evaluate args
                     let args = args
                         .iter()
-                        .map(|arg| crate::utils::resolve_expression(arg, state))
+                        .map(|arg| resolve_expression(arg, state))
                         .collect::<Vec<_>>();
-                    if let Some(callable) = state.sprite.functions.clone().get(function) {
-                        callable.call(state, &args).unwrap_or_else(|e| {
-                            println!("Error calling {}(): {}", function, e);
-                            Value::Null
-                        });
-                    } else if let Some(callable) = state.project.builtins.get(function).cloned() {
-                        callable.call(state, &args).unwrap_or_else(|e| {
-                            println!("Error calling builtin function '{}': {}", function, e);
-                            Value::Null
-                        });
-                    } else if let Some(variable) = state.sprite.variables.get(function).cloned() {
-                        let Value::Closure(closure) = variable else {
-                            println!("Variable '{}' is not a function", function);
-                            return;
-                        };
-                        let function_struct = *closure;
-                        function_struct.call(state, &args).unwrap_or_else(|e| {
-                            println!("Error calling closure '{}': {}", function, e);
-                            Value::Null
-                        });
-                    } else {
-                        println!("Unknown function or variable '{}'", function);
+
+                    match func_val {
+                        Value::Closure(callable) => {
+                            let _ = callable.call(state, &args).unwrap_or_else(|e| {
+                                println!("Error calling function: {}", e);
+                                Value::Null
+                            });
+                        }
+                        _ => {
+                            println!("Attempted to call non-function: {:?}", func_val);
+                        }
                     }
                 }
             }