refactor(AST): make operation node names consistent

Fixes #5

furc/src/ast.cpp

@@ -41,11 +41,11 @@ std::ostream& operator<<(std::ostream& os, unaryop_expression_node_t type) {
     return os;
 }
 
-void unaryop_expression_node::accept(visitor& visitor) const {
+void unary_op_expression_node::accept(visitor& visitor) const {
     visitor.visit(*this);
 }
 
-std::ostream& unaryop_expression_node::print(std::ostream& os) const {
+std::ostream& unary_op_expression_node::print(std::ostream& os) const {
     if (m_node == nullptr) return os;
     switch (m_type) {
     case unaryop_expression_node_t::Positive:
@@ -58,8 +58,8 @@ std::ostream& unaryop_expression_node::print(std::ostream& os) const {
     return os;
 }
 
-bool unaryop_expression_node::equal(const node& rhsNode) const {
-    const auto& rhs = dynamic_cast<const unaryop_expression_node&>(rhsNode);
+bool unary_op_expression_node::equal(const node& rhsNode) const {
+    const auto& rhs = dynamic_cast<const unary_op_expression_node&>(rhsNode);
     return expression_node::equal(rhsNode) && m_type == rhs.m_type && m_node == rhs.m_node;
 }
 
@@ -81,17 +81,17 @@ std::ostream& operator<<(std::ostream& os, binop_expression_node_t type) {
     }
 }
 
-void binop_expression_node::accept(visitor& visitor) const {
+void binary_op_expression_node::accept(visitor& visitor) const {
     visitor.visit(*this);
 }
 
-std::ostream& binop_expression_node::print(std::ostream& os) const {
+std::ostream& binary_op_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 << ')';
 }
 
-bool binop_expression_node::equal(const node& rhsNode) const {
-    const auto& rhs = dynamic_cast<const binop_expression_node&>(rhsNode);
+bool binary_op_expression_node::equal(const node& rhsNode) const {
+    const auto& rhs = dynamic_cast<const binary_op_expression_node&>(rhsNode);
     return expression_node::equal(rhsNode) && m_type == rhs.m_type && m_lhs == rhs.m_lhs && m_rhs == rhs.m_rhs;
 }
 

furc/src/front/ir_generator.cpp

@@ -80,7 +80,7 @@ void ir_generator::visit(const ast::var_read_expression_node& node) {
     }
 }
 
-void ir_generator::visit(const ast::unaryop_expression_node& node) {
+void ir_generator::visit(const ast::unary_op_expression_node& node) {
     throw std::runtime_error("unimplemented");
 }
 
@@ -102,7 +102,7 @@ static inline furlang::ir::binary_op_instruction_t binary_op_instruction_t(ast::
     }
 }
 
-void ir_generator::visit(const ast::binop_expression_node& node) {
+void ir_generator::visit(const ast::binary_op_expression_node& node) {
     node.lhs()->accept(*this);
     ir_register lhs = m_registerCounter - 1;
     node.rhs()->accept(*this);

furc/src/front/parser.cpp

@@ -223,7 +223,7 @@ ast::expression_node_r parser::parse_expression_unary(std::uint32_t precedence)
         { token_t::DMinus, unaryop_info{ ast::unaryop_expression_node_t::PrefixDecrement, 2 } },
     };
 
-    std::shared_ptr<ast::unaryop_expression_node> result;
+    std::shared_ptr<ast::unary_op_expression_node> result;
     while (true) {
         auto it = s_prefixes.find(peek_token()->type);
         if (it == s_prefixes.end()) break;
@@ -243,8 +243,9 @@ ast::expression_node_r parser::parse_expression_unary(std::uint32_t precedence)
             expression = std::move(std::move(expr.value()));
         }
 
-        result =
-            m_arena.allocate_shared<ast::unaryop_expression_node>(token->location, current.type, std::move(expression));
+        result = m_arena.allocate_shared<ast::unary_op_expression_node>(token->location,
+            current.type,
+            std::move(expression));
     }
 
     if (result == nullptr) return parse_expression_primary();
@@ -369,11 +370,12 @@ ast::expression_node_r parser::parse_expression_rhs(ast::expression_node_p&& ini
 
         switch (current.type) {
         case rhsop_info_t::Unaryop:
-            lhs =
-                m_arena.allocate_shared<ast::unaryop_expression_node>(opToken->location, current.unary, std::move(lhs));
+            lhs = m_arena.allocate_shared<ast::unary_op_expression_node>(opToken->location,
+                current.unary,
+                std::move(lhs));
             break;
         case rhsop_info_t::Binop:
-            lhs = m_arena.allocate_shared<ast::binop_expression_node>(opToken->location,
+            lhs = m_arena.allocate_shared<ast::binary_op_expression_node>(opToken->location,
                 current.binary,
                 std::move(lhs),
                 std::move(rhs));