Improve AST nodes

Signed-off-by: CHatingPython <chatingpython@gmail.com>

furc/include/furc/ast/declaration.hpp

@@ -17,24 +17,13 @@ enum class declaration_node_t {
     Variable,
 };
 
-static inline std::ostream& operator<<(std::ostream& os, declaration_node_t type) {
-    switch (type) {
-    case declaration_node_t::FunctionDeclaration: return os << "function declaration";
-    case declaration_node_t::FunctionDefinition: return os << "function definition";
-    case declaration_node_t::Variable: return os << "variable";
-    }
-}
-
-class declaration_node : public abstract_node<node_t::Declaration> {
+class declaration_node : public statement_node {
 public:
-    virtual declaration_node_t type() const = 0;
-public:
-    virtual std::ostream& print(std::ostream& os) const = 0;
+    node_t category() const override { return node_t::Declaration; }
 
-    friend std::ostream& operator<<(std::ostream& os, const declaration_node& node) {
-        os << node.type();
-        return node.print(os);
-    }
+    statement_node_t statement_type() const override { return statement_node_t::Declaration; }
+
+    virtual declaration_node_t declaration_type() const = 0;
 };
 
 struct function_body {
@@ -49,11 +38,11 @@ public:
     function_declarartion_node(front::token name)
       : m_name(name) {}
 public:
-    declaration_node_t type() const override { return declaration_node_t::FunctionDeclaration; }
+    declaration_node_t declaration_type() const override { return declaration_node_t::FunctionDeclaration; }
 
     front::token name() const { return m_name; }
 public:
-    std::ostream& print(std::ostream& os) const override { return os << ": " << m_name; }
+    std::ostream& print(std::ostream& os) const override { return os << "function " << m_name.value << " declaration"; }
 protected:
     front::token m_name;
 };
@@ -66,37 +55,33 @@ public:
     ~function_definition_node() override = default;
 
     function_definition_node(function_definition_node&& other) noexcept
-      : function_declarartion_node(std::move(other)), m_name(other.m_name), m_body(std::move(other.m_body)) {}
+      : function_declarartion_node(std::move(other)), m_body(std::move(other.m_body)) {}
 
     function_definition_node(const function_definition_node&) = delete;
 
     function_definition_node& operator=(function_definition_node&& other) noexcept {
         if (this == &other) return *this;
         function_declarartion_node::operator=(std::move(other));
-        m_name = other.m_name;
         m_body = std::move(other.m_body);
         return *this;
     }
 
     function_definition_node& operator=(const function_definition_node&) = delete;
 public:
-    declaration_node_t type() const override { return declaration_node_t::FunctionDefinition; }
+    declaration_node_t declaration_type() const override { return declaration_node_t::FunctionDefinition; }
 
     const function_body_handle& body() const { return m_body; }
 public:
     std::ostream& print(std::ostream& os) const override {
-        os << ": " << m_name.value;
+        os << "function " << m_name.value << " definition:";
         if (m_body.present()) {
-            os << '\n' << m_body->begin << ": begin:";
-            for (const auto& entry : m_body->statements) {
+            for (const auto& entry : m_body->statements)
                 os << '\n' << entry;
-            }
-            os << '\n' << m_body->end << ": end";
+            return os << '\n' << m_body->end << ": " << m_name.value << " end";
         }
-        return os;
+        return os << (std::string)m_body; // error
     }
 private:
-    front::token         m_name;
     function_body_handle m_body;
 };
 

furc/include/furc/ast/expression.hpp

@@ -0,0 +1,26 @@
+#ifndef FURC_AST_EXPRESSION_HPP
+#define FURC_AST_EXPRESSION_HPP
+
+#include "furc/ast/node.hpp"
+#include "furc/ast/statement.hpp"
+
+namespace furc {
+namespace ast {
+
+enum class expression_node_t {
+    Literal
+};
+
+class expression_node : public statement_node {
+public:
+    node_t category() const override { return node_t::Expression; }
+
+    statement_node_t statement_type() const override { return statement_node_t::Expression; }
+
+    virtual expression_node_t expression_type() const = 0;
+};
+
+} // namespace ast
+} // namespace furc
+
+#endif // FURC_AST_EXPRESSION_HPP

