furc/include/furc/ast/visitor.hpp

@@ -16,17 +16,17 @@ public:
     visitor(const visitor&)            = default;
     visitor& operator=(const visitor&) = default;
 public:
-    virtual void visit_string_literal_node(const string_literal_node&) {}
+    virtual void visit(const string_literal_node&) {}
-    virtual void visit_integer_literal_node(const integer_literal_node&) {}
+    virtual void visit(const integer_literal_node&) {}
-    virtual void visit_var_read_expression_node(const var_read_expression_node&) {}
+    virtual void visit(const var_read_expression_node&) {}
-    virtual void visit_unaryop_expression_node(const unaryop_expression_node&) {}
+    virtual void visit(const unaryop_expression_node&) {}
-    virtual void visit_binop_expression_node(const binop_expression_node&) {}
+    virtual void visit(const binop_expression_node&) {}
-    virtual void visit_var_assign_expression_node(const var_assign_expression_node&) {}
+    virtual void visit(const var_assign_expression_node&) {}
-    virtual void visit_function_declaration_node(const function_declaration_node&) {}
+    virtual void visit(const function_declaration_node&) {}
-    virtual void visit_function_definition_node(const function_definition_node&) {}
+    virtual void visit(const function_definition_node&) {}
-    virtual void visit_return_statement_node(const return_statement_node&) {}
+    virtual void visit(const return_statement_node&) {}
-    virtual void visit_if_statement_node(const if_statement_node&) {}
+    virtual void visit(const if_statement_node&) {}
-    virtual void visit_compound_statement_node(const compound_statement_node&) {}
+    virtual void visit(const compound_statement_node&) {}
 
     virtual void visit_error(const node_handle<node>& handle) {}
 };

furc/include/furc/front/ir_generator.hpp

@@ -20,16 +20,16 @@ public:
 public:
     furlang::ir::module&& move_module() { return std::move(m_module); }
 public:
-    void visit_function_definition_node(const ast::function_definition_node& funcDef) override;
+    void visit(const ast::function_definition_node& funcDef) override;
-    void visit_return_statement_node(const ast::return_statement_node& returnStmt) override;
+    void visit(const ast::return_statement_node& returnStmt) override;
-    void visit_if_statement_node(const ast::if_statement_node& node) override;
+    void visit(const ast::if_statement_node& node) override;
-    void visit_compound_statement_node(const ast::compound_statement_node& node) override;
+    void visit(const ast::compound_statement_node& node) override;
-    void visit_string_literal_node(const ast::string_literal_node& node) override;
+    void visit(const ast::string_literal_node& node) override;
-    void visit_integer_literal_node(const ast::integer_literal_node& node) override;
+    void visit(const ast::integer_literal_node& node) override;
-    void visit_var_read_expression_node(const ast::var_read_expression_node& node) override;
+    void visit(const ast::var_read_expression_node& node) override;
-    void visit_unaryop_expression_node(const ast::unaryop_expression_node& node) override;
+    void visit(const ast::unaryop_expression_node& node) override;
-    void visit_binop_expression_node(const ast::binop_expression_node& node) override;
+    void visit(const ast::binop_expression_node& node) override;
-    void visit_var_assign_expression_node(const ast::var_assign_expression_node& node) override;
+    void visit(const ast::var_assign_expression_node& node) override;
 private:
     furlang::ir::block_index push_block();
 private:

furc/src/ast.cpp

