fix(semantic): additional fixes for function analysis

Author: Entenwilli

src/lexer/token.rs

@@ -14,6 +14,9 @@ pub enum KeywordType {
     True,
     False,
     Null,
+    Print,
+    Read,
+    Flush,
     Alloc,
     AllocArray,
     Int,
@@ -38,6 +41,9 @@ impl KeywordType {
             Self::True => "true",
             Self::False => "false",
             Self::Null => "null",
+            Self::Print => "print",
+            Self::Read => "read",
+            Self::Flush => "flush",
             Self::Alloc => "alloc",
             Self::AllocArray => "alloc_array",
             Self::Int => "int",
@@ -62,6 +68,9 @@ impl KeywordType {
             "true" => Some(Self::True),
             "false" => Some(Self::False),
             "null" => Some(Self::Null),
+            "print" => Some(Self::Print),
+            "read" => Some(Self::Read),
+            "flush" => Some(Self::Flush),
             "alloc" => Some(Self::Alloc),
             "alloc_array" => Some(Self::AllocArray),
             "int" => Some(Self::Int),
@@ -83,6 +92,10 @@ impl KeywordType {
     pub fn is_type(&self) -> bool {
         matches!(self, Self::Bool | Self::Int)
     }
+
+    pub fn is_function(&self) -> bool {
+        matches!(self, Self::Flush | Self::Read | Self::Print)
+    }
 }
 
 #[derive(Eq, Hash, Clone, Debug, PartialEq)]
@@ -296,6 +309,10 @@ impl Token {
         }
     }
 
+    pub fn is_function(&self) -> bool {
+        matches!(self, Self::Keyword(_, keyword_type) if keyword_type.is_function())
+    }
+
     pub fn is_assignment_operator(&self) -> bool {
         matches!(self, Self::Operator(_, operator) if operator.is_assignment_operator())
     }

src/parser/ast/call_tree.rs

@@ -4,9 +4,11 @@ use crate::{
     lexer::{collection::ParserTokens, token::SeperatorType},
     parser::{
         ast::{
-            call_parameter_tree::CallParameterTree, identifier_tree::IdentifierExpressionTree, Tree,
+            call_parameter_tree::CallParameterTree, identifier_tree::IdentifierExpressionTree,
+            name_tree::NameTree, Tree,
         },
         error::ParseError,
+        symbols::Name,
     },
     util::span::Span,
 };
@@ -23,7 +25,15 @@ impl Tree for CallTree {
         self.identifier.span().merge(&self.closing_span)
     }
     fn from_tokens(tokens: &mut ParserTokens) -> Result<Self, ParseError> {
-        let identifier = IdentifierExpressionTree::from_tokens(tokens)?;
+        let identifier = if tokens.peek().ok_or(ParseError::ReachedEnd)?.is_function() {
+            let token = tokens.consume()?;
+            IdentifierExpressionTree::new(NameTree::new(
+                Name::IdentifierName(token.as_string().to_string()),
+                token.span(),
+            ))
+        } else {
+            IdentifierExpressionTree::from_tokens(tokens)?
+        };
         tokens.expect_seperator(SeperatorType::ParenOpen)?;
         let mut call_parameter = Vec::new();
         if !tokens

src/parser/ast/expression_tree.rs

@@ -204,6 +204,9 @@ impl ExpressionTree {
                     ))
                 }
             }
+            Token::Keyword(_, keyword_type) if keyword_type.is_function() => {
+                Ok(ExpressionTree::CallTree(CallTree::from_tokens(tokens)?))
+            }
             Token::NumberLiteral(_, _, _) => Ok(ExpressionTree::IntegerLiteralTree(
                 IntegerLiteralTree::from_tokens(tokens)?,
             )),

src/parser/ast/identifier_tree.rs

@@ -31,6 +31,10 @@ impl Tree for IdentifierExpressionTree {
 }
 
 impl IdentifierExpressionTree {
+    pub fn new(name: NameTree) -> IdentifierExpressionTree {
+        IdentifierExpressionTree { name }
+    }
+
     pub fn name(&self) -> &NameTree {
         &self.name
     }

src/parser/ast/name_tree.rs

@@ -32,6 +32,10 @@ impl Tree for NameTree {
 }
 
 impl NameTree {
+    pub fn new(name: Name, span: Span) -> NameTree {
+        NameTree { name, span }
+    }
+
     pub fn name(&self) -> &Name {
         &self.name
     }

src/parser/ast/program_tree.rs

@@ -47,14 +47,7 @@ impl Tree for ProgramTree {
         if functions.is_empty() {
             return Err(ParseError::NoFunctions);
         }
-        if functions
-            .iter()
-            .any(|v| v.name_tree().name().as_string() == "main")
-        {
-            Ok(ProgramTree { functions })
-        } else {
-            Err(ParseError::NoMainFunction)
-        }
+        Ok(ProgramTree { functions })
     }
 }
 

src/parser/error.rs

@@ -19,7 +19,6 @@ pub enum ParseError {
     NotAStatement,
     NotAOperation,
     NoFunctions,
-    NoMainFunction,
     ReachedEnd,
     WhitespaceError,
     InvalidCharacter,

src/semantic/ast/program_tree.rs

@@ -28,7 +28,18 @@ impl SemanticAnalysis for ProgramTree {
         for function in self.functions() {
             function.analyze(state)?;
         }
-        Ok(())
+        if let Some(main_function) = self
+            .functions()
+            .iter()
+            .find(|v| v.name_tree().name().as_string() == "main")
+        {
+            if main_function.parameters().len() > 0 {
+                return Err(SemanticError::InvalidMainFunction);
+            }
+            Ok(())
+        } else {
+            Err(SemanticError::NoMainFunction)
+        }
     }
     fn r#type(&self, _: &mut AnalysisState) -> Result<Type, SemanticError> {
         Ok(Type::Unit)

src/semantic/error.rs

@@ -25,11 +25,13 @@ pub enum SemanticError {
     ConditionMustBeBoolean(ExpressionTree),
     FunctionNotReturning(BlockTree),
     ForAdvancementDefinesVariable,
+    NoMainFunction,
     MainMustReturnInt,
     IncompatibleReturnType(ExpressionTree),
     FunctionAlreadyDefined(Name),
     UndefinedFunction(Name),
     FunctionParameterMismatch,
+    InvalidMainFunction,
 }
 
 impl Display for SemanticError {
@@ -119,6 +121,12 @@ impl Display for SemanticError {
             SemanticError::FunctionParameterMismatch => {
                 writeln!(f, "Mismatching function parameters!")
             }
+            SemanticError::NoMainFunction => {
+                writeln!(f, "No main function!")
+            }
+            SemanticError::InvalidMainFunction => {
+                writeln!(f, "Invalid main function")
+            }
         }
     }
 }