furc/include/furc/ast/literal.hpp

@@ -0,0 +1,65 @@
+#ifndef FURC_AST_LITERAL_HPP
+#define FURC_AST_LITERAL_HPP
+
+#include "furc/ast/expression.hpp"
+#include "furc/ast/node.hpp"
+
+#include <ostream>
+
+namespace furc {
+namespace ast {
+
+enum class literal_node_t {
+    String,
+    Integer
+};
+
+static inline std::ostream& operator<<(std::ostream& os, literal_node_t type) {
+    switch (type) {
+    case literal_node_t::String: return os << "string";
+    case literal_node_t::Integer: return os << "integer";
+    }
+}
+
+class literal_node : public expression_node {
+public:
+    node_t category() const override { return node_t::Literal; }
+
+    expression_node_t expression_type() const override { return expression_node_t::Literal; }
+
+    virtual literal_node_t literal_type() const = 0;
+};
+
+class string_literal_node : public literal_node {
+public:
+    string_literal_node(handle<std::string_view>&& value)
+      : m_value(std::move(value)) {}
+public:
+    literal_node_t literal_type() const override { return literal_node_t::String; }
+
+    const handle<std::string_view>& value() const { return m_value; }
+public:
+    std::ostream& print(std::ostream& os) const override {
+        if (m_value.error()) return os << (std::string)m_value;
+        return os << '"' << *m_value << '"';
+    }
+private:
+    handle<std::string_view> m_value;
+};
+
+class integer_literal_node : public literal_node {
+public:
+    integer_literal_node(handle<std::uint64_t>&& value)
+      : m_value(std::move(value)) {}
+public:
+    literal_node_t literal_type() const override { return literal_node_t::Integer; }
+
+    const handle<std::uint64_t>& value() const { return m_value; }
+private:
+    handle<std::uint64_t> m_value;
+};
+
+} // namespace ast
+} // namespace furc
+
+#endif // FURC_AST_LITERAL_HPP

furc/include/furc/ast/node.hpp

@@ -16,6 +16,16 @@ enum class node_t {
     Program,
 };
 
+static inline std::ostream& operator<<(std::ostream& os, node_t type) {
+    switch (type) {
+    case node_t::Literal: return os << "literal";
+    case node_t::Expression: return os << "expression";
+    case node_t::Statement: return os << "statement";
+    case node_t::Declaration: return os << "declaration";
+    case node_t::Program: return os << "program";
+    }
+}
+
 class node {
 public:
     node()          = default;
@@ -27,12 +37,10 @@ public:
     node& operator=(const node&) = delete;
 public:
     virtual node_t category() const = 0;
-};
 
-template <node_t Category>
-class abstract_node : public node {
-public:
-    node_t category() const override { return Category; }
+    virtual std::ostream& print(std::ostream& os) const = 0;
+
+    friend std::ostream& operator<<(std::ostream& os, const node& node) { return node.print(os); }
 };
 
 template <typename T, typename Error = std::string>

furc/include/furc/ast/program.hpp

@@ -10,17 +10,19 @@
 namespace furc {
 namespace ast {
 
-class program_node : public abstract_node<node_t::Program> {
+class program_node : public node {
 public:
-    program_node() {}
+    program_node() = default;
+
+    node_t category() const override { return node_t::Program; }
 public:
     void push(node_handle<declaration_node>&& declaration) { m_declarations.push_back(std::move(declaration)); }
 
     const std::vector<node_handle<declaration_node>>& declarations() const { return m_declarations; }
 public:
-    friend std::ostream& operator<<(std::ostream& os, const program_node& node) {
-        os << "program";
-        for (const auto& handle : node.m_declarations) {
+    std::ostream& print(std::ostream& os) const override {
+        os << "program:";
+        for (const auto& handle : m_declarations) {
             os << '\n' << handle;
         }
         return os;

furc/include/furc/ast/statement.hpp

@@ -9,49 +9,25 @@ namespace furc {
 namespace ast {
 
 enum class statement_node_t {
+    Expression,
     Declaration,
     Return,
 };
 
-static inline std::ostream& operator<<(std::ostream& os, statement_node_t type) {
-    switch (type) {
-    case statement_node_t::Declaration: return os << "declaration";
-    case statement_node_t::Return: return os << "return";
-    }
-}
-
-class statement_node : public abstract_node<node_t::Statement> {
+class statement_node : public node {
 public:
-    virtual statement_node_t type() const = 0;
-public:
-    virtual std::ostream& print(std::ostream& os) const = 0;
+    node_t category() const override { return node_t::Statement; }
 
-    friend std::ostream& operator<<(std::ostream& os, const statement_node& node) {
-        os << node.type() << " statement";
-        return node.print(os);
-    }
-};
-
-class declaration_node;
-class declaration_statement_node : public statement_node {
-public:
-    declaration_statement_node(node_handle<declaration_node>&& declaration)
-      : m_declaration(std::move(declaration)) {}
-public:
-    statement_node_t type() const override { return statement_node_t::Declaration; }
-
-    std::ostream& print(std::ostream& os) const override { return os; }
-private:
-    node_handle<declaration_node> m_declaration;
+    virtual statement_node_t statement_type() const = 0;
 };
 
 class return_statement_node : public statement_node {
 public:
     return_statement_node() = default;
 public:
-    statement_node_t type() const override { return statement_node_t::Return; }
+    statement_node_t statement_type() const override { return statement_node_t::Return; }
 
-    std::ostream& print(std::ostream& os) const override { return os; }
+    std::ostream& print(std::ostream& os) const override { return os << "return statement"; }
 };
 
 } // namespace ast

furc/include/furc/front/parser.hpp

@@ -2,6 +2,8 @@
 #define FURC_FRONT_PARSER_HPP
 
 #include "furc/ast/declaration.hpp"
+#include "furc/ast/expression.hpp"
+#include "furc/ast/literal.hpp"
 #include "furc/ast/node.hpp"
 #include "furc/ast/program.hpp"
 #include "furc/front/lexer.hpp"
@@ -28,6 +30,8 @@ public:
 private:
     ast::node_handle<ast::declaration_node> parse_declaration();
     ast::node_handle<ast::statement_node>   parse_statement();
+    ast::node_handle<ast::expression_node>  parse_expression();
+    ast::node_handle<ast::literal_node>     parse_literal();
 
     ast::function_body_handle parse_body();
 private:

furc/include/furc/front/token.hpp

@@ -14,6 +14,7 @@ enum class token_t {
     None,
     Identifier,
     Keyword,
+    String,
     Integer,
     Lparen,
     Rparen,
@@ -32,6 +33,7 @@ static inline std::ostream& operator<<(std::ostream& os, token_t type) {
     case token_t::None: return os << "none";
     case token_t::Identifier: return os << "identifier";
     case token_t::Keyword: return os << "keyword";
+    case token_t::String: return os << "string";
     case token_t::Integer: return os << "integer";
     case token_t::Lparen: return os << "'('";
     case token_t::Rparen: return os << "')'";
@@ -51,6 +53,7 @@ static inline std::string operator+(const std::string& str, token_t type) {
     case token_t::None: return str + "none";
     case token_t::Identifier: return str + "identifier";
     case token_t::Keyword: return str + "keyword";
+    case token_t::String: return str + "string";
     case token_t::Integer: return str + "integer";
     case token_t::Lparen: return str + "'('";
     case token_t::Rparen: return str + "')'";
@@ -103,9 +106,10 @@ struct token {
     bool operator==(const token& rhs) const {
         if (type != rhs.type) return false;
         switch (type) {
-        case token_t::Identifier: return value == rhs.value;
-        case token_t::Keyword: return keyword == rhs.keyword;
+        case token_t::Identifier:
+        case token_t::String:
         case token_t::Integer: return value == rhs.value;
+        case token_t::Keyword: return keyword == rhs.keyword;
         case token_t::None:
         case token_t::Lparen:
         case token_t::Rparen:
@@ -124,6 +128,7 @@ struct token {
 static inline std::ostream& operator<<(std::ostream& os, const token& token) {
     switch (token.type) {
     case token_t::Identifier:
+    case token_t::String:
     case token_t::Integer: return os << token.value;
     case token_t::Keyword: return os << token.keyword;
     default: return os << token.type;