@@ -13,7 +13,7 @@ bool literal_node::equal(const node& rhs) const {
 }
 
 void string_literal_node::accept(visitor& visitor) const {
-    visitor.visit_string_literal_node(*this);
+    visitor.visit(*this);
 }
 
 std::ostream& string_literal_node::print(std::ostream& os) const {
@@ -26,7 +26,7 @@ bool string_literal_node::equal(const node& rhs) const {
 }
 
 void integer_literal_node::accept(visitor& visitor) const {
-    visitor.visit_integer_literal_node(*this);
+    visitor.visit(*this);
 }
 
 std::ostream& integer_literal_node::print(std::ostream& os) const {
@@ -43,7 +43,7 @@ bool expression_node::equal(const node& rhs) const {
 }
 
 void var_read_expression_node::accept(visitor& visitor) const {
-    visitor.visit_var_read_expression_node(*this);
+    visitor.visit(*this);
 }
 
 std::ostream& var_read_expression_node::print(std::ostream& os) const {
@@ -69,7 +69,7 @@ std::ostream& operator<<(std::ostream& os, unaryop_expression_node_t type) {
 }
 
 void unaryop_expression_node::accept(visitor& visitor) const {
-    visitor.visit_unaryop_expression_node(*this);
+    visitor.visit(*this);
 }
 
 std::ostream& unaryop_expression_node::print(std::ostream& os) const {
@@ -108,7 +108,7 @@ 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);
+    visitor.visit(*this);
 }
 
 std::ostream& binop_expression_node::print(std::ostream& os) const {
@@ -122,7 +122,7 @@ bool binop_expression_node::equal(const node& rhsNode) const {
 }
 
 void var_assign_expression_node::accept(visitor& visitor) const {
-    visitor.visit_var_assign_expression_node(*this);
+    visitor.visit(*this);
 }
 
 std::ostream& var_assign_expression_node::print(std::ostream& os) const {
@@ -139,7 +139,7 @@ bool declaration_node::equal(const node& rhs) const {
 }
 
 void function_declaration_node::accept(visitor& visitor) const {
-    visitor.visit_function_declaration_node(*this);
+    visitor.visit(*this);
 }
 
 std::ostream& function_declaration_node::print(std::ostream& os) const {
@@ -151,7 +151,7 @@ bool function_declaration_node::equal(const node& rhs) const {
 }
 
 void function_definition_node::accept(visitor& visitor) const {
-    visitor.visit_function_definition_node(*this);
+    visitor.visit(*this);
 }
 
 std::ostream& function_definition_node::print(std::ostream& os) const {
@@ -175,7 +175,7 @@ bool statement_node::equal(const node& rhs) const {
 }
 
 void return_statement_node::accept(visitor& visitor) const {
-    visitor.visit_return_statement_node(*this);
+    visitor.visit(*this);
 }
 
 std::ostream& return_statement_node::print(std::ostream& os) const {
@@ -189,7 +189,7 @@ bool return_statement_node::equal(const node& rhs) const {
 }
 
 void if_statement_node::accept(visitor& visitor) const {
-    visitor.visit_if_statement_node(*this);
+    visitor.visit(*this);
 }
 
 std::ostream& if_statement_node::print(std::ostream& os) const {
@@ -205,7 +205,7 @@ bool if_statement_node::equal(const node& rhsNode) const {
 }
 
 void compound_statement_node::accept(visitor& visitor) const {
-    visitor.visit_compound_statement_node(*this);
+    visitor.visit(*this);
 }
 
 std::ostream& compound_statement_node::print(std::ostream& os) const {

furc/src/front/ir_generator.cpp

@@ -13,7 +13,7 @@ namespace {
 namespace ir = furlang::ir;
 }
 
-void ir_generator::visit_function_definition_node(const ast::function_definition_node& funcDef) {
+void ir_generator::visit(const ast::function_definition_node& funcDef) {
     m_currentFunction = std::make_unique<furlang::ir::function>(std::string(funcDef.name()->string));
 
     push_block();
@@ -28,7 +28,7 @@ void ir_generator::visit_function_definition_node(const ast::function_definition
     m_module.push(std::move(m_currentFunction));
 }
 
-void ir_generator::visit_return_statement_node(const ast::return_statement_node& returnStmt) {
+void ir_generator::visit(const ast::return_statement_node& returnStmt) {
     if (returnStmt.value().has_error()) {
         std::cerr << returnStmt.value() << '\n';
     }
@@ -41,7 +41,7 @@ void ir_generator::visit_return_statement_node(const ast::return_statement_node&
     }
 }
 
-void ir_generator::visit_if_statement_node(const ast::if_statement_node& node) {
+void ir_generator::visit(const ast::if_statement_node& node) {
     node.cond()->accept(*this);
     std::uint32_t cond = m_registerCounter - 1;
     m_currentBlock->emplace<ir::branch_cond_instruction>(ir::operand::new_reg(cond),
@@ -60,28 +60,28 @@ void ir_generator::visit_if_statement_node(const ast::if_statement_node& node) {
     push_block();
 }
 
-void ir_generator::visit_compound_statement_node(const ast::compound_statement_node& node) {
+void ir_generator::visit(const ast::compound_statement_node& node) {
     for (const auto& stmt : node.body()->statements) {
         stmt->accept(*this);
     }
 }
 
-void ir_generator::visit_string_literal_node(const ast::string_literal_node& node) {
+void ir_generator::visit(const ast::string_literal_node& node) {
     m_currentBlock->emplace<furlang::ir::assign_instruction>(ir::operand::new_string(std::string(*node.value())),
         ir::operand::new_reg(m_registerCounter++));
 }
 
-void ir_generator::visit_integer_literal_node(const ast::integer_literal_node& node) {
+void ir_generator::visit(const ast::integer_literal_node& node) {
     m_currentBlock->emplace<furlang::ir::assign_instruction>(ir::operand::new_integer(*node.value()),
         ir::operand::new_reg(m_registerCounter++));
 }
 
-void ir_generator::visit_var_read_expression_node(const ast::var_read_expression_node& node) {
+void ir_generator::visit(const ast::var_read_expression_node& node) {
     m_currentBlock->emplace<furlang::ir::assign_instruction>(ir::operand::new_variable(std::string(*node.get_name())),
         ir::operand::new_reg(m_registerCounter++));
 }
 
-void ir_generator::visit_unaryop_expression_node(const ast::unaryop_expression_node& node) {
+void ir_generator::visit(const ast::unaryop_expression_node& node) {
     throw std::runtime_error("unimplemented");
 }
 
@@ -103,7 +103,7 @@ static inline furlang::ir::binary_op_instruction_t binary_op_instruction_t(ast::
     }
 }
 
-void ir_generator::visit_binop_expression_node(const ast::binop_expression_node& node) {
+void ir_generator::visit(const ast::binop_expression_node& node) {
     node.lhs()->accept(*this);
     std::uint32_t lhs = m_registerCounter - 1;
     node.rhs()->accept(*this);
@@ -115,7 +115,7 @@ void ir_generator::visit_binop_expression_node(const ast::binop_expression_node&
         ir::operand::new_reg(dst));
 }
 
-void ir_generator::visit_var_assign_expression_node(const ast::var_assign_expression_node& node) {
+void ir_generator::visit(const ast::var_assign_expression_node& node) {
     node.rhs()->accept(*this);
     std::uint32_t rhs = m_registerCounter - 1;
     assert(node.lhs()->expression_type() == ast::expression_node_t::VarRead);