Begin adding function calls

src/abstract_tree/expression.rs

@@ -3,10 +3,11 @@ use crate::{
     error::{RuntimeError, ValidationError},
 };
 
-use super::{AbstractTree, Action, Identifier, Index, Logic, Math, Type, ValueNode};
+use super::{AbstractTree, Action, FunctionCall, Identifier, Index, Logic, Math, Type, ValueNode};
 
 #[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
 pub enum Expression {
+    FunctionCall(FunctionCall),
     Identifier(Identifier),
     Index(Box<Index>),
     Logic(Box<Logic>),
@@ -17,6 +18,7 @@ pub enum Expression {
 impl AbstractTree for Expression {
     fn expected_type(&self, _context: &Context) -> Result<Type, ValidationError> {
         match self {
+            Expression::FunctionCall(function_call) => function_call.expected_type(_context),
             Expression::Identifier(identifier) => identifier.expected_type(_context),
             Expression::Index(index) => index.expected_type(_context),
             Expression::Logic(logic) => logic.expected_type(_context),
@@ -27,6 +29,7 @@ impl AbstractTree for Expression {
 
     fn validate(&self, _context: &Context) -> Result<(), ValidationError> {
         match self {
+            Expression::FunctionCall(function_call) => function_call.validate(_context),
             Expression::Identifier(identifier) => identifier.validate(_context),
             Expression::Index(index) => index.validate(_context),
             Expression::Logic(logic) => logic.validate(_context),
@@ -37,6 +40,7 @@ impl AbstractTree for Expression {
 
     fn run(self, _context: &Context) -> Result<Action, RuntimeError> {
         match self {
+            Expression::FunctionCall(function_call) => function_call.run(_context),
             Expression::Identifier(identifier) => identifier.run(_context),
             Expression::Index(index) => index.run(_context),
             Expression::Logic(logic) => logic.run(_context),

src/abstract_tree/function_call.rs

@@ -0,0 +1,35 @@
+use crate::{
+    context::Context,
+    error::{RuntimeError, ValidationError},
+};
+
+use super::{AbstractTree, Action, Expression, Type};
+
+#[derive(Debug, Clone, Eq, PartialEq, PartialOrd, Ord)]
+pub struct FunctionCall {
+    function: Box<Expression>,
+    arguments: Vec<Expression>,
+}
+
+impl FunctionCall {
+    pub fn new(function: Expression, arguments: Vec<Expression>) -> Self {
+        FunctionCall {
+            function: Box::new(function),
+            arguments,
+        }
+    }
+}
+
+impl AbstractTree for FunctionCall {
+    fn expected_type(&self, _context: &Context) -> Result<Type, ValidationError> {
+        todo!()
+    }
+
+    fn validate(&self, _context: &Context) -> Result<(), ValidationError> {
+        todo!()
+    }
+
+    fn run(self, _context: &Context) -> Result<Action, RuntimeError> {
+        todo!()
+    }
+}

src/abstract_tree/mod.rs

@@ -1,6 +1,7 @@
 pub mod assignment;
 pub mod block;
 pub mod expression;
+pub mod function_call;
 pub mod identifier;
 pub mod if_else;
 pub mod index;
@@ -15,6 +16,7 @@ pub use self::{
     assignment::{Assignment, AssignmentOperator},
     block::Block,
     expression::Expression,
+    function_call::FunctionCall,
     identifier::Identifier,
     if_else::IfElse,
     index::Index,

src/parser.rs

@@ -302,7 +302,26 @@ pub fn parser<'src>() -> DustParser<'src> {
                 }))
             });
 
+        let function_call = expression
+            .clone()
+            .then(
+                expression
+                    .clone()
+                    .separated_by(just(Token::Control(Control::Comma)))
+                    .collect()
+                    .delimited_by(
+                        just(Token::Control(Control::ParenOpen)),
+                        just(Token::Control(Control::ParenClose)),
+                    ),
+            )
+            .map(|(function, arguments)| {
+                Statement::Expression(Expression::FunctionCall(FunctionCall::new(
+                    function, arguments,
+                )))
+            });
+
         choice((
+            function_call,
             assignment,
             expression_statement,
             r#break,
@@ -327,6 +346,17 @@ mod tests {
 
     use super::*;
 
+    #[test]
+    fn function_call() {
+        assert_eq!(
+            parse(&lex("output()").unwrap()).unwrap()[0].0,
+            Statement::Expression(Expression::FunctionCall(FunctionCall::new(
+                Expression::Identifier(Identifier::new("output")),
+                Vec::with_capacity(0),
+            )))
+        )
+    }
+
     #[test]
     fn range() {
         assert_eq!(