source: src/AST/Pass.impl.hpp@ be73f30

ADT arm-eh ast-experimental enum forall-pointer-decay jacob/cs343-translation new-ast-unique-expr pthread-emulation qualifiedEnum
Last change on this file since be73f30 was 293dc1c, checked in by Andrew Beach <ajbeach@…>, 5 years ago

TranslationUnit is now used at the top-level of the new-ast passes.
  • Property mode set to 100644
File size: 58.4 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2019 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// ast::Pass.impl.hpp --
8//
9// Author : Thierry Delisle
10// Created On : Thu May 09 15::37::05 2019
11// Last Modified By :
12// Last Modified On :
13// Update Count :
14//
15
16#pragma once
17// IWYU pragma: private, include "AST/Pass.hpp"
18
19#include <type_traits>
20#include <unordered_map>
21
22#include "AST/TranslationUnit.hpp"
23#include "AST/TypeSubstitution.hpp"
24
25#define VISIT_START( node ) \
26 using namespace ast; \
27 /* back-up the visit children */ \
28 __attribute__((unused)) ast::__pass::visit_children_guard guard1( ast::__pass::visit_children(core, 0) ); \
29 /* setup the scope for passes that want to run code at exit */ \
30 __attribute__((unused)) ast::__pass::guard_value guard2( ast::__pass::at_cleanup (core, 0) ); \
31 /* begin tracing memory allocation if requested by this pass */ \
32 __pass::beginTrace( core, 0 ); \
33 /* call the implementation of the previsit of this pass */ \
34 __pass::previsit( core, node, 0 );
35
36#define VISIT( code... ) \
37 /* if this node should visit its children */ \
38 if ( __visit_children() ) { \
39 /* visit the children */ \
40 code \
41 }
42
43#define VISIT_END( type, node ) \
44 /* call the implementation of the postvisit of this pass */ \
45 auto __return = __pass::postvisit( core, node, 0 ); \
46 assertf(__return, "post visit should never return null"); \
47 /* end tracing memory allocation if requested by this pass */ \
48 __pass::endTrace( core, 0 ); \
49 return __return;
50
51#ifdef PEDANTIC_PASS_ASSERT
52#define __pedantic_pass_assert(...) assert (__VA_ARGS__)
53#define __pedantic_pass_assertf(...) assertf(__VA_ARGS__)
54#else
55#define __pedantic_pass_assert(...)
56#define __pedantic_pass_assertf(...)
57#endif
58
59namespace ast {
60 template<typename node_t>
61 node_t * shallowCopy( const node_t * node );
62
63 namespace __pass {
64 // Check if this is either a null pointer or a pointer to an empty container
65 template<typename T>
66 static inline bool empty( T * ptr ) {
67 return !ptr || ptr->empty();
68 }
69
70 template< typename core_t, typename node_t >
71 static inline node_t* mutate(const node_t *node) {
72 return std::is_base_of<PureVisitor, core_t>::value ? ::ast::shallowCopy(node) : ::ast::mutate(node);
73 }
74
75 //------------------------------
76 template<typename it_t, template <class...> class container_t>
77 static inline void take_all( it_t it, container_t<ast::ptr<ast::Decl>> * decls, bool * mutated = nullptr ) {
78 if(empty(decls)) return;
79
80 std::transform(decls->begin(), decls->end(), it, [](const ast::Decl * decl) -> auto {
81 return new DeclStmt( decl->location, decl );
82 });
83 decls->clear();
84 if(mutated) *mutated = true;
85 }
86
87 template<typename it_t, template <class...> class container_t>
88 static inline void take_all( it_t it, container_t<ast::ptr<ast::Stmt>> * decls, bool * mutated = nullptr ) {
89 if(empty(decls)) return;
90
91 std::move(decls->begin(), decls->end(), it);
92 decls->clear();
93 if(mutated) *mutated = true;
94 }
95
96 //------------------------------
97 /// Check if should be skipped, different for pointers and containers
98 template<typename node_t>
99 bool skip( const ast::ptr<node_t> & val) {
100 return !val;
101 }
102
103 template< template <class...> class container_t, typename node_t >
104 bool skip( const container_t<ast::ptr< node_t >> & val ) {
105 return val.empty();
106 }
107
108 //------------------------------
109 /// Get the value to visit, different for pointers and containers
110 template<typename node_t>
111 auto get( const ast::ptr<node_t> & val, int ) -> decltype(val.get()) {
112 return val.get();
113 }
114
115 template<typename node_t>
116 const node_t & get( const node_t & val, long) {
117 return val;
118 }
119
120
121 //------------------------------
122 /// Check if value was mutated, different for pointers and containers
123 template<typename lhs_t, typename rhs_t>
124 bool differs( const lhs_t * old_val, const rhs_t * new_val ) {
125 return old_val != new_val;
126 }
127
128 template< template <class...> class container_t, typename node_t >
129 bool differs( const container_t<ast::ptr< node_t >> &, const container_t<ast::ptr< node_t >> & new_val ) {
130 return !new_val.empty();
131 }
132 }
133
134 template< typename core_t >
135 template< typename node_t >
136 auto ast::Pass< core_t >::call_accept( const node_t * node )
137 -> typename std::enable_if<
138 !std::is_base_of<ast::Expr, node_t>::value &&
139 !std::is_base_of<ast::Stmt, node_t>::value
140 , decltype( node->accept(*this) )
141 >::type
142 {
143 __pedantic_pass_assert( __visit_children() );
144 __pedantic_pass_assert( node );
145
146 static_assert( !std::is_base_of<ast::Expr, node_t>::value, "ERROR");
147 static_assert( !std::is_base_of<ast::Stmt, node_t>::value, "ERROR");
148
149 return node->accept( *this );
150 }
151
152 template< typename core_t >
153 const ast::Expr * ast::Pass< core_t >::call_accept( const ast::Expr * expr ) {
154 __pedantic_pass_assert( __visit_children() );
155 __pedantic_pass_assert( expr );
156
157 const ast::TypeSubstitution ** typeSubs_ptr = __pass::typeSubs( core, 0 );
158 if ( typeSubs_ptr && expr->env ) {
159 *typeSubs_ptr = expr->env;
160 }
161
162 return expr->accept( *this );
163 }
164
165 template< typename core_t >
166 const ast::Stmt * ast::Pass< core_t >::call_accept( const ast::Stmt * stmt ) {
167 __pedantic_pass_assert( __visit_children() );
168 __pedantic_pass_assert( stmt );
169
170 return stmt->accept( *this );
171 }
172
173 template< typename core_t >
174 const ast::Stmt * ast::Pass< core_t >::call_accept_as_compound( const ast::Stmt * stmt ) {
175 __pedantic_pass_assert( __visit_children() );
176 __pedantic_pass_assert( stmt );
177
178 // add a few useful symbols to the scope
179 using __pass::empty;
180
181 // get the stmts/decls that will need to be spliced in
182 auto stmts_before = __pass::stmtsToAddBefore( core, 0);
183 auto stmts_after = __pass::stmtsToAddAfter ( core, 0);
184 auto decls_before = __pass::declsToAddBefore( core, 0);
185 auto decls_after = __pass::declsToAddAfter ( core, 0);
186
187 // These may be modified by subnode but most be restored once we exit this statemnet.
188 ValueGuardPtr< const ast::TypeSubstitution * > __old_env ( __pass::typeSubs( core, 0 ) );
189 ValueGuardPtr< typename std::remove_pointer< decltype(stmts_before) >::type > __old_decls_before( stmts_before );
190 ValueGuardPtr< typename std::remove_pointer< decltype(stmts_after ) >::type > __old_decls_after ( stmts_after );
191 ValueGuardPtr< typename std::remove_pointer< decltype(decls_before) >::type > __old_stmts_before( decls_before );
192 ValueGuardPtr< typename std::remove_pointer< decltype(decls_after ) >::type > __old_stmts_after ( decls_after );
193
194 // Now is the time to actually visit the node
195 const ast::Stmt * nstmt = stmt->accept( *this );
196
197 // If the pass doesn't want to add anything then we are done
198 if( empty(stmts_before) && empty(stmts_after) && empty(decls_before) && empty(decls_after) ) {
199 return nstmt;
200 }
201
202 // Make sure that it is either adding statements or declartions but not both
203 // this is because otherwise the order would be awkward to predict
204 assert(( empty( stmts_before ) && empty( stmts_after ))
205 || ( empty( decls_before ) && empty( decls_after )) );
206
207 // Create a new Compound Statement to hold the new decls/stmts
208 ast::CompoundStmt * compound = new ast::CompoundStmt( stmt->location );
209
210 // Take all the declarations that go before
211 __pass::take_all( std::back_inserter( compound->kids ), decls_before );
212 __pass::take_all( std::back_inserter( compound->kids ), stmts_before );
213
214 // Insert the original declaration
215 compound->kids.emplace_back( nstmt );
216
217 // Insert all the declarations that go before
218 __pass::take_all( std::back_inserter( compound->kids ), decls_after );
219 __pass::take_all( std::back_inserter( compound->kids ), stmts_after );
220
221 return compound;
222 }
223
224 template< typename core_t >
225 template< template <class...> class container_t >
226 container_t< ptr<Stmt> > ast::Pass< core_t >::call_accept( const container_t< ptr<Stmt> > & statements ) {
227 __pedantic_pass_assert( __visit_children() );
228 if( statements.empty() ) return {};
229
230 // We are going to aggregate errors for all these statements
231 SemanticErrorException errors;
232
233 // add a few useful symbols to the scope
234 using __pass::empty;
235
236 // get the stmts/decls that will need to be spliced in
237 auto stmts_before = __pass::stmtsToAddBefore( core, 0);
238 auto stmts_after = __pass::stmtsToAddAfter ( core, 0);
239 auto decls_before = __pass::declsToAddBefore( core, 0);
240 auto decls_after = __pass::declsToAddAfter ( core, 0);
241
242 // These may be modified by subnode but most be restored once we exit this statemnet.
243 ValueGuardPtr< typename std::remove_pointer< decltype(stmts_before) >::type > __old_decls_before( stmts_before );
244 ValueGuardPtr< typename std::remove_pointer< decltype(stmts_after ) >::type > __old_decls_after ( stmts_after );
245 ValueGuardPtr< typename std::remove_pointer< decltype(decls_before) >::type > __old_stmts_before( decls_before );
246 ValueGuardPtr< typename std::remove_pointer< decltype(decls_after ) >::type > __old_stmts_after ( decls_after );
247
248 // update pass statitistics
249 pass_visitor_stats.depth++;
250 pass_visitor_stats.max->push(pass_visitor_stats.depth);
251 pass_visitor_stats.avg->push(pass_visitor_stats.depth);
252
253 bool mutated = false;
254 container_t< ptr<Stmt> > new_kids;
255 for( const Stmt * stmt : statements ) {
256 try {
257 __pedantic_pass_assert( stmt );
258 const ast::Stmt * new_stmt = stmt->accept( *this );
259 assert( new_stmt );
260 if(new_stmt != stmt ) mutated = true;
261
262 // Make sure that it is either adding statements or declartions but not both
263 // this is because otherwise the order would be awkward to predict
264 assert(( empty( stmts_before ) && empty( stmts_after ))
265 || ( empty( decls_before ) && empty( decls_after )) );
266
267
268
269 // Take all the statements which should have gone after, N/A for first iteration
270 __pass::take_all( std::back_inserter( new_kids ), decls_before, &mutated );
271 __pass::take_all( std::back_inserter( new_kids ), stmts_before, &mutated );
272
273 // Now add the statement if there is one
274 new_kids.emplace_back( new_stmt );
275
276 // Take all the declarations that go before
277 __pass::take_all( std::back_inserter( new_kids ), decls_after, &mutated );
278 __pass::take_all( std::back_inserter( new_kids ), stmts_after, &mutated );
279 }
280 catch ( SemanticErrorException &e ) {
281 errors.append( e );
282 }
283 }
284 pass_visitor_stats.depth--;
285 if ( !errors.isEmpty() ) { throw errors; }
286
287 return mutated ? new_kids : container_t< ptr<Stmt> >();
288 }
289
290 template< typename core_t >
291 template< template <class...> class container_t, typename node_t >
292 container_t< ast::ptr<node_t> > ast::Pass< core_t >::call_accept( const container_t< ast::ptr<node_t> > & container ) {
293 __pedantic_pass_assert( __visit_children() );
294 if( container.empty() ) return {};
295 SemanticErrorException errors;
296
297 pass_visitor_stats.depth++;
298 pass_visitor_stats.max->push(pass_visitor_stats.depth);
299 pass_visitor_stats.avg->push(pass_visitor_stats.depth);
300
301 bool mutated = false;
302 container_t< ast::ptr<node_t> > new_kids;
303 for ( const node_t * node : container ) {
304 try {
305 __pedantic_pass_assert( node );
306 const node_t * new_stmt = strict_dynamic_cast< const node_t * >( node->accept( *this ) );
307 if(new_stmt != node ) mutated = true;
308
309 new_kids.emplace_back( new_stmt );
310 }
311 catch( SemanticErrorException &e ) {
312 errors.append( e );
313 }
314 }
315 pass_visitor_stats.depth--;
316 if ( ! errors.isEmpty() ) { throw errors; }
317
318 return mutated ? new_kids : container_t< ast::ptr<node_t> >();
319 }
320
321 template< typename core_t >
322 template<typename node_t, typename parent_t, typename child_t>
323 void ast::Pass< core_t >::maybe_accept(
324 const node_t * & parent,
325 child_t parent_t::*child
326 ) {
327 static_assert( std::is_base_of<parent_t, node_t>::value, "Error deducing member object" );
328
329 if(__pass::skip(parent->*child)) return;
330 const auto & old_val = __pass::get(parent->*child, 0);
331
332 static_assert( !std::is_same<const ast::Node * &, decltype(old_val)>::value, "ERROR");
333
334 auto new_val = call_accept( old_val );
335
336 static_assert( !std::is_same<const ast::Node *, decltype(new_val)>::value || std::is_same<int, decltype(old_val)>::value, "ERROR");
337
338 if( __pass::differs(old_val, new_val) ) {
339 auto new_parent = __pass::mutate<core_t>(parent);
340 new_parent->*child = new_val;
341 parent = new_parent;
342 }
343 }
344
345 template< typename core_t >
346 template<typename node_t, typename parent_t, typename child_t>
347 void ast::Pass< core_t >::maybe_accept_as_compound(
348 const node_t * & parent,
349 child_t parent_t::*child
350 ) {
351 static_assert( std::is_base_of<parent_t, node_t>::value, "Error deducing member object" );
352
353 if(__pass::skip(parent->*child)) return;
354 const auto & old_val = __pass::get(parent->*child, 0);
355
356 static_assert( !std::is_same<const ast::Node * &, decltype(old_val)>::value, "ERROR");
357
358 auto new_val = call_accept_as_compound( old_val );
359
360 static_assert( !std::is_same<const ast::Node *, decltype(new_val)>::value || std::is_same<int, decltype(old_val)>::value, "ERROR");
361
362 if( __pass::differs(old_val, new_val) ) {
363 auto new_parent = __pass::mutate<core_t>(parent);
364 new_parent->*child = new_val;
365 parent = new_parent;
366 }
367 }
368
369
370 template< typename core_t >
371 template< typename node_t >
372 void ast::Pass< core_t >::mutate_forall( const node_t *& node ) {
373 if ( auto subs = __pass::forall::subs( core, 0 ) ) {
374 // tracking TypeDecl substitution, full clone
375 if ( node->forall.empty() ) return;
376
377 node_t * mut = __pass::mutate<core_t>( node );
378 mut->forall = subs->clone( node->forall, *this );
379 node = mut;
380 } else {
381 // not tracking TypeDecl substitution, just mutate
382 maybe_accept( node, &node_t::forall );
383 }
384 }
385}
386
387//------------------------------------------------------------------------------------------------------------------------------------------------------------------------
388//========================================================================================================================================================================
389//========================================================================================================================================================================
390//========================================================================================================================================================================
391//========================================================================================================================================================================
392//========================================================================================================================================================================
393//------------------------------------------------------------------------------------------------------------------------------------------------------------------------
394
395template< typename core_t >
396inline void ast::accept_all( std::list< ast::ptr<ast::Decl> > & decls, ast::Pass< core_t > & visitor ) {
397 // We are going to aggregate errors for all these statements
398 SemanticErrorException errors;
399
400 // add a few useful symbols to the scope
401 using __pass::empty;
402
403 // get the stmts/decls that will need to be spliced in
404 auto decls_before = __pass::declsToAddBefore( visitor.core, 0);
405 auto decls_after = __pass::declsToAddAfter ( visitor.core, 0);
406
407 // update pass statitistics
408 pass_visitor_stats.depth++;
409 pass_visitor_stats.max->push(pass_visitor_stats.depth);
410 pass_visitor_stats.avg->push(pass_visitor_stats.depth);
411
412 for ( std::list< ast::ptr<ast::Decl> >::iterator i = decls.begin(); ; ++i ) {
413 // splice in new declarations after previous decl
414 if ( !empty( decls_after ) ) { decls.splice( i, *decls_after ); }
415
416 if ( i == decls.end() ) break;
417
418 try {
419 // run visitor on declaration
420 ast::ptr<ast::Decl> & node = *i;
421 assert( node );
422 node = node->accept( visitor );
423 }
424 catch( SemanticErrorException &e ) {
425 errors.append( e );
426 }
427
428 // splice in new declarations before current decl
429 if ( !empty( decls_before ) ) { decls.splice( i, *decls_before ); }
430 }
431 pass_visitor_stats.depth--;
432 if ( !errors.isEmpty() ) { throw errors; }
433}
434
435template< typename core_t >
436inline void ast::accept_all( ast::TranslationUnit & unit, ast::Pass< core_t > & visitor ) {
437 return ast::accept_all( unit.decls, visitor );
438}
439
440// A NOTE ON THE ORDER OF TRAVERSAL
441//
442// Types and typedefs have their base types visited before they are added to the type table. This is ok, since there is
443// no such thing as a recursive type or typedef.
444//
445// typedef struct { T *x; } T; // never allowed
446//
447// for structs/unions, it is possible to have recursion, so the decl should be added as if it's incomplete to begin, the
448// members are traversed, and then the complete type should be added (assuming the type is completed by this particular
449// declaration).
450//
451// struct T { struct T *x; }; // allowed
452//
453// It is important to add the complete type to the symbol table *after* the members/base has been traversed, since that
454// traversal may modify the definition of the type and these modifications should be visible when the symbol table is
455// queried later in this pass.
456
457//--------------------------------------------------------------------------
458// ObjectDecl
459template< typename core_t >
460const ast::DeclWithType * ast::Pass< core_t >::visit( const ast::ObjectDecl * node ) {
461 VISIT_START( node );
462
463 VISIT(
464 {
465 guard_symtab guard { *this };
466 maybe_accept( node, &ObjectDecl::type );
467 }
468 maybe_accept( node, &ObjectDecl::init );
469 maybe_accept( node, &ObjectDecl::bitfieldWidth );
470 maybe_accept( node, &ObjectDecl::attributes );
471 )
472
473 __pass::symtab::addId( core, 0, node );
474
475 VISIT_END( DeclWithType, node );
476}
477
478//--------------------------------------------------------------------------
479// FunctionDecl
480template< typename core_t >
481const ast::DeclWithType * ast::Pass< core_t >::visit( const ast::FunctionDecl * node ) {
482 VISIT_START( node );
483
484 __pass::symtab::addId( core, 0, node );
485
486 VISIT(maybe_accept( node, &FunctionDecl::withExprs );)
487 {
488 // with clause introduces a level of scope (for the with expression members).
489 // with clause exprs are added to the symbol table before parameters so that parameters
490 // shadow with exprs and not the other way around.
491 guard_symtab guard { *this };
492 __pass::symtab::addWith( core, 0, node->withExprs, node );
493 {
494 guard_symtab guard { *this };
495 // implicit add __func__ identifier as specified in the C manual 6.4.2.2
496 static ast::ptr< ast::ObjectDecl > func{ new ast::ObjectDecl{
497 CodeLocation{}, "__func__",
498 new ast::ArrayType{
499 new ast::BasicType{ ast::BasicType::Char, ast::CV::Const },
500 nullptr, VariableLen, DynamicDim
501 }
502 } };
503 __pass::symtab::addId( core, 0, func );
504 VISIT(
505 // parameter declarations are now directly here
506 maybe_accept( node, &FunctionDecl::params );
507 maybe_accept( node, &FunctionDecl::returns );
508 // foralls are still in function type
509 maybe_accept( node, &FunctionDecl::type );
510 // First remember that we are now within a function.
511 ValueGuard< bool > oldInFunction( inFunction );
512 inFunction = true;
513 // The function body needs to have the same scope as parameters.
514 // A CompoundStmt will not enter a new scope if atFunctionTop is true.
515 ValueGuard< bool > oldAtFunctionTop( atFunctionTop );
516 atFunctionTop = true;
517 maybe_accept( node, &FunctionDecl::stmts );
518 maybe_accept( node, &FunctionDecl::attributes );
519 )
520 }
521 }
522
523 VISIT_END( DeclWithType, node );
524}
525
526//--------------------------------------------------------------------------
527// StructDecl
528template< typename core_t >
529const ast::Decl * ast::Pass< core_t >::visit( const ast::StructDecl * node ) {
530 VISIT_START( node );
531
532 // make up a forward declaration and add it before processing the members
533 // needs to be on the heap because addStruct saves the pointer
534 __pass::symtab::addStructFwd( core, 0, node );
535
536 VISIT({
537 guard_symtab guard { * this };
538 maybe_accept( node, &StructDecl::params );
539 maybe_accept( node, &StructDecl::members );
540 })
541
542 // this addition replaces the forward declaration
543 __pass::symtab::addStruct( core, 0, node );
544
545 VISIT_END( Decl, node );
546}
547
548//--------------------------------------------------------------------------
549// UnionDecl
550template< typename core_t >
551const ast::Decl * ast::Pass< core_t >::visit( const ast::UnionDecl * node ) {
552 VISIT_START( node );
553
554 // make up a forward declaration and add it before processing the members
555 __pass::symtab::addUnionFwd( core, 0, node );
556
557 VISIT({
558 guard_symtab guard { * this };
559 maybe_accept( node, &UnionDecl::params );
560 maybe_accept( node, &UnionDecl::members );
561 })
562
563 __pass::symtab::addUnion( core, 0, node );
564
565 VISIT_END( Decl, node );
566}
567
568//--------------------------------------------------------------------------
569// EnumDecl
570template< typename core_t >
571const ast::Decl * ast::Pass< core_t >::visit( const ast::EnumDecl * node ) {
572 VISIT_START( node );
573
574 __pass::symtab::addEnum( core, 0, node );
575
576 VISIT(
577 // unlike structs, traits, and unions, enums inject their members into the global scope
578 maybe_accept( node, &EnumDecl::params );
579 maybe_accept( node, &EnumDecl::members );
580 )
581
582 VISIT_END( Decl, node );
583}
584
585//--------------------------------------------------------------------------
586// TraitDecl
587template< typename core_t >
588const ast::Decl * ast::Pass< core_t >::visit( const ast::TraitDecl * node ) {
589 VISIT_START( node );
590
591 VISIT({
592 guard_symtab guard { *this };
593 maybe_accept( node, &TraitDecl::params );
594 maybe_accept( node, &TraitDecl::members );
595 })
596
597 __pass::symtab::addTrait( core, 0, node );
598
599 VISIT_END( Decl, node );
600}
601
602//--------------------------------------------------------------------------
603// TypeDecl
604template< typename core_t >
605const ast::Decl * ast::Pass< core_t >::visit( const ast::TypeDecl * node ) {
606 VISIT_START( node );
607
608 VISIT({
609 guard_symtab guard { *this };
610 maybe_accept( node, &TypeDecl::params );
611 maybe_accept( node, &TypeDecl::base );
612 })
613
614 // see A NOTE ON THE ORDER OF TRAVERSAL, above
615 // note that assertions come after the type is added to the symtab, since they are not part of the type proper
616 // and may depend on the type itself
617 __pass::symtab::addType( core, 0, node );
618
619 VISIT(
620 maybe_accept( node, &TypeDecl::assertions );
621
622 {
623 guard_symtab guard { *this };
624 maybe_accept( node, &TypeDecl::init );
625 }
626 )
627
628 VISIT_END( Decl, node );
629}
630
631//--------------------------------------------------------------------------
632// TypedefDecl
633template< typename core_t >
634const ast::Decl * ast::Pass< core_t >::visit( const ast::TypedefDecl * node ) {
635 VISIT_START( node );
636
637 VISIT({
638 guard_symtab guard { *this };
639 maybe_accept( node, &TypedefDecl::params );
640 maybe_accept( node, &TypedefDecl::base );
641 })
642
643 __pass::symtab::addType( core, 0, node );
644
645 VISIT( maybe_accept( node, &TypedefDecl::assertions ); )
646
647 VISIT_END( Decl, node );
648}
649
650//--------------------------------------------------------------------------
651// AsmDecl
652template< typename core_t >
653const ast::AsmDecl * ast::Pass< core_t >::visit( const ast::AsmDecl * node ) {
654 VISIT_START( node );
655
656 VISIT(
657 maybe_accept( node, &AsmDecl::stmt );
658 )
659
660 VISIT_END( AsmDecl, node );
661}
662
663//--------------------------------------------------------------------------
664// StaticAssertDecl
665template< typename core_t >
666const ast::StaticAssertDecl * ast::Pass< core_t >::visit( const ast::StaticAssertDecl * node ) {
667 VISIT_START( node );
668
669 VISIT(
670 maybe_accept( node, &StaticAssertDecl::cond );
671 maybe_accept( node, &StaticAssertDecl::msg );
672 )
673
674 VISIT_END( StaticAssertDecl, node );
675}
676
677//--------------------------------------------------------------------------
678// CompoundStmt
679template< typename core_t >
680const ast::CompoundStmt * ast::Pass< core_t >::visit( const ast::CompoundStmt * node ) {
681 VISIT_START( node );
682 VISIT(
683 // Do not enter (or leave) a new scope if atFunctionTop. Remember to save the result.
684 auto guard1 = makeFuncGuard( [this, enterScope = !this->atFunctionTop]() {
685 if ( enterScope ) __pass::symtab::enter(core, 0);
686 }, [this, leaveScope = !this->atFunctionTop]() {
687 if ( leaveScope ) __pass::symtab::leave(core, 0);
688 });
689 ValueGuard< bool > guard2( atFunctionTop );
690 atFunctionTop = false;
691 guard_scope guard3 { *this };
692 maybe_accept( node, &CompoundStmt::kids );
693 )
694 VISIT_END( CompoundStmt, node );
695}
696
697//--------------------------------------------------------------------------
698// ExprStmt
699template< typename core_t >
700const ast::Stmt * ast::Pass< core_t >::visit( const ast::ExprStmt * node ) {
701 VISIT_START( node );
702
703 VISIT(
704 maybe_accept( node, &ExprStmt::expr );
705 )
706
707 VISIT_END( Stmt, node );
708}
709
710//--------------------------------------------------------------------------
711// AsmStmt
712template< typename core_t >
713const ast::Stmt * ast::Pass< core_t >::visit( const ast::AsmStmt * node ) {
714 VISIT_START( node )
715
716 VISIT(
717 maybe_accept( node, &AsmStmt::instruction );
718 maybe_accept( node, &AsmStmt::output );
719 maybe_accept( node, &AsmStmt::input );
720 maybe_accept( node, &AsmStmt::clobber );
721 )
722
723 VISIT_END( Stmt, node );
724}
725
726//--------------------------------------------------------------------------
727// DirectiveStmt
728template< typename core_t >
729const ast::Stmt * ast::Pass< core_t >::visit( const ast::DirectiveStmt * node ) {
730 VISIT_START( node )
731
732 VISIT_END( Stmt, node );
733}
734
735//--------------------------------------------------------------------------
736// IfStmt
737template< typename core_t >
738const ast::Stmt * ast::Pass< core_t >::visit( const ast::IfStmt * node ) {
739 VISIT_START( node );
740
741 VISIT({
742 // if statements introduce a level of scope (for the initialization)
743 guard_symtab guard { *this };
744 maybe_accept( node, &IfStmt::inits );
745 maybe_accept( node, &IfStmt::cond );
746 maybe_accept_as_compound( node, &IfStmt::thenPart );
747 maybe_accept_as_compound( node, &IfStmt::elsePart );
748 })
749
750 VISIT_END( Stmt, node );
751}
752
753//--------------------------------------------------------------------------
754// WhileStmt
755template< typename core_t >
756const ast::Stmt * ast::Pass< core_t >::visit( const ast::WhileStmt * node ) {
757 VISIT_START( node );
758
759 VISIT({
760 // while statements introduce a level of scope (for the initialization)
761 guard_symtab guard { *this };
762 maybe_accept( node, &WhileStmt::inits );
763 maybe_accept( node, &WhileStmt::cond );
764 maybe_accept_as_compound( node, &WhileStmt::body );
765 })
766
767 VISIT_END( Stmt, node );
768}
769
770//--------------------------------------------------------------------------
771// ForStmt
772template< typename core_t >
773const ast::Stmt * ast::Pass< core_t >::visit( const ast::ForStmt * node ) {
774 VISIT_START( node );
775
776 VISIT({
777 // for statements introduce a level of scope (for the initialization)
778 guard_symtab guard { *this };
779 // xxx - old ast does not create WithStmtsToAdd scope for loop inits. should revisit this later.
780 maybe_accept( node, &ForStmt::inits );
781 maybe_accept( node, &ForStmt::cond );
782 maybe_accept( node, &ForStmt::inc );
783 maybe_accept_as_compound( node, &ForStmt::body );
784 })
785
786 VISIT_END( Stmt, node );
787}
788
789//--------------------------------------------------------------------------
790// SwitchStmt
791template< typename core_t >
792const ast::Stmt * ast::Pass< core_t >::visit( const ast::SwitchStmt * node ) {
793 VISIT_START( node );
794
795 VISIT(
796 maybe_accept( node, &SwitchStmt::cond );
797 maybe_accept( node, &SwitchStmt::stmts );
798 )
799
800 VISIT_END( Stmt, node );
801}
802
803//--------------------------------------------------------------------------
804// CaseStmt
805template< typename core_t >
806const ast::Stmt * ast::Pass< core_t >::visit( const ast::CaseStmt * node ) {
807 VISIT_START( node );
808
809 VISIT(
810 maybe_accept( node, &CaseStmt::cond );
811 maybe_accept( node, &CaseStmt::stmts );
812 )
813
814 VISIT_END( Stmt, node );
815}
816
817//--------------------------------------------------------------------------
818// BranchStmt
819template< typename core_t >
820const ast::Stmt * ast::Pass< core_t >::visit( const ast::BranchStmt * node ) {
821 VISIT_START( node );
822 VISIT_END( Stmt, node );
823}
824
825//--------------------------------------------------------------------------
826// ReturnStmt
827template< typename core_t >
828const ast::Stmt * ast::Pass< core_t >::visit( const ast::ReturnStmt * node ) {
829 VISIT_START( node );
830
831 VISIT(
832 maybe_accept( node, &ReturnStmt::expr );
833 )
834
835 VISIT_END( Stmt, node );
836}
837
838//--------------------------------------------------------------------------
839// ThrowStmt
840template< typename core_t >
841const ast::Stmt * ast::Pass< core_t >::visit( const ast::ThrowStmt * node ) {
842 VISIT_START( node );
843
844 VISIT(
845 maybe_accept( node, &ThrowStmt::expr );
846 maybe_accept( node, &ThrowStmt::target );
847 )
848
849 VISIT_END( Stmt, node );
850}
851
852//--------------------------------------------------------------------------
853// TryStmt
854template< typename core_t >
855const ast::Stmt * ast::Pass< core_t >::visit( const ast::TryStmt * node ) {
856 VISIT_START( node );
857
858 VISIT(
859 maybe_accept( node, &TryStmt::body );
860 maybe_accept( node, &TryStmt::handlers );
861 maybe_accept( node, &TryStmt::finally );
862 )
863
864 VISIT_END( Stmt, node );
865}
866
867//--------------------------------------------------------------------------
868// CatchStmt
869template< typename core_t >
870const ast::Stmt * ast::Pass< core_t >::visit( const ast::CatchStmt * node ) {
871 VISIT_START( node );
872
873 VISIT({
874 // catch statements introduce a level of scope (for the caught exception)
875 guard_symtab guard { *this };
876 maybe_accept( node, &CatchStmt::decl );
877 maybe_accept( node, &CatchStmt::cond );
878 maybe_accept_as_compound( node, &CatchStmt::body );
879 })
880
881 VISIT_END( Stmt, node );
882}
883
884//--------------------------------------------------------------------------
885// FinallyStmt
886template< typename core_t >
887const ast::Stmt * ast::Pass< core_t >::visit( const ast::FinallyStmt * node ) {
888 VISIT_START( node );
889
890 VISIT(
891 maybe_accept( node, &FinallyStmt::body );
892 )
893
894 VISIT_END( Stmt, node );
895}
896
897//--------------------------------------------------------------------------
898// FinallyStmt
899template< typename core_t >
900const ast::Stmt * ast::Pass< core_t >::visit( const ast::SuspendStmt * node ) {
901 VISIT_START( node );
902
903 VISIT(
904 maybe_accept( node, &SuspendStmt::then );
905 )
906
907 VISIT_END( Stmt, node );
908}
909
910//--------------------------------------------------------------------------
911// WaitForStmt
912template< typename core_t >
913const ast::Stmt * ast::Pass< core_t >::visit( const ast::WaitForStmt * node ) {
914 VISIT_START( node );
915 // for( auto & clause : node->clauses ) {
916 // maybeAccept_impl( clause.target.function, *this );
917 // maybeAccept_impl( clause.target.arguments, *this );
918
919 // maybeAccept_impl( clause.statement, *this );
920 // maybeAccept_impl( clause.condition, *this );
921 // }
922
923 VISIT({
924 std::vector<WaitForStmt::Clause> new_clauses;
925 new_clauses.reserve( node->clauses.size() );
926 bool mutated = false;
927 for( const auto & clause : node->clauses ) {
928
929 const Expr * func = clause.target.func ? clause.target.func->accept(*this) : nullptr;
930 if(func != clause.target.func) mutated = true;
931
932 std::vector<ptr<Expr>> new_args;
933 new_args.reserve(clause.target.args.size());
934 for( const auto & arg : clause.target.args ) {
935 auto a = arg->accept(*this);
936 new_args.push_back( a );
937 if( a != arg ) mutated = true;
938 }
939
940 const Stmt * stmt = clause.stmt ? clause.stmt->accept(*this) : nullptr;
941 if(stmt != clause.stmt) mutated = true;
942
943 const Expr * cond = clause.cond ? clause.cond->accept(*this) : nullptr;
944 if(cond != clause.cond) mutated = true;
945
946 new_clauses.push_back( WaitForStmt::Clause{ {func, std::move(new_args) }, stmt, cond } );
947 }
948
949 if(mutated) {
950 auto n = __pass::mutate<core_t>(node);
951 n->clauses = std::move( new_clauses );
952 node = n;
953 }
954 })
955
956 #define maybe_accept(field) \
957 if(node->field) { \
958 auto nval = call_accept( node->field ); \
959 if(nval != node->field ) { \
960 auto nparent = __pass::mutate<core_t>(node); \
961 nparent->field = nval; \
962 node = nparent; \
963 } \
964 }
965
966 VISIT(
967 maybe_accept( timeout.time );
968 maybe_accept( timeout.stmt );
969 maybe_accept( timeout.cond );
970 maybe_accept( orElse.stmt );
971 maybe_accept( orElse.cond );
972 )
973
974 #undef maybe_accept
975
976 VISIT_END( Stmt, node );
977}
978
979//--------------------------------------------------------------------------
980// WithStmt
981template< typename core_t >
982const ast::Decl * ast::Pass< core_t >::visit( const ast::WithStmt * node ) {
983 VISIT_START( node );
984
985 VISIT(
986 maybe_accept( node, &WithStmt::exprs );
987 {
988 // catch statements introduce a level of scope (for the caught exception)
989 guard_symtab guard { *this };
990 __pass::symtab::addWith( core, 0, node->exprs, node );
991 maybe_accept( node, &WithStmt::stmt );
992 }
993 )
994 VISIT_END( Stmt, node );
995}
996
997//--------------------------------------------------------------------------
998// NullStmt
999template< typename core_t >
1000const ast::NullStmt * ast::Pass< core_t >::visit( const ast::NullStmt * node ) {
1001 VISIT_START( node );
1002 VISIT_END( NullStmt, node );
1003}
1004
1005//--------------------------------------------------------------------------
1006// DeclStmt
1007template< typename core_t >
1008const ast::Stmt * ast::Pass< core_t >::visit( const ast::DeclStmt * node ) {
1009 VISIT_START( node );
1010
1011 VISIT(
1012 maybe_accept( node, &DeclStmt::decl );
1013 )
1014
1015 VISIT_END( Stmt, node );
1016}
1017
1018//--------------------------------------------------------------------------
1019// ImplicitCtorDtorStmt
1020template< typename core_t >
1021const ast::Stmt * ast::Pass< core_t >::visit( const ast::ImplicitCtorDtorStmt * node ) {
1022 VISIT_START( node );
1023
1024 // For now this isn't visited, it is unclear if this causes problem
1025 // if all tests are known to pass, remove this code
1026 VISIT(
1027 maybe_accept( node, &ImplicitCtorDtorStmt::callStmt );
1028 )
1029
1030 VISIT_END( Stmt, node );
1031}
1032
1033//--------------------------------------------------------------------------
1034// ApplicationExpr
1035template< typename core_t >
1036const ast::Expr * ast::Pass< core_t >::visit( const ast::ApplicationExpr * node ) {
1037 VISIT_START( node );
1038
1039 VISIT(
1040 {
1041 guard_symtab guard { *this };
1042 maybe_accept( node, &ApplicationExpr::result );
1043 }
1044 maybe_accept( node, &ApplicationExpr::func );
1045 maybe_accept( node, &ApplicationExpr::args );
1046 )
1047
1048 VISIT_END( Expr, node );
1049}
1050
1051//--------------------------------------------------------------------------
1052// UntypedExpr
1053template< typename core_t >
1054const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedExpr * node ) {
1055 VISIT_START( node );
1056
1057 VISIT(
1058 {
1059 guard_symtab guard { *this };
1060 maybe_accept( node, &UntypedExpr::result );
1061 }
1062
1063 maybe_accept( node, &UntypedExpr::args );
1064 )
1065
1066 VISIT_END( Expr, node );
1067}
1068
1069//--------------------------------------------------------------------------
1070// NameExpr
1071template< typename core_t >
1072const ast::Expr * ast::Pass< core_t >::visit( const ast::NameExpr * node ) {
1073 VISIT_START( node );
1074
1075 VISIT({
1076 guard_symtab guard { *this };
1077 maybe_accept( node, &NameExpr::result );
1078 })
1079
1080 VISIT_END( Expr, node );
1081}
1082
1083//--------------------------------------------------------------------------
1084// CastExpr
1085template< typename core_t >
1086const ast::Expr * ast::Pass< core_t >::visit( const ast::CastExpr * node ) {
1087 VISIT_START( node );
1088
1089 VISIT({
1090 guard_symtab guard { *this };
1091 maybe_accept( node, &CastExpr::result );
1092 }
1093 maybe_accept( node, &CastExpr::arg );
1094 )
1095
1096 VISIT_END( Expr, node );
1097}
1098
1099//--------------------------------------------------------------------------
1100// KeywordCastExpr
1101template< typename core_t >
1102const ast::Expr * ast::Pass< core_t >::visit( const ast::KeywordCastExpr * node ) {
1103 VISIT_START( node );
1104
1105 VISIT({
1106 guard_symtab guard { *this };
1107 maybe_accept( node, &KeywordCastExpr::result );
1108 }
1109 maybe_accept( node, &KeywordCastExpr::arg );
1110 )
1111
1112 VISIT_END( Expr, node );
1113}
1114
1115//--------------------------------------------------------------------------
1116// VirtualCastExpr
1117template< typename core_t >
1118const ast::Expr * ast::Pass< core_t >::visit( const ast::VirtualCastExpr * node ) {
1119 VISIT_START( node );
1120
1121 VISIT({
1122 guard_symtab guard { *this };
1123 maybe_accept( node, &VirtualCastExpr::result );
1124 }
1125 maybe_accept( node, &VirtualCastExpr::arg );
1126 )
1127
1128 VISIT_END( Expr, node );
1129}
1130
1131//--------------------------------------------------------------------------
1132// AddressExpr
1133template< typename core_t >
1134const ast::Expr * ast::Pass< core_t >::visit( const ast::AddressExpr * node ) {
1135 VISIT_START( node );
1136
1137 VISIT({
1138 guard_symtab guard { *this };
1139 maybe_accept( node, &AddressExpr::result );
1140 }
1141 maybe_accept( node, &AddressExpr::arg );
1142 )
1143
1144 VISIT_END( Expr, node );
1145}
1146
1147//--------------------------------------------------------------------------
1148// LabelAddressExpr
1149template< typename core_t >
1150const ast::Expr * ast::Pass< core_t >::visit( const ast::LabelAddressExpr * node ) {
1151 VISIT_START( node );
1152
1153 VISIT({
1154 guard_symtab guard { *this };
1155 maybe_accept( node, &LabelAddressExpr::result );
1156 })
1157
1158 VISIT_END( Expr, node );
1159}
1160
1161//--------------------------------------------------------------------------
1162// UntypedMemberExpr
1163template< typename core_t >
1164const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedMemberExpr * node ) {
1165 VISIT_START( node );
1166
1167 VISIT({
1168 guard_symtab guard { *this };
1169 maybe_accept( node, &UntypedMemberExpr::result );
1170 }
1171 maybe_accept( node, &UntypedMemberExpr::aggregate );
1172 maybe_accept( node, &UntypedMemberExpr::member );
1173 )
1174
1175 VISIT_END( Expr, node );
1176}
1177
1178//--------------------------------------------------------------------------
1179// MemberExpr
1180template< typename core_t >
1181const ast::Expr * ast::Pass< core_t >::visit( const ast::MemberExpr * node ) {
1182 VISIT_START( node );
1183
1184 VISIT({
1185 guard_symtab guard { *this };
1186 maybe_accept( node, &MemberExpr::result );
1187 }
1188 maybe_accept( node, &MemberExpr::aggregate );
1189 )
1190
1191 VISIT_END( Expr, node );
1192}
1193
1194//--------------------------------------------------------------------------
1195// VariableExpr
1196template< typename core_t >
1197const ast::Expr * ast::Pass< core_t >::visit( const ast::VariableExpr * node ) {
1198 VISIT_START( node );
1199
1200 VISIT({
1201 guard_symtab guard { *this };
1202 maybe_accept( node, &VariableExpr::result );
1203 })
1204
1205 VISIT_END( Expr, node );
1206}
1207
1208//--------------------------------------------------------------------------
1209// ConstantExpr
1210template< typename core_t >
1211const ast::Expr * ast::Pass< core_t >::visit( const ast::ConstantExpr * node ) {
1212 VISIT_START( node );
1213
1214 VISIT({
1215 guard_symtab guard { *this };
1216 maybe_accept( node, &ConstantExpr::result );
1217 })
1218
1219 VISIT_END( Expr, node );
1220}
1221
1222//--------------------------------------------------------------------------
1223// SizeofExpr
1224template< typename core_t >
1225const ast::Expr * ast::Pass< core_t >::visit( const ast::SizeofExpr * node ) {
1226 VISIT_START( node );
1227
1228 VISIT({
1229 guard_symtab guard { *this };
1230 maybe_accept( node, &SizeofExpr::result );
1231 }
1232 if ( node->type ) {
1233 maybe_accept( node, &SizeofExpr::type );
1234 } else {
1235 maybe_accept( node, &SizeofExpr::expr );
1236 }
1237 )
1238
1239 VISIT_END( Expr, node );
1240}
1241
1242//--------------------------------------------------------------------------
1243// AlignofExpr
1244template< typename core_t >
1245const ast::Expr * ast::Pass< core_t >::visit( const ast::AlignofExpr * node ) {
1246 VISIT_START( node );
1247
1248 VISIT({
1249 guard_symtab guard { *this };
1250 maybe_accept( node, &AlignofExpr::result );
1251 }
1252 if ( node->type ) {
1253 maybe_accept( node, &AlignofExpr::type );
1254 } else {
1255 maybe_accept( node, &AlignofExpr::expr );
1256 }
1257 )
1258
1259 VISIT_END( Expr, node );
1260}
1261
1262//--------------------------------------------------------------------------
1263// UntypedOffsetofExpr
1264template< typename core_t >
1265const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedOffsetofExpr * node ) {
1266 VISIT_START( node );
1267
1268 VISIT({
1269 guard_symtab guard { *this };
1270 maybe_accept( node, &UntypedOffsetofExpr::result );
1271 }
1272 maybe_accept( node, &UntypedOffsetofExpr::type );
1273 )
1274
1275 VISIT_END( Expr, node );
1276}
1277
1278//--------------------------------------------------------------------------
1279// OffsetofExpr
1280template< typename core_t >
1281const ast::Expr * ast::Pass< core_t >::visit( const ast::OffsetofExpr * node ) {
1282 VISIT_START( node );
1283
1284 VISIT({
1285 guard_symtab guard { *this };
1286 maybe_accept( node, &OffsetofExpr::result );
1287 }
1288 maybe_accept( node, &OffsetofExpr::type );
1289 )
1290
1291 VISIT_END( Expr, node );
1292}
1293
1294//--------------------------------------------------------------------------
1295// OffsetPackExpr
1296template< typename core_t >
1297const ast::Expr * ast::Pass< core_t >::visit( const ast::OffsetPackExpr * node ) {
1298 VISIT_START( node );
1299
1300 VISIT({
1301 guard_symtab guard { *this };
1302 maybe_accept( node, &OffsetPackExpr::result );
1303 }
1304 maybe_accept( node, &OffsetPackExpr::type );
1305 )
1306
1307 VISIT_END( Expr, node );
1308}
1309
1310//--------------------------------------------------------------------------
1311// LogicalExpr
1312template< typename core_t >
1313const ast::Expr * ast::Pass< core_t >::visit( const ast::LogicalExpr * node ) {
1314 VISIT_START( node );
1315
1316 VISIT({
1317 guard_symtab guard { *this };
1318 maybe_accept( node, &LogicalExpr::result );
1319 }
1320 maybe_accept( node, &LogicalExpr::arg1 );
1321 maybe_accept( node, &LogicalExpr::arg2 );
1322 )
1323
1324 VISIT_END( Expr, node );
1325}
1326
1327//--------------------------------------------------------------------------
1328// ConditionalExpr
1329template< typename core_t >
1330const ast::Expr * ast::Pass< core_t >::visit( const ast::ConditionalExpr * node ) {
1331 VISIT_START( node );
1332
1333 VISIT({
1334 guard_symtab guard { *this };
1335 maybe_accept( node, &ConditionalExpr::result );
1336 }
1337 maybe_accept( node, &ConditionalExpr::arg1 );
1338 maybe_accept( node, &ConditionalExpr::arg2 );
1339 maybe_accept( node, &ConditionalExpr::arg3 );
1340 )
1341
1342 VISIT_END( Expr, node );
1343}
1344
1345//--------------------------------------------------------------------------
1346// CommaExpr
1347template< typename core_t >
1348const ast::Expr * ast::Pass< core_t >::visit( const ast::CommaExpr * node ) {
1349 VISIT_START( node );
1350
1351 VISIT({
1352 guard_symtab guard { *this };
1353 maybe_accept( node, &CommaExpr::result );
1354 }
1355 maybe_accept( node, &CommaExpr::arg1 );
1356 maybe_accept( node, &CommaExpr::arg2 );
1357 )
1358
1359 VISIT_END( Expr, node );
1360}
1361
1362//--------------------------------------------------------------------------
1363// TypeExpr
1364template< typename core_t >
1365const ast::Expr * ast::Pass< core_t >::visit( const ast::TypeExpr * node ) {
1366 VISIT_START( node );
1367
1368 VISIT({
1369 guard_symtab guard { *this };
1370 maybe_accept( node, &TypeExpr::result );
1371 }
1372 maybe_accept( node, &TypeExpr::type );
1373 )
1374
1375 VISIT_END( Expr, node );
1376}
1377
1378//--------------------------------------------------------------------------
1379// AsmExpr
1380template< typename core_t >
1381const ast::Expr * ast::Pass< core_t >::visit( const ast::AsmExpr * node ) {
1382 VISIT_START( node );
1383
1384 VISIT({
1385 guard_symtab guard { *this };
1386 maybe_accept( node, &AsmExpr::result );
1387 }
1388 maybe_accept( node, &AsmExpr::constraint );
1389 maybe_accept( node, &AsmExpr::operand );
1390 )
1391
1392 VISIT_END( Expr, node );
1393}
1394
1395//--------------------------------------------------------------------------
1396// ImplicitCopyCtorExpr
1397template< typename core_t >
1398const ast::Expr * ast::Pass< core_t >::visit( const ast::ImplicitCopyCtorExpr * node ) {
1399 VISIT_START( node );
1400
1401 VISIT({
1402 guard_symtab guard { *this };
1403 maybe_accept( node, &ImplicitCopyCtorExpr::result );
1404 }
1405 maybe_accept( node, &ImplicitCopyCtorExpr::callExpr );
1406 )
1407
1408 VISIT_END( Expr, node );
1409}
1410
1411//--------------------------------------------------------------------------
1412// ConstructorExpr
1413template< typename core_t >
1414const ast::Expr * ast::Pass< core_t >::visit( const ast::ConstructorExpr * node ) {
1415 VISIT_START( node );
1416
1417 VISIT({
1418 guard_symtab guard { *this };
1419 maybe_accept( node, &ConstructorExpr::result );
1420 }
1421 maybe_accept( node, &ConstructorExpr::callExpr );
1422 )
1423
1424 VISIT_END( Expr, node );
1425}
1426
1427//--------------------------------------------------------------------------
1428// CompoundLiteralExpr
1429template< typename core_t >
1430const ast::Expr * ast::Pass< core_t >::visit( const ast::CompoundLiteralExpr * node ) {
1431 VISIT_START( node );
1432
1433 VISIT({
1434 guard_symtab guard { *this };
1435 maybe_accept( node, &CompoundLiteralExpr::result );
1436 }
1437 maybe_accept( node, &CompoundLiteralExpr::init );
1438 )
1439
1440 VISIT_END( Expr, node );
1441}
1442
1443//--------------------------------------------------------------------------
1444// RangeExpr
1445template< typename core_t >
1446const ast::Expr * ast::Pass< core_t >::visit( const ast::RangeExpr * node ) {
1447 VISIT_START( node );
1448
1449 VISIT({
1450 guard_symtab guard { *this };
1451 maybe_accept( node, &RangeExpr::result );
1452 }
1453 maybe_accept( node, &RangeExpr::low );
1454 maybe_accept( node, &RangeExpr::high );
1455 )
1456
1457 VISIT_END( Expr, node );
1458}
1459
1460//--------------------------------------------------------------------------
1461// UntypedTupleExpr
1462template< typename core_t >
1463const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedTupleExpr * node ) {
1464 VISIT_START( node );
1465
1466 VISIT({
1467 guard_symtab guard { *this };
1468 maybe_accept( node, &UntypedTupleExpr::result );
1469 }
1470 maybe_accept( node, &UntypedTupleExpr::exprs );
1471 )
1472
1473 VISIT_END( Expr, node );
1474}
1475
1476//--------------------------------------------------------------------------
1477// TupleExpr
1478template< typename core_t >
1479const ast::Expr * ast::Pass< core_t >::visit( const ast::TupleExpr * node ) {
1480 VISIT_START( node );
1481
1482 VISIT({
1483 guard_symtab guard { *this };
1484 maybe_accept( node, &TupleExpr::result );
1485 }
1486 maybe_accept( node, &TupleExpr::exprs );
1487 )
1488
1489 VISIT_END( Expr, node );
1490}
1491
1492//--------------------------------------------------------------------------
1493// TupleIndexExpr
1494template< typename core_t >
1495const ast::Expr * ast::Pass< core_t >::visit( const ast::TupleIndexExpr * node ) {
1496 VISIT_START( node );
1497
1498 VISIT({
1499 guard_symtab guard { *this };
1500 maybe_accept( node, &TupleIndexExpr::result );
1501 }
1502 maybe_accept( node, &TupleIndexExpr::tuple );
1503 )
1504
1505 VISIT_END( Expr, node );
1506}
1507
1508//--------------------------------------------------------------------------
1509// TupleAssignExpr
1510template< typename core_t >
1511const ast::Expr * ast::Pass< core_t >::visit( const ast::TupleAssignExpr * node ) {
1512 VISIT_START( node );
1513
1514 VISIT({
1515 guard_symtab guard { *this };
1516 maybe_accept( node, &TupleAssignExpr::result );
1517 }
1518 maybe_accept( node, &TupleAssignExpr::stmtExpr );
1519 )
1520
1521 VISIT_END( Expr, node );
1522}
1523
1524//--------------------------------------------------------------------------
1525// StmtExpr
1526template< typename core_t >
1527const ast::Expr * ast::Pass< core_t >::visit( const ast::StmtExpr * node ) {
1528 VISIT_START( node );
1529
1530 VISIT(// don't want statements from outer CompoundStmts to be added to this StmtExpr
1531 // get the stmts that will need to be spliced in
1532 auto stmts_before = __pass::stmtsToAddBefore( core, 0);
1533 auto stmts_after = __pass::stmtsToAddAfter ( core, 0);
1534
1535 // These may be modified by subnode but most be restored once we exit this statemnet.
1536 ValueGuardPtr< const ast::TypeSubstitution * > __old_env( __pass::typeSubs( core, 0 ) );
1537 ValueGuardPtr< typename std::remove_pointer< decltype(stmts_before) >::type > __old_decls_before( stmts_before );
1538 ValueGuardPtr< typename std::remove_pointer< decltype(stmts_after ) >::type > __old_decls_after ( stmts_after );
1539
1540 {
1541 guard_symtab guard { *this };
1542 maybe_accept( node, &StmtExpr::result );
1543 }
1544 maybe_accept( node, &StmtExpr::stmts );
1545 maybe_accept( node, &StmtExpr::returnDecls );
1546 maybe_accept( node, &StmtExpr::dtors );
1547 )
1548
1549 VISIT_END( Expr, node );
1550}
1551
1552//--------------------------------------------------------------------------
1553// UniqueExpr
1554template< typename core_t >
1555const ast::Expr * ast::Pass< core_t >::visit( const ast::UniqueExpr * node ) {
1556 VISIT_START( node );
1557
1558 VISIT({
1559 guard_symtab guard { *this };
1560 maybe_accept( node, &UniqueExpr::result );
1561 }
1562 maybe_accept( node, &UniqueExpr::expr );
1563 )
1564
1565 VISIT_END( Expr, node );
1566}
1567
1568//--------------------------------------------------------------------------
1569// UntypedInitExpr
1570template< typename core_t >
1571const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedInitExpr * node ) {
1572 VISIT_START( node );
1573
1574 VISIT({
1575 guard_symtab guard { *this };
1576 maybe_accept( node, &UntypedInitExpr::result );
1577 }
1578 maybe_accept( node, &UntypedInitExpr::expr );
1579 // not currently visiting initAlts, but this doesn't matter since this node is only used in the resolver.
1580 )
1581
1582 VISIT_END( Expr, node );
1583}
1584
1585//--------------------------------------------------------------------------
1586// InitExpr
1587template< typename core_t >
1588const ast::Expr * ast::Pass< core_t >::visit( const ast::InitExpr * node ) {
1589 VISIT_START( node );
1590
1591 VISIT({
1592 guard_symtab guard { *this };
1593 maybe_accept( node, &InitExpr::result );
1594 }
1595 maybe_accept( node, &InitExpr::expr );
1596 maybe_accept( node, &InitExpr::designation );
1597 )
1598
1599 VISIT_END( Expr, node );
1600}
1601
1602//--------------------------------------------------------------------------
1603// DeletedExpr
1604template< typename core_t >
1605const ast::Expr * ast::Pass< core_t >::visit( const ast::DeletedExpr * node ) {
1606 VISIT_START( node );
1607
1608 VISIT({
1609 guard_symtab guard { *this };
1610 maybe_accept( node, &DeletedExpr::result );
1611 }
1612 maybe_accept( node, &DeletedExpr::expr );
1613 // don't visit deleteStmt, because it is a pointer to somewhere else in the tree.
1614 )
1615
1616 VISIT_END( Expr, node );
1617}
1618
1619//--------------------------------------------------------------------------
1620// DefaultArgExpr
1621template< typename core_t >
1622const ast::Expr * ast::Pass< core_t >::visit( const ast::DefaultArgExpr * node ) {
1623 VISIT_START( node );
1624
1625 VISIT({
1626 guard_symtab guard { *this };
1627 maybe_accept( node, &DefaultArgExpr::result );
1628 }
1629 maybe_accept( node, &DefaultArgExpr::expr );
1630 )
1631
1632 VISIT_END( Expr, node );
1633}
1634
1635//--------------------------------------------------------------------------
1636// GenericExpr
1637template< typename core_t >
1638const ast::Expr * ast::Pass< core_t >::visit( const ast::GenericExpr * node ) {
1639 VISIT_START( node );
1640
1641 VISIT({
1642 guard_symtab guard { *this };
1643 maybe_accept( node, &GenericExpr::result );
1644 }
1645 maybe_accept( node, &GenericExpr::control );
1646
1647 std::vector<GenericExpr::Association> new_kids;
1648 new_kids.reserve(node->associations.size());
1649 bool mutated = false;
1650 for( const auto & assoc : node->associations ) {
1651 const Type * type = nullptr;
1652 if( assoc.type ) {
1653 guard_symtab guard { *this };
1654 type = assoc.type->accept( *this );
1655 if( type != assoc.type ) mutated = true;
1656 }
1657 const Expr * expr = nullptr;
1658 if( assoc.expr ) {
1659 expr = assoc.expr->accept( *this );
1660 if( expr != assoc.expr ) mutated = true;
1661 }
1662 new_kids.emplace_back( type, expr );
1663 }
1664
1665 if(mutated) {
1666 auto n = __pass::mutate<core_t>(node);
1667 n->associations = std::move( new_kids );
1668 node = n;
1669 }
1670 )
1671
1672 VISIT_END( Expr, node );
1673}
1674
1675//--------------------------------------------------------------------------
1676// VoidType
1677template< typename core_t >
1678const ast::Type * ast::Pass< core_t >::visit( const ast::VoidType * node ) {
1679 VISIT_START( node );
1680
1681 VISIT_END( Type, node );
1682}
1683
1684//--------------------------------------------------------------------------
1685// BasicType
1686template< typename core_t >
1687const ast::Type * ast::Pass< core_t >::visit( const ast::BasicType * node ) {
1688 VISIT_START( node );
1689
1690 VISIT_END( Type, node );
1691}
1692
1693//--------------------------------------------------------------------------
1694// PointerType
1695template< typename core_t >
1696const ast::Type * ast::Pass< core_t >::visit( const ast::PointerType * node ) {
1697 VISIT_START( node );
1698
1699 VISIT(
1700 // xxx - should PointerType visit/mutate dimension?
1701 maybe_accept( node, &PointerType::base );
1702 )
1703
1704 VISIT_END( Type, node );
1705}
1706
1707//--------------------------------------------------------------------------
1708// ArrayType
1709template< typename core_t >
1710const ast::Type * ast::Pass< core_t >::visit( const ast::ArrayType * node ) {
1711 VISIT_START( node );
1712
1713 VISIT(
1714 maybe_accept( node, &ArrayType::dimension );
1715 maybe_accept( node, &ArrayType::base );
1716 )
1717
1718 VISIT_END( Type, node );
1719}
1720
1721//--------------------------------------------------------------------------
1722// ReferenceType
1723template< typename core_t >
1724const ast::Type * ast::Pass< core_t >::visit( const ast::ReferenceType * node ) {
1725 VISIT_START( node );
1726
1727 VISIT(
1728 maybe_accept( node, &ReferenceType::base );
1729 )
1730
1731 VISIT_END( Type, node );
1732}
1733
1734//--------------------------------------------------------------------------
1735// QualifiedType
1736template< typename core_t >
1737const ast::Type * ast::Pass< core_t >::visit( const ast::QualifiedType * node ) {
1738 VISIT_START( node );
1739
1740 VISIT(
1741 maybe_accept( node, &QualifiedType::parent );
1742 maybe_accept( node, &QualifiedType::child );
1743 )
1744
1745 VISIT_END( Type, node );
1746}
1747
1748//--------------------------------------------------------------------------
1749// FunctionType
1750template< typename core_t >
1751const ast::Type * ast::Pass< core_t >::visit( const ast::FunctionType * node ) {
1752 VISIT_START( node );
1753
1754 VISIT({
1755 guard_forall_subs forall_guard { *this, node };
1756 mutate_forall( node );
1757 maybe_accept( node, &FunctionType::returns );
1758 maybe_accept( node, &FunctionType::params );
1759 })
1760
1761 VISIT_END( Type, node );
1762}
1763
1764//--------------------------------------------------------------------------
1765// StructInstType
1766template< typename core_t >
1767const ast::Type * ast::Pass< core_t >::visit( const ast::StructInstType * node ) {
1768 VISIT_START( node );
1769
1770 __pass::symtab::addStruct( core, 0, node->name );
1771
1772 VISIT({
1773 guard_symtab guard { *this };
1774 guard_forall_subs forall_guard { *this, node };
1775 mutate_forall( node );
1776 maybe_accept( node, &StructInstType::params );
1777 })
1778
1779 VISIT_END( Type, node );
1780}
1781
1782//--------------------------------------------------------------------------
1783// UnionInstType
1784template< typename core_t >
1785const ast::Type * ast::Pass< core_t >::visit( const ast::UnionInstType * node ) {
1786 VISIT_START( node );
1787
1788 __pass::symtab::addUnion( core, 0, node->name );
1789
1790 VISIT({
1791 guard_symtab guard { *this };
1792 guard_forall_subs forall_guard { *this, node };
1793 mutate_forall( node );
1794 maybe_accept( node, &UnionInstType::params );
1795 })
1796
1797 VISIT_END( Type, node );
1798}
1799
1800//--------------------------------------------------------------------------
1801// EnumInstType
1802template< typename core_t >
1803const ast::Type * ast::Pass< core_t >::visit( const ast::EnumInstType * node ) {
1804 VISIT_START( node );
1805
1806 VISIT({
1807 guard_forall_subs forall_guard { *this, node };
1808 mutate_forall( node );
1809 maybe_accept( node, &EnumInstType::params );
1810 })
1811
1812 VISIT_END( Type, node );
1813}
1814
1815//--------------------------------------------------------------------------
1816// TraitInstType
1817template< typename core_t >
1818const ast::Type * ast::Pass< core_t >::visit( const ast::TraitInstType * node ) {
1819 VISIT_START( node );
1820
1821 VISIT({
1822 guard_forall_subs forall_guard { *this, node };
1823 mutate_forall( node );
1824 maybe_accept( node, &TraitInstType::params );
1825 })
1826
1827 VISIT_END( Type, node );
1828}
1829
1830//--------------------------------------------------------------------------
1831// TypeInstType
1832template< typename core_t >
1833const ast::Type * ast::Pass< core_t >::visit( const ast::TypeInstType * node ) {
1834 VISIT_START( node );
1835
1836 VISIT(
1837 {
1838 guard_forall_subs forall_guard { *this, node };
1839 mutate_forall( node );
1840 maybe_accept( node, &TypeInstType::params );
1841 }
1842 // ensure that base re-bound if doing substitution
1843 __pass::forall::replace( core, 0, node );
1844 )
1845
1846 VISIT_END( Type, node );
1847}
1848
1849//--------------------------------------------------------------------------
1850// TupleType
1851template< typename core_t >
1852const ast::Type * ast::Pass< core_t >::visit( const ast::TupleType * node ) {
1853 VISIT_START( node );
1854
1855 VISIT(
1856 maybe_accept( node, &TupleType::types );
1857 maybe_accept( node, &TupleType::members );
1858 )
1859
1860 VISIT_END( Type, node );
1861}
1862
1863//--------------------------------------------------------------------------
1864// TypeofType
1865template< typename core_t >
1866const ast::Type * ast::Pass< core_t >::visit( const ast::TypeofType * node ) {
1867 VISIT_START( node );
1868
1869 VISIT(
1870 maybe_accept( node, &TypeofType::expr );
1871 )
1872
1873 VISIT_END( Type, node );
1874}
1875
1876//--------------------------------------------------------------------------
1877// VarArgsType
1878template< typename core_t >
1879const ast::Type * ast::Pass< core_t >::visit( const ast::VarArgsType * node ) {
1880 VISIT_START( node );
1881
1882 VISIT_END( Type, node );
1883}
1884
1885//--------------------------------------------------------------------------
1886// ZeroType
1887template< typename core_t >
1888const ast::Type * ast::Pass< core_t >::visit( const ast::ZeroType * node ) {
1889 VISIT_START( node );
1890
1891 VISIT_END( Type, node );
1892}
1893
1894//--------------------------------------------------------------------------
1895// OneType
1896template< typename core_t >
1897const ast::Type * ast::Pass< core_t >::visit( const ast::OneType * node ) {
1898 VISIT_START( node );
1899
1900 VISIT_END( Type, node );
1901}
1902
1903//--------------------------------------------------------------------------
1904// GlobalScopeType
1905template< typename core_t >
1906const ast::Type * ast::Pass< core_t >::visit( const ast::GlobalScopeType * node ) {
1907 VISIT_START( node );
1908
1909 VISIT_END( Type, node );
1910}
1911
1912
1913//--------------------------------------------------------------------------
1914// Designation
1915template< typename core_t >
1916const ast::Designation * ast::Pass< core_t >::visit( const ast::Designation * node ) {
1917 VISIT_START( node );
1918
1919 VISIT( maybe_accept( node, &Designation::designators ); )
1920
1921 VISIT_END( Designation, node );
1922}
1923
1924//--------------------------------------------------------------------------
1925// SingleInit
1926template< typename core_t >
1927const ast::Init * ast::Pass< core_t >::visit( const ast::SingleInit * node ) {
1928 VISIT_START( node );
1929
1930 VISIT(
1931 maybe_accept( node, &SingleInit::value );
1932 )
1933
1934 VISIT_END( Init, node );
1935}
1936
1937//--------------------------------------------------------------------------
1938// ListInit
1939template< typename core_t >
1940const ast::Init * ast::Pass< core_t >::visit( const ast::ListInit * node ) {
1941 VISIT_START( node );
1942
1943 VISIT(
1944 maybe_accept( node, &ListInit::designations );
1945 maybe_accept( node, &ListInit::initializers );
1946 )
1947
1948 VISIT_END( Init, node );
1949}
1950
1951//--------------------------------------------------------------------------
1952// ConstructorInit
1953template< typename core_t >
1954const ast::Init * ast::Pass< core_t >::visit( const ast::ConstructorInit * node ) {
1955 VISIT_START( node );
1956
1957 VISIT(
1958 maybe_accept( node, &ConstructorInit::ctor );
1959 maybe_accept( node, &ConstructorInit::dtor );
1960 maybe_accept( node, &ConstructorInit::init );
1961 )
1962
1963 VISIT_END( Init, node );
1964}
1965
1966//--------------------------------------------------------------------------
1967// Attribute
1968template< typename core_t >
1969const ast::Attribute * ast::Pass< core_t >::visit( const ast::Attribute * node ) {
1970 VISIT_START( node );
1971
1972 VISIT(
1973 maybe_accept( node, &Attribute::params );
1974 )
1975
1976 VISIT_END( Attribute, node );
1977}
1978
1979//--------------------------------------------------------------------------
1980// TypeSubstitution
1981template< typename core_t >
1982const ast::TypeSubstitution * ast::Pass< core_t >::visit( const ast::TypeSubstitution * node ) {
1983 VISIT_START( node );
1984
1985 VISIT(
1986 {
1987 bool mutated = false;
1988 std::unordered_map< std::string, ast::ptr< ast::Type > > new_map;
1989 for ( const auto & p : node->typeEnv ) {
1990 guard_symtab guard { *this };
1991 auto new_node = p.second->accept( *this );
1992 if (new_node != p.second) mutated = true;
1993 new_map.insert({ p.first, new_node });
1994 }
1995 if (mutated) {
1996 auto new_node = __pass::mutate<core_t>( node );
1997 new_node->typeEnv.swap( new_map );
1998 node = new_node;
1999 }
2000 }
2001
2002 {
2003 bool mutated = false;
2004 std::unordered_map< std::string, ast::ptr< ast::Expr > > new_map;
2005 for ( const auto & p : node->varEnv ) {
2006 guard_symtab guard { *this };
2007 auto new_node = p.second->accept( *this );
2008 if (new_node != p.second) mutated = true;
2009 new_map.insert({ p.first, new_node });
2010 }
2011 if (mutated) {
2012 auto new_node = __pass::mutate<core_t>( node );
2013 new_node->varEnv.swap( new_map );
2014 node = new_node;
2015 }
2016 }
2017 )
2018
2019 VISIT_END( TypeSubstitution, node );
2020}
2021
2022#undef VISIT_START
2023#undef VISIT
2024#undef VISIT_END
Note: See TracBrowser for help on using the repository browser.