Add AST visitor

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

furc/src/ast.cpp

@@ -12,13 +12,8 @@ bool literal_node::equal(const node& rhs) const {
     return literal_type() == reinterpret_cast<const literal_node&>(rhs).literal_type();
 }
 
-std::ostream& integer_literal_node::print(std::ostream& os) const {
-    if (m_value.has_error()) return os << m_value.error();
-    return os << *m_value;
-}
-
-bool integer_literal_node::equal(const node& rhs) const {
-    return literal_node::equal(rhs) && m_value == reinterpret_cast<const integer_literal_node&>(rhs).m_value;
+void string_literal_node::accept(visitor& visitor) const {
+    visitor.visit_string_literal_node(*this);
 }
 
 std::ostream& string_literal_node::print(std::ostream& os) const {
@@ -30,10 +25,27 @@ bool string_literal_node::equal(const node& rhs) const {
     return literal_node::equal(rhs) && m_value == reinterpret_cast<const string_literal_node&>(rhs).m_value;
 }
 
+void integer_literal_node::accept(visitor& visitor) const {
+    visitor.visit_integer_literal_node(*this);
+}
+
+std::ostream& integer_literal_node::print(std::ostream& os) const {
+    if (m_value.has_error()) return os << m_value.error();
+    return os << *m_value;
+}
+
+bool integer_literal_node::equal(const node& rhs) const {
+    return literal_node::equal(rhs) && m_value == reinterpret_cast<const integer_literal_node&>(rhs).m_value;
+}
+
 bool expression_node::equal(const node& rhs) const {
     return expression_type() == reinterpret_cast<const expression_node&>(rhs).expression_type();
 }
 
+void var_read_expression_node::accept(visitor& visitor) const {
+    visitor.visit_var_read_expression_node(*this);
+}
+
 std::ostream& var_read_expression_node::print(std::ostream& os) const {
     if (m_name.present()) return os << *m_name;
     return os << m_name.error();
@@ -56,6 +68,10 @@ std::ostream& operator<<(std::ostream& os, unaryop_expression_node_t type) {
     return os;
 }
 
+void unaryop_expression_node::accept(visitor& visitor) const {
+    visitor.visit_unaryop_expression_node(*this);
+}
+
 std::ostream& unaryop_expression_node::print(std::ostream& os) const {
     switch (m_type) {
     case unaryop_expression_node_t::Positive:
@@ -91,6 +107,10 @@ std::ostream& operator<<(std::ostream& os, binop_expression_node_t type) {
     }
 }
 
+void binop_expression_node::accept(visitor& visitor) const {
+    visitor.visit_binop_expression_node(*this);
+}
+
 std::ostream& binop_expression_node::print(std::ostream& os) const {
     if (m_type == binop_expression_node_t::None) return os;
     return os << '(' << *m_lhs << ' ' << m_type << ' ' << *m_rhs << ')';
@@ -101,6 +121,10 @@ bool binop_expression_node::equal(const node& rhsNode) const {
     return expression_node::equal(rhsNode) && m_type == rhs.m_type && m_lhs == rhs.m_lhs && m_rhs == rhs.m_rhs;
 }
 
+void var_assign_expression_node::accept(visitor& visitor) const {
+    visitor.visit_var_assign_expression_node(*this);
+}
+
 std::ostream& var_assign_expression_node::print(std::ostream& os) const {
     return os << '(' << *m_lhs << ' ' << m_compound << "= " << *m_rhs << ')';
 }
@@ -114,6 +138,10 @@ bool declaration_node::equal(const node& rhs) const {
     return declaration_type() == reinterpret_cast<const declaration_node&>(rhs).declaration_type();
 }
 
+void function_declaration_node::accept(visitor& visitor) const {
+    visitor.visit_function_declaration_node(*this);
+}
+
 std::ostream& function_declaration_node::print(std::ostream& os) const {
     return os << "function " << m_name->string << " declaration";
 }
@@ -122,6 +150,10 @@ bool function_declaration_node::equal(const node& rhs) const {
     return declaration_node::equal(rhs) && m_name == reinterpret_cast<const function_declaration_node&>(rhs).m_name;
 }
 
+void function_definition_node::accept(visitor& visitor) const {
+    visitor.visit_function_definition_node(*this);
+}
+
 std::ostream& function_definition_node::print(std::ostream& os) const {
     function_declaration_node::print(os);
     os << ':';
@@ -142,6 +174,10 @@ bool statement_node::equal(const node& rhs) const {
     return statement_type() == reinterpret_cast<const statement_node&>(rhs).statement_type();
 }
 
+void return_statement_node::accept(visitor& visitor) const {
+    visitor.visit_return_statement_node(*this);
+}
+
 std::ostream& return_statement_node::print(std::ostream& os) const {
     os << "return statement";
     if (m_value.present()) return os << ' ' << *m_value;
@@ -152,8 +188,14 @@ bool return_statement_node::equal(const node& rhs) const {
     return statement_node::equal(rhs) && m_value == reinterpret_cast<const return_statement_node&>(rhs).m_value;
 }
 
-bool program_node::equal(const node& rhs) const {
-    return m_declarations == reinterpret_cast<const program_node&>(rhs).m_declarations;
+void program_node::accept(visitor& visitor) const {
+    for (const auto& decl : m_declarations) {
+        if (decl.has_error()) {
+            visitor.visit_error(decl);
+        } else {
+            decl->accept(visitor);
+        }
+    }
 }
 
 std::ostream& program_node::print(std::ostream& os) const {
@@ -164,4 +206,8 @@ std::ostream& program_node::print(std::ostream& os) const {
     return os;
 }
 
+bool program_node::equal(const node& rhs) const {
+    return m_declarations == reinterpret_cast<const program_node&>(rhs).m_declarations;
+}
+
 } // namespace furc::ast