25918451630

Committed 15 May 2026 12:43PM UTC coverage: 60.929% (+2.1%) from 58.859%

Build # 25918451630

Build Type

push

github

Committed by

turleypol

Commit Message

added dynamic property which returns a pointer of the object instead of
a copy like the current imp.
needed to be able to eg store a vector

Coverage Stats

43 of 61 new or added lines in 2 files covered. (70.49%)

14455 existing lines in 345 files now uncovered.

44695 of 73356 relevant lines covered (60.93%)

449621.59 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.98

/pol-core/bscript/compiler/ast/NodeVisitor.cpp

#include "NodeVisitor.h"

#include "bscript/compiler/ast/Argument.h"
#include "bscript/compiler/ast/ArrayInitializer.h"
#include "bscript/compiler/ast/BasicForLoop.h"
#include "bscript/compiler/ast/BinaryOperator.h"
#include "bscript/compiler/ast/BinaryOperatorShortCircuit.h"
#include "bscript/compiler/ast/BindingStatement.h"
#include "bscript/compiler/ast/Block.h"
#include "bscript/compiler/ast/BooleanValue.h"
#include "bscript/compiler/ast/BranchSelector.h"
#include "bscript/compiler/ast/CaseDispatchDefaultSelector.h"
#include "bscript/compiler/ast/CaseDispatchGroup.h"
#include "bscript/compiler/ast/CaseDispatchGroups.h"
#include "bscript/compiler/ast/CaseDispatchSelectors.h"
#include "bscript/compiler/ast/CaseStatement.h"
#include "bscript/compiler/ast/ClassBody.h"
#include "bscript/compiler/ast/ClassDeclaration.h"
#include "bscript/compiler/ast/ClassInstance.h"
#include "bscript/compiler/ast/ClassParameterDeclaration.h"
#include "bscript/compiler/ast/ClassParameterList.h"
#include "bscript/compiler/ast/ConditionalOperator.h"
#include "bscript/compiler/ast/ConstDeclaration.h"
#include "bscript/compiler/ast/ConstantPredicateLoop.h"
#include "bscript/compiler/ast/CstyleForLoop.h"
#include "bscript/compiler/ast/DebugStatementMarker.h"
#include "bscript/compiler/ast/DictionaryEntry.h"
#include "bscript/compiler/ast/DictionaryInitializer.h"
#include "bscript/compiler/ast/DoWhileLoop.h"
#include "bscript/compiler/ast/ElementAccess.h"
#include "bscript/compiler/ast/ElementAssignment.h"
#include "bscript/compiler/ast/ElementIndexes.h"
#include "bscript/compiler/ast/ElvisOperator.h"
#include "bscript/compiler/ast/EmptyStatement.h"
#include "bscript/compiler/ast/EnumDeclaration.h"
#include "bscript/compiler/ast/ErrorInitializer.h"
#include "bscript/compiler/ast/ExitStatement.h"
#include "bscript/compiler/ast/FloatValue.h"
#include "bscript/compiler/ast/ForeachLoop.h"
#include "bscript/compiler/ast/FormatExpression.h"
#include "bscript/compiler/ast/FunctionBody.h"
#include "bscript/compiler/ast/FunctionCall.h"
#include "bscript/compiler/ast/FunctionExpression.h"
#include "bscript/compiler/ast/FunctionParameterDeclaration.h"
#include "bscript/compiler/ast/FunctionParameterList.h"
#include "bscript/compiler/ast/GeneratedFunction.h"
#include "bscript/compiler/ast/IfThenElseStatement.h"
#include "bscript/compiler/ast/IndexBinding.h"
#include "bscript/compiler/ast/InterpolateString.h"
#include "bscript/compiler/ast/JumpStatement.h"
#include "bscript/compiler/ast/MemberAccess.h"
#include "bscript/compiler/ast/MemberAssignment.h"
#include "bscript/compiler/ast/MemberAssignmentByOperator.h"
#include "bscript/compiler/ast/MethodCall.h"
#include "bscript/compiler/ast/MethodCallArgumentList.h"
#include "bscript/compiler/ast/ModuleFunctionDeclaration.h"
#include "bscript/compiler/ast/Node.h"
#include "bscript/compiler/ast/Program.h"
#include "bscript/compiler/ast/ProgramParameterDeclaration.h"
#include "bscript/compiler/ast/ProgramParameterList.h"
#include "bscript/compiler/ast/RegularExpressionValue.h"
#include "bscript/compiler/ast/RepeatUntilLoop.h"
#include "bscript/compiler/ast/ReturnStatement.h"
#include "bscript/compiler/ast/SequenceBinding.h"
#include "bscript/compiler/ast/SpreadElement.h"
#include "bscript/compiler/ast/StringValue.h"
#include "bscript/compiler/ast/StructInitializer.h"
#include "bscript/compiler/ast/StructMemberInitializer.h"
#include "bscript/compiler/ast/TopLevelStatements.h"
#include "bscript/compiler/ast/UnaryOperator.h"
#include "bscript/compiler/ast/UninitializedFunctionDeclaration.h"
#include "bscript/compiler/ast/UserFunction.h"
#include "bscript/compiler/ast/ValueConsumer.h"
#include "bscript/compiler/ast/VarStatement.h"
#include "bscript/compiler/ast/VariableAssignmentStatement.h"
#include "bscript/compiler/ast/VariableBinding.h"
#include "bscript/compiler/ast/WhileLoop.h"

