Added parser project

ast/inc/NodeTypes.h

@@ -1,3 +1,5 @@
+#pragma once
+
 #include <LXC.h>
 
 #include <NodeBase.h>
@@ -5,23 +7,17 @@
 
 namespace LXC::AST
 {
-    // Will be replaced later to account for things like namespaces //
-    typedef std::string Identifier;
-
-    // Foward declares so it can be used in VarDecl //
-    class VarAssignment;
-
     class FunctionCall final : public NodeValue
     {
         public:
-            FunctionCall(Identifier& functionName, std::vector<std::unique_ptr<NodeValue>>& arguments);
+            FunctionCall(Identifier& functionName, ValueList& arguments);
     
         private:
             // The name of the function //
             Identifier m_FuncName;
 
             // The arguments of the function //
-            std::vector<std::unique_ptr<NodeValue>> m_Arguments;
+            ValueList m_Arguments;
     };
 
     class IntLiteral final : public NodeValue
@@ -37,11 +33,11 @@ namespace LXC::AST
     class Operation final : public NodeValue
     {
         public:
-            Operation(std::unique_ptr<NodeValue>& left, Lexer::Token::TokenType operand, std::unique_ptr<NodeValue>& right);
+            Operation(NodeValuePtr& left, Lexer::Token::TokenType operand, NodeValuePtr& right);
 
         private:
             // The sides of the operation //
-            std::unique_ptr<NodeValue> m_Lhs, m_Rhs;
+            NodeValuePtr m_Lhs, m_Rhs;
 
             // The operand of the operation //
             Lexer::Token::TokenType m_Operand;
@@ -51,27 +47,27 @@ namespace LXC::AST
     {
         public:
             VarDeclaration(Identifier& name);
-            VarDeclaration(Identifier& name, std::unique_ptr<VarAssignment>& value);
+            VarDeclaration(Identifier& name, NodeValuePtr& value);
 
         private:
             // The name of the variable //
             Identifier m_Name;
 
             // Default value of the variable (nullable) //
-            std::unique_ptr<VarAssignment> m_Value;
+            NodeValuePtr m_Value;
     };
 
     class VarAssignment final : public Node
     {
         public:
-            VarAssignment(Identifier& name, std::unique_ptr<NodeValue>& value);
+            VarAssignment(Identifier& name, NodeValuePtr& value);
         
         private:
             // The name of the variable //
             Identifier m_Name;
 
             // Value to assign to the variable //
-            std::unique_ptr<NodeValue> m_Value;
+            NodeValuePtr m_Value;
     };
 
     class VarAccess final : public NodeValue
@@ -87,23 +83,23 @@ namespace LXC::AST
     class IfBranch final : public Node
     {
         public:
-            IfBranch(std::unique_ptr<NodeValue>& condition, std::vector<std::unique_ptr<Node>>& body);
+            IfBranch(NodeValuePtr& condition, SyntaxBranch& body);
         
         private:
             // The condition of the branch //
-            std::unique_ptr<NodeValue> m_Condition;
+            NodeValuePtr m_Condition;
 
             // The body of the if-statement //
-            std::vector<std::unique_ptr<Node>> m_Body;
+            SyntaxBranch m_Body;
     };
 
     class ReturnStatement final : public Node
     {
         public:
-            ReturnStatement(std::unique_ptr<NodeValue>& value);
+            ReturnStatement(NodeValuePtr& value);
 
         private:
             // The value to return (nullable) //
-            std::unique_ptr<NodeValue> m_ReturnValue;
+            NodeValuePtr m_ReturnValue;
     };
 }