GCC Code Coverage Report

src/
Coverage:
low: ≥ 0%
medium: ≥ 75.0%
high: ≥ 90.0%
Lines:
78 / 89
87.6%
Branches:
2 / 2, 4 excl
100.0%
Functions:
69 / 80
86.2%
ast/abstract-ast-visitor-intf.spice
Line Branch Exec Source
1 // Copyright (c) 2021-2026 ChilliBits. All rights reserved.
2
3 // Std imports
4 import "std/type/any";
5
6 // Own imports
7 import "@/ast/ast-nodes";
8
9 /**
10 * Full visitor interface. Declared in a separate file so that ast-nodes.spice can import
11 * it and call typed visitXxx methods from accept() overrides, without going through the
12 * larger abstract-ast-visitor.spice which brings in additional dependencies.
13 *
14 * Circular imports are supported: ast-nodes.spice imports this file, and this file imports
15 * ast-nodes.spice. The compiler handles the cycle natively.
16 *
17 * All methods have default implementations below, so that each compiler pass only implements the
18 * visit methods it needs. By default, a visit method visits all children of the node.
19 */
20 public type IAbstractAstVisitor interface {
21 public f<Any> visit(IVisitable*);
22 public f<Any> visitChildren(ASTNode*);
23 public f<Any> visitEntry(ASTEntryNode*);
24 public f<Any> visitMainFctDef(ASTMainFctDefNode*);
25 public f<Any> visitFctDef(ASTFctDefNode*);
26 public f<Any> visitProcDef(ASTProcDefNode*);
27 public f<Any> visitFctName(ASTFctNameNode*);
28 public f<Any> visitStructDef(ASTStructDefNode*);
29 public f<Any> visitInterfaceDef(ASTInterfaceDefNode*);
30 public f<Any> visitUnionDef(ASTUnionDefNode*);
31 public f<Any> visitEnumDef(ASTEnumDefNode*);
32 public f<Any> visitGenericTypeDef(ASTGenericTypeDefNode*);
33 public f<Any> visitAliasDef(ASTAliasDefNode*);
34 public f<Any> visitGlobalVarDef(ASTGlobalVarDefNode*);
35 public f<Any> visitExtDecl(ASTExtDeclNode*);
36 public f<Any> visitImportDef(ASTImportDefNode*);
37 public f<Any> visitUnsafeBlock(ASTUnsafeBlockNode*);
38 public f<Any> visitForLoop(ASTForLoopNode*);
39 public f<Any> visitForeachLoop(ASTForeachLoopNode*);
40 public f<Any> visitWhileLoop(ASTWhileLoopNode*);
41 public f<Any> visitDoWhileLoop(ASTDoWhileLoopNode*);
42 public f<Any> visitIfStmt(ASTIfStmtNode*);
43 public f<Any> visitElseStmt(ASTElseStmtNode*);
44 public f<Any> visitSwitchStmt(ASTSwitchStmtNode*);
45 public f<Any> visitCaseBranch(ASTCaseBranchNode*);
46 public f<Any> visitDefaultBranch(ASTDefaultBranchNode*);
47 public f<Any> visitAnonymousBlockStmt(ASTAnonymousBlockStmtNode*);
48 public f<Any> visitStmtLst(ASTStmtLstNode*);
49 public f<Any> visitTypeLst(ASTTypeLstNode*);
50 public f<Any> visitTypeLstWithEllipsis(ASTTypeLstWithEllipsisNode*);
51 public f<Any> visitTypeAltsLst(ASTTypeAltsLstNode*);
52 public f<Any> visitParamLst(ASTParamLstNode*);
53 public f<Any> visitArgLst(ASTArgLstNode*);
54 public f<Any> visitEnumItemLst(ASTEnumItemLstNode*);
55 public f<Any> visitEnumItem(ASTEnumItemNode*);
56 public f<Any> visitField(ASTFieldNode*);
57 public f<Any> visitSignature(ASTSignatureNode*);
58 public f<Any> visitDeclStmt(ASTDeclStmtNode*);
59 public f<Any> visitExprStmt(ASTExprStmtNode*);
60 public f<Any> visitQualifierLst(ASTQualifierLstNode*);
61 public f<Any> visitQualifier(ASTQualifierNode*);
62 public f<Any> visitModAttr(ASTModAttrNode*);
63 public f<Any> visitTopLevelDefinitionAttr(ASTTopLevelDefAttrNode*);
64 public f<Any> visitLambdaAttr(ASTLambdaAttrNode*);
65 public f<Any> visitAttrLst(ASTAttrLstNode*);
66 public f<Any> visitAttr(ASTAttrNode*);
67 public f<Any> visitCaseConstant(ASTCaseConstantNode*);
68 public f<Any> visitReturnStmt(ASTReturnStmtNode*);
69 public f<Any> visitBreakStmt(ASTBreakStmtNode*);
70 public f<Any> visitContinueStmt(ASTContinueStmtNode*);
71 public f<Any> visitFallthroughStmt(ASTFallthroughStmtNode*);
72 public f<Any> visitAssertStmt(ASTAssertStmtNode*);
73 public f<Any> visitAssignExpr(ASTAssignExprNode*);
74 public f<Any> visitTernaryExpr(ASTTernaryExprNode*);
75 public f<Any> visitLogicalOrExpr(ASTLogicalOrExprNode*);
76 public f<Any> visitLogicalAndExpr(ASTLogicalAndExprNode*);
77 public f<Any> visitBitwiseOrExpr(ASTBitwiseOrExprNode*);
78 public f<Any> visitBitwiseXorExpr(ASTBitwiseXorExprNode*);
79 public f<Any> visitBitwiseAndExpr(ASTBitwiseAndExprNode*);
80 public f<Any> visitEqualityExpr(ASTEqualityExprNode*);
81 public f<Any> visitRelationalExpr(ASTRelationalExprNode*);
82 public f<Any> visitShiftExpr(ASTShiftExprNode*);
83 public f<Any> visitAdditiveExpr(ASTAdditiveExprNode*);
84 public f<Any> visitMultiplicativeExpr(ASTMultiplicativeExprNode*);
85 public f<Any> visitCastExpr(ASTCastExprNode*);
86 public f<Any> visitPrefixUnaryExpr(ASTPrefixUnaryExprNode*);
87 public f<Any> visitPostfixUnaryExpr(ASTPostfixUnaryExprNode*);
88 public f<Any> visitAtomicExpr(ASTAtomicExprNode*);
89 public f<Any> visitValue(ASTValueNode*);
90 public f<Any> visitConstant(ASTConstantNode*);
91 public f<Any> visitFctCall(ASTFctCallNode*);
92 public f<Any> visitArrayInitialization(ASTArrayInitializationNode*);
93 public f<Any> visitStructInstantiation(ASTStructInstantiationNode*);
94 public f<Any> visitLambdaFunc(ASTLambdaFuncNode*);
95 public f<Any> visitLambdaProc(ASTLambdaProcNode*);
96 public f<Any> visitLambdaExpr(ASTLambdaExprNode*);
97 public f<Any> visitDataType(ASTDataTypeNode*);
98 public f<Any> visitBaseDataType(ASTBaseDataTypeNode*);
99 public f<Any> visitCustomDataType(ASTCustomDataTypeNode*);
100 public f<Any> visitFunctionDataType(ASTFunctionDataTypeNode*);
101 }
102
103 // ─── default methods ──────────────────────────────────────────────────────────
104
105 // Typed double-dispatch entry point. The runtime type of node determines which accept() override fires, which in turn
106 // calls the appropriate visit method of the concrete visitor.
107 3761487 #[ignoreUnusedReturnValue]
108 3761487 public f<Any> IAbstractAstVisitor.visit(IVisitable* node) {
109 3761487 return node.accept(this);
110 }
111
112 // Depth-first structural traversal. Visitors can override this to customize the traversal of all default visit methods.
113 3457009 #[ignoreUnusedReturnValue]
114 3457009 public f<Any> IAbstractAstVisitor.visitChildren(ASTNode* node) {
115
2/2
✓ Branch 0 taken 3320831 times.
✓ Branch 1 taken 3457009 times.
 6777840 foreach ASTNode* child : node.children {
116 3320831 assert child != nil<ASTNode*>;
117 3320831 assert child.visitable != nil<IVisitable*>;
118 3320831 const Any _ = child.visitable.accept(this);
119 3320831 }
120 3457009 return Any();
121 }
122
123 3699 public f<Any> IAbstractAstVisitor.visitEntry(ASTEntryNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
124 760 public f<Any> IAbstractAstVisitor.visitMainFctDef(ASTMainFctDefNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
125 ✗ public f<Any> IAbstractAstVisitor.visitFctDef(ASTFctDefNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
126 ✗ public f<Any> IAbstractAstVisitor.visitProcDef(ASTProcDefNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
127 46167 public f<Any> IAbstractAstVisitor.visitFctName(ASTFctNameNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
128 ✗ public f<Any> IAbstractAstVisitor.visitStructDef(ASTStructDefNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
129 ✗ public f<Any> IAbstractAstVisitor.visitInterfaceDef(ASTInterfaceDefNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
130 ✗ public f<Any> IAbstractAstVisitor.visitUnionDef(ASTUnionDefNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
131 ✗ public f<Any> IAbstractAstVisitor.visitEnumDef(ASTEnumDefNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
132 3104 public f<Any> IAbstractAstVisitor.visitGenericTypeDef(ASTGenericTypeDefNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
133 ✗ public f<Any> IAbstractAstVisitor.visitAliasDef(ASTAliasDefNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
134 ✗ public f<Any> IAbstractAstVisitor.visitGlobalVarDef(ASTGlobalVarDefNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
135 5426 public f<Any> IAbstractAstVisitor.visitExtDecl(ASTExtDeclNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
136 7394 public f<Any> IAbstractAstVisitor.visitImportDef(ASTImportDefNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
137 12737 public f<Any> IAbstractAstVisitor.visitUnsafeBlock(ASTUnsafeBlockNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
138 4333 public f<Any> IAbstractAstVisitor.visitForLoop(ASTForLoopNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
139 431 public f<Any> IAbstractAstVisitor.visitForeachLoop(ASTForeachLoopNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
140 1830 public f<Any> IAbstractAstVisitor.visitWhileLoop(ASTWhileLoopNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
141 49 public f<Any> IAbstractAstVisitor.visitDoWhileLoop(ASTDoWhileLoopNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
142 25370 public f<Any> IAbstractAstVisitor.visitIfStmt(ASTIfStmtNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
143 1472 public f<Any> IAbstractAstVisitor.visitElseStmt(ASTElseStmtNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
144 71 public f<Any> IAbstractAstVisitor.visitSwitchStmt(ASTSwitchStmtNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
145 198 public f<Any> IAbstractAstVisitor.visitCaseBranch(ASTCaseBranchNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
146 21 public f<Any> IAbstractAstVisitor.visitDefaultBranch(ASTDefaultBranchNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
147 126 public f<Any> IAbstractAstVisitor.visitAnonymousBlockStmt(ASTAnonymousBlockStmtNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
148 93034 public f<Any> IAbstractAstVisitor.visitStmtLst(ASTStmtLstNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
149 39029 public f<Any> IAbstractAstVisitor.visitTypeLst(ASTTypeLstNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
150 5355 public f<Any> IAbstractAstVisitor.visitTypeLstWithEllipsis(ASTTypeLstWithEllipsisNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
151 3104 public f<Any> IAbstractAstVisitor.visitTypeAltsLst(ASTTypeAltsLstNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
152 33487 public f<Any> IAbstractAstVisitor.visitParamLst(ASTParamLstNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
153 124437 public f<Any> IAbstractAstVisitor.visitArgLst(ASTArgLstNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
154 443 public f<Any> IAbstractAstVisitor.visitEnumItemLst(ASTEnumItemLstNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
155 1719 public f<Any> IAbstractAstVisitor.visitEnumItem(ASTEnumItemNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
156 7762 public f<Any> IAbstractAstVisitor.visitField(ASTFieldNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
157 2 public f<Any> IAbstractAstVisitor.visitSignature(ASTSignatureNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
158 24 public f<Any> IAbstractAstVisitor.visitDeclStmt(ASTDeclStmtNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
159 251445 public f<Any> IAbstractAstVisitor.visitExprStmt(ASTExprStmtNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
160 141069 public f<Any> IAbstractAstVisitor.visitQualifierLst(ASTQualifierLstNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
161 166360 public f<Any> IAbstractAstVisitor.visitQualifier(ASTQualifierNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
162 6219 public f<Any> IAbstractAstVisitor.visitModAttr(ASTModAttrNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
163 3076 public f<Any> IAbstractAstVisitor.visitTopLevelDefinitionAttr(ASTTopLevelDefAttrNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
164 21 public f<Any> IAbstractAstVisitor.visitLambdaAttr(ASTLambdaAttrNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
165 10855 public f<Any> IAbstractAstVisitor.visitAttrLst(ASTAttrLstNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
166 9098 public f<Any> IAbstractAstVisitor.visitAttr(ASTAttrNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
167 203 public f<Any> IAbstractAstVisitor.visitCaseConstant(ASTCaseConstantNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
168 80639 public f<Any> IAbstractAstVisitor.visitReturnStmt(ASTReturnStmtNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
169 1458 public f<Any> IAbstractAstVisitor.visitBreakStmt(ASTBreakStmtNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
170 1496 public f<Any> IAbstractAstVisitor.visitContinueStmt(ASTContinueStmtNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
171 26 public f<Any> IAbstractAstVisitor.visitFallthroughStmt(ASTFallthroughStmtNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
172 8168 public f<Any> IAbstractAstVisitor.visitAssertStmt(ASTAssertStmtNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
173 60528 public f<Any> IAbstractAstVisitor.visitAssignExpr(ASTAssignExprNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
174 2810 public f<Any> IAbstractAstVisitor.visitTernaryExpr(ASTTernaryExprNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
175 3902 public f<Any> IAbstractAstVisitor.visitLogicalOrExpr(ASTLogicalOrExprNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
176 2121 public f<Any> IAbstractAstVisitor.visitLogicalAndExpr(ASTLogicalAndExprNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
177 997 public f<Any> IAbstractAstVisitor.visitBitwiseOrExpr(ASTBitwiseOrExprNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
178 151 public f<Any> IAbstractAstVisitor.visitBitwiseXorExpr(ASTBitwiseXorExprNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
179 533 public f<Any> IAbstractAstVisitor.visitBitwiseAndExpr(ASTBitwiseAndExprNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
180 54604 public f<Any> IAbstractAstVisitor.visitEqualityExpr(ASTEqualityExprNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
181 32396 public f<Any> IAbstractAstVisitor.visitRelationalExpr(ASTRelationalExprNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
182 1224 public f<Any> IAbstractAstVisitor.visitShiftExpr(ASTShiftExprNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
183 29461 public f<Any> IAbstractAstVisitor.visitAdditiveExpr(ASTAdditiveExprNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
184 6674 public f<Any> IAbstractAstVisitor.visitMultiplicativeExpr(ASTMultiplicativeExprNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
185 25063 public f<Any> IAbstractAstVisitor.visitCastExpr(ASTCastExprNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
186 14342 public f<Any> IAbstractAstVisitor.visitPrefixUnaryExpr(ASTPrefixUnaryExprNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
187 210119 public f<Any> IAbstractAstVisitor.visitPostfixUnaryExpr(ASTPostfixUnaryExprNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
188 396230 public f<Any> IAbstractAstVisitor.visitAtomicExpr(ASTAtomicExprNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
189 183834 public f<Any> IAbstractAstVisitor.visitValue(ASTValueNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
190 152509 public f<Any> IAbstractAstVisitor.visitConstant(ASTConstantNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
191 80938 public f<Any> IAbstractAstVisitor.visitFctCall(ASTFctCallNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
192 340 public f<Any> IAbstractAstVisitor.visitArrayInitialization(ASTArrayInitializationNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
193 1538 public f<Any> IAbstractAstVisitor.visitStructInstantiation(ASTStructInstantiationNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
194 ✗ public f<Any> IAbstractAstVisitor.visitLambdaFunc(ASTLambdaFuncNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
195 ✗ public f<Any> IAbstractAstVisitor.visitLambdaProc(ASTLambdaProcNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
196 ✗ public f<Any> IAbstractAstVisitor.visitLambdaExpr(ASTLambdaExprNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
197 230549 public f<Any> IAbstractAstVisitor.visitDataType(ASTDataTypeNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
198 230549 public f<Any> IAbstractAstVisitor.visitBaseDataType(ASTBaseDataTypeNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
199 83995 public f<Any> IAbstractAstVisitor.visitCustomDataType(ASTCustomDataTypeNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
200 794 public f<Any> IAbstractAstVisitor.visitFunctionDataType(ASTFunctionDataTypeNode* node) { return this.visitChildren(cast<ASTNode*>(node)); }
201