namespace Pol::Bscript::Compiler
{
void NodeVisitor::visit_argument( Argument& node )
{
  visit_children( node );
}

void NodeVisitor::visit_array_initializer( ArrayInitializer& node )
{
  visit_children( node );
}

void NodeVisitor::visit_basic_for_loop( BasicForLoop& node )
{
  visit_children( node );
}

void NodeVisitor::visit_binary_operator( BinaryOperator& node )
{
  visit_children( node );
}

void NodeVisitor::visit_binding_statement( BindingStatement& node )
{
  visit_children( node );
}

void NodeVisitor::visit_block( Block& node )
{
  visit_children( node );
}

void NodeVisitor::visit_boolean_value( BooleanValue& node )
{
  visit_children( node );
}

void NodeVisitor::visit_branch_selector( BranchSelector& node )
{
  visit_children( node );
}

void NodeVisitor::visit_case_statement( CaseStatement& node )
{
  visit_children( node );
}

void NodeVisitor::visit_case_dispatch_default_selector( CaseDispatchDefaultSelector& node )
{
  visit_children( node );
}

void NodeVisitor::visit_case_dispatch_group( CaseDispatchGroup& node )
{
  visit_children( node );
}

void NodeVisitor::visit_case_dispatch_groups( CaseDispatchGroups& node )
{
  visit_children( node );
}

void NodeVisitor::visit_case_dispatch_selectors( CaseDispatchSelectors& node )
{
  visit_children( node );
}

void NodeVisitor::visit_const_declaration( ConstDeclaration& node )
{
  visit_children( node );
}

void NodeVisitor::visit_cstyle_for_loop( CstyleForLoop& node )
{
  visit_children( node );
}

void NodeVisitor::visit_class_body( ClassBody& node )
{
  visit_children( node );
}
void NodeVisitor::visit_class_declaration( ClassDeclaration& node )
{
  visit_children( node );
}

void NodeVisitor::visit_class_instance( ClassInstance& node )
{
  visit_children( node );
}

void NodeVisitor::visit_class_parameter_declaration( ClassParameterDeclaration& node )
{
  visit_children( node );
}

void NodeVisitor::visit_class_parameter_list( ClassParameterList& node )
{
  visit_children( node );
}

void NodeVisitor::visit_debug_statement_marker( DebugStatementMarker& node )
{
  visit_children( node );
}

void NodeVisitor::visit_dictionary_entry( DictionaryEntry& node )
{
  visit_children( node );
}

void NodeVisitor::visit_dictionary_initializer( DictionaryInitializer& node )
{
  visit_children( node );
}

void NodeVisitor::visit_do_while_loop( DoWhileLoop& node )
{
  visit_children( node );
}

void NodeVisitor::visit_element_access( ElementAccess& node )
{
  visit_children( node );
}

void NodeVisitor::visit_element_assignment( ElementAssignment& node )
{
  visit_children( node );
}

void NodeVisitor::visit_element_indexes( ElementIndexes& node )
{
  visit_children( node );
}

void NodeVisitor::visit_elvis_operator( ElvisOperator& node )
{
  visit_children( node );
}

void NodeVisitor::visit_empty_statement( EmptyStatement& node )
{
  visit_children( node );
}

void NodeVisitor::visit_enum_declaration( EnumDeclaration& node )
{
  visit_children( node );
}

void NodeVisitor::visit_error_initializer( ErrorInitializer& node )
{
  visit_children( node );
}

void NodeVisitor::visit_exit_statement( ExitStatement& ) {}

void NodeVisitor::visit_float_value( FloatValue& ) {}

void NodeVisitor::visit_foreach_loop( ForeachLoop& node )
{
  visit_children( node );
}

void NodeVisitor::visit_function_body( FunctionBody& node )
{
  visit_children( node );
}

void NodeVisitor::visit_function_call( FunctionCall& node )
{
  visit_children( node );
}

void NodeVisitor::visit_function_parameter_declaration( FunctionParameterDeclaration& node )
{
  visit_children( node );
}

void NodeVisitor::visit_function_parameter_list( FunctionParameterList& node )
{
  visit_children( node );
}

void NodeVisitor::visit_function_expression( FunctionExpression& node )
{
  visit_children( node );
}

void NodeVisitor::visit_function_reference( FunctionReference& ) {}

void NodeVisitor::visit_identifier( Identifier& ) {}

void NodeVisitor::visit_if_then_else_statement( IfThenElseStatement& node )
{
  visit_children( node );
}

void NodeVisitor::visit_index_binding( IndexBinding& node )
{
  visit_children( node );
}

void NodeVisitor::visit_integer_value( IntegerValue& ) {}

void NodeVisitor::visit_jump_statement( JumpStatement& node )
{
  visit_children( node );
}

void NodeVisitor::visit_member_access( MemberAccess& node )
{
  visit_children( node );
}

void NodeVisitor::visit_sequence_binding( SequenceBinding& node )
{
  visit_children( node );
}

void NodeVisitor::visit_member_assignment( MemberAssignment& node )
{
  visit_children( node );
}

void NodeVisitor::visit_member_assignment_by_operator( MemberAssignmentByOperator& node )
{
  visit_children( node );
}

void NodeVisitor::visit_method_call( MethodCall& node )
{
  visit_children( node );
}

void NodeVisitor::visit_method_call_argument_list( MethodCallArgumentList& node )
{
  visit_children( node );
}

void NodeVisitor::visit_module_function_declaration( ModuleFunctionDeclaration& node )
{
  visit_children( node );
}

void NodeVisitor::visit_program( Program& node )
{
  visit_children( node );
}

void NodeVisitor::visit_program_parameter_declaration( ProgramParameterDeclaration& node )
{
  visit_children( node );
}

void NodeVisitor::visit_program_parameter_list( ProgramParameterList& node )
{
  visit_children( node );
}

void NodeVisitor::visit_regular_expression_value( RegularExpressionValue& node )
{
  visit_children( node );
}

void NodeVisitor::visit_repeat_until_loop( RepeatUntilLoop& node )
{
  visit_children( node );
}

void NodeVisitor::visit_return_statement( ReturnStatement& node )
{
  visit_children( node );
}

void NodeVisitor::visit_spread_element( SpreadElement& node )
{
  visit_children( node );
}

void NodeVisitor::visit_string_value( StringValue& ) {}

void NodeVisitor::visit_interpolate_string( InterpolateString& node )
{
  visit_children( node );
}

void NodeVisitor::visit_format_expression( FormatExpression& node )
{
  visit_children( node );
}

void NodeVisitor::visit_struct_initializer( StructInitializer& node )
{
  visit_children( node );
}

void NodeVisitor::visit_struct_member_initializer( StructMemberInitializer& node )
{
  visit_children( node );
}

void NodeVisitor::visit_generated_function( GeneratedFunction& node )
{
  visit_children( node );
}

void NodeVisitor::visit_top_level_statements( TopLevelStatements& node )
{
  visit_children( node );
}

void NodeVisitor::visit_unary_operator( UnaryOperator& node )
{
  visit_children( node );
}

void NodeVisitor::visit_uninitialized_function_declaration( UninitializedFunctionDeclaration& node )
{
  visit_children( node );
}

void NodeVisitor::visit_uninitialized_value( UninitializedValue& ) {}

void NodeVisitor::visit_user_function( UserFunction& node )
{
  visit_children( node );
}

void NodeVisitor::visit_value_consumer( ValueConsumer& node )
{
  visit_children( node );
}

void NodeVisitor::visit_var_statement( VarStatement& node )
{
  visit_children( node );
}

void NodeVisitor::visit_variable_assignment_statement( VariableAssignmentStatement& node )
{
  visit_children( node );
}

void NodeVisitor::visit_variable_binding( VariableBinding& node )
{
  visit_children( node );
}

void NodeVisitor::visit_while_loop( WhileLoop& node )
{
  visit_children( node );
}

void NodeVisitor::visit_conditional_operator( ConditionalOperator& node )
{
  visit_children( node );
}

void NodeVisitor::visit_constant_loop( ConstantPredicateLoop& node )
{
  visit_children( node );
}

void NodeVisitor::visit_binary_operator_short_circuit( BinaryOperatorShortCircuit& node )
{
  visit_children( node );
}

void NodeVisitor::visit_children( Node& parent )
{
  for ( const auto& child : parent.children )
  {
    child->accept( *this );
  }
}

}  // namespace Pol::Bscript::Compiler

