Reorganize stmt node

media/test-project/test.spice

@@ -1,16 +1,9 @@
-import "std/data/vector";
+f<string> unusedReturnValue() {
+    return "unused";
+}
 
 f<int> main() {
-    Vector<string> v = Vector<string>();
-    v.pushBack("Hello");
-    v.pushBack("World");
-    v.pushBack("!");
-    v.pushBack("!");
-    v.pushBack("!");
-
-    foreach string s : v {
-        printf("%s\n", s);
-    }
+    unusedReturnValue();
 }
 
 /*f<int> main() {

src/ast/ASTBuilder.cpp

@@ -475,14 +475,7 @@ std::any ASTBuilder::visitSignature(SpiceParser::SignatureContext *ctx) {
   return concludeNode(signatureNode);
 }
 
-std::any ASTBuilder::visitStmt(SpiceParser::StmtContext *ctx) {
-  auto stmtNode = createNode<StmtNode>(ctx);
-
-  // Visit children
-  visitChildren(ctx);
-
-  return concludeNode(stmtNode);
-}
+std::any ASTBuilder::visitStmt(SpiceParser::StmtContext *ctx) { return visitChildren(ctx); }
 
 std::any ASTBuilder::visitDeclStmt(SpiceParser::DeclStmtContext *ctx) {
   auto declStmtNode = createNode<DeclStmtNode>(ctx);

src/ast/ASTNodes.cpp

@@ -511,7 +511,7 @@ bool FctCallNode::hasReturnValueReceiver() const {
     node = node->parent;
   }
   // Also check the condition of the assign expression
-  return node->children.size() > 1 || !node->parent->isStmtNode();
+  return node->children.size() > 1 || !node->parent->isStmtLstNode();
 }
 
 bool LambdaFuncNode::returnsOnAllControlPaths(bool *overrideUnreachable) const {

src/ast/ASTNodes.h

@@ -148,8 +148,11 @@ class ASTNode {
 
   [[nodiscard]] virtual bool isFctOrProcDef() const { return false; }
   [[nodiscard]] virtual bool isStructDef() const { return false; }
+  [[nodiscard]] virtual bool isTopLevelDefNode() const { return false; }
   [[nodiscard]] virtual bool isStmtNode() const { return false; }
+  [[nodiscard]] virtual bool isExprNode() const { return false; }
   [[nodiscard]] virtual bool isParamNode() const { return false; }
+  [[nodiscard]] virtual bool isStmtLstNode() const { return false; }
   [[nodiscard]] virtual bool isAssignExpr() const { return false; }
 
   // Public members
@@ -189,6 +192,24 @@ class TopLevelDefNode : public ASTNode {
   // Visitor methods
   std::any accept(AbstractASTVisitor *visitor) override = 0;
   std::any accept(ParallelizableASTVisitor *visitor) const override = 0;
+
+  // Other methods
+  [[nodiscard]] bool isTopLevelDefNode() const override { return true; }
+};
+
+// =========================================================== StmtNode ==========================================================
+
+class StmtNode : public ASTNode {
+public:
+  // Constructors
+  using ASTNode::ASTNode;
+
+  // Visitor methods
+  std::any accept(AbstractASTVisitor *visitor) override = 0;
+  std::any accept(ParallelizableASTVisitor *visitor) const override = 0;
+
+  // Other methods
+  [[nodiscard]] bool isStmtNode() const override { return true; }
 };
 
 // ========================================================== ExprNode ===========================================================
@@ -201,6 +222,9 @@ class ExprNode : public ASTNode {
   // Visitor methods
   std::any accept(AbstractASTVisitor *visitor) override = 0;
   std::any accept(ParallelizableASTVisitor *visitor) const override = 0;
+
+  // Other methods
+  [[nodiscard]] bool isExprNode() const override { return true; }
 };
 
 // ======================================================== MainFctDefNode =======================================================
@@ -529,10 +553,10 @@ class ImportDefNode : public TopLevelDefNode {
 
 // ======================================================== UnsafeBlockNode ======================================================
 
-class UnsafeBlockNode : public ASTNode {
+class UnsafeBlockNode : public StmtNode {
 public:
   // Constructors
-  using ASTNode::ASTNode;
+  using StmtNode::StmtNode;
 
   // Visitor methods
   std::any accept(AbstractASTVisitor *visitor) override { return visitor->visitUnsafeBlock(this); }
@@ -550,10 +574,10 @@ class UnsafeBlockNode : public ASTNode {
 
 // ========================================================== ForLoopNode ========================================================
 
-class ForLoopNode : public ASTNode {
+class ForLoopNode : public StmtNode {
 public:
   // Constructors
-  using ASTNode::ASTNode;
+  using StmtNode::StmtNode;
 
   // Visitor methods
   std::any accept(AbstractASTVisitor *visitor) override { return visitor->visitForLoop(this); }
@@ -575,10 +599,10 @@ class ForLoopNode : public ASTNode {
 
 // ======================================================== ForeachLoopNode ======================================================
 
-class ForeachLoopNode : public ASTNode {
+class ForeachLoopNode : public StmtNode {
 public:
   // Constructors
-  using ASTNode::ASTNode;
+  using StmtNode::StmtNode;
 
   // Visitor methods
   std::any accept(AbstractASTVisitor *visitor) override { return visitor->visitForeachLoop(this); }
@@ -607,10 +631,10 @@ class ForeachLoopNode : public ASTNode {
 
 // ========================================================= WhileLoopNode =======================================================
 
-class WhileLoopNode : public ASTNode {
+class WhileLoopNode : public StmtNode {
 public:
   // Constructors
-  using ASTNode::ASTNode;
+  using StmtNode::StmtNode;
 
   // Visitor methods
   std::any accept(AbstractASTVisitor *visitor) override { return visitor->visitWhileLoop(this); }
@@ -630,10 +654,10 @@ class WhileLoopNode : public ASTNode {
 
 // ======================================================== DoWhileLoopNode ======================================================
 
-class DoWhileLoopNode : public ASTNode {
+class DoWhileLoopNode : public StmtNode {
 public:
   // Constructors
-  using ASTNode::ASTNode;
+  using StmtNode::StmtNode;
 
   // Visitor methods
   std::any accept(AbstractASTVisitor *visitor) override { return visitor->visitDoWhileLoop(this); }
@@ -653,10 +677,10 @@ class DoWhileLoopNode : public ASTNode {
 
 // ========================================================== IfStmtNode =========================================================
 
-class IfStmtNode : public ASTNode {
+class IfStmtNode : public StmtNode {
 public:
   // Constructors
-  using ASTNode::ASTNode;
+  using StmtNode::StmtNode;
 
   // Visitor methods
   std::any accept(AbstractASTVisitor *visitor) override { return visitor->visitIfStmt(this); }
@@ -677,10 +701,10 @@ class IfStmtNode : public ASTNode {
 
 // ========================================================= ElseStmtNode ========================================================
 
-class ElseStmtNode : public ASTNode {
+class ElseStmtNode : public StmtNode {
 public:
   // Constructors
-  using ASTNode::ASTNode;
+  using StmtNode::StmtNode;
 
   // Visitor methods
   std::any accept(AbstractASTVisitor *visitor) override { return visitor->visitElseStmt(this); }
@@ -701,10 +725,10 @@ class ElseStmtNode : public ASTNode {
 
 // ======================================================== SwitchStmtNode =======================================================
 
-class SwitchStmtNode : public ASTNode {
+class SwitchStmtNode : public StmtNode {
 public:
   // Constructors
-  using ASTNode::ASTNode;
+  using StmtNode::StmtNode;
 
   // Visitor methods
   std::any accept(AbstractASTVisitor *visitor) override { return visitor->visitSwitchStmt(this); }
@@ -769,10 +793,10 @@ class DefaultBranchNode : public ASTNode {
 
 // ==================================================== AnonymousBlockStmtNode ===================================================
 
-class AnonymousBlockStmtNode : public ASTNode {
+class AnonymousBlockStmtNode : public StmtNode {
 public:
   // Constructors
-  using ASTNode::ASTNode;
+  using StmtNode::StmtNode;
 
   // Visitor methods
   std::any accept(AbstractASTVisitor *visitor) override { return visitor->visitAnonymousBlockStmt(this); }
@@ -803,8 +827,9 @@ class StmtLstNode : public ASTNode {
   [[nodiscard]] bool returnsOnAllControlPaths(bool *doSetPredecessorsUnreachable) const override;
   void resizeToNumberOfManifestations(size_t manifestationCount) override {
     ASTNode::resizeToNumberOfManifestations(manifestationCount);
-    dtorFunctions.resize(manifestationCount, std::vector<std::pair<SymbolTableEntry *, Function *>>());
+    dtorFunctions.resize(manifestationCount);
   }
+  [[nodiscard]] bool isStmtLstNode() const override { return true; }
 
   // Public members
   size_t complexity = 0;
@@ -963,27 +988,12 @@ class SignatureNode : public ASTNode {
   std::vector<Function *> signatureManifestations;
 };
 
-// =========================================================== StmtNode ==========================================================
-
-class StmtNode : public ASTNode {
-public:
-  // Constructors
-  using ASTNode::ASTNode;
-
-  // Visitor methods
-  std::any accept(AbstractASTVisitor *visitor) override { return visitor->visitStmt(this); }
-  std::any accept(ParallelizableASTVisitor *visitor) const override { return visitor->visitStmt(this); }
-
-  // Other methods
-  [[nodiscard]] bool isStmtNode() const override { return true; }
-};
-
 // ========================================================= DeclStmtNode ========================================================
 
-class DeclStmtNode : public ASTNode {
+class DeclStmtNode : public StmtNode {
 public:
   // Constructors
-  using ASTNode::ASTNode;
+  using StmtNode::StmtNode;
 
   // Visitor methods
   std::any accept(AbstractASTVisitor *visitor) override { return visitor->visitDeclStmt(this); }
@@ -994,7 +1004,7 @@ class DeclStmtNode : public ASTNode {
   [[nodiscard]] AssignExprNode *assignExpr() const { return getChild<AssignExprNode>(); }
 
   // Util methods
-  void customItemsInitialization(size_t manifestationCount) override { entries.resize(manifestationCount, nullptr); }
+  void customItemsInitialization(size_t manifestationCount) override { entries.resize(manifestationCount); }
   [[nodiscard]] bool isParamNode() const override { return isParam; }
 
   // Public members
@@ -1173,10 +1183,10 @@ class ConstantLstNode : public ASTNode {
 
 // ======================================================== ReturnStmtNode =======================================================
 
-class ReturnStmtNode : public ASTNode {
+class ReturnStmtNode : public StmtNode {
 public:
   // Constructors
-  using ASTNode::ASTNode;
+  using StmtNode::StmtNode;
 
   // Visitor methods
   std::any accept(AbstractASTVisitor *visitor) override { return visitor->visitReturnStmt(this); }
@@ -1187,21 +1197,18 @@ class ReturnStmtNode : public ASTNode {
 
   // Other methods
   [[nodiscard]] bool returnsOnAllControlPaths(bool *) const override { return true; }
-  [[nodiscard]] StmtLstNode *getParentScopeNode() const {
-    assert(dynamic_cast<StmtLstNode *>(parent->parent) != nullptr);
-    return spice_pointer_cast<StmtLstNode *>(parent->parent);
-  }
+  [[nodiscard]] StmtLstNode *getParentScopeNode() const { return spice_pointer_cast<StmtLstNode *>(parent); }
 
   // Public members
   bool hasReturnValue = false;
 };
 
 // ======================================================== BreakStmtNode ========================================================
 
-class BreakStmtNode : public ASTNode {
+class BreakStmtNode : public StmtNode {
 public:
   // Constructors
-  using ASTNode::ASTNode;
+  using StmtNode::StmtNode;
 
   // Visitor methods
   std::any accept(AbstractASTVisitor *visitor) override { return visitor->visitBreakStmt(this); }
@@ -1213,10 +1220,10 @@ class BreakStmtNode : public ASTNode {
 
 // ======================================================= ContinueStmtNode ======================================================
 
-class ContinueStmtNode : public ASTNode {
+class ContinueStmtNode : public StmtNode {
 public:
   // Constructors
-  using ASTNode::ASTNode;
+  using StmtNode::StmtNode;
 
   // Visitor methods
   std::any accept(AbstractASTVisitor *visitor) override { return visitor->visitContinueStmt(this); }
@@ -1228,10 +1235,10 @@ class ContinueStmtNode : public ASTNode {
 
 // ====================================================== FallthroughStmtNode ====================================================
 
-class FallthroughStmtNode : public ASTNode {
+class FallthroughStmtNode : public StmtNode {
 public:
   // Constructors
-  using ASTNode::ASTNode;
+  using StmtNode::StmtNode;
 
   // Visitor methods
   std::any accept(AbstractASTVisitor *visitor) override { return visitor->visitFallthroughStmt(this); }
@@ -1243,10 +1250,10 @@ class FallthroughStmtNode : public ASTNode {
 
 // ======================================================== AssertStmtNode =======================================================
 
-class AssertStmtNode : public ASTNode {
+class AssertStmtNode : public StmtNode {
 public:
   // Constructors
-  using ASTNode::ASTNode;
+  using StmtNode::StmtNode;
 
   // Visitor methods
   std::any accept(AbstractASTVisitor *visitor) override { return visitor->visitAssertStmt(this); }
@@ -1970,7 +1977,7 @@ class StructInstantiationNode : public ExprNode {
   [[nodiscard]] ArgLstNode *fieldLst() const { return getChild<ArgLstNode>(); }
 
   // Util methods
-  void customItemsInitialization(size_t manifestationCount) override { instantiatedStructs.resize(manifestationCount, nullptr); }
+  void customItemsInitialization(size_t manifestationCount) override { instantiatedStructs.resize(manifestationCount); }
 
   // Public members
   std::string fqStructName;
@@ -2144,7 +2151,7 @@ class CustomDataTypeNode : public ASTNode {
   [[nodiscard]] TypeLstNode *templateTypeLst() const { return getChild<TypeLstNode>(); }
 
   // Util methods
-  void customItemsInitialization(size_t manifestationCount) override { customTypes.resize(manifestationCount, nullptr); }
+  void customItemsInitialization(size_t manifestationCount) override { customTypes.resize(manifestationCount); }
 
   // Public members
   std::string fqTypeName;
@@ -2168,7 +2175,7 @@ class FunctionDataTypeNode : public ASTNode {
   [[nodiscard]] TypeLstNode *paramTypeLst() const { return getChild<TypeLstNode>(); }
 
   // Util methods
-  void customItemsInitialization(size_t manifestationCount) override { customTypes.resize(manifestationCount, nullptr); }
+  void customItemsInitialization(size_t manifestationCount) override { customTypes.resize(manifestationCount); }
 
   // Public members
   std::vector<SymbolTableEntry *> customTypes;

src/ast/ASTVisitor.cpp

@@ -74,8 +74,6 @@ std::any ASTVisitor::visitField(FieldNode *node) { return visitChildren(node); }
 
 std::any ASTVisitor::visitSignature(SignatureNode *node) { return visitChildren(node); }
 
-std::any ASTVisitor::visitStmt(StmtNode *node) { return visitChildren(node); }
-
 std::any ASTVisitor::visitDeclStmt(DeclStmtNode *node) { return visitChildren(node); }
 
 std::any ASTVisitor::visitSpecifierLst(SpecifierLstNode *node) { return visitChildren(node); }

src/ast/ASTVisitor.h

@@ -42,7 +42,6 @@ class ASTVisitor : public AbstractASTVisitor {
   std::any visitEnumItem(EnumItemNode *node) override;
   std::any visitField(FieldNode *node) override;
   std::any visitSignature(SignatureNode *node) override;
-  std::any visitStmt(StmtNode *node) override;
   std::any visitDeclStmt(DeclStmtNode *node) override;
   std::any visitSpecifierLst(SpecifierLstNode *node) override;
   std::any visitSpecifier(SpecifierNode *node) override;

src/ast/AbstractASTVisitor.h

@@ -41,7 +41,6 @@ class EnumItemLstNode;
 class EnumItemNode;
 class FieldNode;
 class SignatureNode;
-class StmtNode;
 class DeclStmtNode;
 class SpecifierLstNode;
 class SpecifierNode;
@@ -130,7 +129,6 @@ class AbstractASTVisitor {
   virtual std::any visitEnumItem(EnumItemNode *node) = 0;
   virtual std::any visitField(FieldNode *node) = 0;
   virtual std::any visitSignature(SignatureNode *node) = 0;
-  virtual std::any visitStmt(StmtNode *node) = 0;
   virtual std::any visitDeclStmt(DeclStmtNode *node) = 0;
   virtual std::any visitSpecifierLst(SpecifierLstNode *node) = 0;
   virtual std::any visitSpecifier(SpecifierNode *node) = 0;