Add expression statements

src/ast.cpp

@@ -3,6 +3,13 @@
 #include <sstream>
 
 namespace AST {
+    std::string ExpressionStatement::formatted() {
+        std::stringstream out{ "" };
+        out << this->m_expr->formatted();
+        out << ";";
+        return out.str();
+    }
+
     std::string ReturnStatement::formatted() {
         std::stringstream out{ "" };
         out << "return ";

src/ast.h

@@ -76,6 +76,18 @@ namespace AST {
         virtual void codegen(codegen::Builder& builder, codegen::Scope& scope) override;
     };
 
+    class ExpressionStatement : public Statement {
+    private:
+        std::unique_ptr<Expression> m_expr;
+    public:
+        ExpressionStatement(std::unique_ptr<Expression> expr)
+            : m_expr{ std::move(expr) } {
+        }
+        virtual ~ExpressionStatement() override = default;
+        virtual std::string formatted() override;
+        virtual void codegen(codegen::Builder& builder, codegen::Scope& scope) override;
+    };
+
     class TopLevelStatement : public Node {
     public:
         virtual void codegen(codegen::Builder& builder, codegen::Scope& scope) = 0;

src/codegen.cpp

@@ -32,6 +32,14 @@ namespace AST {
         builder.builder->CreateRet(value);
     }
 
+    void ExpressionStatement::codegen(codegen::Builder& builder, codegen::Scope& scope) {
+        if (!builder.block)
+            return;
+
+        builder.builder->SetInsertPoint(builder.block);
+        this->m_expr->codegen(builder, scope);
+    }
+
     void InitializationStatement::codegen(codegen::Builder& builder, codegen::Scope& scope) {
         if (!builder.block)
             return;

src/parsing.cpp

@@ -58,7 +58,8 @@ namespace parsing {
                 inner.expect(token::Type::Symbol, ";");
 
                 stream.m_position = inner.m_position;
-                return &std::make_unique<AST::InitializationStatement>(std::move(ty), name.content, std::move(expr));
+                auto init = new AST::InitializationStatement{ std::move(ty), name.content, std::move(expr) };
+                return new std::unique_ptr<AST::InitializationStatement>{ init };
             }
             catch (std::runtime_error error) {
                 return new std::string{ error.what() };
@@ -79,10 +80,16 @@ namespace parsing {
                     return new std::unique_ptr<AST::Statement>{ ret };
                 }
                 else if (inner.peek().type == token::Type::Ident) {
-                    auto init = parse_init_statement(inner);
+                    if (auto init = parse_init_statement(inner); init.ok()) {
-                    if (init.ok()) {
+                        stream.m_position = inner.m_position;
                         return new std::unique_ptr<AST::Statement>{ init.unwrap() };
                     }
+                    else if (auto expr = parse_expression(inner); expr.ok()) {
+                        stream.m_position = inner.m_position;
+                        stream.expect(token::Type::Symbol, ";");
+                        auto expr_statement = new AST::ExpressionStatement{ expr.unwrap() };
+                        return new std::unique_ptr<AST::Statement>{ expr_statement };
+                    }
                     else {
                         throw std::runtime_error("Expected initialization statement");
                     }

test.c

@@ -1,4 +1,5 @@
 int main() {
     int a = 5;
+    a;
     return a;
 }