1	#include "NodeVisitor.h"
2
3	#include "bscript/compiler/ast/Argument.h"
4	#include "bscript/compiler/ast/ArrayInitializer.h"
5	#include "bscript/compiler/ast/BasicForLoop.h"
6	#include "bscript/compiler/ast/BinaryOperator.h"
7	#include "bscript/compiler/ast/BinaryOperatorShortCircuit.h"
8	#include "bscript/compiler/ast/BindingStatement.h"
9	#include "bscript/compiler/ast/Block.h"
10	#include "bscript/compiler/ast/BooleanValue.h"
11	#include "bscript/compiler/ast/BranchSelector.h"
12	#include "bscript/compiler/ast/CaseDispatchDefaultSelector.h"
13	#include "bscript/compiler/ast/CaseDispatchGroup.h"
14	#include "bscript/compiler/ast/CaseDispatchGroups.h"
15	#include "bscript/compiler/ast/CaseDispatchSelectors.h"
16	#include "bscript/compiler/ast/CaseStatement.h"
17	#include "bscript/compiler/ast/ClassBody.h"
18	#include "bscript/compiler/ast/ClassDeclaration.h"
19	#include "bscript/compiler/ast/ClassInstance.h"
20	#include "bscript/compiler/ast/ClassParameterDeclaration.h"
21	#include "bscript/compiler/ast/ClassParameterList.h"
22	#include "bscript/compiler/ast/ConditionalOperator.h"
23	#include "bscript/compiler/ast/ConstDeclaration.h"
24	#include "bscript/compiler/ast/ConstantPredicateLoop.h"
25	#include "bscript/compiler/ast/CstyleForLoop.h"
26	#include "bscript/compiler/ast/DebugStatementMarker.h"
27	#include "bscript/compiler/ast/DictionaryEntry.h"
28	#include "bscript/compiler/ast/DictionaryInitializer.h"
29	#include "bscript/compiler/ast/DoWhileLoop.h"
30	#include "bscript/compiler/ast/ElementAccess.h"
31	#include "bscript/compiler/ast/ElementAssignment.h"
32	#include "bscript/compiler/ast/ElementIndexes.h"
33	#include "bscript/compiler/ast/ElvisOperator.h"
34	#include "bscript/compiler/ast/EmptyStatement.h"
35	#include "bscript/compiler/ast/EnumDeclaration.h"
36	#include "bscript/compiler/ast/ErrorInitializer.h"
37	#include "bscript/compiler/ast/ExitStatement.h"
38	#include "bscript/compiler/ast/FloatValue.h"
39	#include "bscript/compiler/ast/ForeachLoop.h"
40	#include "bscript/compiler/ast/FormatExpression.h"
41	#include "bscript/compiler/ast/FunctionBody.h"
42	#include "bscript/compiler/ast/FunctionCall.h"
43	#include "bscript/compiler/ast/FunctionExpression.h"
44	#include "bscript/compiler/ast/FunctionParameterDeclaration.h"
45	#include "bscript/compiler/ast/FunctionParameterList.h"
46	#include "bscript/compiler/ast/GeneratedFunction.h"
47	#include "bscript/compiler/ast/IfThenElseStatement.h"
48	#include "bscript/compiler/ast/IndexBinding.h"
49	#include "bscript/compiler/ast/InterpolateString.h"
50	#include "bscript/compiler/ast/JumpStatement.h"
51	#include "bscript/compiler/ast/MemberAccess.h"
52	#include "bscript/compiler/ast/MemberAssignment.h"
53	#include "bscript/compiler/ast/MemberAssignmentByOperator.h"
54	#include "bscript/compiler/ast/MethodCall.h"
55	#include "bscript/compiler/ast/MethodCallArgumentList.h"
56	#include "bscript/compiler/ast/ModuleFunctionDeclaration.h"
57	#include "bscript/compiler/ast/Node.h"
58	#include "bscript/compiler/ast/Program.h"
59	#include "bscript/compiler/ast/ProgramParameterDeclaration.h"
60	#include "bscript/compiler/ast/ProgramParameterList.h"
61	#include "bscript/compiler/ast/RegularExpressionValue.h"
62	#include "bscript/compiler/ast/RepeatUntilLoop.h"
63	#include "bscript/compiler/ast/ReturnStatement.h"
64	#include "bscript/compiler/ast/SequenceBinding.h"
65	#include "bscript/compiler/ast/SpreadElement.h"
66	#include "bscript/compiler/ast/StringValue.h"
67	#include "bscript/compiler/ast/StructInitializer.h"
68	#include "bscript/compiler/ast/StructMemberInitializer.h"
69	#include "bscript/compiler/ast/TopLevelStatements.h"
70	#include "bscript/compiler/ast/UnaryOperator.h"
71	#include "bscript/compiler/ast/UninitializedFunctionDeclaration.h"
72	#include "bscript/compiler/ast/UserFunction.h"
73	#include "bscript/compiler/ast/ValueConsumer.h"
74	#include "bscript/compiler/ast/VarStatement.h"
75	#include "bscript/compiler/ast/VariableAssignmentStatement.h"
76	#include "bscript/compiler/ast/VariableBinding.h"
77	#include "bscript/compiler/ast/WhileLoop.h"
78
79	namespace Pol::Bscript::Compiler
80	{
81	void NodeVisitor::visit_argument( Argument& node )	76,767✔
82	{
83	visit_children( node );	76,767✔
84	}	76,767✔
85
86	void NodeVisitor::visit_array_initializer( ArrayInitializer& node )	10,346✔
87	{
88	visit_children( node );	10,346✔
89	}	10,346✔
90
91	void NodeVisitor::visit_basic_for_loop( BasicForLoop& node )	290✔
92	{
93	visit_children( node );	290✔
94	}	290✔
95
96	void NodeVisitor::visit_binary_operator( BinaryOperator& node )	27,694✔
97	{
98	visit_children( node );	27,694✔
99	}	27,694✔
100
101	void NodeVisitor::visit_binding_statement( BindingStatement& node )	844✔
102	{
103	visit_children( node );	844✔
104	}	844✔
105
106	void NodeVisitor::visit_block( Block& node )	19,959✔
107	{
108	visit_children( node );	19,959✔
109	}	19,959✔
110
111	void NodeVisitor::visit_boolean_value( BooleanValue& node )	1,454✔
112	{
113	visit_children( node );	1,454✔
114	}	1,454✔
115
116	void NodeVisitor::visit_branch_selector( BranchSelector& node )	12,742✔
117	{
118	visit_children( node );	12,742✔
119	}	12,742✔
120
121	void NodeVisitor::visit_case_statement( CaseStatement& node )	360✔
122	{
123	visit_children( node );	360✔
124	}	360✔
125
126	void NodeVisitor::visit_case_dispatch_default_selector( CaseDispatchDefaultSelector& node )	328✔
127	{
128	visit_children( node );	328✔
129	}	328✔
130
131	void NodeVisitor::visit_case_dispatch_group( CaseDispatchGroup& node )	1,134✔
132	{
133	visit_children( node );	1,134✔
134	}	1,134✔
135
136	void NodeVisitor::visit_case_dispatch_groups( CaseDispatchGroups& node )	470✔
137	{
138	visit_children( node );	470✔
139	}	470✔
140
141	void NodeVisitor::visit_case_dispatch_selectors( CaseDispatchSelectors& node )	2,160✔
142	{
143	visit_children( node );	2,160✔
144	}	2,160✔
145
146	void NodeVisitor::visit_const_declaration( ConstDeclaration& node )	544✔
147	{
148	visit_children( node );	544✔
149	}	544✔
150
151	void NodeVisitor::visit_cstyle_for_loop( CstyleForLoop& node )	228✔
152	{
153	visit_children( node );	228✔
154	}	228✔
155
156	void NodeVisitor::visit_class_body( ClassBody& node )	4,274✔
157	{
158	visit_children( node );	4,274✔
159	}	4,274✔
160	void NodeVisitor::visit_class_declaration( ClassDeclaration& node )	1,370✔
161	{
162	visit_children( node );	1,370✔
163	}	1,370✔
164
165	void NodeVisitor::visit_class_instance( ClassInstance& node )	382✔
166	{
167	visit_children( node );	382✔
168	}	382✔
169
170	void NodeVisitor::visit_class_parameter_declaration( ClassParameterDeclaration& node )	874✔
171	{
172	visit_children( node );	874✔
173	}	874✔
174
175	void NodeVisitor::visit_class_parameter_list( ClassParameterList& node )	2,049✔
176	{
177	visit_children( node );	2,049✔
178	}	2,049✔
179
UNCOV 180	void NodeVisitor::visit_debug_statement_marker( DebugStatementMarker& node )	×
181	{
UNCOV 182	visit_children( node );	×
UNCOV 183	}	×
184
185	void NodeVisitor::visit_dictionary_entry( DictionaryEntry& node )	660✔
186	{
187	visit_children( node );	660✔
188	}	660✔
189
190	void NodeVisitor::visit_dictionary_initializer( DictionaryInitializer& node )	744✔
191	{
192	visit_children( node );	744✔
193	}	744✔
194
195	void NodeVisitor::visit_do_while_loop( DoWhileLoop& node )	25✔
196	{
197	visit_children( node );	25✔
198	}	25✔
199
200	void NodeVisitor::visit_element_access( ElementAccess& node )	8,653✔
201	{
202	visit_children( node );	8,653✔
203	}	8,653✔
204
205	void NodeVisitor::visit_element_assignment( ElementAssignment& node )	1,901✔
206	{
207	visit_children( node );	1,901✔
208	}	1,901✔
209
210	void NodeVisitor::visit_element_indexes( ElementIndexes& node )	13,148✔
211	{
212	visit_children( node );	13,148✔
213	}	13,148✔
214
215	void NodeVisitor::visit_elvis_operator( ElvisOperator& node )	684✔
216	{
217	visit_children( node );	684✔
218	}	684✔
219
UNCOV 220	void NodeVisitor::visit_empty_statement( EmptyStatement& node )	×
221	{
UNCOV 222	visit_children( node );	×
UNCOV 223	}	×
224
225	void NodeVisitor::visit_enum_declaration( EnumDeclaration& node )	244✔
226	{
227	visit_children( node );	244✔
228	}	244✔
229
230	void NodeVisitor::visit_error_initializer( ErrorInitializer& node )	1,197✔
231	{
232	visit_children( node );	1,197✔
233	}	1,197✔
234
235	void NodeVisitor::visit_exit_statement( ExitStatement& ) {}	78✔
236
237	void NodeVisitor::visit_float_value( FloatValue& ) {}	2,264✔
238
239	void NodeVisitor::visit_foreach_loop( ForeachLoop& node )	1,555✔
240	{
241	visit_children( node );	1,555✔
242	}	1,555✔
243
244	void NodeVisitor::visit_function_body( FunctionBody& node )	20,802✔
245	{
246	visit_children( node );	20,802✔
247	}	20,802✔
248
249	void NodeVisitor::visit_function_call( FunctionCall& node )	55,993✔
250	{
251	visit_children( node );	55,993✔
252	}	55,993✔
253
254	void NodeVisitor::visit_function_parameter_declaration( FunctionParameterDeclaration& node )	296,003✔
255	{
256	visit_children( node );	296,003✔
257	}	296,003✔
258
259	void NodeVisitor::visit_function_parameter_list( FunctionParameterList& node )	138,100✔
260	{
261	visit_children( node );	138,100✔
262	}	138,100✔
263
264	void NodeVisitor::visit_function_expression( FunctionExpression& node )	1,656✔
265	{
266	visit_children( node );	1,656✔
267	}	1,656✔
268
269	void NodeVisitor::visit_function_reference( FunctionReference& ) {}	1,760✔
270
271	void NodeVisitor::visit_identifier( Identifier& ) {}	78,590✔
272
273	void NodeVisitor::visit_if_then_else_statement( IfThenElseStatement& node )	12,742✔
274	{
275	visit_children( node );	12,742✔
276	}	12,742✔
277
278	void NodeVisitor::visit_index_binding( IndexBinding& node )	302✔
279	{
280	visit_children( node );	302✔
281	}	302✔
282
283	void NodeVisitor::visit_integer_value( IntegerValue& ) {}	266,676✔
284
285	void NodeVisitor::visit_jump_statement( JumpStatement& node )	2,040✔
286	{
287	visit_children( node );	2,040✔
288	}	2,040✔
289
290	void NodeVisitor::visit_member_access( MemberAccess& node )	19,895✔
291	{
292	visit_children( node );	19,895✔
293	}	19,895✔
294
295	void NodeVisitor::visit_sequence_binding( SequenceBinding& node )	366✔
296	{
297	visit_children( node );	366✔
298	}	366✔
299
300	void NodeVisitor::visit_member_assignment( MemberAssignment& node )	2,384✔
301	{
302	visit_children( node );	2,384✔
303	}	2,384✔
304
305	void NodeVisitor::visit_member_assignment_by_operator( MemberAssignmentByOperator& node )	252✔
306	{
307	visit_children( node );	252✔
308	}	252✔
309
310	void NodeVisitor::visit_method_call( MethodCall& node )	18,411✔
311	{
312	visit_children( node );	18,411✔
313	}	18,411✔
314
315	void NodeVisitor::visit_method_call_argument_list( MethodCallArgumentList& node )	20,849✔
316	{
317	visit_children( node );	20,849✔
318	}	20,849✔
319
320	void NodeVisitor::visit_module_function_declaration( ModuleFunctionDeclaration& node )	126,747✔
321	{
322	visit_children( node );	126,747✔
323	}	126,747✔
324
325	void NodeVisitor::visit_program( Program& node )	1,435✔
326	{
327	visit_children( node );	1,435✔
328	}	1,435✔
329
330	void NodeVisitor::visit_program_parameter_declaration( ProgramParameterDeclaration& node )	638✔
331	{
332	visit_children( node );	638✔
333	}	638✔
334
335	void NodeVisitor::visit_program_parameter_list( ProgramParameterList& node )	2,337✔
336	{
337	visit_children( node );	2,337✔
338	}	2,337✔
339
340	void NodeVisitor::visit_regular_expression_value( RegularExpressionValue& node )	656✔
341	{
342	visit_children( node );	656✔
343	}	656✔
344
345	void NodeVisitor::visit_repeat_until_loop( RepeatUntilLoop& node )	88✔
346	{
347	visit_children( node );	88✔
348	}	88✔
349
350	void NodeVisitor::visit_return_statement( ReturnStatement& node )	15,699✔
351	{
352	visit_children( node );	15,699✔
353	}	15,699✔
354
355	void NodeVisitor::visit_spread_element( SpreadElement& node )	2,933✔
356	{
357	visit_children( node );	2,933✔
358	}	2,933✔
359
360	void NodeVisitor::visit_string_value( StringValue& ) {}	119,892✔
361
362	void NodeVisitor::visit_interpolate_string( InterpolateString& node )	10,245✔
363	{
364	visit_children( node );	10,245✔
365	}	10,245✔
366
367	void NodeVisitor::visit_format_expression( FormatExpression& node )	442✔
368	{
369	visit_children( node );	442✔
370	}	442✔
371
372	void NodeVisitor::visit_struct_initializer( StructInitializer& node )	3,803✔
373	{
374	visit_children( node );	3,803✔
375	}	3,803✔
376
377	void NodeVisitor::visit_struct_member_initializer( StructMemberInitializer& node )	7,851✔
378	{
379	visit_children( node );	7,851✔
380	}	7,851✔
381
UNCOV 382	void NodeVisitor::visit_generated_function( GeneratedFunction& node )	×
383	{
UNCOV 384	visit_children( node );	×
UNCOV 385	}	×
386
387	void NodeVisitor::visit_top_level_statements( TopLevelStatements& node )	12,516✔
388	{
389	visit_children( node );	12,516✔
390	}	12,516✔
391
392	void NodeVisitor::visit_unary_operator( UnaryOperator& node )	2,158✔
393	{
394	visit_children( node );	2,158✔
395	}	2,158✔
396
397	void NodeVisitor::visit_uninitialized_function_declaration( UninitializedFunctionDeclaration& node )	194✔
398	{
399	visit_children( node );	194✔
400	}	194✔
401
402	void NodeVisitor::visit_uninitialized_value( UninitializedValue& ) {}	549✔
403
404	void NodeVisitor::visit_user_function( UserFunction& node )	11,499✔
405	{
406	visit_children( node );	11,499✔
407	}	11,499✔
408
409	void NodeVisitor::visit_value_consumer( ValueConsumer& node )	47,824✔
410	{
411	visit_children( node );	47,824✔
412	}	47,824✔
413
414	void NodeVisitor::visit_var_statement( VarStatement& node )	19,329✔
415	{
416	visit_children( node );	19,329✔
417	}	19,329✔
418
419	void NodeVisitor::visit_variable_assignment_statement( VariableAssignmentStatement& node )	4,684✔
420	{
421	visit_children( node );	4,684✔
422	}	4,684✔
423
424	void NodeVisitor::visit_variable_binding( VariableBinding& node )	2,454✔
425	{
426	visit_children( node );	2,454✔
427	}	2,454✔
428
429	void NodeVisitor::visit_while_loop( WhileLoop& node )	471✔
430	{
431	visit_children( node );	471✔
432	}	471✔
433
434	void NodeVisitor::visit_conditional_operator( ConditionalOperator& node )	348✔
435	{
436	visit_children( node );	348✔
437	}	348✔
438
439	void NodeVisitor::visit_constant_loop( ConstantPredicateLoop& node )	489✔
440	{
441	visit_children( node );	489✔
442	}	489✔
443
444	void NodeVisitor::visit_binary_operator_short_circuit( BinaryOperatorShortCircuit& node )	212✔
445	{
446	visit_children( node );	212✔
447	}	212✔
448
449	void NodeVisitor::visit_children( Node& parent )	534,995✔
450	{
451	for ( const auto& child : parent.children )	1,348,396✔
452	{
453	child->accept( *this );	813,401✔
454	}
455	}	534,995✔
456
457	} // namespace Pol::Bscript::Compiler

polserver / polserver / 25918451630

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous