chore(ast): more ast types and other improvements

Author: jahan-addison

roxas/ast.cc

@@ -5,18 +5,6 @@ namespace roxas {
 
 namespace ast {
 
-node::node(std::string const& type)
-    : type_(std::move(type))
-    , literal_({ literal::UNKNOWN, "unknown" })
-    , children_({})
-{
-}
-
-void node::print()
-{
-    std::cout << "node type: " << type_;
-}
-
 } // namespace ast
 
 } // namespace roxas

roxas/ast.h

@@ -1,8 +1,10 @@
 #pragma once
 
+#include <memory>
 #include <optional>
 #include <string>
 #include <tuple>
+#include <variant>
 #include <vector>
 
 namespace roxas {
@@ -11,14 +13,24 @@ namespace ast {
 
 class node;
 struct definition;
+class lvalue_node;
+class rvalue_node;
 
-} // namespace ast
+class Abstract_Syntax_Tree
+{
+  public:
+    Abstract_Syntax_Tree(Abstract_Syntax_Tree const&) = delete;
+    Abstract_Syntax_Tree& operator=(Abstract_Syntax_Tree const&) = delete;
 
-using AST = std::vector<ast::definition>;
+    using ast_type = std::vector<ast::definition>;
 
-AST parse_tree_to_ast(std::string const& parse_tree);
+  public:
+    explicit Abstract_Syntax_Tree(std::string_view parse_tree);
+    ~Abstract_Syntax_Tree();
 
-namespace ast {
+  private:
+    ast_type ast_;
+};
 
 enum class literal : int
 {
@@ -28,33 +40,98 @@ enum class literal : int
     UNKNOWN
 };
 
-using literal_datatype = std::tuple<literal, std::string>;
-
 struct definition
 {
     enum class type : int
     {
         FUNCTION,
-        VECTOR
+        VECTOR,
+        UNKNOWN
     };
 
-    type type{ type::FUNCTION };
+    type type{ type::UNKNOWN };
     std::vector<node> children{};
 };
 
+using literal_type = std::tuple<literal, std::string>;
+
 class node
 {
   public:
     node(node const&) = delete;
     node& operator=(node const&) = delete;
+    virtual ~node() = default;
+
+  protected:
+    node() = default;
+
+  public:
+    virtual void print() const = 0;
+};
+
+class expression_node final : public node
+{
+  public:
+    using expression_datatype =
+        std::vector<std::variant<std::monostate, lvalue_node, rvalue_node>>;
+    explicit expression_node(std::string type)
+        : type_(std::move(type))
+    {
+    }
+
+    void print() const override;
+
+  private:
+    std::string type_;
+    expression_datatype expr_;
+};
+
+class statement_node final : public node
+{
+  public:
+    using statement_datatype = std::
+        variant<std::monostate, std::string, expression_node, literal_type>;
+    explicit statement_node(std::string type)
+        : type_(std::move(type))
+    {
+    }
+
+    void print() const override;
+
+  private:
+    std::string type_;
+    statement_datatype data_;
+    std::vector<node> children_;
+};
+
+class lvalue_node final : public node
+{
+  public:
+    explicit lvalue_node(std::string type = "unknown")
+        : identifier_(std::move(type))
+    {
+    }
+
+    void print() const override;
+
+  private:
+    std::string identifier_;
+};
+
+class rvalue_node final : public node
+{
+  public:
+    using rvalue_datatype = expression_node;
+    explicit rvalue_node(std::string type = "unknown")
+        : type_(std::move(type))
+    {
+    }
 
-    explicit node(std::string const& type);
-    void print();
+    void print() const override;
 
   private:
     std::string type_;
-    std::optional<literal_datatype> literal_;
-    std::optional<std::vector<node>> children_;
+    rvalue_datatype rvalue_{ type_ };
 };
 
 } // namespace ast

roxas/parse_tree.cc

@@ -55,9 +55,9 @@ std::string read_source_file(fs::path path)
  * @param env_path an optional absolute path to a venv directory where
  * dependecies are installed
  */
-ParseTreeModuleLoader::ParseTreeModuleLoader(std::string const& module_path,
-                                             std::string const& module_name,
-                                             std::string const& file_path,
+ParseTreeModuleLoader::ParseTreeModuleLoader(std::string module_path,
+                                             std::string module_name,
+                                             std::string file_path,
                                              std::string const& env_path)
     : module_path_(std::move(module_path))
     , module_name_(std::move(module_name))

roxas/parse_tree.h

@@ -42,9 +42,9 @@ class ParseTreeModuleLoader
      * @param env_path an optional absolute path to a venv directory where
      * dependecies are installed
      */
-    ParseTreeModuleLoader(std::string const& module_path,
-                          std::string const& module_name,
-                          std::string const& file_path,
+    ParseTreeModuleLoader(std::string module_path,
+                          std::string module_name,
+                          std::string file_path,
                           std::string const& env_path = "");
 
     /**