Refactor: implement "TypeCheckVisitor" for type-checking

src/ast/ArithmeticExpressionNode.cpp

@@ -2,22 +2,6 @@
 
 #include "ir/ArithmeticTac.hpp"
 
-std::string ArithmeticExpressionNode::checkTypes(SymbolTable &st) const {
-    const auto lhsType = left->checkTypes(st);
-    const auto rhsType = right->checkTypes(st);
-
-    if (!lhsType.empty() && !rhsType.empty()) {
-        if (lhsType == "int" && rhsType == "int") {
-            return "int";
-        }
-    }
-    std::cerr << "Error: ";
-    std::cerr << "(line " << lineno << ") ";
-    std::cerr << type << " operation does not support operands of types ";
-    std::cerr << "'" << lhsType << "' and '" << rhsType << "'.\n";
-    return "";
-}
-
 Operand PlusNode::generateIR(CFG &graph, SymbolTable &st) {
     auto lhs_name = left->generateIR(graph, st);
     auto rhs_name = right->generateIR(graph, st);

src/ast/ArithmeticExpressionNode.hpp

@@ -8,15 +8,12 @@ class ArithmeticExpressionNode : public Node {
     Node *left, *right;
 
   public:
-    ArithmeticExpressionNode(const std::string &t,
-                             std::unique_ptr<Node> left_,
+    ArithmeticExpressionNode(const std::string &t, std::unique_ptr<Node> left_,
                              std::unique_ptr<Node> right_, int l)
         : Node(t, l) {
         left = append_child(std::move(left_));
         right = append_child(std::move(right_));
     }
-
-    std::string checkTypes(SymbolTable &st) const override;
 };
 
 class PlusNode : public ArithmeticExpressionNode {

src/ast/ArrayAccessNode.cpp

@@ -1,28 +1,6 @@
 #include "ast/ArrayAccessNode.hpp"
 #include "ir/Tac.hpp"
 
-std::string ArrayAccessNode::checkTypes(SymbolTable &st) const {
-    const auto arrayType = array->checkTypes(st);
-    const auto indexType = index->checkTypes(st);
-
-    if (indexType != "int") {
-        std::cerr << "Error: (line " << lineno << ") ";
-        std::cerr << "Invalid array index type ";
-        std::cerr << "'" << indexType << "', ";
-        std::cerr << "expected type 'int'.\n";
-        return "";
-    }
-    if (arrayType != "int[]") {
-        std::cerr << "Error: (line " << lineno << ") ";
-        std::cerr << "Invalid array type ";
-        std::cerr << "'" << indexType << "', ";
-        std::cerr << "expected type 'int[]'.\n";
-        return "";
-    }
-
-    return "int";
-}
-
 Operand ArrayAccessNode::generateIR(CFG &graph, SymbolTable &st) {
     auto indexName = index->generateIR(graph, st);
     auto arrayName = array->value;

src/ast/ArrayAccessNode.hpp

@@ -13,7 +13,6 @@ class ArrayAccessNode : public Node {
         array = append_child(std::move(array_));
         index = append_child(std::move(index_));
     }
-    std::string checkTypes(SymbolTable &st) const override;
     Operand generateIR(CFG &graph, SymbolTable &st) override;
 };
 

src/ast/ArrayLengthNode.cpp

@@ -1,18 +1,6 @@
 #include "ast/ArrayLengthNode.hpp"
 #include "ir/Tac.hpp"
 
-std::string ArrayLengthNode::checkTypes(SymbolTable &st) const {
-    const auto arrayType = array->checkTypes(st);
-    if (arrayType != "int[]") {
-        std::cerr << "Error: (line " << lineno << ") Invalid type '"
-                  << arrayType
-                  << "' for array length, "
-                     "expected type 'int[]'.\n";
-        return "";
-    }
-    return "int";
-}
-
 Operand ArrayLengthNode::generateIR(CFG &graph, SymbolTable &st) {
     auto name = graph.getTemporaryName();
     st.addIntegerVariable(name);

src/ast/ArrayLengthNode.hpp

@@ -9,7 +9,7 @@ class ArrayLengthNode : public Node {
   public:
     ArrayLengthNode(std::unique_ptr<Node> array_, int l)
         : Node("Array length", l), array(std::move(array_)) {}
-    std::string checkTypes(SymbolTable &st) const override;
+    [[nodiscard]] const Node &getArrayNode() const { return *array; }
     Operand generateIR(CFG &graph, SymbolTable &st) override;
 };
 

src/ast/BooleanExpressionNode.cpp

@@ -1,21 +1,6 @@
 #include "ast/BooleanExpressionNode.hpp"
 #include "ir/BooleanTac.hpp"
 
-std::string BooleanExpressionNode::checkTypes(SymbolTable &st) const {
-    const auto lhsType = left->checkTypes(st);
-    const auto rhsType = right->checkTypes(st);
-
-    if (lhsType == "boolean" && rhsType == "boolean") {
-        return "boolean";
-    }
-
-    std::cerr << "Error: ";
-    std::cerr << "(line " << lineno << ") ";
-    std::cerr << type << " operation does not support operands of types ";
-    std::cerr << lhsType << " and " << rhsType << ".\n";
-    return "";
-}
-
 Operand AndNode::generateIR(CFG &graph, SymbolTable &st) {
     auto lhs_name = left->generateIR(graph, st);
     auto rhs_name = right->generateIR(graph, st);

src/ast/BooleanExpressionNode.hpp

@@ -14,7 +14,6 @@ class BooleanExpressionNode : public Node {
         left = append_child(std::move(left_));
         right = append_child(std::move(right_));
     }
-    std::string checkTypes(SymbolTable &st) const override;
 };
 
 class AndNode : public BooleanExpressionNode {

src/ast/BooleanNode.cpp

@@ -1,7 +1,4 @@
 #include "ast/BooleanNode.hpp"
 #include "ir/Tac.hpp"
-
-std::string TrueNode::checkTypes(SymbolTable &st) const { return "boolean"; }
-std::string FalseNode::checkTypes(SymbolTable &st) const { return "boolean"; }
 Operand TrueNode::generateIR(CFG &graph, SymbolTable &st) { return true; }
 Operand FalseNode::generateIR(CFG &graph, SymbolTable &st) { return false; }

src/ast/BooleanNode.hpp

@@ -6,13 +6,11 @@
 class TrueNode : public Node {
   public:
     TrueNode(int l) : Node("TRUE", l) {};
-    std::string checkTypes(SymbolTable &st) const override;
     Operand generateIR(CFG &graph, SymbolTable &st) override;
 };
 class FalseNode : public Node {
   public:
     FalseNode(int l) : Node("FALSE", l) {};
-    std::string checkTypes(SymbolTable &st) const override;
     Operand generateIR(CFG &graph, SymbolTable &st) override;
 };
 

src/ast/ClassAllocationNode.cpp

@@ -1,10 +1,6 @@
 #include "ast/ClassAllocationNode.hpp"
 #include "ir/Tac.hpp"
 
-std::string ClassAllocationNode::checkTypes(SymbolTable &st) const {
-    return id;
-}
-
 Operand ClassAllocationNode::generateIR(CFG &graph, SymbolTable &st) {
     auto name = graph.getTemporaryName();
     st.addVariable(id, name);

src/ast/ClassAllocationNode.hpp

@@ -9,7 +9,6 @@ class ClassAllocationNode : public Node {
   public:
     ClassAllocationNode(std::unique_ptr<Node> object, int l)
         : Node("Class allocation", object->value, l), id{object->value} {}
-    std::string checkTypes(SymbolTable &st) const override;
     Operand generateIR(CFG &graph, SymbolTable &st) override;
 };
 

src/ast/ClassNode.cpp

@@ -4,16 +4,6 @@
 
 void ClassNode::accept(AstVisitor &visitor) const { visitor.visit(*this); }
 
-std::string ClassNode::checkTypes(SymbolTable &st) const {
-    st.enterClassScope(className);
-    auto type = body->checkTypes(st);
-    st.exitScope();
-    if (type.empty()) {
-        return "";
-    }
-    return "void";
-}
-
 Operand ClassNode::generateIR(CFG &graph, SymbolTable &st) {
     auto *currentClass = st.lookupClass(className);
     st.enterClassScope(currentClass);

src/ast/ClassNode.hpp

@@ -19,7 +19,6 @@ class ClassNode : public Node {
     [[nodiscard]] const std::string &getClassName() const { return className; }
     [[nodiscard]] const Node &getBodyNode() const { return *body; }
 
-    std::string checkTypes(SymbolTable &st) const override;
     Operand generateIR(CFG &graph, SymbolTable &st) override;
 };
 

src/ast/ControlStatementNode.cpp

@@ -1,18 +1,6 @@
 #include "ast/ControlStatementNode.hpp"
 #include "ir/Tac.hpp"
 
-std::string ControlStatementNode::checkTypes(SymbolTable &st) const {
-    const auto condType = cond->checkTypes(st);
-    if (!condType.empty() && condType != "boolean") {
-        std::cerr << "Error: ";
-        std::cerr << "(line " << lineno << ") ";
-        std::cerr << "Condition for " << type << "-statement of invalid type "
-                  << condType << ".\n";
-        return "";
-    }
-    return "void";
-}
-
 Operand IfNode::generateIR(CFG &graph, SymbolTable &st) {
     auto *trueBlock = graph.newBlock();
     auto *joinBlock = graph.newBlock();

src/ast/ControlStatementNode.hpp

@@ -13,7 +13,6 @@ class ControlStatementNode : public Node {
         cond = append_child(std::move(cond_));
         stmts = append_child(std::move(stmts_));
     }
-    std::string checkTypes(SymbolTable &st) const override;
 };
 class IfNode : public ControlStatementNode {
     Node *cond, *stmt;

src/ast/IdentifierNode.cpp

@@ -1,25 +1,5 @@
 #include "ast/IdentifierNode.hpp"
 
-std::string IdentifierNode::checkTypes(SymbolTable &st) const {
-    auto variableLookup = st.lookupVariable(value);
-    if (variableLookup) {
-        return variableLookup->getType();
-    }
-    auto classLookup = st.lookupClass(value);
-    if (classLookup) {
-        return classLookup->getType();
-    }
-    auto methodLookup = st.lookupMethod(value);
-    if (methodLookup) {
-        return methodLookup->getType();
-    }
-
-    std::cerr << "Error: ";
-    std::cerr << "(line " << lineno << ") ";
-    std::cerr << "Undeclared identifier " << value << ".\n";
-    return "";
-}
-
 Operand IdentifierNode::generateIR(CFG &graph, SymbolTable &st) {
     return value;
 }

src/ast/IdentifierNode.hpp

@@ -11,8 +11,6 @@ class IdentifierNode : public Node {
     IdentifierNode(const std::string &value_, int l)
         : Node("Identifier", value_, l), value{value_} {}
 
-    std::string checkTypes(SymbolTable &st) const override;
-
     Operand generateIR(CFG &graph, SymbolTable &st) override;
 };
 

src/ast/IntegerArrayAllocationNode.cpp

@@ -1,18 +1,6 @@
 #include "ast/IntegerArrayAllocationNode.hpp"
 #include "ir/Tac.hpp"
 
-std::string IntegerArrayAllocationNode::checkTypes(SymbolTable &st) const {
-    const auto lengthType = length->checkTypes(st);
-    if (lengthType != "int") {
-        std::cerr << "Error: (line " << lineno << ") Invalid type '"
-                  << lengthType
-                  << "' for array length"
-                     ", expected type 'int'.\n";
-        return "";
-    }
-    return "int[]";
-}
-
 Operand IntegerArrayAllocationNode::generateIR(CFG &graph, SymbolTable &st) {
     auto name = graph.getTemporaryName();
     st.addVariable("int[]", name);

src/ast/IntegerArrayAllocationNode.hpp

@@ -9,7 +9,7 @@ class IntegerArrayAllocationNode : public Node {
   public:
     IntegerArrayAllocationNode(std::unique_ptr<Node> length_, int l)
         : Node("Integer array allocation", l), length(std::move(length_)) {}
-    std::string checkTypes(SymbolTable &st) const override;
+    [[nodiscard]] const Node &getLengthNode() const { return *length; }
     Operand generateIR(CFG &graph, SymbolTable &st) override;
 };
 

src/ast/IntegerNode.cpp

@@ -1,5 +1,3 @@
 #include "ast/IntegerNode.hpp"
 
-std::string IntegerNode::checkTypes(SymbolTable &st) const { return "int"; }
-
 Operand IntegerNode::generateIR(CFG &graph, SymbolTable &st) { return value; }

src/ast/IntegerNode.hpp

@@ -13,8 +13,6 @@ class IntegerNode : public Node {
     IntegerNode(const std::string &value_, int l)
         : Node("Integer", value_, l), value{std::stoi(value_)} {}
 
-    std::string checkTypes(SymbolTable &st) const override;
-
     Operand generateIR(CFG &graph, SymbolTable &st) override;
 };
 

src/ast/LogicalExpressionNode.cpp

@@ -1,26 +1,6 @@
 #include "ast/LogicalExpressionNode.hpp"
 #include "ir/LogicalTac.hpp"
 
-std::string LogicalExpressionNode::checkTypes(SymbolTable &st) const {
-    const auto lhsType = left->checkTypes(st);
-    const auto rhsType = right->checkTypes(st);
-
-    if (lhsType == "int" && rhsType == "int") {
-        return "boolean";
-    }
-
-    if (!lhsType.empty() && !rhsType.empty()) {
-        std::cerr << "Error: (line " << lineno << ") " << type << " "
-                  << "operation does not "
-                     "support operands of types '"
-                  << lhsType
-                  << "' and "
-                     "'"
-                  << rhsType << "'.\n";
-    }
-    return "";
-}
-
 Operand LessThanNode::generateIR(CFG &graph, SymbolTable &st) {
     auto lhs_name = left->generateIR(graph, st);
     auto rhs_name = right->generateIR(graph, st);
@@ -37,21 +17,6 @@ Operand GreaterThanNode::generateIR(CFG &graph, SymbolTable &st) {
     graph.addInstruction(new GreaterThanTac(name, lhs_name, rhs_name));
     return name;
 }
-std::string EqualToNode::checkTypes(SymbolTable &st) const {
-    const auto lhsType = left->checkTypes(st);
-    const auto rhsType = right->checkTypes(st);
-
-    if ((lhsType == "boolean" && rhsType == "boolean") ||
-        (lhsType == "int" && rhsType == "int")) {
-        return "boolean";
-    }
-    std::cerr << "Error: ";
-    std::cerr << "(line " << lineno << ") ";
-    std::cerr << "Operator '==' does not support operands of types ";
-    std::cerr << "'" << lhsType << "' and '" << rhsType << "'.\n";
-    return "";
-}
-
 Operand EqualToNode::generateIR(CFG &graph, SymbolTable &st) {
     auto lhs_name = left->generateIR(graph, st);
     auto rhs_name = right->generateIR(graph, st);

src/ast/LogicalExpressionNode.hpp

@@ -14,15 +14,13 @@ class LogicalExpressionNode : public Node {
         left = append_child(std::move(left_));
         right = append_child(std::move(right_));
     }
-
-    std::string checkTypes(SymbolTable &st) const override;
 };
 
 class LessThanNode : public LogicalExpressionNode {
   public:
     LessThanNode(std::unique_ptr<Node> left, std::unique_ptr<Node> right, int l)
-        : LogicalExpressionNode("Less-than", std::move(left),
-                                std::move(right), l) {}
+        : LogicalExpressionNode("Less-than", std::move(left), std::move(right),
+                                l) {}
     Operand generateIR(CFG &graph, SymbolTable &st) override;
 };
 
@@ -45,7 +43,6 @@ class EqualToNode : public Node {
         left = append_child(std::move(left_));
         right = append_child(std::move(right_));
     }
-    std::string checkTypes(SymbolTable &st) const override;
     Operand generateIR(CFG &graph, SymbolTable &st) override;
 };
 

src/ast/MainClassNode.cpp

@@ -4,13 +4,6 @@
 
 void MainClassNode::accept(AstVisitor &visitor) const { visitor.visit(*this); }
 
-std::string MainClassNode::checkTypes(SymbolTable &st) const {
-    st.enterClassScope(mainClassName);
-    body->checkTypes(st);
-    st.exitScope();
-    return "void";
-}
-
 Operand MainClassNode::generateIR(CFG &graph, SymbolTable &st) {
     st.enterClassScope(mainClassName);
     st.enterMethodScope("main");