Initial work on expression parsing.

src/Parser/Statements/ParsedStatement.hpp

@@ -7,7 +7,6 @@
 #include "../../CoreData/FuncAttr.hpp"
 #include "../../CoreData/TypeMod.hpp"
 #include "../../TextSpan.hpp"
-#include "../Expressions/ParsedExpression.hpp"
 #include "ParsedStatementKind.hpp"
 namespace MalachScript::Parser {
     class ParsedStatement {
@@ -114,11 +113,11 @@ namespace MalachScript::Parser {
             std::unique_ptr<const ParsedTypeStatement> _typeStatement = nullptr;
             TypeMod _typeMod = TypeMod::None;
             Identifier _identifier;
-            std::unique_ptr<const ParsedExpression> _defaultExpression = nullptr;
+            std::unique_ptr<const ParsedStatement> _defaultExpression = nullptr;
 
         public:
             ParsedParameter(const ParsedTypeStatement* typeStatement, TypeMod typeMod, const Identifier& identifier,
-                            const ParsedExpression* defaultExpression)
+                            const ParsedStatement* defaultExpression)
                 : _typeStatement(typeStatement), _typeMod(typeMod), _identifier(identifier),
                   _defaultExpression(defaultExpression){};
 
@@ -135,10 +134,10 @@ namespace MalachScript::Parser {
             [[nodiscard]] Identifier& GetIdentifier() noexcept { return _identifier; }
             [[nodiscard]] const Identifier& GetIdentifier() const noexcept { return _identifier; }
 
-            [[nodiscard]] std::unique_ptr<const ParsedExpression>& GetDefaultExpression() noexcept {
+            [[nodiscard]] std::unique_ptr<const ParsedStatement>& GetDefaultExpression() noexcept {
                 return _defaultExpression;
             }
-            [[nodiscard]] const std::unique_ptr<const ParsedExpression>& GetDefaultExpression() const noexcept {
+            [[nodiscard]] const std::unique_ptr<const ParsedStatement>& GetDefaultExpression() const noexcept {
                 return _defaultExpression;
             }
         };
@@ -246,6 +245,68 @@ namespace MalachScript::Parser {
         FuncAttr _setAttr = FuncAttr::None;
         std::unique_ptr<const ParsedStatement> _setStatement;
     };
+
+    class ParsedStatBlockStatement : public ParsedStatementImpl<ParsedStatementKind::StatBlock> {
+    public:
+        ParsedStatBlockStatement(const TextSpan& span, const std::vector<const ParsedStatement*>& statements)
+            : ParsedStatementImpl(span), _statements(statements.size()) {
+            for (size_t i = 0; i < statements.size(); i++) {
+                _statements[i] = std::unique_ptr<const ParsedStatement>(statements[i]);
+            }
+        }
+
+        [[nodiscard]] const std::vector<std::unique_ptr<const ParsedStatement>>& GetStatements() const noexcept {
+            return _statements;
+        }
+
+    private:
+        std::vector<std::unique_ptr<const ParsedStatement>> _statements;
+    };
+
+    class ParsedVarStatement : public ParsedStatementImpl<ParsedStatementKind::StatBlock> {
+    public:
+        ParsedVarStatement(const TextSpan& span, AccessModifier access, const ParsedStatement* typeStatement,
+                           Identifier identifier)
+            : ParsedStatementImpl(span), _access(access), _typeStatement(typeStatement), _identifier(identifier) {}
+
+        [[nodiscard]] AccessModifier GetAccess() const noexcept { return _access; }
+        [[nodiscard]] const std::unique_ptr<const ParsedStatement>& GetTypeStatement() const noexcept {
+            return _typeStatement;
+        }
+        [[nodiscard]] const Identifier& GetIdentifier() const noexcept { return _identifier; }
+
+    private:
+        AccessModifier _access;
+        std::unique_ptr<const ParsedStatement> _typeStatement;
+        Identifier _identifier;
+    };
+
+    class ParsedIfStatement : public ParsedStatementImpl<ParsedStatementKind::If> {
+    public:
+        ParsedIfStatement(const TextSpan& span, const ParsedStatement* condition, const ParsedStatement* body,
+                          const ParsedStatement* elseStatement)
+            : ParsedStatementImpl(span), _condition(condition), _body(body), _elseStatement(elseStatement) {}
+
+    private:
+        std::unique_ptr<const ParsedStatement> _condition;
+        std::unique_ptr<const ParsedStatement> _body;
+        std::unique_ptr<const ParsedStatement> _elseStatement;
+    };
+
+    template <class TOperator>
+    class ParsedBinaryStatement : public ParsedStatementImpl<ParsedStatementKind::BinaryExpression> {
+    public:
+        ParsedBinaryStatement(const TextSpan& span, const ParsedStatement* leftHand, TOperator op,
+                              const ParsedStatement* rightHand)
+            : ParsedStatementImpl(span), _leftHand(leftHand), _operator(op), _rightHand(rightHand) {}
+
+        [[nodiscard]] inline size_t GetOperatorType() const noexcept { return typeid(TOperator).hash_code(); }
+
+    private:
+        std::unique_ptr<const ParsedStatement> _leftHand;
+        TOperator _operator;
+        std::unique_ptr<const ParsedStatement> _rightHand;
+    };
 }
 
 #endif // MALACHSCRIPT_PARSEDSTATEMENT_HPP