From 31c697a097d5a088e56695ce38c9f787883322fd Mon Sep 17 00:00:00 2001
From: Sofia <sofia@teascade.net>
Date: Thu, 2 Apr 2026 01:41:39 +0300
Subject: [PATCH] Use unique_ptrs everywhere again

---
 src/ast.h       | 25 ++++++++++++++++++-------
 src/main.cpp    |  2 +-
 src/parsing.cpp |  5 +++--
 src/parsing.h   |  2 +-
 src/result.h    |  8 ++++----
 5 files changed, 27 insertions(+), 15 deletions(-)

diff --git a/src/ast.h b/src/ast.h
index b3f5976..de210c3 100644
--- a/src/ast.h
+++ b/src/ast.h
@@ -8,36 +8,47 @@
 namespace AST {
     class Node {};
 
-    class Expression : Node {};
+    class Expression : public Node {};
     class Type {};
-    class Statement : Node {};
+    class Statement : public Node {};
 
-    class IntLiteralExpression : Expression {
+    class IntLiteralExpression : public Expression {
     private:
         int m_value;
     };
 
 
-    class ReturnStatement : Statement {
+    class ReturnStatement : public Statement {
     private:
         std::unique_ptr<Expression> m_expr;
     };
 
-    class TopLevelStatement : Node {};
+    class TopLevelStatement : public Node {};
 
-    class Function : TopLevelStatement {
+    class Function : public TopLevelStatement {
     private:
         std::unique_ptr<Type> m_return_ty;
         std::vector<std::pair<std::string, std::unique_ptr<Type>>> m_params;
         std::string m_name;
         std::vector<std::unique_ptr<Statement>> m_statements;
+    public:
+        Function(
+            Type* return_ty,
+            std::vector<std::pair<std::string, std::unique_ptr<Type>>> params,
+            std::string name,
+            std::vector<std::unique_ptr<Statement>> statements)
+            : m_return_ty{ std::move(return_ty) }
+            , m_params{ std::move(params) }
+            , m_name{ name }
+            , m_statements{ std::move(statements) } {
+        }
     };
 
     enum class FundamentalTypeKind {
         Int,
     };
 
-    class FundamentalType : Type {
+    class FundamentalType : public Type {
     private:
         FundamentalTypeKind m_ty;
     };
diff --git a/src/main.cpp b/src/main.cpp
index 04f8979..e2ecaac 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -53,7 +53,7 @@ int main() {
 
     auto stream = token::TokenStream{ tokens };
 
-    std::vector<AST::TopLevelStatement> statements;
+    std::vector<std::unique_ptr<AST::TopLevelStatement>> statements;
     auto statement = parsing::parse_top_level_statement(stream);
     while (statement.ok()) {
         statements.push_back(statement.unwrap());
diff --git a/src/parsing.cpp b/src/parsing.cpp
index ff1e14f..2e32aab 100644
--- a/src/parsing.cpp
+++ b/src/parsing.cpp
@@ -2,7 +2,8 @@
 
 
 namespace parsing {
-    Result<AST::TopLevelStatement, std::string> parse_top_level_statement(token::TokenStream& stream) {
-        return Result<AST::TopLevelStatement, std::string>{ "test" };
+    Result<std::unique_ptr<AST::TopLevelStatement>, std::string> parse_top_level_statement(token::TokenStream& stream) {
+        auto fun = new AST::Function{ nullptr, {}, "main", {} };
+        return Result<std::unique_ptr<AST::TopLevelStatement>, std::string>{ std::unique_ptr<AST::TopLevelStatement>{ fun } };
     }
 }
\ No newline at end of file
diff --git a/src/parsing.h b/src/parsing.h
index 79391fb..0722f6d 100644
--- a/src/parsing.h
+++ b/src/parsing.h
@@ -6,7 +6,7 @@
 #include "tokens.h"
 
 namespace parsing {
-    Result<AST::TopLevelStatement, std::string> parse_top_level_statement(token::TokenStream& stream);
+    Result<std::unique_ptr<AST::TopLevelStatement>, std::string> parse_top_level_statement(token::TokenStream& stream);
 }
 
 #endif
\ No newline at end of file
diff --git a/src/result.h b/src/result.h
index acae79d..54de95a 100644
--- a/src/result.h
+++ b/src/result.h
@@ -11,16 +11,16 @@ private:
     std::unique_ptr<TErr> m_error;
 
 public:
-    Result(T value) : m_value{ std::make_unique(value) }, m_error{ nullptr } {}
-    Result(TErr error) : m_value{ nullptr }, m_error{ std::make_unique<TErr>(error) } {}
+    Result(T value) : m_value{ std::make_unique<T>() }, m_error{ nullptr } {}
+    Result(TErr error) : m_value{ nullptr }, m_error{ std::make_unique<TErr>() } {}
 
     bool ok() {
-        return m_error == nullptr;
+        return !m_error;
     }
 
     T unwrap() {
         if (m_value) {
-            return *m_value;
+            return std::move(*m_value);
         }
         else {
             throw std::runtime_error("Tried to unwrap " + *m_error + "!");