Context Navigation

source: src/Common/PassVisitor.impl.h@ df75fe97

Visit:

ADT arm-eh ast-experimental enum forall-pointer-decay jacob/cs343-translation jenkins-sandbox new-ast new-ast-unique-expr pthread-emulation qualifiedEnum

Last change on this file since df75fe97 was 033ff37, checked in by Peter A. Buhr <pabuhr@…>, 6 years ago
remove attribute expression '@'name mechanism
Property mode set to `100644`
File size: 107.5 KB

Rev	Line
[13932f14]	1	#pragma once
[3268a58]	2	// IWYU pragma: private, include "PassVisitor.h"
[13932f14]	3
[3c398b6]	4	#define VISIT_START( node ) \
	5	__attribute__((unused)) \
	6	ChildrenGuard children_guard( get_visit_children_ptr() ); \
	7	__attribute__((unused)) \
[62423350]	8	guard_value_impl guard( at_cleanup_impl(pass, 0) ); \
[3c398b6]	9	call_previsit( node ); \
[6e09f211]	10
	11	#define VISIT_END( node ) \
	12	call_postvisit( node ); \
[9c1600c]	13
[3c398b6]	14	#define MUTATE_START( node ) \
	15	__attribute__((unused)) \
	16	ChildrenGuard children_guard( get_visit_children_ptr() ); \
	17	__attribute__((unused)) \
[62423350]	18	guard_value_impl guard( at_cleanup_impl(pass, 0) ); \
[3c398b6]	19	call_premutate( node ); \
[296b2be]	20
	21	#define MUTATE_END( type, node ) \
[6a625de]	22	auto __return = call_postmutate< type * >( node ); \
	23	assert( __return ); \
	24	return __return;
[296b2be]	25
	26
[134322e]	27	template<typename T>
	28	static inline bool empty( T * ptr ) {
	29	return !ptr \|\| ptr->empty();
	30	}
	31
[6ca154b]	32	typedef std::list< Statement * > StmtList_t;
	33	typedef std::list< Declaration * > DeclList_t;
	34
	35	template<typename iterator_t>
	36	static inline void splice( iterator_t it, DeclList_t * decls ) {
	37	std::transform(
	38	decls->begin(),
	39	decls->end(),
	40	it,
	41	[](Declaration * decl) -> auto {
[ba3706f]	42	return new DeclStmt( decl );
[6ca154b]	43	}
	44	);
	45	decls->clear();
	46	}
[134322e]	47
	48	template< typename pass_type >
[07c178f0]	49	inline void acceptAll( std::list< Declaration* > &decls, PassVisitor< pass_type >& visitor ) {
[6ca154b]	50	DeclList_t* beforeDecls = visitor.get_beforeDecls();
	51	DeclList_t* afterDecls = visitor.get_afterDecls();
[a16764a6]	52	SemanticErrorException errors;
[134322e]	53
[675716e]	54	pass_visitor_stats.depth++;
	55	pass_visitor_stats.max->push(pass_visitor_stats.depth);
	56	pass_visitor_stats.avg->push(pass_visitor_stats.depth);
[6ca154b]	57	for ( std::list< Declaration* >::iterator i = decls.begin(); ; ++i ) {
[675716e]	58
	59
[6ca154b]	60	// splice in new declarations after previous decl
[d24d4e1]	61	if ( !empty( afterDecls ) ) { decls.splice( i, *afterDecls ); }
[6ca154b]	62
	63	if ( i == decls.end() ) break;
	64
[522363e]	65	try {
	66	// run visitor on declaration
[3c398b6]	67	maybeAccept_impl( *i, visitor );
[a16764a6]	68	} catch( SemanticErrorException &e ) {
[522363e]	69	errors.append( e );
	70	}
[6ca154b]	71
	72	// splice in new declarations before current decl
	73	if ( !empty( beforeDecls ) ) { decls.splice( i, *beforeDecls ); }
[134322e]	74	}
[675716e]	75	pass_visitor_stats.depth--;
[522363e]	76	if ( ! errors.isEmpty() ) {
	77	throw errors;
	78	}
[6ca154b]	79	}
[134322e]	80
[7870799]	81	template< typename pass_type >
	82	inline void acceptAll( const std::list< const Declaration * > & decls, PassVisitor< pass_type >& visitor ) {
	83	SemanticErrorException errors;
	84
	85	pass_visitor_stats.depth++;
	86	pass_visitor_stats.max->push(pass_visitor_stats.depth);
	87	pass_visitor_stats.avg->push(pass_visitor_stats.depth);
	88	for ( const Declaration * decl : decls ) {
	89	try {
	90	// run visitor on declaration
	91	maybeAccept_impl( decl, visitor );
	92	}
	93	catch( SemanticErrorException &e ) {
	94	errors.append( e );
	95	}
	96	}
	97	pass_visitor_stats.depth--;
	98	if ( ! errors.isEmpty() ) {
	99	throw errors;
	100	}
	101	}
	102
[6ca154b]	103	template< typename pass_type >
[07c178f0]	104	inline void mutateAll( std::list< Declaration* > &decls, PassVisitor< pass_type >& mutator ) {
[6ca154b]	105	DeclList_t* beforeDecls = mutator.get_beforeDecls();
	106	DeclList_t* afterDecls = mutator.get_afterDecls();
[a16764a6]	107	SemanticErrorException errors;
[6ca154b]	108
[675716e]	109	pass_visitor_stats.depth++;
	110	pass_visitor_stats.max->push(pass_visitor_stats.depth);
	111	pass_visitor_stats.avg->push(pass_visitor_stats.depth);
[6ca154b]	112	for ( std::list< Declaration* >::iterator i = decls.begin(); ; ++i ) {
	113	// splice in new declarations after previous decl
[d24d4e1]	114	if ( !empty( afterDecls ) ) { decls.splice( i, *afterDecls ); }
[6ca154b]	115
	116	if ( i == decls.end() ) break;
[522363e]	117	try {
	118	// run mutator on declaration
[3c398b6]	119	maybeMutate_impl( *i, mutator );
[a16764a6]	120	} catch( SemanticErrorException &e ) {
[522363e]	121	errors.append( e );
	122	}
[6ca154b]	123
	124	// splice in new declarations before current decl
	125	if ( !empty( beforeDecls ) ) { decls.splice( i, *beforeDecls ); }
	126	}
[675716e]	127	pass_visitor_stats.depth--;
[522363e]	128	if ( ! errors.isEmpty() ) {
	129	throw errors;
	130	}
[134322e]	131	}
	132
[3c398b6]	133	template< typename TreeType, typename pass_type >
	134	inline void maybeAccept_impl( TreeType * tree, PassVisitor< pass_type > & visitor ) {
	135	if ( ! visitor.get_visit_children() ) return;
	136	if ( tree ) {
	137	tree->accept( visitor );
	138	}
	139	}
	140
[7870799]	141	template< typename TreeType, typename pass_type >
	142	inline void maybeAccept_impl( const TreeType * tree, PassVisitor< pass_type > & visitor ) {
	143	if ( ! visitor.get_visit_children() ) return;
	144	if ( tree ) {
	145	tree->accept( visitor );
	146	}
	147	}
	148
[3c398b6]	149	template< typename Container, typename pass_type >
	150	inline void maybeAccept_impl( Container & container, PassVisitor< pass_type > & visitor ) {
	151	if ( ! visitor.get_visit_children() ) return;
[a16764a6]	152	SemanticErrorException errors;
[675716e]	153
	154	pass_visitor_stats.depth++;
	155	pass_visitor_stats.max->push(pass_visitor_stats.depth);
	156	pass_visitor_stats.avg->push(pass_visitor_stats.depth);
[e0886db]	157	for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
	158	try {
	159	if ( *i ) {
	160	(*i)->accept( visitor );
	161	}
[a16764a6]	162	} catch( SemanticErrorException &e ) {
[e0886db]	163	errors.append( e );
	164	}
	165	}
[675716e]	166	pass_visitor_stats.depth--;
[e0886db]	167	if ( ! errors.isEmpty() ) {
	168	throw errors;
	169	}
	170	}
	171
[7870799]	172	template< typename Container, typename pass_type >
	173	inline void maybeAccept_impl( const Container & container, PassVisitor< pass_type > & visitor ) {
	174	if ( ! visitor.get_visit_children() ) return;
	175	SemanticErrorException errors;
	176
	177	pass_visitor_stats.depth++;
	178	pass_visitor_stats.max->push(pass_visitor_stats.depth);
	179	pass_visitor_stats.avg->push(pass_visitor_stats.depth);
	180	for ( const auto & i : container ) {
	181	try {
	182	if ( i ) {
	183	i->accept( visitor );
	184	}
	185	} catch( SemanticErrorException &e ) {
	186	errors.append( e );
	187	}
	188	}
	189	pass_visitor_stats.depth--;
	190	if ( ! errors.isEmpty() ) {
	191	throw errors;
	192	}
	193	}
	194
[3c398b6]	195	template< typename TreeType, typename pass_type >
	196	inline void maybeMutate_impl( TreeType *& tree, PassVisitor< pass_type > & mutator ) {
	197	if ( ! mutator.get_visit_children() ) return;
	198
	199	if ( tree ) {
	200	tree = strict_dynamic_cast< TreeType * >( tree->acceptMutator( mutator ) );
	201	}
	202	}
	203
	204	template< typename Container, typename pass_type >
	205	inline void maybeMutate_impl( Container & container, PassVisitor< pass_type > & mutator ) {
[37e3af4]	206
[3c398b6]	207	if ( ! mutator.get_visit_children() ) return;
[a16764a6]	208	SemanticErrorException errors;
[675716e]	209
	210	pass_visitor_stats.depth++;
	211	pass_visitor_stats.max->push(pass_visitor_stats.depth);
	212	pass_visitor_stats.avg->push(pass_visitor_stats.depth);
[e0886db]	213	for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
	214	try {
	215	if ( *i ) {
	216	i = dynamic_cast< typename Container::value_type >( (i)->acceptMutator( mutator ) );
	217	assert( *i );
	218	} // if
[a16764a6]	219	} catch( SemanticErrorException &e ) {
[e0886db]	220	errors.append( e );
	221	} // try
	222	} // for
[675716e]	223	pass_visitor_stats.depth--;
[e0886db]	224	if ( ! errors.isEmpty() ) {
	225	throw errors;
	226	} // if
	227	}
	228
[296b2be]	229	template< typename pass_type >
[6ca154b]	230	template< typename func_t >
	231	void PassVisitor< pass_type >::handleStatementList( std::list< Statement * > & statements, func_t func ) {
[3c398b6]	232	if ( ! get_visit_children() ) return;
[a16764a6]	233	SemanticErrorException errors;
[296b2be]	234
[2a7b3ca]	235	// don't want statements from outer CompoundStmts to be added to this CompoundStmt
	236	ValueGuardPtr< StmtList_t > oldBeforeStmts( get_beforeStmts() );
	237	ValueGuardPtr< StmtList_t > oldAfterStmts ( get_afterStmts () );
	238	ValueGuardPtr< DeclList_t > oldBeforeDecls( get_beforeDecls() );
	239	ValueGuardPtr< DeclList_t > oldAfterDecls ( get_afterDecls () );
	240
[134322e]	241	StmtList_t* beforeStmts = get_beforeStmts();
	242	StmtList_t* afterStmts = get_afterStmts();
[6ca154b]	243	DeclList_t* beforeDecls = get_beforeDecls();
	244	DeclList_t* afterDecls = get_afterDecls();
[134322e]	245
[675716e]	246	pass_visitor_stats.depth++;
	247	pass_visitor_stats.max->push(pass_visitor_stats.depth);
	248	pass_visitor_stats.avg->push(pass_visitor_stats.depth);
[296b2be]	249	for ( std::list< Statement* >::iterator i = statements.begin(); i != statements.end(); ++i ) {
[6ca154b]	250
	251	if ( !empty( afterDecls ) ) { splice( std::inserter( statements, i ), afterDecls ); }
[134322e]	252	if ( !empty( afterStmts ) ) { statements.splice( i, *afterStmts ); }
[6ca154b]	253
[296b2be]	254	try {
[6ca154b]	255	func( *i );
[37e3af4]	256	assert( *i );
[6ca154b]	257	assert(( empty( beforeStmts ) && empty( afterStmts ))
	258	\|\| ( empty( beforeDecls ) && empty( afterDecls )) );
	259
[a16764a6]	260	} catch ( SemanticErrorException &e ) {
[296b2be]	261	errors.append( e );
[134322e]	262	}
[6ca154b]	263
	264	if ( !empty( beforeDecls ) ) { splice( std::inserter( statements, i ), beforeDecls ); }
[134322e]	265	if ( !empty( beforeStmts ) ) { statements.splice( i, *beforeStmts ); }
[296b2be]	266	}
[675716e]	267	pass_visitor_stats.depth--;
[134322e]	268
[6ca154b]	269	if ( !empty( afterDecls ) ) { splice( std::back_inserter( statements ), afterDecls); }
[134322e]	270	if ( !empty( afterStmts ) ) { statements.splice( statements.end(), *afterStmts ); }
	271	if ( !errors.isEmpty() ) { throw errors; }
[296b2be]	272	}
	273
	274	template< typename pass_type >
[6ca154b]	275	void PassVisitor< pass_type >::visitStatementList( std::list< Statement * > & statements ) {
	276	handleStatementList( statements, [this]( Statement * stmt) {
[3c398b6]	277	maybeAccept_impl( stmt, *this );
[6ca154b]	278	});
	279	}
[134322e]	280
[7870799]	281	template< typename pass_type >
	282	void PassVisitor< pass_type >::visitStatementList( const std::list< Statement * > & statements ) {
	283	if ( ! get_visit_children() ) return;
	284	SemanticErrorException errors;
	285
	286	pass_visitor_stats.depth++;
	287	pass_visitor_stats.max->push(pass_visitor_stats.depth);
	288	pass_visitor_stats.avg->push(pass_visitor_stats.depth);
	289	for ( const Statement * i : statements ) {
	290	try {
	291	maybeAccept_impl( i, *this );
	292	} catch ( SemanticErrorException &e ) {
	293	errors.append( e );
	294	}
	295	}
	296	pass_visitor_stats.depth--;
	297	if ( !errors.isEmpty() ) { throw errors; }
	298	}
	299
[6ca154b]	300	template< typename pass_type >
	301	void PassVisitor< pass_type >::mutateStatementList( std::list< Statement * > & statements ) {
	302	handleStatementList( statements, [this]( Statement *& stmt) {
[3c398b6]	303	maybeMutate_impl( stmt, *this );
[6ca154b]	304	});
[134322e]	305	}
	306
[6ca154b]	307
[134322e]	308	template< typename pass_type >
[6ca154b]	309	template< typename func_t >
	310	Statement * PassVisitor< pass_type >::handleStatement( Statement * stmt, func_t func ) {
[3c398b6]	311	if ( ! get_visit_children() ) return stmt;
	312
[134322e]	313	// don't want statements from outer CompoundStmts to be added to this CompoundStmt
[02fdb8e]	314	ValueGuardPtr< typename std::remove_pointer<decltype(get_env_ptr())>::type > oldEnv( get_env_ptr() );
[6ca154b]	315	ValueGuardPtr< DeclList_t > oldBeforeDecls( get_beforeDecls() );
	316	ValueGuardPtr< DeclList_t > oldAfterDecls ( get_afterDecls () );
	317	ValueGuardPtr< StmtList_t > oldBeforeStmts( get_beforeStmts() );
	318	ValueGuardPtr< StmtList_t > oldAfterStmts ( get_afterStmts () );
[296b2be]	319
[6ca154b]	320	Statement *newStmt = func( stmt );
[134322e]	321
	322	StmtList_t* beforeStmts = get_beforeStmts();
	323	StmtList_t* afterStmts = get_afterStmts();
[6ca154b]	324	DeclList_t* beforeDecls = get_beforeDecls();
	325	DeclList_t* afterDecls = get_afterDecls();
[134322e]	326
[6ca154b]	327	if( empty(beforeStmts) && empty(afterStmts) && empty(beforeDecls) && empty(afterDecls) ) { return newStmt; }
	328	assert(( empty( beforeStmts ) && empty( afterStmts ))
	329	\|\| ( empty( beforeDecls ) && empty( afterDecls )) );
[134322e]	330
[ba3706f]	331	CompoundStmt *compound = new CompoundStmt();
[6ca154b]	332	if( !empty(beforeDecls) ) { splice( std::back_inserter( compound->get_kids() ), beforeDecls ); }
[134322e]	333	if( !empty(beforeStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *beforeStmts ); }
	334	compound->get_kids().push_back( newStmt );
[6ca154b]	335	if( !empty(afterDecls) ) { splice( std::back_inserter( compound->get_kids() ), afterDecls ); }
[134322e]	336	if( !empty(afterStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *afterStmts ); }
	337	return compound;
	338	}
	339
	340	template< typename pass_type >
[6ca154b]	341	Statement * PassVisitor< pass_type >::visitStatement( Statement * stmt ) {
	342	return handleStatement( stmt, [this]( Statement * stmt ) {
[3c398b6]	343	maybeAccept_impl( stmt, *this );
[6ca154b]	344	return stmt;
	345	});
	346	}
[134322e]	347
[7870799]	348	template< typename pass_type >
	349	void PassVisitor< pass_type >::visitStatement( const Statement * stmt ) {
	350	if ( ! get_visit_children() ) return;
	351
	352	// don't want statements from outer CompoundStmts to be added to this CompoundStmt
	353	ValueGuardPtr< typename std::remove_pointer<decltype(get_env_ptr())>::type > oldEnv( get_env_ptr() );
	354
	355	maybeAccept_impl( stmt, *this );
	356	}
	357
[6ca154b]	358	template< typename pass_type >
	359	Statement * PassVisitor< pass_type >::mutateStatement( Statement * stmt ) {
	360	return handleStatement( stmt, [this]( Statement * stmt ) {
[3c398b6]	361	maybeMutate_impl( stmt, *this );
	362	return stmt;
[6ca154b]	363	});
[296b2be]	364	}
	365
	366	template< typename pass_type >
[6ca154b]	367	template< typename func_t >
	368	Expression * PassVisitor< pass_type >::handleExpression( Expression * expr, func_t func ) {
[3c398b6]	369	if ( ! get_visit_children() ) return expr;
[296b2be]	370	if( !expr ) return nullptr;
	371
[134322e]	372	auto env_ptr = get_env_ptr();
	373	if ( env_ptr && expr->get_env() ) {
	374	*env_ptr = expr->get_env();
[296b2be]	375	}
[6ca154b]	376
[3c398b6]	377	// should env be moved onto the result of the mutate?
[6ca154b]	378	return func( expr );
	379	}
	380
	381	template< typename pass_type >
	382	Expression * PassVisitor< pass_type >::visitExpression( Expression * expr ) {
	383	return handleExpression(expr, [this]( Expression * expr ) {
[3c398b6]	384	maybeAccept_impl( expr, *this );
[6ca154b]	385	return expr;
[d24d4e1]	386	});
[296b2be]	387	}
[ab904dc]	388
[7870799]	389	template< typename pass_type >
	390	void PassVisitor< pass_type >::visitExpression( const Expression * expr ) {
	391	if ( ! get_visit_children() ) return;
	392	if( !expr ) return;
	393
	394	auto env_ptr = get_env_ptr();
	395	if ( env_ptr && expr->get_env() ) {
	396	*env_ptr = expr->get_env();
	397	}
	398
	399	maybeAccept_impl( expr, *this );
	400	}
	401
[6ca154b]	402	template< typename pass_type >
	403	Expression * PassVisitor< pass_type >::mutateExpression( Expression * expr ) {
	404	return handleExpression(expr, [this]( Expression * expr ) {
[3c398b6]	405	maybeMutate_impl( expr, *this );
	406	return expr;
[6ca154b]	407	});
	408	}
[ab904dc]	409
[3c398b6]	410	template< typename TreeType, typename VisitorType >
	411	inline void indexerScopedAccept( TreeType * tree, VisitorType & visitor ) {
	412	if ( ! visitor.get_visit_children() ) return;
	413	auto guard = makeFuncGuard(
	414	[&visitor]() { visitor.indexerScopeEnter(); },
	415	[&visitor]() { visitor.indexerScopeLeave(); }
	416	);
	417	maybeAccept_impl( tree, visitor );
	418	}
	419
[7870799]	420	template< typename TreeType, typename VisitorType >
	421	inline void indexerScopedAccept( const TreeType * tree, VisitorType & visitor ) {
	422	if ( ! visitor.get_visit_children() ) return;
	423	auto guard = makeFuncGuard(
	424	[&visitor]() { visitor.indexerScopeEnter(); },
	425	[&visitor]() { visitor.indexerScopeLeave(); }
	426	);
	427	maybeAccept_impl( tree, visitor );
	428	}
	429
[3c398b6]	430	template< typename TreeType, typename MutatorType >
	431	inline void indexerScopedMutate( TreeType *& tree, MutatorType & mutator ) {
	432	if ( ! mutator.get_visit_children() ) return;
	433	auto guard = makeFuncGuard(
	434	[&mutator]() { mutator.indexerScopeEnter(); },
	435	[&mutator]() { mutator.indexerScopeLeave(); }
	436	);
	437	maybeMutate_impl( tree, mutator );
	438	}
	439
[296b2be]	440	//------------------------------------------------------------------------------------------------------------------------------------------------------------------------
[e0886db]	441	//========================================================================================================================================================================
	442	//========================================================================================================================================================================
	443	//========================================================================================================================================================================
	444	//========================================================================================================================================================================
	445	//========================================================================================================================================================================
	446	//------------------------------------------------------------------------------------------------------------------------------------------------------------------------
[13932f14]	447
[33a25f9]	448	// A NOTE ON THE ORDER OF TRAVERSAL
	449	//
	450	// Types and typedefs have their base types visited before they are added to the type table. This is ok, since there is
	451	// no such thing as a recursive type or typedef.
	452	//
	453	// typedef struct { T *x; } T; // never allowed
	454	//
	455	// for structs/unions, it is possible to have recursion, so the decl should be added as if it's incomplete to begin, the
	456	// members are traversed, and then the complete type should be added (assuming the type is completed by this particular
	457	// declaration).
	458	//
	459	// struct T { struct T *x; }; // allowed
	460	//
	461	// It is important to add the complete type to the symbol table after the members/base has been traversed, since that
	462	// traversal may modify the definition of the type and these modifications should be visible when the symbol table is
	463	// queried later in this pass.
	464	//
	465	// TODO: figure out whether recursive contexts are sensible/possible/reasonable.
[e0886db]	466
	467	//--------------------------------------------------------------------------
	468	// ObjectDecl
[13932f14]	469	template< typename pass_type >
[ab904dc]	470	void PassVisitor< pass_type >::visit( ObjectDecl * node ) {
[e0886db]	471	VISIT_START( node );
	472
	473	indexerScopedAccept( node->type , *this );
[3c398b6]	474	maybeAccept_impl ( node->init , *this );
	475	maybeAccept_impl ( node->bitfieldWidth, *this );
	476	maybeAccept_impl ( node->attributes , *this );
[e0886db]	477
[2cb70aa]	478	indexerAddId( node );
[e0886db]	479
	480	VISIT_END( node );
	481	}
	482
[7870799]	483	template< typename pass_type >
	484	void PassVisitor< pass_type >::visit( const ObjectDecl * node ) {
	485	VISIT_START( node );
	486
	487	maybeAccept_impl( node->type , *this );
	488	maybeAccept_impl( node->init , *this );
	489	maybeAccept_impl( node->bitfieldWidth, *this );
	490	maybeAccept_impl( node->attributes , *this );
	491
	492	VISIT_END( node );
	493	}
	494
[e0886db]	495	template< typename pass_type >
	496	DeclarationWithType * PassVisitor< pass_type >::mutate( ObjectDecl * node ) {
	497	MUTATE_START( node );
	498
	499	indexerScopedMutate( node->type , *this );
[3c398b6]	500	maybeMutate_impl ( node->init , *this );
	501	maybeMutate_impl ( node->bitfieldWidth, *this );
	502	maybeMutate_impl ( node->attributes , *this );
[e0886db]	503
[2cb70aa]	504	indexerAddId( node );
[e0886db]	505
	506	MUTATE_END( DeclarationWithType, node );
[13932f14]	507	}
	508
[e0886db]	509	//--------------------------------------------------------------------------
	510	// FunctionDecl
[13932f14]	511	template< typename pass_type >
[ab904dc]	512	void PassVisitor< pass_type >::visit( FunctionDecl * node ) {
[e0886db]	513	VISIT_START( node );
	514
[2cb70aa]	515	indexerAddId( node );
[e0886db]	516
[7aaec67]	517	maybeAccept_impl( node->withExprs, *this );
[e0886db]	518	{
[2cb70aa]	519	// with clause introduces a level of scope (for the with expression members).
	520	// with clause exprs are added to the indexer before parameters so that parameters
	521	// shadow with exprs and not the other way around.
[e0886db]	522	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[0ac366b]	523	indexerAddWith( node->withExprs, node );
[7aaec67]	524	{
	525	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
	526	// implicit add __func__ identifier as specified in the C manual 6.4.2.2
	527	static ObjectDecl func(
	528	"__func__", noStorageClasses, LinkageSpec::C, nullptr,
	529	new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char ), nullptr, true, false ),
	530	nullptr
	531	);
	532	indexerAddId( &func );
	533	maybeAccept_impl( node->type, *this );
[61d9b4b]	534	// function body needs to have the same scope as parameters - CompoundStmt will not enter
	535	// a new scope if inFunction is true
	536	ValueGuard< bool > oldInFunction( inFunction );
	537	inFunction = true;
[7aaec67]	538	maybeAccept_impl( node->statements, *this );
	539	maybeAccept_impl( node->attributes, *this );
	540	}
[e0886db]	541	}
	542
	543	VISIT_END( node );
	544	}
	545
[7870799]	546	template< typename pass_type >
	547	void PassVisitor< pass_type >::visit( const FunctionDecl * node ) {
	548	VISIT_START( node );
	549
[e3d7f9f]	550	indexerAddId( node );
	551
[7870799]	552	maybeAccept_impl( node->withExprs, *this );
	553	{
[e3d7f9f]	554	// with clause introduces a level of scope (for the with expression members).
	555	// with clause exprs are added to the indexer before parameters so that parameters
	556	// shadow with exprs and not the other way around.
	557	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
	558	indexerAddWith( node->withExprs, node );
	559	{
	560	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
	561	// implicit add __func__ identifier as specified in the C manual 6.4.2.2
	562	static ObjectDecl func(
	563	"__func__", noStorageClasses, LinkageSpec::C, nullptr,
	564	new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char ), nullptr, true, false ),
	565	nullptr
	566	);
	567	indexerAddId( &func );
	568	maybeAccept_impl( node->type, *this );
	569	// function body needs to have the same scope as parameters - CompoundStmt will not enter
	570	// a new scope if inFunction is true
	571	ValueGuard< bool > oldInFunction( inFunction );
	572	inFunction = true;
	573	maybeAccept_impl( node->statements, *this );
	574	maybeAccept_impl( node->attributes, *this );
	575	}
[7870799]	576	}
	577
	578	VISIT_END( node );
	579	}
	580
[e0886db]	581	template< typename pass_type >
	582	DeclarationWithType * PassVisitor< pass_type >::mutate( FunctionDecl * node ) {
	583	MUTATE_START( node );
	584
[2cb70aa]	585	indexerAddId( node );
[e0886db]	586
	587	{
[2cb70aa]	588	// with clause introduces a level of scope (for the with expression members).
	589	// with clause exprs are added to the indexer before parameters so that parameters
	590	// shadow with exprs and not the other way around.
[e0886db]	591	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[0ac366b]	592	indexerAddWith( node->withExprs, node );
[7aaec67]	593	{
	594	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
	595	// implicit add __func__ identifier as specified in the C manual 6.4.2.2
	596	static ObjectDecl func(
	597	"__func__", noStorageClasses, LinkageSpec::C, nullptr,
	598	new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char ), nullptr, true, false ),
	599	nullptr
	600	);
	601	indexerAddId( &func );
	602	maybeMutate_impl( node->type, *this );
[61d9b4b]	603	// function body needs to have the same scope as parameters - CompoundStmt will not enter
	604	// a new scope if inFunction is true
	605	ValueGuard< bool > oldInFunction( inFunction );
	606	inFunction = true;
[7aaec67]	607	maybeMutate_impl( node->statements, *this );
	608	maybeMutate_impl( node->attributes, *this );
	609	}
[e0886db]	610	}
	611
	612	MUTATE_END( DeclarationWithType, node );
[13932f14]	613	}
	614
[e0886db]	615	//--------------------------------------------------------------------------
	616	// StructDecl
[13932f14]	617	template< typename pass_type >
[ab904dc]	618	void PassVisitor< pass_type >::visit( StructDecl * node ) {
[e0886db]	619	VISIT_START( node );
	620
	621	// make up a forward declaration and add it before processing the members
	622	// needs to be on the heap because addStruct saves the pointer
	623	indexerAddStructFwd( node );
	624
	625	{
	626	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[3c398b6]	627	maybeAccept_impl( node->parameters, *this );
	628	maybeAccept_impl( node->members , *this );
[e0886db]	629	}
	630
	631	// this addition replaces the forward declaration
	632	indexerAddStruct( node );
	633
	634	VISIT_END( node );
	635	}
	636
[7870799]	637	template< typename pass_type >
	638	void PassVisitor< pass_type >::visit( const StructDecl * node ) {
	639	VISIT_START( node );
	640
[e3d7f9f]	641	// make up a forward declaration and add it before processing the members
	642	// needs to be on the heap because addStruct saves the pointer
	643	indexerAddStructFwd( node );
	644
	645	{
	646	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
	647	maybeAccept_impl( node->parameters, *this );
	648	maybeAccept_impl( node->members , *this );
	649	}
	650
	651	// this addition replaces the forward declaration
	652	indexerAddStruct( node );
[7870799]	653
	654	VISIT_END( node );
	655	}
	656
[e0886db]	657	template< typename pass_type >
	658	Declaration * PassVisitor< pass_type >::mutate( StructDecl * node ) {
	659	MUTATE_START( node );
	660
	661	// make up a forward declaration and add it before processing the members
	662	// needs to be on the heap because addStruct saves the pointer
	663	indexerAddStructFwd( node );
	664
	665	{
	666	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[3c398b6]	667	maybeMutate_impl( node->parameters, *this );
	668	maybeMutate_impl( node->members , *this );
[e0886db]	669	}
	670
	671	// this addition replaces the forward declaration
	672	indexerAddStruct( node );
	673
	674	MUTATE_END( Declaration, node );
[13932f14]	675	}
	676
[e0886db]	677	//--------------------------------------------------------------------------
	678	// UnionDecl
[13932f14]	679	template< typename pass_type >
[ab904dc]	680	void PassVisitor< pass_type >::visit( UnionDecl * node ) {
[e0886db]	681	VISIT_START( node );
	682
	683	// make up a forward declaration and add it before processing the members
	684	indexerAddUnionFwd( node );
	685
	686	{
	687	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[3c398b6]	688	maybeAccept_impl( node->parameters, *this );
	689	maybeAccept_impl( node->members , *this );
[e0886db]	690	}
	691
	692	indexerAddUnion( node );
	693
	694	VISIT_END( node );
	695	}
[7870799]	696	template< typename pass_type >
	697	void PassVisitor< pass_type >::visit( const UnionDecl * node ) {
	698	VISIT_START( node );
	699
[e3d7f9f]	700	// make up a forward declaration and add it before processing the members
	701	indexerAddUnionFwd( node );
	702
	703	{
	704	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
	705	maybeAccept_impl( node->parameters, *this );
	706	maybeAccept_impl( node->members , *this );
	707	}
	708
	709	indexerAddUnion( node );
[7870799]	710
	711	VISIT_END( node );
	712	}
[e0886db]	713
	714	template< typename pass_type >
	715	Declaration * PassVisitor< pass_type >::mutate( UnionDecl * node ) {
	716	MUTATE_START( node );
	717
	718	// make up a forward declaration and add it before processing the members
	719	indexerAddUnionFwd( node );
	720
	721	{
	722	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[3c398b6]	723	maybeMutate_impl( node->parameters, *this );
	724	maybeMutate_impl( node->members , *this );
[e0886db]	725	}
	726
	727	indexerAddUnion( node );
	728
	729	MUTATE_END( Declaration, node );
[13932f14]	730	}
	731
[e0886db]	732	//--------------------------------------------------------------------------
	733	// EnumDecl
[13932f14]	734	template< typename pass_type >
[ab904dc]	735	void PassVisitor< pass_type >::visit( EnumDecl * node ) {
[e0886db]	736	VISIT_START( node );
	737
	738	indexerAddEnum( node );
	739
[33a25f9]	740	// unlike structs, traits, and unions, enums inject their members into the global scope
[3c398b6]	741	maybeAccept_impl( node->parameters, *this );
	742	maybeAccept_impl( node->members , *this );
[e0886db]	743
	744	VISIT_END( node );
[13932f14]	745	}
	746
[7870799]	747	template< typename pass_type >
	748	void PassVisitor< pass_type >::visit( const EnumDecl * node ) {
	749	VISIT_START( node );
	750
[e3d7f9f]	751	indexerAddEnum( node );
	752
[7870799]	753	// unlike structs, traits, and unions, enums inject their members into the global scope
	754	maybeAccept_impl( node->parameters, *this );
	755	maybeAccept_impl( node->members , *this );
	756
	757	VISIT_END( node );
	758	}
	759
[e0886db]	760	template< typename pass_type >
	761	Declaration * PassVisitor< pass_type >::mutate( EnumDecl * node ) {
	762	MUTATE_START( node );
	763
	764	indexerAddEnum( node );
	765
[522363e]	766	// unlike structs, traits, and unions, enums inject their members into the global scope
[3c398b6]	767	maybeMutate_impl( node->parameters, *this );
	768	maybeMutate_impl( node->members , *this );
[e0886db]	769
	770	MUTATE_END( Declaration, node );
	771	}
	772
	773	//--------------------------------------------------------------------------
	774	// TraitDecl
[13932f14]	775	template< typename pass_type >
[ab904dc]	776	void PassVisitor< pass_type >::visit( TraitDecl * node ) {
[e0886db]	777	VISIT_START( node );
	778
	779	{
	780	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[3c398b6]	781	maybeAccept_impl( node->parameters, *this );
	782	maybeAccept_impl( node->members , *this );
[e0886db]	783	}
	784
	785	indexerAddTrait( node );
	786
	787	VISIT_END( node );
[13932f14]	788	}
	789
[7870799]	790	template< typename pass_type >
	791	void PassVisitor< pass_type >::visit( const TraitDecl * node ) {
	792	VISIT_START( node );
	793
[e3d7f9f]	794	{
	795	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
	796	maybeAccept_impl( node->parameters, *this );
	797	maybeAccept_impl( node->members , *this );
	798	}
	799
	800	indexerAddTrait( node );
[7870799]	801
	802	VISIT_END( node );
	803	}
	804
[e0886db]	805	template< typename pass_type >
	806	Declaration * PassVisitor< pass_type >::mutate( TraitDecl * node ) {
	807	MUTATE_START( node );
	808
	809	{
	810	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[3c398b6]	811	maybeMutate_impl( node->parameters, *this );
	812	maybeMutate_impl( node->members , *this );
[e0886db]	813	}
	814
	815	indexerAddTrait( node );
	816
	817	MUTATE_END( Declaration, node );
	818	}
	819
	820	//--------------------------------------------------------------------------
	821	// TypeDecl
[13932f14]	822	template< typename pass_type >
[ab904dc]	823	void PassVisitor< pass_type >::visit( TypeDecl * node ) {
[e0886db]	824	VISIT_START( node );
	825
	826	{
	827	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[3c398b6]	828	maybeAccept_impl( node->parameters, *this );
	829	maybeAccept_impl( node->base , *this );
[e0886db]	830	}
	831
[33a25f9]	832	// see A NOTE ON THE ORDER OF TRAVERSAL, above
	833	// note that assertions come after the type is added to the symtab, since they are not part of the type proper
	834	// and may depend on the type itself
[e0886db]	835	indexerAddType( node );
	836
[3c398b6]	837	maybeAccept_impl( node->assertions, *this );
[e0886db]	838
	839	indexerScopedAccept( node->init, *this );
	840
	841	VISIT_END( node );
	842	}
	843
[7870799]	844
	845	template< typename pass_type >
	846	void PassVisitor< pass_type >::visit( const TypeDecl * node ) {
	847	VISIT_START( node );
	848
[e3d7f9f]	849	{
	850	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
	851	maybeAccept_impl( node->parameters, *this );
	852	maybeAccept_impl( node->base , *this );
	853	}
	854
	855	// see A NOTE ON THE ORDER OF TRAVERSAL, above
	856	// note that assertions come after the type is added to the symtab, since they are not part of the type proper
	857	// and may depend on the type itself
	858	indexerAddType( node );
	859
[7870799]	860	maybeAccept_impl( node->assertions, *this );
	861
[e3d7f9f]	862	indexerScopedAccept( node->init, *this );
	863
[7870799]	864	VISIT_END( node );
	865	}
	866
[e0886db]	867	template< typename pass_type >
[982832e]	868	Declaration * PassVisitor< pass_type >::mutate( TypeDecl * node ) {
[e0886db]	869	MUTATE_START( node );
	870
	871	{
	872	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[3c398b6]	873	maybeMutate_impl( node->parameters, *this );
	874	maybeMutate_impl( node->base , *this );
[e0886db]	875	}
	876
[33a25f9]	877	// see A NOTE ON THE ORDER OF TRAVERSAL, above
	878	// note that assertions come after the type is added to the symtab, since they are not part of the type proper
	879	// and may depend on the type itself
[e0886db]	880	indexerAddType( node );
	881
[3c398b6]	882	maybeMutate_impl( node->assertions, *this );
[e0886db]	883
	884	indexerScopedMutate( node->init, *this );
	885
[982832e]	886	MUTATE_END( Declaration, node );
[13932f14]	887	}
	888
[e0886db]	889	//--------------------------------------------------------------------------
	890	// TypedefDecl
[13932f14]	891	template< typename pass_type >
[ab904dc]	892	void PassVisitor< pass_type >::visit( TypedefDecl * node ) {
[e0886db]	893	VISIT_START( node );
	894
	895	{
	896	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[3c398b6]	897	maybeAccept_impl( node->parameters, *this );
	898	maybeAccept_impl( node->base , *this );
[e0886db]	899	}
	900
	901	indexerAddType( node );
	902
[3c398b6]	903	maybeAccept_impl( node->assertions, *this );
[e0886db]	904
	905	VISIT_END( node );
[13932f14]	906	}
	907
[7870799]	908	template< typename pass_type >
	909	void PassVisitor< pass_type >::visit( const TypedefDecl * node ) {
	910	VISIT_START( node );
	911
[e3d7f9f]	912	{
	913	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
	914	maybeAccept_impl( node->parameters, *this );
	915	maybeAccept_impl( node->base , *this );
	916	}
	917
	918	indexerAddType( node );
	919
[7870799]	920	maybeAccept_impl( node->assertions, *this );
	921
	922	VISIT_END( node );
	923	}
	924
[13932f14]	925	template< typename pass_type >
[e0886db]	926	Declaration * PassVisitor< pass_type >::mutate( TypedefDecl * node ) {
	927	MUTATE_START( node );
	928
	929	{
	930	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[3c398b6]	931	maybeMutate_impl( node->parameters, *this );
	932	maybeMutate_impl( node->base , *this );
[e0886db]	933	}
	934
	935	indexerAddType( node );
	936
[3c398b6]	937	maybeMutate_impl( node->assertions, *this );
[e0886db]	938
	939	MUTATE_END( Declaration, node );
[13932f14]	940	}
	941
[9c1600c]	942	//--------------------------------------------------------------------------
[e0886db]	943	// AsmDecl
[13932f14]	944	template< typename pass_type >
[e0886db]	945	void PassVisitor< pass_type >::visit( AsmDecl * node ) {
[9c1600c]	946	VISIT_START( node );
	947
[3c398b6]	948	maybeAccept_impl( node->stmt, *this );
[9c1600c]	949
	950	VISIT_END( node );
[13932f14]	951	}
	952
[7870799]	953	template< typename pass_type >
	954	void PassVisitor< pass_type >::visit( const AsmDecl * node ) {
	955	VISIT_START( node );
	956
	957	maybeAccept_impl( node->stmt, *this );
	958
	959	VISIT_END( node );
	960	}
	961
[296b2be]	962	template< typename pass_type >
[e0886db]	963	AsmDecl * PassVisitor< pass_type >::mutate( AsmDecl * node ) {
[296b2be]	964	MUTATE_START( node );
	965
[3c398b6]	966	maybeMutate_impl( node->stmt, *this );
[e0886db]	967
	968	MUTATE_END( AsmDecl, node );
	969	}
	970
[f6e3e34]	971	//--------------------------------------------------------------------------
	972	// StaticAssertDecl
	973	template< typename pass_type >
	974	void PassVisitor< pass_type >::visit( StaticAssertDecl * node ) {
	975	VISIT_START( node );
	976
[842c3d3]	977	node->condition = visitExpression( node->condition );
	978	maybeAccept_impl( node->message, *this );
[f6e3e34]	979
	980	VISIT_END( node );
	981	}
	982
[7870799]	983	template< typename pass_type >
	984	void PassVisitor< pass_type >::visit( const StaticAssertDecl * node ) {
	985	VISIT_START( node );
	986
	987	visitExpression( node->condition );
	988	maybeAccept_impl( node->message, *this );
	989
	990	VISIT_END( node );
	991	}
	992
[f6e3e34]	993	template< typename pass_type >
	994	StaticAssertDecl * PassVisitor< pass_type >::mutate( StaticAssertDecl * node ) {
	995	MUTATE_START( node );
	996
[842c3d3]	997	node->condition = mutateExpression( node->condition );
	998	maybeMutate_impl( node->message, *this );
[f6e3e34]	999
	1000	MUTATE_END( StaticAssertDecl, node );
	1001	}
	1002
[e0886db]	1003	//--------------------------------------------------------------------------
	1004	// CompoundStmt
	1005	template< typename pass_type >
	1006	void PassVisitor< pass_type >::visit( CompoundStmt * node ) {
	1007	VISIT_START( node );
	1008	{
[61d9b4b]	1009	// do not enter a new scope if inFunction is true - needs to check old state before the assignment
	1010	ValueGuard< bool > oldInFunction( inFunction );
	1011	auto guard1 = makeFuncGuard( [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeEnter(); }, [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeLeave(); } );
[e0886db]	1012	auto guard2 = makeFuncGuard( [this]() { call_beginScope(); }, [this]() { call_endScope(); } );
[61d9b4b]	1013	inFunction = false;
[e0886db]	1014	visitStatementList( node->kids );
	1015	}
	1016	VISIT_END( node );
	1017	}
[296b2be]	1018
[7870799]	1019	template< typename pass_type >
	1020	void PassVisitor< pass_type >::visit( const CompoundStmt * node ) {
	1021	VISIT_START( node );
	1022	{
	1023	// do not enter a new scope if inFunction is true - needs to check old state before the assignment
	1024	ValueGuard< bool > oldInFunction( inFunction );
	1025	auto guard1 = makeFuncGuard( [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeEnter(); }, [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeLeave(); } );
	1026	auto guard2 = makeFuncGuard( [this]() { call_beginScope(); }, [this]() { call_endScope(); } );
	1027	inFunction = false;
	1028	visitStatementList( node->kids );
	1029	}
	1030	VISIT_END( node );
	1031	}
	1032
[e0886db]	1033	template< typename pass_type >
	1034	CompoundStmt * PassVisitor< pass_type >::mutate( CompoundStmt * node ) {
	1035	MUTATE_START( node );
	1036	{
[61d9b4b]	1037	// do not enter a new scope if inFunction is true - needs to check old state before the assignment
	1038	ValueGuard< bool > oldInFunction( inFunction );
	1039	auto guard1 = makeFuncGuard( [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeEnter(); }, [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeLeave(); } );
[e0886db]	1040	auto guard2 = makeFuncGuard( [this]() { call_beginScope(); }, [this]() { call_endScope(); } );
[61d9b4b]	1041	inFunction = false;
[e0886db]	1042	mutateStatementList( node->kids );
	1043	}
[296b2be]	1044	MUTATE_END( CompoundStmt, node );
	1045	}
	1046
[9c1600c]	1047	//--------------------------------------------------------------------------
	1048	// ExprStmt
[13932f14]	1049	template< typename pass_type >
[ab904dc]	1050	void PassVisitor< pass_type >::visit( ExprStmt * node ) {
[9c1600c]	1051	VISIT_START( node );
	1052
[e0886db]	1053	visitExpression( node->expr );
[9c1600c]	1054
	1055	VISIT_END( node );
[13932f14]	1056	}
	1057
[7870799]	1058	template< typename pass_type >
	1059	void PassVisitor< pass_type >::visit( const ExprStmt * node ) {
	1060	VISIT_START( node );
	1061
	1062	visitExpression( node->expr );
	1063
	1064	VISIT_END( node );
	1065	}
	1066
[296b2be]	1067	template< typename pass_type >
	1068	Statement * PassVisitor< pass_type >::mutate( ExprStmt * node ) {
	1069	MUTATE_START( node );
	1070
[e0886db]	1071	node->expr = mutateExpression( node->expr );
[296b2be]	1072
	1073	MUTATE_END( Statement, node );
	1074	}
	1075
[6ca154b]	1076	//--------------------------------------------------------------------------
	1077	// AsmStmt
[13932f14]	1078	template< typename pass_type >
[ab904dc]	1079	void PassVisitor< pass_type >::visit( AsmStmt * node ) {
[bc6f918]	1080	VISIT_START( node )
	1081
	1082	maybeAccept_impl( node->instruction, *this );
	1083	maybeAccept_impl( node->output, *this );
	1084	maybeAccept_impl( node->input, *this );
	1085	maybeAccept_impl( node->clobber, *this );
	1086
	1087	VISIT_END( node );
[13932f14]	1088	}
	1089
[7870799]	1090	template< typename pass_type >
	1091	void PassVisitor< pass_type >::visit( const AsmStmt * node ) {
	1092	VISIT_START( node )
	1093
	1094	maybeAccept_impl( node->instruction, *this );
	1095	maybeAccept_impl( node->output, *this );
	1096	maybeAccept_impl( node->input, *this );
	1097	maybeAccept_impl( node->clobber, *this );
	1098
	1099	VISIT_END( node );
	1100	}
	1101
[6ca154b]	1102	template< typename pass_type >
	1103	Statement * PassVisitor< pass_type >::mutate( AsmStmt * node ) {
[bc6f918]	1104	MUTATE_START( node );
	1105
	1106	maybeMutate_impl( node->instruction, *this );
	1107	maybeMutate_impl( node->output, *this );
	1108	maybeMutate_impl( node->input, *this );
	1109	maybeMutate_impl( node->clobber, *this );
	1110
	1111	MUTATE_END( Statement, node );
[6ca154b]	1112	}
	1113
[cc32d83]	1114	//--------------------------------------------------------------------------
	1115	// AsmStmt
	1116	template< typename pass_type >
	1117	void PassVisitor< pass_type >::visit( DirectiveStmt * node ) {
	1118	VISIT_START( node )
	1119
	1120	VISIT_END( node );
	1121	}
	1122
[7870799]	1123	template< typename pass_type >
	1124	void PassVisitor< pass_type >::visit( const DirectiveStmt * node ) {
	1125	VISIT_START( node )
	1126
	1127	VISIT_END( node );
	1128	}
	1129
[cc32d83]	1130	template< typename pass_type >
	1131	Statement * PassVisitor< pass_type >::mutate( DirectiveStmt * node ) {
	1132	MUTATE_START( node );
	1133
	1134	MUTATE_END( Statement, node );
	1135	}
	1136
[9c1600c]	1137	//--------------------------------------------------------------------------
	1138	// IfStmt
[13932f14]	1139	template< typename pass_type >
[ab904dc]	1140	void PassVisitor< pass_type >::visit( IfStmt * node ) {
[4551a6e]	1141	VISIT_START( node );
[33a25f9]	1142	{
	1143	// if statements introduce a level of scope (for the initialization)
	1144	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[7870799]	1145	maybeAccept_impl( node->initialization, *this );
[3c398b6]	1146	visitExpression ( node->condition );
[33a25f9]	1147	node->thenPart = visitStatement( node->thenPart );
	1148	node->elsePart = visitStatement( node->elsePart );
	1149	}
[9c1600c]	1150	VISIT_END( node );
[13932f14]	1151	}
	1152
[7870799]	1153	template< typename pass_type >
	1154	void PassVisitor< pass_type >::visit( const IfStmt * node ) {
	1155	VISIT_START( node );
[e3d7f9f]	1156	{
	1157	// if statements introduce a level of scope (for the initialization)
	1158	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
	1159	maybeAccept_impl( node->initialization, *this );
	1160	visitExpression ( node->condition );
	1161	visitStatement ( node->thenPart );
	1162	visitStatement ( node->elsePart );
	1163	}
[7870799]	1164	VISIT_END( node );
	1165	}
	1166
[296b2be]	1167	template< typename pass_type >
	1168	Statement * PassVisitor< pass_type >::mutate( IfStmt * node ) {
[4551a6e]	1169	MUTATE_START( node );
[e0886db]	1170	{
[33a25f9]	1171	// if statements introduce a level of scope (for the initialization)
[e0886db]	1172	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[7870799]	1173	maybeMutate_impl( node->initialization, *this );
[e0886db]	1174	node->condition = mutateExpression( node->condition );
	1175	node->thenPart = mutateStatement ( node->thenPart );
	1176	node->elsePart = mutateStatement ( node->elsePart );
	1177	}
[296b2be]	1178	MUTATE_END( Statement, node );
	1179	}
	1180
[9c1600c]	1181	//--------------------------------------------------------------------------
	1182	// WhileStmt
[13932f14]	1183	template< typename pass_type >
[ab904dc]	1184	void PassVisitor< pass_type >::visit( WhileStmt * node ) {
[4551a6e]	1185	VISIT_START( node );
[9c1600c]	1186
[ee3c93d]	1187	{
	1188	// while statements introduce a level of scope (for the initialization)
	1189	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
	1190	maybeAccept_impl( node->initialization, *this );
	1191	visitExpression ( node->condition );
	1192	node->body = visitStatement( node->body );
	1193	}
[9c1600c]	1194
	1195	VISIT_END( node );
[13932f14]	1196	}
	1197
[7870799]	1198	template< typename pass_type >
	1199	void PassVisitor< pass_type >::visit( const WhileStmt * node ) {
	1200	VISIT_START( node );
	1201
[e3d7f9f]	1202	{
	1203	// while statements introduce a level of scope (for the initialization)
	1204	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
	1205	maybeAccept_impl( node->initialization, *this );
	1206	visitExpression ( node->condition );
	1207	visitStatement ( node->body );
	1208	}
[7870799]	1209
	1210	VISIT_END( node );
	1211	}
	1212
[296b2be]	1213	template< typename pass_type >
	1214	Statement * PassVisitor< pass_type >::mutate( WhileStmt * node ) {
[4551a6e]	1215	MUTATE_START( node );
[296b2be]	1216
[ee3c93d]	1217	{
	1218	// while statements introduce a level of scope (for the initialization)
	1219	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
	1220	maybeMutate_impl( node->initialization, *this );
	1221	node->condition = mutateExpression( node->condition );
	1222	node->body = mutateStatement ( node->body );
	1223	}
	1224
[296b2be]	1225
	1226	MUTATE_END( Statement, node );
	1227	}
	1228
[9c1600c]	1229	//--------------------------------------------------------------------------
[6ca154b]	1230	// ForStmt
[13932f14]	1231	template< typename pass_type >
[ab904dc]	1232	void PassVisitor< pass_type >::visit( ForStmt * node ) {
[4551a6e]	1233	VISIT_START( node );
[e0886db]	1234	{
[33a25f9]	1235	// for statements introduce a level of scope (for the initialization)
[e0886db]	1236	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[3c398b6]	1237	maybeAccept_impl( node->initialization, *this );
[e0886db]	1238	visitExpression( node->condition );
	1239	visitExpression( node->increment );
	1240	node->body = visitStatement( node->body );
	1241	}
[9c1600c]	1242	VISIT_END( node );
[13932f14]	1243	}
	1244
[7870799]	1245	template< typename pass_type >
	1246	void PassVisitor< pass_type >::visit( const ForStmt * node ) {
	1247	VISIT_START( node );
[e3d7f9f]	1248	{
	1249	// for statements introduce a level of scope (for the initialization)
	1250	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
	1251	maybeAccept_impl( node->initialization, *this );
	1252	visitExpression( node->condition );
	1253	visitExpression( node->increment );
	1254	visitStatement ( node->body );
	1255	}
[7870799]	1256	VISIT_END( node );
	1257	}
	1258
[296b2be]	1259	template< typename pass_type >
	1260	Statement * PassVisitor< pass_type >::mutate( ForStmt * node ) {
[4551a6e]	1261	MUTATE_START( node );
[e0886db]	1262	{
[33a25f9]	1263	// for statements introduce a level of scope (for the initialization)
[e0886db]	1264	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[3c398b6]	1265	maybeMutate_impl( node->initialization, *this );
[e0886db]	1266	node->condition = mutateExpression( node->condition );
	1267	node->increment = mutateExpression( node->increment );
	1268	node->body = mutateStatement ( node->body );
	1269	}
[296b2be]	1270	MUTATE_END( Statement, node );
	1271	}
	1272
[9c1600c]	1273	//--------------------------------------------------------------------------
	1274	// SwitchStmt
[13932f14]	1275	template< typename pass_type >
[ab904dc]	1276	void PassVisitor< pass_type >::visit( SwitchStmt * node ) {
[4551a6e]	1277	VISIT_START( node );
[9c1600c]	1278
[e0886db]	1279	visitExpression ( node->condition );
	1280	visitStatementList( node->statements );
[9c1600c]	1281
	1282	VISIT_END( node );
[13932f14]	1283	}
	1284
[7870799]	1285	template< typename pass_type >
	1286	void PassVisitor< pass_type >::visit( const SwitchStmt * node ) {
	1287	VISIT_START( node );
	1288
	1289	visitExpression ( node->condition );
	1290	visitStatementList( node->statements );
	1291
	1292	VISIT_END( node );
	1293	}
	1294
[296b2be]	1295	template< typename pass_type >
	1296	Statement * PassVisitor< pass_type >::mutate( SwitchStmt * node ) {
[4551a6e]	1297	MUTATE_START( node );
	1298
[e0886db]	1299	node->condition = mutateExpression( node->condition );
	1300	mutateStatementList( node->statements );
[4551a6e]	1301
[296b2be]	1302	MUTATE_END( Statement, node );
	1303	}
	1304
[9c1600c]	1305	//--------------------------------------------------------------------------
[35df560]	1306	// CaseStmt
[13932f14]	1307	template< typename pass_type >
[ab904dc]	1308	void PassVisitor< pass_type >::visit( CaseStmt * node ) {
[4551a6e]	1309	VISIT_START( node );
	1310
[e0886db]	1311	visitExpression ( node->condition );
	1312	visitStatementList( node->stmts );
[4551a6e]	1313
[9c1600c]	1314	VISIT_END( node );
[13932f14]	1315	}
	1316
[7870799]	1317	template< typename pass_type >
	1318	void PassVisitor< pass_type >::visit( const CaseStmt * node ) {
	1319	VISIT_START( node );
	1320
	1321	visitExpression ( node->condition );
	1322	visitStatementList( node->stmts );
	1323
	1324	VISIT_END( node );
	1325	}
	1326
[296b2be]	1327	template< typename pass_type >
	1328	Statement * PassVisitor< pass_type >::mutate( CaseStmt * node ) {
[4551a6e]	1329	MUTATE_START( node );
	1330
[e0886db]	1331	node->condition = mutateExpression( node->condition );
	1332	mutateStatementList( node->stmts );
[4551a6e]	1333
[296b2be]	1334	MUTATE_END( Statement, node );
	1335	}
	1336
[6ca154b]	1337	//--------------------------------------------------------------------------
	1338	// BranchStmt
[13932f14]	1339	template< typename pass_type >
[ab904dc]	1340	void PassVisitor< pass_type >::visit( BranchStmt * node ) {
[33c0ce8]	1341	VISIT_START( node );
	1342	VISIT_END( node );
[13932f14]	1343	}
	1344
[7870799]	1345	template< typename pass_type >
	1346	void PassVisitor< pass_type >::visit( const BranchStmt * node ) {
	1347	VISIT_START( node );
	1348	VISIT_END( node );
	1349	}
	1350
[6ca154b]	1351	template< typename pass_type >
	1352	Statement * PassVisitor< pass_type >::mutate( BranchStmt * node ) {
[33c0ce8]	1353	MUTATE_START( node );
	1354	MUTATE_END( Statement, node );
[6ca154b]	1355	}
	1356
[9c1600c]	1357	//--------------------------------------------------------------------------
	1358	// ReturnStmt
[13932f14]	1359	template< typename pass_type >
[ab904dc]	1360	void PassVisitor< pass_type >::visit( ReturnStmt * node ) {
[9c1600c]	1361	VISIT_START( node );
	1362
[e0886db]	1363	visitExpression( node->expr );
[9c1600c]	1364
	1365	VISIT_END( node );
[13932f14]	1366	}
	1367
[7870799]	1368	template< typename pass_type >
	1369	void PassVisitor< pass_type >::visit( const ReturnStmt * node ) {
	1370	VISIT_START( node );
	1371
	1372	visitExpression( node->expr );
	1373
	1374	VISIT_END( node );
	1375	}
	1376
[296b2be]	1377	template< typename pass_type >
	1378	Statement * PassVisitor< pass_type >::mutate( ReturnStmt * node ) {
	1379	MUTATE_START( node );
	1380
[e0886db]	1381	node->expr = mutateExpression( node->expr );
[296b2be]	1382
	1383	MUTATE_END( Statement, node );
	1384	}
	1385
[6e09f211]	1386	//--------------------------------------------------------------------------
	1387	// ThrowStmt
	1388	template< typename pass_type >
	1389	void PassVisitor< pass_type >::visit( ThrowStmt * node ) {
[33c0ce8]	1390	VISIT_START( node );
	1391
	1392	maybeAccept_impl( node->expr, *this );
	1393	maybeAccept_impl( node->target, *this );
	1394
	1395	VISIT_END( node );
[6e09f211]	1396	}
	1397
[7870799]	1398	template< typename pass_type >
	1399	void PassVisitor< pass_type >::visit( const ThrowStmt * node ) {
	1400	VISIT_START( node );
	1401
	1402	maybeAccept_impl( node->expr, *this );
	1403	maybeAccept_impl( node->target, *this );
	1404
	1405	VISIT_END( node );
	1406	}
	1407
[6e09f211]	1408	template< typename pass_type >
	1409	Statement * PassVisitor< pass_type >::mutate( ThrowStmt * node ) {
[33c0ce8]	1410	MUTATE_START( node );
	1411
	1412	maybeMutate_impl( node->expr, *this );
	1413	maybeMutate_impl( node->target, *this );
	1414
	1415	MUTATE_END( Statement, node );
[6e09f211]	1416	}
	1417
[9c1600c]	1418	//--------------------------------------------------------------------------
	1419	// TryStmt
[13932f14]	1420	template< typename pass_type >
[ab904dc]	1421	void PassVisitor< pass_type >::visit( TryStmt * node ) {
[9c1600c]	1422	VISIT_START( node );
	1423
[3c398b6]	1424	maybeAccept_impl( node->block , *this );
	1425	maybeAccept_impl( node->handlers , *this );
	1426	maybeAccept_impl( node->finallyBlock, *this );
[9c1600c]	1427
	1428	VISIT_END( node );
[13932f14]	1429	}
	1430
[7870799]	1431	template< typename pass_type >
	1432	void PassVisitor< pass_type >::visit( const TryStmt * node ) {
	1433	VISIT_START( node );
	1434
	1435	maybeAccept_impl( node->block , *this );
	1436	maybeAccept_impl( node->handlers , *this );
	1437	maybeAccept_impl( node->finallyBlock, *this );
	1438
	1439	VISIT_END( node );
	1440	}
	1441
[296b2be]	1442	template< typename pass_type >
	1443	Statement * PassVisitor< pass_type >::mutate( TryStmt * node ) {
	1444	MUTATE_START( node );
	1445
[3c398b6]	1446	maybeMutate_impl( node->block , *this );
	1447	maybeMutate_impl( node->handlers , *this );
	1448	maybeMutate_impl( node->finallyBlock, *this );
[4551a6e]	1449
[296b2be]	1450	MUTATE_END( Statement, node );
	1451	}
	1452
[9c1600c]	1453	//--------------------------------------------------------------------------
	1454	// CatchStmt
[13932f14]	1455	template< typename pass_type >
[ab904dc]	1456	void PassVisitor< pass_type >::visit( CatchStmt * node ) {
[9c1600c]	1457	VISIT_START( node );
[e0886db]	1458	{
[33a25f9]	1459	// catch statements introduce a level of scope (for the caught exception)
[e0886db]	1460	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[3c398b6]	1461	maybeAccept_impl( node->decl, *this );
[e0886db]	1462	node->cond = visitExpression( node->cond );
	1463	node->body = visitStatement ( node->body );
	1464	}
[9c1600c]	1465	VISIT_END( node );
[13932f14]	1466	}
	1467
[7870799]	1468	template< typename pass_type >
	1469	void PassVisitor< pass_type >::visit( const CatchStmt * node ) {
	1470	VISIT_START( node );
[e3d7f9f]	1471	{
	1472	// catch statements introduce a level of scope (for the caught exception)
	1473	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
	1474	maybeAccept_impl( node->decl, *this );
	1475	visitExpression ( node->cond );
	1476	visitStatement ( node->body );
	1477	}
[7870799]	1478	VISIT_END( node );
	1479	}
	1480
[296b2be]	1481	template< typename pass_type >
	1482	Statement * PassVisitor< pass_type >::mutate( CatchStmt * node ) {
	1483	MUTATE_START( node );
[e0886db]	1484	{
[33a25f9]	1485	// catch statements introduce a level of scope (for the caught exception)
[e0886db]	1486	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[3c398b6]	1487	maybeMutate_impl( node->decl, *this );
[e0886db]	1488	node->cond = mutateExpression( node->cond );
	1489	node->body = mutateStatement ( node->body );
	1490	}
[296b2be]	1491	MUTATE_END( Statement, node );
	1492	}
	1493
[2065609]	1494	//--------------------------------------------------------------------------
	1495	// FinallyStmt
[13932f14]	1496	template< typename pass_type >
[ab904dc]	1497	void PassVisitor< pass_type >::visit( FinallyStmt * node ) {
[11b7028]	1498	VISIT_START( node );
	1499
	1500	maybeAccept_impl( node->block, *this );
	1501
	1502	VISIT_END( node );
[13932f14]	1503	}
	1504
[7870799]	1505	template< typename pass_type >
	1506	void PassVisitor< pass_type >::visit( const FinallyStmt * node ) {
	1507	VISIT_START( node );
	1508
	1509	maybeAccept_impl( node->block, *this );
	1510
	1511	VISIT_END( node );
	1512	}
	1513
[2065609]	1514	template< typename pass_type >
	1515	Statement * PassVisitor< pass_type >::mutate( FinallyStmt * node ) {
[11b7028]	1516	MUTATE_START( node );
	1517
	1518	maybeMutate_impl( node->block, *this );
	1519
	1520	MUTATE_END( Statement, node );
[2065609]	1521	}
	1522
	1523	//--------------------------------------------------------------------------
	1524	// WaitForStmt
	1525	template< typename pass_type >
	1526	void PassVisitor< pass_type >::visit( WaitForStmt * node ) {
[834b892]	1527	VISIT_START( node );
	1528
	1529	for( auto & clause : node->clauses ) {
	1530	maybeAccept_impl( clause.target.function, *this );
	1531	maybeAccept_impl( clause.target.arguments, *this );
	1532
	1533	maybeAccept_impl( clause.statement, *this );
	1534	maybeAccept_impl( clause.condition, *this );
	1535	}
	1536
	1537	maybeAccept_impl( node->timeout.time, *this );
	1538	maybeAccept_impl( node->timeout.statement, *this );
	1539	maybeAccept_impl( node->timeout.condition, *this );
	1540	maybeAccept_impl( node->orelse.statement, *this );
	1541	maybeAccept_impl( node->orelse.condition, *this );
	1542
	1543	VISIT_END( node );
[2065609]	1544	}
	1545
[7870799]	1546	template< typename pass_type >
	1547	void PassVisitor< pass_type >::visit( const WaitForStmt * node ) {
	1548	VISIT_START( node );
	1549
	1550	for( auto & clause : node->clauses ) {
	1551	maybeAccept_impl( clause.target.function, *this );
	1552	maybeAccept_impl( clause.target.arguments, *this );
	1553
	1554	maybeAccept_impl( clause.statement, *this );
	1555	maybeAccept_impl( clause.condition, *this );
	1556	}
	1557
	1558	maybeAccept_impl( node->timeout.time, *this );
	1559	maybeAccept_impl( node->timeout.statement, *this );
	1560	maybeAccept_impl( node->timeout.condition, *this );
	1561	maybeAccept_impl( node->orelse.statement, *this );
	1562	maybeAccept_impl( node->orelse.condition, *this );
	1563
	1564	VISIT_END( node );
	1565	}
	1566
[2065609]	1567	template< typename pass_type >
	1568	Statement * PassVisitor< pass_type >::mutate( WaitForStmt * node ) {
[834b892]	1569	MUTATE_START( node );
	1570
	1571	for( auto & clause : node->clauses ) {
	1572	maybeMutate_impl( clause.target.function, *this );
	1573	maybeMutate_impl( clause.target.arguments, *this );
	1574
	1575	maybeMutate_impl( clause.statement, *this );
	1576	maybeMutate_impl( clause.condition, *this );
	1577	}
	1578
	1579	maybeMutate_impl( node->timeout.time, *this );
	1580	maybeMutate_impl( node->timeout.statement, *this );
	1581	maybeMutate_impl( node->timeout.condition, *this );
	1582	maybeMutate_impl( node->orelse.statement, *this );
	1583	maybeMutate_impl( node->orelse.condition, *this );
	1584
	1585	MUTATE_END( Statement, node );
[2065609]	1586	}
	1587
[d8893ca]	1588
	1589
[61255ad]	1590	//--------------------------------------------------------------------------
[7870799]	1591	// WithStmt
[61255ad]	1592	template< typename pass_type >
	1593	void PassVisitor< pass_type >::visit( WithStmt * node ) {
[d8893ca]	1594	VISIT_START( node );
	1595	maybeAccept_impl( node->exprs, *this );
	1596	{
	1597	// catch statements introduce a level of scope (for the caught exception)
	1598	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[0ac366b]	1599	indexerAddWith( node->exprs, node );
[d8893ca]	1600	maybeAccept_impl( node->stmt, *this );
	1601	}
	1602	VISIT_END( node );
[61255ad]	1603	}
	1604
[7870799]	1605	template< typename pass_type >
	1606	void PassVisitor< pass_type >::visit( const WithStmt * node ) {
	1607	VISIT_START( node );
	1608	maybeAccept_impl( node->exprs, *this );
[e3d7f9f]	1609	{
	1610	// catch statements introduce a level of scope (for the caught exception)
	1611	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
	1612	indexerAddWith( node->exprs, node );
	1613	maybeAccept_impl( node->stmt, *this );
	1614	}
[7870799]	1615	VISIT_END( node );
	1616	}
	1617
[61255ad]	1618	template< typename pass_type >
[e67991f]	1619	Declaration * PassVisitor< pass_type >::mutate( WithStmt * node ) {
[d8893ca]	1620	MUTATE_START( node );
	1621	maybeMutate_impl( node->exprs, *this );
	1622	{
	1623	// catch statements introduce a level of scope (for the caught exception)
	1624	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[0ac366b]	1625	indexerAddWith( node->exprs, node );
[d8893ca]	1626	maybeMutate_impl( node->stmt, *this );
	1627	}
[e67991f]	1628	MUTATE_END( Declaration, node );
[61255ad]	1629	}
	1630
[2065609]	1631	//--------------------------------------------------------------------------
	1632	// NullStmt
[13932f14]	1633	template< typename pass_type >
[ab904dc]	1634	void PassVisitor< pass_type >::visit( NullStmt * node ) {
[5964127]	1635	VISIT_START( node );
	1636	VISIT_END( node );
[13932f14]	1637	}
	1638
[7870799]	1639	template< typename pass_type >
	1640	void PassVisitor< pass_type >::visit( const NullStmt * node ) {
	1641	VISIT_START( node );
	1642	VISIT_END( node );
	1643	}
	1644
[2065609]	1645	template< typename pass_type >
	1646	NullStmt * PassVisitor< pass_type >::mutate( NullStmt * node ) {
[5964127]	1647	MUTATE_START( node );
	1648	MUTATE_END( NullStmt, node );
[2065609]	1649	}
	1650
	1651	//--------------------------------------------------------------------------
	1652	// DeclStmt
[13932f14]	1653	template< typename pass_type >
[ab904dc]	1654	void PassVisitor< pass_type >::visit( DeclStmt * node ) {
[5964127]	1655	VISIT_START( node );
	1656
	1657	maybeAccept_impl( node->decl, *this );
	1658
	1659	VISIT_END( node );
[13932f14]	1660	}
	1661
[7870799]	1662	template< typename pass_type >
	1663	void PassVisitor< pass_type >::visit( const DeclStmt * node ) {
	1664	VISIT_START( node );
	1665
	1666	maybeAccept_impl( node->decl, *this );
	1667
	1668	VISIT_END( node );
	1669	}
	1670
[2065609]	1671	template< typename pass_type >
	1672	Statement * PassVisitor< pass_type >::mutate( DeclStmt * node ) {
[5964127]	1673	MUTATE_START( node );
	1674
	1675	maybeMutate_impl( node->decl, *this );
	1676
	1677	MUTATE_END( Statement, node );
[2065609]	1678	}
	1679
	1680	//--------------------------------------------------------------------------
	1681	// ImplicitCtorDtorStmt
[13932f14]	1682	template< typename pass_type >
[ab904dc]	1683	void PassVisitor< pass_type >::visit( ImplicitCtorDtorStmt * node ) {
[599fbb6]	1684	VISIT_START( node );
	1685
	1686	maybeAccept_impl( node->callStmt, *this );
	1687
	1688	VISIT_END( node );
[13932f14]	1689	}
	1690
[7870799]	1691	template< typename pass_type >
	1692	void PassVisitor< pass_type >::visit( const ImplicitCtorDtorStmt * node ) {
	1693	VISIT_START( node );
	1694
	1695	maybeAccept_impl( node->callStmt, *this );
	1696
	1697	VISIT_END( node );
	1698	}
	1699
[2065609]	1700	template< typename pass_type >
	1701	Statement * PassVisitor< pass_type >::mutate( ImplicitCtorDtorStmt * node ) {
[599fbb6]	1702	MUTATE_START( node );
	1703
	1704	maybeMutate_impl( node->callStmt, *this );
	1705
	1706	MUTATE_END( Statement, node );
[2065609]	1707	}
	1708
	1709	//--------------------------------------------------------------------------
	1710	// ApplicationExpr
[13932f14]	1711	template< typename pass_type >
[ab904dc]	1712	void PassVisitor< pass_type >::visit( ApplicationExpr * node ) {
[e0886db]	1713	VISIT_START( node );
	1714
	1715	indexerScopedAccept( node->result , *this );
[e3d7f9f]	1716	maybeAccept_impl ( node->function, *this );
	1717	maybeAccept_impl ( node->args , *this );
[e0886db]	1718
	1719	VISIT_END( node );
[13932f14]	1720	}
	1721
[7870799]	1722	template< typename pass_type >
	1723	void PassVisitor< pass_type >::visit( const ApplicationExpr * node ) {
	1724	VISIT_START( node );
	1725
[e3d7f9f]	1726	indexerScopedAccept( node->result , *this );
	1727	maybeAccept_impl ( node->function, *this );
	1728	maybeAccept_impl ( node->args , *this );
[7870799]	1729
	1730	VISIT_END( node );
	1731	}
	1732
[2065609]	1733	template< typename pass_type >
	1734	Expression * PassVisitor< pass_type >::mutate( ApplicationExpr * node ) {
[e0886db]	1735	MUTATE_START( node );
	1736
	1737	indexerScopedMutate( node->env , *this );
	1738	indexerScopedMutate( node->result , *this );
[3c398b6]	1739	maybeMutate_impl ( node->function, *this );
	1740	maybeMutate_impl ( node->args , *this );
[e0886db]	1741
	1742	MUTATE_END( Expression, node );
[2065609]	1743	}
	1744
[9c1600c]	1745	//--------------------------------------------------------------------------
	1746	// UntypedExpr
[13932f14]	1747	template< typename pass_type >
[ab904dc]	1748	void PassVisitor< pass_type >::visit( UntypedExpr * node ) {
[9c1600c]	1749	VISIT_START( node );
	1750
[3c398b6]	1751	// maybeAccept_impl( node->get_env(), *this );
[e0886db]	1752	indexerScopedAccept( node->result, *this );
[2a7b3ca]	1753
[e0886db]	1754	for ( auto expr : node->args ) {
[9c1600c]	1755	visitExpression( expr );
	1756	}
	1757
	1758	VISIT_END( node );
[13932f14]	1759	}
	1760
[7870799]	1761	template< typename pass_type >
	1762	void PassVisitor< pass_type >::visit( const UntypedExpr * node ) {
	1763	VISIT_START( node );
	1764
[e3d7f9f]	1765	indexerScopedAccept( node->result, *this );
[7870799]	1766
	1767	for ( auto expr : node->args ) {
	1768	visitExpression( expr );
	1769	}
	1770
	1771	VISIT_END( node );
	1772	}
	1773
[296b2be]	1774	template< typename pass_type >
	1775	Expression * PassVisitor< pass_type >::mutate( UntypedExpr * node ) {
	1776	MUTATE_START( node );
	1777
[e0886db]	1778	indexerScopedMutate( node->env , *this );
	1779	indexerScopedMutate( node->result, *this );
[2a7b3ca]	1780
[e0886db]	1781	for ( auto& expr : node->args ) {
[296b2be]	1782	expr = mutateExpression( expr );
	1783	}
	1784
	1785	MUTATE_END( Expression, node );
	1786	}
	1787
[e0886db]	1788	//--------------------------------------------------------------------------
	1789	// NameExpr
[13932f14]	1790	template< typename pass_type >
[ab904dc]	1791	void PassVisitor< pass_type >::visit( NameExpr * node ) {
[e0886db]	1792	VISIT_START( node );
	1793
	1794	indexerScopedAccept( node->result, *this );
	1795
	1796	VISIT_END( node );
[13932f14]	1797	}
	1798
[7870799]	1799	template< typename pass_type >
	1800	void PassVisitor< pass_type >::visit( const NameExpr * node ) {
	1801	VISIT_START( node );
	1802
[e3d7f9f]	1803	indexerScopedAccept( node->result, *this );
[7870799]	1804
	1805	VISIT_END( node );
	1806	}
	1807
[13932f14]	1808	template< typename pass_type >
[e0886db]	1809	Expression * PassVisitor< pass_type >::mutate( NameExpr * node ) {
	1810	MUTATE_START( node );
	1811
	1812	indexerScopedMutate( node->env , *this );
	1813	indexerScopedMutate( node->result, *this );
	1814
	1815	MUTATE_END( Expression, node );
[13932f14]	1816	}
	1817
[e0886db]	1818	//--------------------------------------------------------------------------
	1819	// CastExpr
[a5f0529]	1820	template< typename pass_type >
[e0886db]	1821	void PassVisitor< pass_type >::visit( CastExpr * node ) {
	1822	VISIT_START( node );
	1823
	1824	indexerScopedAccept( node->result, *this );
[e3d7f9f]	1825	maybeAccept_impl ( node->arg , *this );
[e0886db]	1826
	1827	VISIT_END( node );
[a5f0529]	1828	}
	1829
[7870799]	1830	template< typename pass_type >
	1831	void PassVisitor< pass_type >::visit( const CastExpr * node ) {
	1832	VISIT_START( node );
	1833
[e3d7f9f]	1834	indexerScopedAccept( node->result, *this );
	1835	maybeAccept_impl ( node->arg , *this );
[7870799]	1836
	1837	VISIT_END( node );
	1838	}
	1839
[13932f14]	1840	template< typename pass_type >
[e0886db]	1841	Expression * PassVisitor< pass_type >::mutate( CastExpr * node ) {
	1842	MUTATE_START( node );
	1843
	1844	indexerScopedMutate( node->env , *this );
	1845	indexerScopedMutate( node->result, *this );
[3c398b6]	1846	maybeMutate_impl ( node->arg , *this );
[e0886db]	1847
	1848	MUTATE_END( Expression, node );
[13932f14]	1849	}
	1850
[e0886db]	1851	//--------------------------------------------------------------------------
[9a705dc8]	1852	// KeywordCastExpr
	1853	template< typename pass_type >
	1854	void PassVisitor< pass_type >::visit( KeywordCastExpr * node ) {
	1855	VISIT_START( node );
	1856
	1857	indexerScopedAccept( node->result, *this );
	1858	maybeAccept_impl ( node->arg , *this );
	1859
	1860	VISIT_END( node );
	1861	}
	1862
[7870799]	1863	template< typename pass_type >
	1864	void PassVisitor< pass_type >::visit( const KeywordCastExpr * node ) {
	1865	VISIT_START( node );
	1866
[e3d7f9f]	1867	indexerScopedAccept( node->result, *this );
	1868	maybeAccept_impl ( node->arg , *this );
[7870799]	1869
	1870	VISIT_END( node );
	1871	}
	1872
[9a705dc8]	1873	template< typename pass_type >
	1874	Expression * PassVisitor< pass_type >::mutate( KeywordCastExpr * node ) {
	1875	MUTATE_START( node );
	1876
	1877	indexerScopedMutate( node->env , *this );
	1878	indexerScopedMutate( node->result, *this );
	1879	maybeMutate_impl ( node->arg , *this );
	1880
	1881	MUTATE_END( Expression, node );
	1882	}
	1883
	1884	//--------------------------------------------------------------------------
[e0886db]	1885	// VirtualCastExpr
[13932f14]	1886	template< typename pass_type >
[e0886db]	1887	void PassVisitor< pass_type >::visit( VirtualCastExpr * node ) {
	1888	VISIT_START( node );
	1889
	1890	indexerScopedAccept( node->result, *this );
[e3d7f9f]	1891	maybeAccept_impl ( node->arg, *this );
[e0886db]	1892
	1893	VISIT_END( node );
[13932f14]	1894	}
	1895
[7870799]	1896	template< typename pass_type >
	1897	void PassVisitor< pass_type >::visit( const VirtualCastExpr * node ) {
	1898	VISIT_START( node );
	1899
[e3d7f9f]	1900	indexerScopedAccept( node->result, *this );
	1901	maybeAccept_impl ( node->arg, *this );
[7870799]	1902
	1903	VISIT_END( node );
	1904	}
	1905
[13932f14]	1906	template< typename pass_type >
[e0886db]	1907	Expression * PassVisitor< pass_type >::mutate( VirtualCastExpr * node ) {
	1908	MUTATE_START( node );
	1909
	1910	indexerScopedMutate( node->env , *this );
	1911	indexerScopedMutate( node->result, *this );
[3c398b6]	1912	maybeMutate_impl ( node->arg , *this );
[e0886db]	1913
	1914	MUTATE_END( Expression, node );
[13932f14]	1915	}
	1916
[e0886db]	1917	//--------------------------------------------------------------------------
	1918	// AddressExpr
[13932f14]	1919	template< typename pass_type >
[e0886db]	1920	void PassVisitor< pass_type >::visit( AddressExpr * node ) {
	1921	VISIT_START( node );
	1922
	1923	indexerScopedAccept( node->result, *this );
[3c398b6]	1924	maybeAccept_impl ( node->arg , *this );
[e0886db]	1925
	1926	VISIT_END( node );
[13932f14]	1927	}
	1928
[7870799]	1929	template< typename pass_type >
	1930	void PassVisitor< pass_type >::visit( const AddressExpr * node ) {
	1931	VISIT_START( node );
	1932
[e3d7f9f]	1933	indexerScopedAccept( node->result, *this );
	1934	maybeAccept_impl ( node->arg , *this );
[7870799]	1935
	1936	VISIT_END( node );
	1937	}
	1938
[13932f14]	1939	template< typename pass_type >
[e0886db]	1940	Expression * PassVisitor< pass_type >::mutate( AddressExpr * node ) {
	1941	MUTATE_START( node );
	1942
	1943	indexerScopedMutate( node->env , *this );
	1944	indexerScopedMutate( node->result, *this );
[3c398b6]	1945	maybeMutate_impl ( node->arg , *this );
[e0886db]	1946
	1947	MUTATE_END( Expression, node );
	1948	}
	1949
	1950	//--------------------------------------------------------------------------
	1951	// LabelAddressExpr
	1952	template< typename pass_type >
	1953	void PassVisitor< pass_type >::visit( LabelAddressExpr * node ) {
	1954	VISIT_START( node );
	1955
	1956	indexerScopedAccept( node->result, *this );
	1957
	1958	VISIT_END( node );
	1959	}
	1960
[7870799]	1961	template< typename pass_type >
	1962	void PassVisitor< pass_type >::visit( const LabelAddressExpr * node ) {
	1963	VISIT_START( node );
	1964
[e3d7f9f]	1965	indexerScopedAccept( node->result, *this );
[7870799]	1966
	1967	VISIT_END( node );
	1968	}
	1969
[e0886db]	1970	template< typename pass_type >
	1971	Expression * PassVisitor< pass_type >::mutate( LabelAddressExpr * node ) {
	1972	MUTATE_START( node );
	1973
	1974	indexerScopedMutate( node->env , *this );
	1975	indexerScopedMutate( node->result, *this );
	1976
	1977	MUTATE_END( Expression, node );
	1978	}
	1979
	1980	//--------------------------------------------------------------------------
	1981	// UntypedMemberExpr
	1982	template< typename pass_type >
	1983	void PassVisitor< pass_type >::visit( UntypedMemberExpr * node ) {
	1984	VISIT_START( node );
	1985
	1986	indexerScopedAccept( node->result , *this );
[3c398b6]	1987	maybeAccept_impl ( node->aggregate, *this );
	1988	maybeAccept_impl ( node->member , *this );
[e0886db]	1989
	1990	VISIT_END( node );
[13932f14]	1991	}
	1992
[7870799]	1993	template< typename pass_type >
	1994	void PassVisitor< pass_type >::visit( const UntypedMemberExpr * node ) {
	1995	VISIT_START( node );
	1996
[e3d7f9f]	1997	indexerScopedAccept( node->result , *this );
	1998	maybeAccept_impl ( node->aggregate, *this );
	1999	maybeAccept_impl ( node->member , *this );
[7870799]	2000
	2001	VISIT_END( node );
	2002	}
	2003
[e0886db]	2004	template< typename pass_type >
	2005	Expression * PassVisitor< pass_type >::mutate( UntypedMemberExpr * node ) {
	2006	MUTATE_START( node );
	2007
	2008	indexerScopedMutate( node->env , *this );
	2009	indexerScopedMutate( node->result , *this );
[3c398b6]	2010	maybeMutate_impl ( node->aggregate, *this );
	2011	maybeMutate_impl ( node->member , *this );
[e0886db]	2012
	2013	MUTATE_END( Expression, node );
	2014	}
	2015
	2016	//--------------------------------------------------------------------------
	2017	// MemberExpr
	2018	template< typename pass_type >
	2019	void PassVisitor< pass_type >::visit( MemberExpr * node ) {
	2020	VISIT_START( node );
	2021
	2022	indexerScopedAccept( node->result , *this );
[3c398b6]	2023	maybeAccept_impl ( node->aggregate, *this );
[e0886db]	2024
	2025	VISIT_END( node );
	2026	}
	2027
[7870799]	2028	template< typename pass_type >
	2029	void PassVisitor< pass_type >::visit( const MemberExpr * node ) {
	2030	VISIT_START( node );
	2031
[e3d7f9f]	2032	indexerScopedAccept( node->result , *this );
	2033	maybeAccept_impl ( node->aggregate, *this );
[7870799]	2034
	2035	VISIT_END( node );
	2036	}
	2037
[e0886db]	2038	template< typename pass_type >
	2039	Expression * PassVisitor< pass_type >::mutate( MemberExpr * node ) {
	2040	MUTATE_START( node );
	2041
	2042	indexerScopedMutate( node->env , *this );
	2043	indexerScopedMutate( node->result , *this );
[3c398b6]	2044	maybeMutate_impl ( node->aggregate, *this );
[e0886db]	2045
	2046	MUTATE_END( Expression, node );
	2047	}
	2048
	2049	//--------------------------------------------------------------------------
	2050	// VariableExpr
	2051	template< typename pass_type >
	2052	void PassVisitor< pass_type >::visit( VariableExpr * node ) {
	2053	VISIT_START( node );
	2054
	2055	indexerScopedAccept( node->result, *this );
	2056
	2057	VISIT_END( node );
	2058	}
	2059
[7870799]	2060	template< typename pass_type >
	2061	void PassVisitor< pass_type >::visit( const VariableExpr * node ) {
	2062	VISIT_START( node );
	2063
[e3d7f9f]	2064	indexerScopedAccept( node->result, *this );
[7870799]	2065
	2066	VISIT_END( node );
	2067	}
	2068
[e0886db]	2069	template< typename pass_type >
	2070	Expression * PassVisitor< pass_type >::mutate( VariableExpr * node ) {
	2071	MUTATE_START( node );
	2072
	2073	indexerScopedMutate( node->env , *this );
	2074	indexerScopedMutate( node->result, *this );
	2075
	2076	MUTATE_END( Expression, node );
	2077	}
	2078
	2079	//--------------------------------------------------------------------------
	2080	// ConstantExpr
[13932f14]	2081	template< typename pass_type >
[ab904dc]	2082	void PassVisitor< pass_type >::visit( ConstantExpr * node ) {
[e0886db]	2083	VISIT_START( node );
	2084
	2085	indexerScopedAccept( node->result , *this );
[3c398b6]	2086	maybeAccept_impl ( &node->constant, *this );
[e0886db]	2087
	2088	VISIT_END( node );
[13932f14]	2089	}
	2090
[7870799]	2091	template< typename pass_type >
	2092	void PassVisitor< pass_type >::visit( const ConstantExpr * node ) {
	2093	VISIT_START( node );
	2094
[e3d7f9f]	2095	indexerScopedAccept( node->result , *this );
	2096	maybeAccept_impl ( &node->constant, *this );
[7870799]	2097
	2098	VISIT_END( node );
	2099	}
	2100
[e0886db]	2101	template< typename pass_type >
	2102	Expression * PassVisitor< pass_type >::mutate( ConstantExpr * node ) {
	2103	MUTATE_START( node );
	2104
	2105	indexerScopedMutate( node->env , *this );
	2106	indexerScopedMutate( node->result, *this );
[3c398b6]	2107	Constant * ptr = &node->constant;
	2108	maybeMutate_impl( ptr, *this );
	2109	node->constant = *ptr;
[e0886db]	2110
	2111	MUTATE_END( Expression, node );
	2112	}
	2113
	2114	//--------------------------------------------------------------------------
	2115	// SizeofExpr
[13932f14]	2116	template< typename pass_type >
[ab904dc]	2117	void PassVisitor< pass_type >::visit( SizeofExpr * node ) {
[e0886db]	2118	VISIT_START( node );
	2119
	2120	indexerScopedAccept( node->result, *this );
	2121	if ( node->get_isType() ) {
[3c398b6]	2122	maybeAccept_impl( node->type, *this );
[e0886db]	2123	} else {
[3c398b6]	2124	maybeAccept_impl( node->expr, *this );
[e0886db]	2125	}
	2126
	2127	VISIT_END( node );
[13932f14]	2128	}
	2129
[7870799]	2130	template< typename pass_type >
	2131	void PassVisitor< pass_type >::visit( const SizeofExpr * node ) {
	2132	VISIT_START( node );
	2133
[e3d7f9f]	2134	indexerScopedAccept( node->result, *this );
[7870799]	2135	if ( node->get_isType() ) {
	2136	maybeAccept_impl( node->type, *this );
	2137	} else {
	2138	maybeAccept_impl( node->expr, *this );
	2139	}
	2140
	2141	VISIT_END( node );
	2142	}
	2143
[e0886db]	2144	template< typename pass_type >
	2145	Expression * PassVisitor< pass_type >::mutate( SizeofExpr * node ) {
	2146	MUTATE_START( node );
	2147
	2148	indexerScopedMutate( node->env , *this );
	2149	indexerScopedMutate( node->result, *this );
	2150	if ( node->get_isType() ) {
[3c398b6]	2151	maybeMutate_impl( node->type, *this );
[e0886db]	2152	} else {
[3c398b6]	2153	maybeMutate_impl( node->expr, *this );
[e0886db]	2154	}
	2155
	2156	MUTATE_END( Expression, node );
	2157	}
	2158
	2159	//--------------------------------------------------------------------------
	2160	// AlignofExpr
[13932f14]	2161	template< typename pass_type >
[ab904dc]	2162	void PassVisitor< pass_type >::visit( AlignofExpr * node ) {
[e0886db]	2163	VISIT_START( node );
	2164
	2165	indexerScopedAccept( node->result, *this );
	2166	if ( node->get_isType() ) {
[3c398b6]	2167	maybeAccept_impl( node->type, *this );
[e0886db]	2168	} else {
[3c398b6]	2169	maybeAccept_impl( node->expr, *this );
[e0886db]	2170	}
	2171
	2172	VISIT_END( node );
[13932f14]	2173	}
	2174
[7870799]	2175	template< typename pass_type >
	2176	void PassVisitor< pass_type >::visit( const AlignofExpr * node ) {
	2177	VISIT_START( node );
	2178
[e3d7f9f]	2179	indexerScopedAccept( node->result, *this );
[7870799]	2180	if ( node->get_isType() ) {
	2181	maybeAccept_impl( node->type, *this );
	2182	} else {
	2183	maybeAccept_impl( node->expr, *this );
	2184	}
	2185
	2186	VISIT_END( node );
	2187	}
	2188
[e0886db]	2189	template< typename pass_type >
	2190	Expression * PassVisitor< pass_type >::mutate( AlignofExpr * node ) {
	2191	MUTATE_START( node );
	2192
	2193	indexerScopedMutate( node->env , *this );
	2194	indexerScopedMutate( node->result, *this );
	2195	if ( node->get_isType() ) {
[3c398b6]	2196	maybeMutate_impl( node->type, *this );
[e0886db]	2197	} else {
[3c398b6]	2198	maybeMutate_impl( node->expr, *this );
[e0886db]	2199	}
	2200
	2201	MUTATE_END( Expression, node );
	2202	}
	2203
	2204	//--------------------------------------------------------------------------
	2205	// UntypedOffsetofExpr
[13932f14]	2206	template< typename pass_type >
[ab904dc]	2207	void PassVisitor< pass_type >::visit( UntypedOffsetofExpr * node ) {
[e0886db]	2208	VISIT_START( node );
	2209
	2210	indexerScopedAccept( node->result, *this );
[3c398b6]	2211	maybeAccept_impl ( node->type , *this );
[e0886db]	2212
	2213	VISIT_END( node );
[13932f14]	2214	}
	2215
[7870799]	2216	template< typename pass_type >
	2217	void PassVisitor< pass_type >::visit( const UntypedOffsetofExpr * node ) {
	2218	VISIT_START( node );
	2219
[e3d7f9f]	2220	indexerScopedAccept( node->result, *this );
	2221	maybeAccept_impl ( node->type , *this );
[7870799]	2222
	2223	VISIT_END( node );
	2224	}
	2225
[e0886db]	2226	template< typename pass_type >
	2227	Expression * PassVisitor< pass_type >::mutate( UntypedOffsetofExpr * node ) {
	2228	MUTATE_START( node );
	2229
	2230	indexerScopedMutate( node->env , *this );
	2231	indexerScopedMutate( node->result, *this );
[3c398b6]	2232	maybeMutate_impl ( node->type , *this );
[e0886db]	2233
	2234	MUTATE_END( Expression, node );
	2235	}
	2236
	2237	//--------------------------------------------------------------------------
	2238	// OffsetofExpr
[13932f14]	2239	template< typename pass_type >
[ab904dc]	2240	void PassVisitor< pass_type >::visit( OffsetofExpr * node ) {
[e0886db]	2241	VISIT_START( node );
	2242
	2243	indexerScopedAccept( node->result, *this );
[3c398b6]	2244	maybeAccept_impl ( node->type , *this );
[e0886db]	2245
	2246	VISIT_END( node );
[13932f14]	2247	}
	2248
[7870799]	2249	template< typename pass_type >
	2250	void PassVisitor< pass_type >::visit( const OffsetofExpr * node ) {
	2251	VISIT_START( node );
	2252
[e3d7f9f]	2253	indexerScopedAccept( node->result, *this );
	2254	maybeAccept_impl ( node->type , *this );
[7870799]	2255
	2256	VISIT_END( node );
	2257	}
	2258
[e0886db]	2259	template< typename pass_type >
	2260	Expression * PassVisitor< pass_type >::mutate( OffsetofExpr * node ) {
	2261	MUTATE_START( node );
	2262
	2263	indexerScopedMutate( node->env , *this );
	2264	indexerScopedMutate( node->result, *this );
[3c398b6]	2265	maybeMutate_impl ( node->type , *this );
[e0886db]	2266
	2267	MUTATE_END( Expression, node );
	2268	}
	2269
	2270	//--------------------------------------------------------------------------
	2271	// OffsetPackExpr
[13932f14]	2272	template< typename pass_type >
[ab904dc]	2273	void PassVisitor< pass_type >::visit( OffsetPackExpr * node ) {
[e0886db]	2274	VISIT_START( node );
	2275
	2276	indexerScopedAccept( node->result, *this );
[3c398b6]	2277	maybeAccept_impl ( node->type , *this );
[e0886db]	2278
	2279	VISIT_END( node );
[13932f14]	2280	}
	2281
[7870799]	2282	template< typename pass_type >
	2283	void PassVisitor< pass_type >::visit( const OffsetPackExpr * node ) {
	2284	VISIT_START( node );
	2285
[e3d7f9f]	2286	indexerScopedAccept( node->result, *this );
	2287	maybeAccept_impl ( node->type , *this );
[7870799]	2288
	2289	VISIT_END( node );
	2290	}
	2291
[e0886db]	2292	template< typename pass_type >
	2293	Expression * PassVisitor< pass_type >::mutate( OffsetPackExpr * node ) {
	2294	MUTATE_START( node );
	2295
	2296	indexerScopedMutate( node->env , *this );
	2297	indexerScopedMutate( node->result, *this );
[3c398b6]	2298	maybeMutate_impl ( node->type , *this );
[e0886db]	2299
	2300	MUTATE_END( Expression, node );
	2301	}
	2302
	2303	//--------------------------------------------------------------------------
	2304	// LogicalExpr
[13932f14]	2305	template< typename pass_type >
[ab904dc]	2306	void PassVisitor< pass_type >::visit( LogicalExpr * node ) {
[e0886db]	2307	VISIT_START( node );
	2308
	2309	indexerScopedAccept( node->result, *this );
[3c398b6]	2310	maybeAccept_impl ( node->arg1 , *this );
	2311	maybeAccept_impl ( node->arg2 , *this );
[e0886db]	2312
	2313	VISIT_END( node );
	2314	}
	2315
[7870799]	2316	template< typename pass_type >
	2317	void PassVisitor< pass_type >::visit( const LogicalExpr * node ) {
	2318	VISIT_START( node );
	2319
[e3d7f9f]	2320	indexerScopedAccept( node->result, *this );
	2321	maybeAccept_impl ( node->arg1 , *this );
	2322	maybeAccept_impl ( node->arg2 , *this );
[7870799]	2323
	2324	VISIT_END( node );
	2325	}
	2326
[e0886db]	2327	template< typename pass_type >
	2328	Expression * PassVisitor< pass_type >::mutate( LogicalExpr * node ) {
	2329	MUTATE_START( node );
	2330
	2331	indexerScopedMutate( node->env , *this );
	2332	indexerScopedMutate( node->result, *this );
[3c398b6]	2333	maybeMutate_impl ( node->arg1 , *this );
	2334	maybeMutate_impl ( node->arg2 , *this );
[e0886db]	2335
	2336	MUTATE_END( Expression, node );
[13932f14]	2337	}
	2338
[e0886db]	2339	//--------------------------------------------------------------------------
	2340	// ConditionalExpr
[13932f14]	2341	template< typename pass_type >
[ab904dc]	2342	void PassVisitor< pass_type >::visit( ConditionalExpr * node ) {
[e0886db]	2343	VISIT_START( node );
	2344
	2345	indexerScopedAccept( node->result, *this );
[3c398b6]	2346	maybeAccept_impl ( node->arg1 , *this );
	2347	maybeAccept_impl ( node->arg2 , *this );
	2348	maybeAccept_impl ( node->arg3 , *this );
[e0886db]	2349
	2350	VISIT_END( node );
[13932f14]	2351	}
	2352
[e0886db]	2353	template< typename pass_type >
[7870799]	2354	void PassVisitor< pass_type >::visit( const ConditionalExpr * node ) {
	2355	VISIT_START( node );
	2356
[e3d7f9f]	2357	indexerScopedAccept( node->result, *this );
	2358	maybeAccept_impl ( node->arg1 , *this );
	2359	maybeAccept_impl ( node->arg2 , *this );
	2360	maybeAccept_impl ( node->arg3 , *this );
[7870799]	2361
	2362	VISIT_END( node );
	2363	}
	2364
	2365	template< typename pass_type >
	2366	Expression * PassVisitor< pass_type >::mutate( ConditionalExpr * node ) {
	2367	MUTATE_START( node );
[e0886db]	2368
	2369	indexerScopedMutate( node->env , *this );
	2370	indexerScopedMutate( node->result, *this );
[3c398b6]	2371	maybeMutate_impl ( node->arg1 , *this );
	2372	maybeMutate_impl ( node->arg2 , *this );
	2373	maybeMutate_impl ( node->arg3 , *this );
[e0886db]	2374
	2375	MUTATE_END( Expression, node );
	2376	}
	2377
	2378	//--------------------------------------------------------------------------
	2379	// CommaExpr
[13932f14]	2380	template< typename pass_type >
[ab904dc]	2381	void PassVisitor< pass_type >::visit( CommaExpr * node ) {
[e0886db]	2382	VISIT_START( node );
	2383
	2384	indexerScopedAccept( node->result, *this );
[3c398b6]	2385	maybeAccept_impl ( node->arg1 , *this );
	2386	maybeAccept_impl ( node->arg2 , *this );
[e0886db]	2387
	2388	VISIT_END( node );
	2389	}
	2390
[7870799]	2391	template< typename pass_type >
	2392	void PassVisitor< pass_type >::visit( const CommaExpr * node ) {
	2393	VISIT_START( node );
	2394
[e3d7f9f]	2395	indexerScopedAccept( node->result, *this );
	2396	maybeAccept_impl ( node->arg1 , *this );
	2397	maybeAccept_impl ( node->arg2 , *this );
[7870799]	2398
	2399	VISIT_END( node );
	2400	}
	2401
[e0886db]	2402	template< typename pass_type >
	2403	Expression * PassVisitor< pass_type >::mutate( CommaExpr * node ) {
	2404	MUTATE_START( node );
	2405
	2406	indexerScopedMutate( node->env , *this );
	2407	indexerScopedMutate( node->result, *this );
[3c398b6]	2408	maybeMutate_impl ( node->arg1 , *this );
	2409	maybeMutate_impl ( node->arg2 , *this );
[e0886db]	2410
	2411	MUTATE_END( Expression, node );
[13932f14]	2412	}
	2413
[e0886db]	2414	//--------------------------------------------------------------------------
	2415	// TypeExpr
[13932f14]	2416	template< typename pass_type >
[ab904dc]	2417	void PassVisitor< pass_type >::visit( TypeExpr * node ) {
[e0886db]	2418	VISIT_START( node );
	2419
	2420	indexerScopedAccept( node->result, *this );
[3c398b6]	2421	maybeAccept_impl ( node->type, *this );
[e0886db]	2422
	2423	VISIT_END( node );
[13932f14]	2424	}
	2425
[7870799]	2426	template< typename pass_type >
	2427	void PassVisitor< pass_type >::visit( const TypeExpr * node ) {
	2428	VISIT_START( node );
	2429
[e3d7f9f]	2430	indexerScopedAccept( node->result, *this );
	2431	maybeAccept_impl ( node->type, *this );
[7870799]	2432
	2433	VISIT_END( node );
	2434	}
	2435
[e0886db]	2436	template< typename pass_type >
	2437	Expression * PassVisitor< pass_type >::mutate( TypeExpr * node ) {
	2438	MUTATE_START( node );
	2439
	2440	indexerScopedMutate( node->env , *this );
	2441	indexerScopedMutate( node->result, *this );
[3c398b6]	2442	maybeMutate_impl ( node->type , *this );
[e0886db]	2443
	2444	MUTATE_END( Expression, node );
	2445	}
	2446
	2447	//--------------------------------------------------------------------------
	2448	// AsmExpr
[13932f14]	2449	template< typename pass_type >
[ab904dc]	2450	void PassVisitor< pass_type >::visit( AsmExpr * node ) {
[e0886db]	2451	VISIT_START( node );
	2452
	2453	indexerScopedAccept( node->result , *this );
[3c398b6]	2454	maybeAccept_impl ( node->inout , *this );
	2455	maybeAccept_impl ( node->constraint, *this );
	2456	maybeAccept_impl ( node->operand , *this );
[e0886db]	2457
	2458	VISIT_END( node );
[13932f14]	2459	}
	2460
[7870799]	2461	template< typename pass_type >
	2462	void PassVisitor< pass_type >::visit( const AsmExpr * node ) {
	2463	VISIT_START( node );
	2464
[e3d7f9f]	2465	indexerScopedAccept( node->result , *this );
	2466	maybeAccept_impl ( node->inout , *this );
	2467	maybeAccept_impl ( node->constraint, *this );
	2468	maybeAccept_impl ( node->operand , *this );
[7870799]	2469
	2470	VISIT_END( node );
	2471	}
	2472
[e0886db]	2473	template< typename pass_type >
	2474	Expression * PassVisitor< pass_type >::mutate( AsmExpr * node ) {
	2475	MUTATE_START( node );
	2476
	2477	indexerScopedMutate( node->env , *this );
	2478	indexerScopedMutate( node->result , *this );
[3c398b6]	2479	maybeMutate_impl ( node->inout , *this );
	2480	maybeMutate_impl ( node->constraint, *this );
	2481	maybeMutate_impl ( node->operand , *this );
[e0886db]	2482
	2483	MUTATE_END( Expression, node );
	2484	}
	2485
	2486	//--------------------------------------------------------------------------
	2487	// ImplicitCopyCtorExpr
[13932f14]	2488	template< typename pass_type >
[ab904dc]	2489	void PassVisitor< pass_type >::visit( ImplicitCopyCtorExpr * node ) {
[e0886db]	2490	VISIT_START( node );
	2491
[2f86ddf]	2492	indexerScopedAccept( node->result , *this );
	2493	maybeAccept_impl ( node->callExpr , *this );
[e0886db]	2494
	2495	VISIT_END( node );
	2496	}
	2497
[7870799]	2498	template< typename pass_type >
	2499	void PassVisitor< pass_type >::visit( const ImplicitCopyCtorExpr * node ) {
	2500	VISIT_START( node );
	2501
[e3d7f9f]	2502	indexerScopedAccept( node->result , *this );
	2503	maybeAccept_impl ( node->callExpr , *this );
[7870799]	2504
	2505	VISIT_END( node );
	2506	}
	2507
[e0886db]	2508	template< typename pass_type >
	2509	Expression * PassVisitor< pass_type >::mutate( ImplicitCopyCtorExpr * node ) {
	2510	MUTATE_START( node );
	2511
[2f86ddf]	2512	indexerScopedMutate( node->env , *this );
	2513	indexerScopedMutate( node->result , *this );
	2514	maybeMutate_impl ( node->callExpr , *this );
[e0886db]	2515
	2516	MUTATE_END( Expression, node );
[13932f14]	2517	}
	2518
[e0886db]	2519	//--------------------------------------------------------------------------
	2520	// ConstructorExpr
[13932f14]	2521	template< typename pass_type >
[ab904dc]	2522	void PassVisitor< pass_type >::visit( ConstructorExpr * node ) {
[e0886db]	2523	VISIT_START( node );
	2524
	2525	indexerScopedAccept( node->result , *this );
[3c398b6]	2526	maybeAccept_impl ( node->callExpr, *this );
[e0886db]	2527
	2528	VISIT_END( node );
	2529	}
	2530
[7870799]	2531	template< typename pass_type >
	2532	void PassVisitor< pass_type >::visit( const ConstructorExpr * node ) {
	2533	VISIT_START( node );
	2534
[e3d7f9f]	2535	indexerScopedAccept( node->result , *this );
	2536	maybeAccept_impl ( node->callExpr, *this );
[7870799]	2537
	2538	VISIT_END( node );
	2539	}
	2540
[e0886db]	2541	template< typename pass_type >
	2542	Expression * PassVisitor< pass_type >::mutate( ConstructorExpr * node ) {
	2543	MUTATE_START( node );
	2544
	2545	indexerScopedMutate( node->env , *this );
	2546	indexerScopedMutate( node->result , *this );
[3c398b6]	2547	maybeMutate_impl ( node->callExpr, *this );
[e0886db]	2548
	2549	MUTATE_END( Expression, node );
[13932f14]	2550	}
	2551
[e0886db]	2552	//--------------------------------------------------------------------------
	2553	// CompoundLiteralExpr
[13932f14]	2554	template< typename pass_type >
[ab904dc]	2555	void PassVisitor< pass_type >::visit( CompoundLiteralExpr * node ) {
[e0886db]	2556	VISIT_START( node );
	2557
	2558	indexerScopedAccept( node->result , *this );
[3c398b6]	2559	maybeAccept_impl ( node->initializer, *this );
[e0886db]	2560
	2561	VISIT_END( node );
[13932f14]	2562	}
	2563
[7870799]	2564	template< typename pass_type >
	2565	void PassVisitor< pass_type >::visit( const CompoundLiteralExpr * node ) {
	2566	VISIT_START( node );
	2567
[e3d7f9f]	2568	indexerScopedAccept( node->result , *this );
	2569	maybeAccept_impl ( node->initializer, *this );
[7870799]	2570
	2571	VISIT_END( node );
	2572	}
	2573
[e0886db]	2574	template< typename pass_type >
	2575	Expression * PassVisitor< pass_type >::mutate( CompoundLiteralExpr * node ) {
	2576	MUTATE_START( node );
	2577
	2578	indexerScopedMutate( node->env , *this );
	2579	indexerScopedMutate( node->result , *this );
[3c398b6]	2580	maybeMutate_impl ( node->initializer, *this );
[e0886db]	2581
	2582	MUTATE_END( Expression, node );
	2583	}
	2584
	2585	//--------------------------------------------------------------------------
	2586	// RangeExpr
[13932f14]	2587	template< typename pass_type >
[ab904dc]	2588	void PassVisitor< pass_type >::visit( RangeExpr * node ) {
[e0886db]	2589	VISIT_START( node );
	2590
	2591	indexerScopedAccept( node->result, *this );
[3c398b6]	2592	maybeAccept_impl ( node->low , *this );
	2593	maybeAccept_impl ( node->high , *this );
[e0886db]	2594
	2595	VISIT_END( node );
[13932f14]	2596	}
	2597
[7870799]	2598	template< typename pass_type >
	2599	void PassVisitor< pass_type >::visit( const RangeExpr * node ) {
	2600	VISIT_START( node );
	2601
[e3d7f9f]	2602	indexerScopedAccept( node->result, *this );
	2603	maybeAccept_impl ( node->low , *this );
	2604	maybeAccept_impl ( node->high , *this );
[7870799]	2605
	2606	VISIT_END( node );
	2607	}
	2608
[e0886db]	2609	template< typename pass_type >
	2610	Expression * PassVisitor< pass_type >::mutate( RangeExpr * node ) {
	2611	MUTATE_START( node );
	2612
	2613	indexerScopedMutate( node->env , *this );
	2614	indexerScopedMutate( node->result, *this );
[3c398b6]	2615	maybeMutate_impl ( node->low , *this );
	2616	maybeMutate_impl ( node->high , *this );
[e0886db]	2617
	2618	MUTATE_END( Expression, node );
	2619	}
	2620
	2621	//--------------------------------------------------------------------------
	2622	// UntypedTupleExpr
[13932f14]	2623	template< typename pass_type >
[ab904dc]	2624	void PassVisitor< pass_type >::visit( UntypedTupleExpr * node ) {
[e0886db]	2625	VISIT_START( node );
	2626
	2627	indexerScopedAccept( node->result, *this );
[3c398b6]	2628	maybeAccept_impl ( node->exprs , *this );
[e0886db]	2629
	2630	VISIT_END( node );
	2631	}
	2632
[7870799]	2633	template< typename pass_type >
	2634	void PassVisitor< pass_type >::visit( const UntypedTupleExpr * node ) {
	2635	VISIT_START( node );
	2636
[e3d7f9f]	2637	indexerScopedAccept( node->result, *this );
	2638	maybeAccept_impl ( node->exprs , *this );
[7870799]	2639
	2640	VISIT_END( node );
	2641	}
	2642
[e0886db]	2643	template< typename pass_type >
	2644	Expression * PassVisitor< pass_type >::mutate( UntypedTupleExpr * node ) {
	2645	MUTATE_START( node );
	2646
	2647	indexerScopedMutate( node->env , *this );
	2648	indexerScopedMutate( node->result, *this );
[3c398b6]	2649	maybeMutate_impl ( node->exprs , *this );
[e0886db]	2650
	2651	MUTATE_END( Expression, node );
	2652	}
	2653
	2654	//--------------------------------------------------------------------------
	2655	// TupleExpr
	2656	template< typename pass_type >
	2657	void PassVisitor< pass_type >::visit( TupleExpr * node ) {
	2658	VISIT_START( node );
	2659
	2660	indexerScopedAccept( node->result, *this );
[3c398b6]	2661	maybeAccept_impl ( node->exprs , *this );
[e0886db]	2662
	2663	VISIT_END( node );
	2664	}
	2665
[7870799]	2666	template< typename pass_type >
	2667	void PassVisitor< pass_type >::visit( const TupleExpr * node ) {
	2668	VISIT_START( node );
	2669
[e3d7f9f]	2670	indexerScopedAccept( node->result, *this );
	2671	maybeAccept_impl ( node->exprs , *this );
[7870799]	2672
	2673	VISIT_END( node );
	2674	}
	2675
[e0886db]	2676	template< typename pass_type >
	2677	Expression * PassVisitor< pass_type >::mutate( TupleExpr * node ) {
	2678	MUTATE_START( node );
	2679
	2680	indexerScopedMutate( node->env , *this );
	2681	indexerScopedMutate( node->result, *this );
[3c398b6]	2682	maybeMutate_impl ( node->exprs , *this );
[e0886db]	2683
	2684	MUTATE_END( Expression, node );
	2685	}
	2686
	2687	//--------------------------------------------------------------------------
	2688	// TupleIndexExpr
	2689	template< typename pass_type >
	2690	void PassVisitor< pass_type >::visit( TupleIndexExpr * node ) {
	2691	VISIT_START( node );
	2692
	2693	indexerScopedAccept( node->result, *this );
[3c398b6]	2694	maybeAccept_impl ( node->tuple , *this );
[e0886db]	2695
	2696	VISIT_END( node );
	2697	}
	2698
[7870799]	2699	template< typename pass_type >
	2700	void PassVisitor< pass_type >::visit( const TupleIndexExpr * node ) {
	2701	VISIT_START( node );
	2702
[e3d7f9f]	2703	indexerScopedAccept( node->result, *this );
	2704	maybeAccept_impl ( node->tuple , *this );
[7870799]	2705
	2706	VISIT_END( node );
	2707	}
	2708
[e0886db]	2709	template< typename pass_type >
	2710	Expression * PassVisitor< pass_type >::mutate( TupleIndexExpr * node ) {
	2711	MUTATE_START( node );
	2712
	2713	indexerScopedMutate( node->env , *this );
	2714	indexerScopedMutate( node->result, *this );
[3c398b6]	2715	maybeMutate_impl ( node->tuple , *this );
[e0886db]	2716
	2717	MUTATE_END( Expression, node );
	2718	}
	2719
	2720	//--------------------------------------------------------------------------
	2721	// TupleAssignExpr
	2722	template< typename pass_type >
	2723	void PassVisitor< pass_type >::visit( TupleAssignExpr * node ) {
	2724	VISIT_START( node );
	2725
	2726	indexerScopedAccept( node->result , *this );
[3c398b6]	2727	maybeAccept_impl ( node->stmtExpr, *this );
[e0886db]	2728
	2729	VISIT_END( node );
[13932f14]	2730	}
	2731
[7870799]	2732	template< typename pass_type >
	2733	void PassVisitor< pass_type >::visit( const TupleAssignExpr * node ) {
	2734	VISIT_START( node );
	2735
[e3d7f9f]	2736	indexerScopedAccept( node->result , *this );
[7870799]	2737	maybeAccept_impl( node->stmtExpr, *this );
	2738
	2739	VISIT_END( node );
	2740	}
	2741
[13932f14]	2742	template< typename pass_type >
[e0886db]	2743	Expression * PassVisitor< pass_type >::mutate( TupleAssignExpr * node ) {
	2744	MUTATE_START( node );
[13932f14]	2745
[e0886db]	2746	indexerScopedMutate( node->env , *this );
	2747	indexerScopedMutate( node->result , *this );
[3c398b6]	2748	maybeMutate_impl ( node->stmtExpr, *this );
[13932f14]	2749
[e0886db]	2750	MUTATE_END( Expression, node );
[13932f14]	2751	}
	2752
[9c1600c]	2753	//--------------------------------------------------------------------------
[e0886db]	2754	// StmtExpr
[13932f14]	2755	template< typename pass_type >
[ab904dc]	2756	void PassVisitor< pass_type >::visit( StmtExpr * node ) {
[9c1600c]	2757	VISIT_START( node );
	2758
	2759	// don't want statements from outer CompoundStmts to be added to this StmtExpr
[02fdb8e]	2760	ValueGuardPtr< typename std::remove_pointer<decltype(get_env_ptr())>::type > oldEnv( get_env_ptr() );
[9c1600c]	2761	ValueGuardPtr< std::list< Statement* > > oldBeforeStmts( get_beforeStmts() );
	2762	ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () );
	2763
[e0886db]	2764	indexerScopedAccept( node->result , *this );
[3c398b6]	2765	maybeAccept_impl ( node->statements , *this );
	2766	maybeAccept_impl ( node->returnDecls, *this );
	2767	maybeAccept_impl ( node->dtors , *this );
[9c1600c]	2768
	2769	VISIT_END( node );
[13932f14]	2770	}
	2771
[7870799]	2772	template< typename pass_type >
	2773	void PassVisitor< pass_type >::visit( const StmtExpr * node ) {
	2774	VISIT_START( node );
	2775
[e3d7f9f]	2776	// don't want statements from outer CompoundStmts to be added to this StmtExpr
	2777	ValueGuardPtr< typename std::remove_pointer<decltype(get_env_ptr())>::type > oldEnv( get_env_ptr() );
	2778	ValueGuardPtr< std::list< Statement* > > oldBeforeStmts( get_beforeStmts() );
	2779	ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () );
	2780
	2781	indexerScopedAccept( node->result , *this );
	2782	maybeAccept_impl ( node->statements , *this );
	2783	maybeAccept_impl ( node->returnDecls, *this );
	2784	maybeAccept_impl ( node->dtors , *this );
[7870799]	2785
	2786	VISIT_END( node );
	2787	}
	2788
[296b2be]	2789	template< typename pass_type >
	2790	Expression * PassVisitor< pass_type >::mutate( StmtExpr * node ) {
	2791	MUTATE_START( node );
[4551a6e]	2792
[296b2be]	2793	// don't want statements from outer CompoundStmts to be added to this StmtExpr
[02fdb8e]	2794	ValueGuardPtr< typename std::remove_pointer<decltype(get_env_ptr())>::type > oldEnv( get_env_ptr() );
[134322e]	2795	ValueGuardPtr< std::list< Statement* > > oldBeforeStmts( get_beforeStmts() );
	2796	ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () );
[296b2be]	2797
[e0886db]	2798	indexerScopedMutate( node->result , *this );
[3c398b6]	2799	maybeMutate_impl ( node->statements , *this );
	2800	maybeMutate_impl ( node->returnDecls, *this );
	2801	maybeMutate_impl ( node->dtors , *this );
[296b2be]	2802
	2803	MUTATE_END( Expression, node );
	2804	}
	2805
[e0886db]	2806	//--------------------------------------------------------------------------
	2807	// UniqueExpr
[13932f14]	2808	template< typename pass_type >
[ab904dc]	2809	void PassVisitor< pass_type >::visit( UniqueExpr * node ) {
[e0886db]	2810	VISIT_START( node );
	2811
	2812	indexerScopedAccept( node->result, *this );
[3c398b6]	2813	maybeAccept_impl ( node->expr , *this );
[e0886db]	2814
	2815	VISIT_END( node );
	2816	}
	2817
[7870799]	2818	template< typename pass_type >
	2819	void PassVisitor< pass_type >::visit( const UniqueExpr * node ) {
	2820	VISIT_START( node );
	2821
[e3d7f9f]	2822	indexerScopedAccept( node->result, *this );
	2823	maybeAccept_impl ( node->expr , *this );
[7870799]	2824
	2825	VISIT_END( node );
	2826	}
	2827
[e0886db]	2828	template< typename pass_type >
	2829	Expression * PassVisitor< pass_type >::mutate( UniqueExpr * node ) {
	2830	MUTATE_START( node );
	2831
	2832	indexerScopedMutate( node->env , *this );
	2833	indexerScopedMutate( node->result, *this );
[3c398b6]	2834	maybeMutate_impl ( node->expr , *this );
[e0886db]	2835
	2836	MUTATE_END( Expression, node );
[13932f14]	2837	}
	2838
[73367a8]	2839	//--------------------------------------------------------------------------
	2840	// UntypedInitExpr
	2841	template< typename pass_type >
	2842	void PassVisitor< pass_type >::visit( UntypedInitExpr * node ) {
	2843	VISIT_START( node );
	2844
	2845	indexerScopedAccept( node->result, *this );
	2846	maybeAccept_impl ( node->expr , *this );
	2847	// not currently visiting initAlts, but this doesn't matter since this node is only used in the resolver.
	2848
	2849	VISIT_END( node );
	2850	}
	2851
[7870799]	2852	template< typename pass_type >
	2853	void PassVisitor< pass_type >::visit( const UntypedInitExpr * node ) {
	2854	VISIT_START( node );
	2855
[e3d7f9f]	2856	indexerScopedAccept( node->result, *this );
	2857	maybeAccept_impl ( node->expr , *this );
[7870799]	2858	// not currently visiting initAlts, but this doesn't matter since this node is only used in the resolver.
	2859
	2860	VISIT_END( node );
	2861	}
	2862
[73367a8]	2863	template< typename pass_type >
	2864	Expression * PassVisitor< pass_type >::mutate( UntypedInitExpr * node ) {
	2865	MUTATE_START( node );
	2866
	2867	indexerScopedMutate( node->env , *this );
	2868	indexerScopedMutate( node->result, *this );
	2869	maybeMutate_impl ( node->expr , *this );
	2870	// not currently visiting initAlts, but this doesn't matter since this node is only used in the resolver.
	2871
	2872	MUTATE_END( Expression, node );
	2873	}
	2874
	2875	//--------------------------------------------------------------------------
	2876	// InitExpr
	2877	template< typename pass_type >
	2878	void PassVisitor< pass_type >::visit( InitExpr * node ) {
	2879	VISIT_START( node );
	2880
	2881	indexerScopedAccept( node->result, *this );
	2882	maybeAccept_impl ( node->expr , *this );
	2883	maybeAccept_impl ( node->designation, *this );
	2884
	2885	VISIT_END( node );
	2886	}
	2887
[7870799]	2888	template< typename pass_type >
	2889	void PassVisitor< pass_type >::visit( const InitExpr * node ) {
	2890	VISIT_START( node );
	2891
[e3d7f9f]	2892	indexerScopedAccept( node->result, *this );
	2893	maybeAccept_impl ( node->expr , *this );
	2894	maybeAccept_impl ( node->designation, *this );
[7870799]	2895
	2896	VISIT_END( node );
	2897	}
	2898
[73367a8]	2899	template< typename pass_type >
	2900	Expression * PassVisitor< pass_type >::mutate( InitExpr * node ) {
	2901	MUTATE_START( node );
	2902
	2903	indexerScopedMutate( node->env , *this );
	2904	indexerScopedMutate( node->result, *this );
	2905	maybeMutate_impl ( node->expr , *this );
	2906	maybeMutate_impl ( node->designation, *this );
	2907
	2908	MUTATE_END( Expression, node );
	2909	}
	2910
[44b4114]	2911	//--------------------------------------------------------------------------
	2912	// DeletedExpr
	2913	template< typename pass_type >
	2914	void PassVisitor< pass_type >::visit( DeletedExpr * node ) {
	2915	VISIT_START( node );
	2916
	2917	indexerScopedAccept( node->result, *this );
[e3d7f9f]	2918	maybeAccept_impl ( node->expr, *this );
[44b4114]	2919	// don't visit deleteStmt, because it is a pointer to somewhere else in the tree.
	2920
	2921	VISIT_END( node );
	2922	}
	2923
[7870799]	2924	template< typename pass_type >
	2925	void PassVisitor< pass_type >::visit( const DeletedExpr * node ) {
	2926	VISIT_START( node );
	2927
[e3d7f9f]	2928	indexerScopedAccept( node->result, *this );
	2929	maybeAccept_impl ( node->expr, *this );
[7870799]	2930	// don't visit deleteStmt, because it is a pointer to somewhere else in the tree.
	2931
	2932	VISIT_END( node );
	2933	}
	2934
[44b4114]	2935	template< typename pass_type >
	2936	Expression * PassVisitor< pass_type >::mutate( DeletedExpr * node ) {
	2937	MUTATE_START( node );
	2938
	2939	indexerScopedMutate( node->env, *this );
	2940	indexerScopedMutate( node->result, *this );
	2941	maybeMutate_impl( node->expr, *this );
	2942
	2943	MUTATE_END( Expression, node );
	2944	}
	2945
[0f79853]	2946	//--------------------------------------------------------------------------
	2947	// DefaultArgExpr
	2948	template< typename pass_type >
	2949	void PassVisitor< pass_type >::visit( DefaultArgExpr * node ) {
	2950	VISIT_START( node );
	2951
	2952	indexerScopedAccept( node->result, *this );
[e3d7f9f]	2953	maybeAccept_impl ( node->expr, *this );
[0f79853]	2954
	2955	VISIT_END( node );
	2956	}
	2957
[7870799]	2958	template< typename pass_type >
	2959	void PassVisitor< pass_type >::visit( const DefaultArgExpr * node ) {
	2960	VISIT_START( node );
	2961
[e3d7f9f]	2962	indexerScopedAccept( node->result, *this );
	2963	maybeAccept_impl ( node->expr, *this );
[7870799]	2964
	2965	VISIT_END( node );
	2966	}
	2967
[0f79853]	2968	template< typename pass_type >
	2969	Expression * PassVisitor< pass_type >::mutate( DefaultArgExpr * node ) {
	2970	MUTATE_START( node );
	2971
	2972	indexerScopedMutate( node->env, *this );
	2973	indexerScopedMutate( node->result, *this );
	2974	maybeMutate_impl( node->expr, *this );
	2975
	2976	MUTATE_END( Expression, node );
	2977	}
	2978
[d807ca28]	2979	//--------------------------------------------------------------------------
	2980	// GenericExpr
	2981	template< typename pass_type >
	2982	void PassVisitor< pass_type >::visit( GenericExpr * node ) {
	2983	VISIT_START( node );
	2984
	2985	indexerScopedAccept( node->result, *this );
	2986	maybeAccept_impl( node->control, *this );
	2987	for ( GenericExpr::Association & assoc : node->associations ) {
	2988	indexerScopedAccept( assoc.type, *this );
	2989	maybeAccept_impl( assoc.expr, *this );
	2990	}
	2991
	2992	VISIT_END( node );
	2993	}
	2994
[7870799]	2995	template< typename pass_type >
	2996	void PassVisitor< pass_type >::visit( const GenericExpr * node ) {
	2997	VISIT_START( node );
	2998
[e3d7f9f]	2999	indexerScopedAccept( node->result, *this );
[7870799]	3000	maybeAccept_impl( node->control, *this );
	3001	for ( const GenericExpr::Association & assoc : node->associations ) {
[e3d7f9f]	3002	indexerScopedAccept( assoc.type, *this );
[7870799]	3003	maybeAccept_impl( assoc.expr, *this );
	3004	}
	3005
	3006	VISIT_END( node );
	3007	}
	3008
[d807ca28]	3009	template< typename pass_type >
	3010	Expression * PassVisitor< pass_type >::mutate( GenericExpr * node ) {
	3011	MUTATE_START( node );
	3012
	3013	indexerScopedMutate( node->env, *this );
	3014	indexerScopedMutate( node->result, *this );
	3015	maybeMutate_impl( node->control, *this );
	3016	for ( GenericExpr::Association & assoc : node->associations ) {
	3017	indexerScopedMutate( assoc.type, *this );
	3018	maybeMutate_impl( assoc.expr, *this );
	3019	}
	3020
	3021	MUTATE_END( Expression, node );
	3022	}
	3023
[17fc7a5]	3024	//--------------------------------------------------------------------------
	3025	// VoidType
[13932f14]	3026	template< typename pass_type >
[ab904dc]	3027	void PassVisitor< pass_type >::visit( VoidType * node ) {
[599fbb6]	3028	VISIT_START( node );
	3029
	3030	maybeAccept_impl( node->forall, *this );
	3031
	3032	VISIT_END( node );
	3033	}
	3034
[7870799]	3035	template< typename pass_type >
	3036	void PassVisitor< pass_type >::visit( const VoidType * node ) {
	3037	VISIT_START( node );
	3038
	3039	maybeAccept_impl( node->forall, *this );
	3040
	3041	VISIT_END( node );
	3042	}
	3043
[599fbb6]	3044	template< typename pass_type >
	3045	Type * PassVisitor< pass_type >::mutate( VoidType * node ) {
	3046	MUTATE_START( node );
	3047
	3048	maybeMutate_impl( node->forall, *this );
	3049
	3050	MUTATE_END( Type, node );
[13932f14]	3051	}
	3052
[17fc7a5]	3053	//--------------------------------------------------------------------------
	3054	// BasicType
[13932f14]	3055	template< typename pass_type >
[ab904dc]	3056	void PassVisitor< pass_type >::visit( BasicType * node ) {
[17fc7a5]	3057	VISIT_START( node );
	3058
	3059	maybeAccept_impl( node->forall, *this );
	3060
	3061	VISIT_END( node );
	3062	}
	3063
[7870799]	3064	template< typename pass_type >
	3065	void PassVisitor< pass_type >::visit( const BasicType * node ) {
	3066	VISIT_START( node );
	3067
	3068	maybeAccept_impl( node->forall, *this );
	3069
	3070	VISIT_END( node );
	3071	}
	3072
[17fc7a5]	3073	template< typename pass_type >
	3074	Type * PassVisitor< pass_type >::mutate( BasicType * node ) {
	3075	MUTATE_START( node );
	3076
	3077	maybeMutate_impl( node->forall, *this );
	3078
	3079	MUTATE_END( Type, node );
[13932f14]	3080	}
	3081
[17fc7a5]	3082	//--------------------------------------------------------------------------
	3083	// PointerType
[13932f14]	3084	template< typename pass_type >
[ab904dc]	3085	void PassVisitor< pass_type >::visit( PointerType * node ) {
[17fc7a5]	3086	VISIT_START( node );
	3087
	3088	maybeAccept_impl( node->forall, *this );
[cfaf9be]	3089	// xxx - should PointerType visit/mutate dimension?
[17fc7a5]	3090	maybeAccept_impl( node->base, *this );
	3091
	3092	VISIT_END( node );
[13932f14]	3093	}
	3094
[7870799]	3095	template< typename pass_type >
	3096	void PassVisitor< pass_type >::visit( const PointerType * node ) {
	3097	VISIT_START( node );
	3098
	3099	maybeAccept_impl( node->forall, *this );
	3100	// xxx - should PointerType visit/mutate dimension?
	3101	maybeAccept_impl( node->base, *this );
	3102
	3103	VISIT_END( node );
	3104	}
	3105
[17fc7a5]	3106	template< typename pass_type >
	3107	Type * PassVisitor< pass_type >::mutate( PointerType * node ) {
	3108	MUTATE_START( node );
	3109
	3110	maybeMutate_impl( node->forall, *this );
[cfaf9be]	3111	// xxx - should PointerType visit/mutate dimension?
[17fc7a5]	3112	maybeMutate_impl( node->base, *this );
	3113
	3114	MUTATE_END( Type, node );
	3115	}
	3116
	3117	//--------------------------------------------------------------------------
	3118	// ArrayType
[13932f14]	3119	template< typename pass_type >
[ab904dc]	3120	void PassVisitor< pass_type >::visit( ArrayType * node ) {
[17fc7a5]	3121	VISIT_START( node );
	3122
	3123	maybeAccept_impl( node->forall, *this );
	3124	maybeAccept_impl( node->dimension, *this );
	3125	maybeAccept_impl( node->base, *this );
	3126
	3127	VISIT_END( node );
[13932f14]	3128	}
	3129
[7870799]	3130	template< typename pass_type >
	3131	void PassVisitor< pass_type >::visit( const ArrayType * node ) {
	3132	VISIT_START( node );
	3133
	3134	maybeAccept_impl( node->forall, *this );
	3135	maybeAccept_impl( node->dimension, *this );
	3136	maybeAccept_impl( node->base, *this );
	3137
	3138	VISIT_END( node );
	3139	}
	3140
[17fc7a5]	3141	template< typename pass_type >
	3142	Type * PassVisitor< pass_type >::mutate( ArrayType * node ) {
	3143	MUTATE_START( node );
	3144
	3145	maybeMutate_impl( node->forall, *this );
	3146	maybeMutate_impl( node->dimension, *this );
	3147	maybeMutate_impl( node->base, *this );
	3148
	3149	MUTATE_END( Type, node );
	3150	}
	3151
	3152	//--------------------------------------------------------------------------
	3153	// ReferenceType
[6b9b047]	3154	template< typename pass_type >
	3155	void PassVisitor< pass_type >::visit( ReferenceType * node ) {
[17fc7a5]	3156	VISIT_START( node );
	3157
	3158	maybeAccept_impl( node->forall, *this );
	3159	maybeAccept_impl( node->base, *this );
	3160
	3161	VISIT_END( node );
	3162	}
	3163
[7870799]	3164	template< typename pass_type >
	3165	void PassVisitor< pass_type >::visit( const ReferenceType * node ) {
	3166	VISIT_START( node );
	3167
	3168	maybeAccept_impl( node->forall, *this );
	3169	maybeAccept_impl( node->base, *this );
	3170
	3171	VISIT_END( node );
	3172	}
	3173
[17fc7a5]	3174	template< typename pass_type >
	3175	Type * PassVisitor< pass_type >::mutate( ReferenceType * node ) {
	3176	MUTATE_START( node );
	3177
	3178	maybeMutate_impl( node->forall, *this );
	3179	maybeMutate_impl( node->base, *this );
	3180
	3181	MUTATE_END( Type, node );
[6b9b047]	3182	}
	3183
[c5d7701]	3184	//--------------------------------------------------------------------------
	3185	// QualifiedType
	3186	template< typename pass_type >
	3187	void PassVisitor< pass_type >::visit( QualifiedType * node ) {
	3188	VISIT_START( node );
	3189
	3190	maybeAccept_impl( node->forall, *this );
[c194661]	3191	maybeAccept_impl( node->parent, *this );
	3192	maybeAccept_impl( node->child, *this );
[c5d7701]	3193
	3194	VISIT_END( node );
	3195	}
	3196
[7870799]	3197	template< typename pass_type >
	3198	void PassVisitor< pass_type >::visit( const QualifiedType * node ) {
	3199	VISIT_START( node );
	3200
	3201	maybeAccept_impl( node->forall, *this );
	3202	maybeAccept_impl( node->parent, *this );
	3203	maybeAccept_impl( node->child, *this );
	3204
	3205	VISIT_END( node );
	3206	}
	3207
[c5d7701]	3208	template< typename pass_type >
	3209	Type * PassVisitor< pass_type >::mutate( QualifiedType * node ) {
	3210	MUTATE_START( node );
	3211
	3212	maybeMutate_impl( node->forall, *this );
[c194661]	3213	maybeMutate_impl( node->parent, *this );
	3214	maybeMutate_impl( node->child, *this );
[c5d7701]	3215
	3216	MUTATE_END( Type, node );
	3217	}
	3218
[17fc7a5]	3219	//--------------------------------------------------------------------------
	3220	// FunctionType
[13932f14]	3221	template< typename pass_type >
[ab904dc]	3222	void PassVisitor< pass_type >::visit( FunctionType * node ) {
[17fc7a5]	3223	VISIT_START( node );
	3224
	3225	maybeAccept_impl( node->forall, *this );
	3226	maybeAccept_impl( node->returnVals, *this );
	3227	maybeAccept_impl( node->parameters, *this );
	3228
	3229	VISIT_END( node );
	3230	}
	3231
[7870799]	3232	template< typename pass_type >
	3233	void PassVisitor< pass_type >::visit( const FunctionType * node ) {
	3234	VISIT_START( node );
	3235
	3236	maybeAccept_impl( node->forall, *this );
	3237	maybeAccept_impl( node->returnVals, *this );
	3238	maybeAccept_impl( node->parameters, *this );
	3239
	3240	VISIT_END( node );
	3241	}
	3242
[17fc7a5]	3243	template< typename pass_type >
	3244	Type * PassVisitor< pass_type >::mutate( FunctionType * node ) {
	3245	MUTATE_START( node );
	3246
	3247	maybeMutate_impl( node->forall, *this );
	3248	maybeMutate_impl( node->returnVals, *this );
	3249	maybeMutate_impl( node->parameters, *this );
	3250
	3251	MUTATE_END( Type, node );
[13932f14]	3252	}
	3253
[e0886db]	3254	//--------------------------------------------------------------------------
	3255	// StructInstType
[13932f14]	3256	template< typename pass_type >
[ab904dc]	3257	void PassVisitor< pass_type >::visit( StructInstType * node ) {
[e0886db]	3258	VISIT_START( node );
	3259
	3260	indexerAddStruct( node->name );
	3261
	3262	{
	3263	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[3c398b6]	3264	maybeAccept_impl( node->forall , *this );
	3265	maybeAccept_impl( node->parameters, *this );
[e0886db]	3266	}
	3267
	3268	VISIT_END( node );
	3269	}
	3270
[7870799]	3271	template< typename pass_type >
	3272	void PassVisitor< pass_type >::visit( const StructInstType * node ) {
	3273	VISIT_START( node );
	3274
[e3d7f9f]	3275	indexerAddStruct( node->name );
	3276
	3277	{
	3278	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
	3279	maybeAccept_impl( node->forall , *this );
	3280	maybeAccept_impl( node->parameters, *this );
	3281	}
[7870799]	3282
	3283	VISIT_END( node );
	3284	}
	3285
[e0886db]	3286	template< typename pass_type >
	3287	Type * PassVisitor< pass_type >::mutate( StructInstType * node ) {
	3288	MUTATE_START( node );
	3289
	3290	indexerAddStruct( node->name );
	3291
	3292	{
	3293	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[3c398b6]	3294	maybeMutate_impl( node->forall , *this );
	3295	maybeMutate_impl( node->parameters, *this );
[e0886db]	3296	}
	3297
	3298	MUTATE_END( Type, node );
[13932f14]	3299	}
	3300
[e0886db]	3301	//--------------------------------------------------------------------------
	3302	// UnionInstType
[13932f14]	3303	template< typename pass_type >
[ab904dc]	3304	void PassVisitor< pass_type >::visit( UnionInstType * node ) {
[e0886db]	3305	VISIT_START( node );
	3306
	3307	indexerAddStruct( node->name );
	3308
	3309	{
	3310	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[3c398b6]	3311	maybeAccept_impl( node->forall , *this );
	3312	maybeAccept_impl( node->parameters, *this );
[e0886db]	3313	}
	3314
	3315	VISIT_END( node );
	3316	}
	3317
[7870799]	3318	template< typename pass_type >
	3319	void PassVisitor< pass_type >::visit( const UnionInstType * node ) {
	3320	VISIT_START( node );
	3321
[e3d7f9f]	3322	indexerAddStruct( node->name );
	3323
	3324	{
	3325	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
	3326	maybeAccept_impl( node->forall , *this );
	3327	maybeAccept_impl( node->parameters, *this );
	3328	}
[7870799]	3329
	3330	VISIT_END( node );
	3331	}
	3332
[e0886db]	3333	template< typename pass_type >
	3334	Type * PassVisitor< pass_type >::mutate( UnionInstType * node ) {
	3335	MUTATE_START( node );
	3336
	3337	indexerAddStruct( node->name );
	3338
	3339	{
	3340	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[3c398b6]	3341	maybeMutate_impl( node->forall , *this );
	3342	maybeMutate_impl( node->parameters, *this );
[e0886db]	3343	}
	3344
	3345	MUTATE_END( Type, node );
[13932f14]	3346	}
	3347
[e0886db]	3348	//--------------------------------------------------------------------------
	3349	// EnumInstType
[13932f14]	3350	template< typename pass_type >
[ab904dc]	3351	void PassVisitor< pass_type >::visit( EnumInstType * node ) {
[86e84e4]	3352	VISIT_START( node );
	3353
	3354	maybeAccept_impl( node->forall, *this );
	3355	maybeAccept_impl( node->parameters, *this );
	3356
	3357	VISIT_END( node );
[13932f14]	3358	}
	3359
[7870799]	3360	template< typename pass_type >
	3361	void PassVisitor< pass_type >::visit( const EnumInstType * node ) {
	3362	VISIT_START( node );
	3363
	3364	maybeAccept_impl( node->forall, *this );
	3365	maybeAccept_impl( node->parameters, *this );
	3366
	3367	VISIT_END( node );
	3368	}
	3369
[e0886db]	3370	template< typename pass_type >
	3371	Type * PassVisitor< pass_type >::mutate( EnumInstType * node ) {
[86e84e4]	3372	MUTATE_START( node );
	3373
	3374	maybeMutate_impl( node->forall, *this );
	3375	maybeMutate_impl( node->parameters, *this );
	3376
	3377	MUTATE_END( Type, node );
[e0886db]	3378	}
	3379
	3380	//--------------------------------------------------------------------------
	3381	// TraitInstType
[13932f14]	3382	template< typename pass_type >
[ab904dc]	3383	void PassVisitor< pass_type >::visit( TraitInstType * node ) {
[e0886db]	3384	VISIT_START( node );
	3385
[3c398b6]	3386	maybeAccept_impl( node->forall , *this );
	3387	maybeAccept_impl( node->parameters, *this );
[e0886db]	3388
	3389	VISIT_END( node );
	3390	}
	3391
[7870799]	3392	template< typename pass_type >
	3393	void PassVisitor< pass_type >::visit( const TraitInstType * node ) {
	3394	VISIT_START( node );
	3395
	3396	maybeAccept_impl( node->forall , *this );
	3397	maybeAccept_impl( node->parameters, *this );
	3398
	3399	VISIT_END( node );
	3400	}
	3401
[e0886db]	3402	template< typename pass_type >
	3403	Type * PassVisitor< pass_type >::mutate( TraitInstType * node ) {
	3404	MUTATE_START( node );
	3405
[3c398b6]	3406	maybeMutate_impl( node->forall , *this );
	3407	maybeMutate_impl( node->parameters, *this );
[e0886db]	3408
	3409	MUTATE_END( Type, node );
[13932f14]	3410	}
	3411
[e0886db]	3412	//--------------------------------------------------------------------------
	3413	// TypeInstType
[13932f14]	3414	template< typename pass_type >
[ab904dc]	3415	void PassVisitor< pass_type >::visit( TypeInstType * node ) {
[86e84e4]	3416	VISIT_START( node );
	3417
	3418	maybeAccept_impl( node->forall , *this );
	3419	maybeAccept_impl( node->parameters, *this );
	3420
	3421	VISIT_END( node );
	3422	}
	3423
[7870799]	3424	template< typename pass_type >
	3425	void PassVisitor< pass_type >::visit( const TypeInstType * node ) {
	3426	VISIT_START( node );
	3427
	3428	maybeAccept_impl( node->forall , *this );
	3429	maybeAccept_impl( node->parameters, *this );
	3430
	3431	VISIT_END( node );
	3432	}
	3433
[86e84e4]	3434	template< typename pass_type >
	3435	Type * PassVisitor< pass_type >::mutate( TypeInstType * node ) {
	3436	MUTATE_START( node );
	3437
	3438	maybeMutate_impl( node->forall , *this );
	3439	maybeMutate_impl( node->parameters, *this );
	3440
	3441	MUTATE_END( Type, node );
[13932f14]	3442	}
	3443
[a8a2b0a]	3444	//--------------------------------------------------------------------------
	3445	// TupleType
[13932f14]	3446	template< typename pass_type >
[ab904dc]	3447	void PassVisitor< pass_type >::visit( TupleType * node ) {
[a8a2b0a]	3448	VISIT_START( node );
	3449
	3450	maybeAccept_impl( node->forall, *this );
	3451	maybeAccept_impl( node->types, *this );
	3452	maybeAccept_impl( node->members, *this );
	3453
	3454	VISIT_END( node );
[13932f14]	3455	}
	3456
[7870799]	3457	template< typename pass_type >
	3458	void PassVisitor< pass_type >::visit( const TupleType * node ) {
	3459	VISIT_START( node );
	3460
	3461	maybeAccept_impl( node->forall, *this );
	3462	maybeAccept_impl( node->types, *this );
	3463	maybeAccept_impl( node->members, *this );
	3464
	3465	VISIT_END( node );
	3466	}
	3467
[a8a2b0a]	3468	template< typename pass_type >
	3469	Type * PassVisitor< pass_type >::mutate( TupleType * node ) {
	3470	MUTATE_START( node );
	3471
	3472	maybeMutate_impl( node->forall, *this );
	3473	maybeMutate_impl( node->types, *this );
	3474	maybeMutate_impl( node->members, *this );
	3475
	3476	MUTATE_END( Type, node );
	3477	}
	3478
	3479	//--------------------------------------------------------------------------
	3480	// TypeofType
[13932f14]	3481	template< typename pass_type >
[ab904dc]	3482	void PassVisitor< pass_type >::visit( TypeofType * node ) {
[a8a2b0a]	3483	VISIT_START( node );
	3484
	3485	assert( node->expr );
	3486	maybeAccept_impl( node->expr, *this );
	3487
	3488	VISIT_END( node );
[13932f14]	3489	}
	3490
[7870799]	3491	template< typename pass_type >
	3492	void PassVisitor< pass_type >::visit( const TypeofType * node ) {
	3493	VISIT_START( node );
	3494
	3495	assert( node->expr );
	3496	maybeAccept_impl( node->expr, *this );
	3497
	3498	VISIT_END( node );
	3499	}
	3500
[a8a2b0a]	3501	template< typename pass_type >
	3502	Type * PassVisitor< pass_type >::mutate( TypeofType * node ) {
	3503	MUTATE_START( node );
	3504
	3505	assert( node->expr );
	3506	maybeMutate_impl( node->expr, *this );
	3507
	3508	MUTATE_END( Type, node );
	3509	}
	3510
	3511	//--------------------------------------------------------------------------
	3512	// AttrType
[13932f14]	3513	template< typename pass_type >
[ab904dc]	3514	void PassVisitor< pass_type >::visit( AttrType * node ) {
[a8a2b0a]	3515	VISIT_START( node );
	3516
	3517	if ( node->isType ) {
	3518	assert( node->type );
	3519	maybeAccept_impl( node->type, *this );
	3520	} else {
	3521	assert( node->expr );
	3522	maybeAccept_impl( node->expr, *this );
	3523	} // if
	3524
	3525	VISIT_END( node );
[13932f14]	3526	}
	3527
[7870799]	3528	template< typename pass_type >
	3529	void PassVisitor< pass_type >::visit( const AttrType * node ) {
	3530	VISIT_START( node );
	3531
	3532	if ( node->isType ) {
	3533	assert( node->type );
	3534	maybeAccept_impl( node->type, *this );
	3535	} else {
	3536	assert( node->expr );
	3537	maybeAccept_impl( node->expr, *this );
	3538	} // if
	3539
	3540	VISIT_END( node );
	3541	}
	3542
[a8a2b0a]	3543	template< typename pass_type >
	3544	Type * PassVisitor< pass_type >::mutate( AttrType * node ) {
	3545	MUTATE_START( node );
	3546
	3547	if ( node->isType ) {
	3548	assert( node->type );
	3549	maybeMutate_impl( node->type, *this );
	3550	} else {
	3551	assert( node->expr );
	3552	maybeMutate_impl( node->expr, *this );
	3553	} // if
	3554
	3555	MUTATE_END( Type, node );
	3556	}
	3557
	3558	//--------------------------------------------------------------------------
	3559	// VarArgsType
[13932f14]	3560	template< typename pass_type >
[ab904dc]	3561	void PassVisitor< pass_type >::visit( VarArgsType * node ) {
[a8a2b0a]	3562	VISIT_START( node );
	3563
	3564	maybeAccept_impl( node->forall, *this );
	3565
	3566	VISIT_END( node );
[13932f14]	3567	}
	3568
[7870799]	3569	template< typename pass_type >
	3570	void PassVisitor< pass_type >::visit( const VarArgsType * node ) {
	3571	VISIT_START( node );
	3572
	3573	maybeAccept_impl( node->forall, *this );
	3574
	3575	VISIT_END( node );
	3576	}
	3577
[a8a2b0a]	3578	template< typename pass_type >
	3579	Type * PassVisitor< pass_type >::mutate( VarArgsType * node ) {
	3580	MUTATE_START( node );
	3581
	3582	maybeMutate_impl( node->forall, *this );
	3583
	3584	MUTATE_END( Type, node );
	3585	}
	3586
	3587	//--------------------------------------------------------------------------
	3588	// ZeroType
[13932f14]	3589	template< typename pass_type >
[ab904dc]	3590	void PassVisitor< pass_type >::visit( ZeroType * node ) {
[a8a2b0a]	3591	VISIT_START( node );
	3592
	3593	maybeAccept_impl( node->forall, *this );
	3594
	3595	VISIT_END( node );
[13932f14]	3596	}
	3597
[7870799]	3598	template< typename pass_type >
	3599	void PassVisitor< pass_type >::visit( const ZeroType * node ) {
	3600	VISIT_START( node );
	3601
	3602	maybeAccept_impl( node->forall, *this );
	3603
	3604	VISIT_END( node );
	3605	}
	3606
[a8a2b0a]	3607	template< typename pass_type >
	3608	Type * PassVisitor< pass_type >::mutate( ZeroType * node ) {
	3609	MUTATE_START( node );
	3610
	3611	maybeMutate_impl( node->forall, *this );
	3612
	3613	MUTATE_END( Type, node );
	3614	}
	3615
	3616	//--------------------------------------------------------------------------
	3617	// OneType
[13932f14]	3618	template< typename pass_type >
[ab904dc]	3619	void PassVisitor< pass_type >::visit( OneType * node ) {
[a8a2b0a]	3620	VISIT_START( node );
	3621
	3622	maybeAccept_impl( node->forall, *this );
	3623
	3624	VISIT_END( node );
[13932f14]	3625	}
	3626
[7870799]	3627	template< typename pass_type >
	3628	void PassVisitor< pass_type >::visit( const OneType * node ) {
	3629	VISIT_START( node );
	3630
	3631	maybeAccept_impl( node->forall, *this );
	3632
	3633	VISIT_END( node );
	3634	}
	3635
[a8a2b0a]	3636	template< typename pass_type >
	3637	Type * PassVisitor< pass_type >::mutate( OneType * node ) {
	3638	MUTATE_START( node );
	3639
	3640	maybeMutate_impl( node->forall, *this );
	3641
	3642	MUTATE_END( Type, node );
	3643	}
	3644
[47498bd]	3645	//--------------------------------------------------------------------------
	3646	// GlobalScopeType
	3647	template< typename pass_type >
	3648	void PassVisitor< pass_type >::visit( GlobalScopeType * node ) {
	3649	VISIT_START( node );
	3650
	3651	maybeAccept_impl( node->forall, *this );
	3652
	3653	VISIT_END( node );
	3654	}
	3655
[7870799]	3656	template< typename pass_type >
	3657	void PassVisitor< pass_type >::visit( const GlobalScopeType * node ) {
	3658	VISIT_START( node );
	3659
	3660	maybeAccept_impl( node->forall, *this );
	3661
	3662	VISIT_END( node );
	3663	}
	3664
[47498bd]	3665	template< typename pass_type >
	3666	Type * PassVisitor< pass_type >::mutate( GlobalScopeType * node ) {
	3667	MUTATE_START( node );
	3668
	3669	maybeMutate_impl( node->forall, *this );
	3670
	3671	MUTATE_END( Type, node );
	3672	}
	3673
[a8a2b0a]	3674	//--------------------------------------------------------------------------
	3675	// Designation
[b11d8e2]	3676	template< typename pass_type >
	3677	void PassVisitor< pass_type >::visit( Designation * node ) {
	3678	VISIT_START( node );
	3679
[a8a2b0a]	3680	maybeAccept_impl( node->designators, *this );
[b11d8e2]	3681
	3682	VISIT_END( node );
	3683	}
	3684
[7870799]	3685	template< typename pass_type >
	3686	void PassVisitor< pass_type >::visit( const Designation * node ) {
	3687	VISIT_START( node );
	3688
	3689	maybeAccept_impl( node->designators, *this );
	3690
	3691	VISIT_END( node );
	3692	}
	3693
[b11d8e2]	3694	template< typename pass_type >
	3695	Designation * PassVisitor< pass_type >::mutate( Designation * node ) {
	3696	MUTATE_START( node );
	3697
[a8a2b0a]	3698	maybeMutate_impl( node->designators, *this );
[b11d8e2]	3699
	3700	MUTATE_END( Designation, node );
	3701	}
	3702
[9c1600c]	3703	//--------------------------------------------------------------------------
[e0886db]	3704	// SingleInit
[13932f14]	3705	template< typename pass_type >
[ab904dc]	3706	void PassVisitor< pass_type >::visit( SingleInit * node ) {
[9c1600c]	3707	VISIT_START( node );
	3708
[a8a2b0a]	3709	visitExpression( node->value );
[9c1600c]	3710
	3711	VISIT_END( node );
[13932f14]	3712	}
	3713
[7870799]	3714	template< typename pass_type >
	3715	void PassVisitor< pass_type >::visit( const SingleInit * node ) {
	3716	VISIT_START( node );
	3717
	3718	visitExpression( node->value );
	3719
	3720	VISIT_END( node );
	3721	}
	3722
[296b2be]	3723	template< typename pass_type >
	3724	Initializer * PassVisitor< pass_type >::mutate( SingleInit * node ) {
	3725	MUTATE_START( node );
	3726
[a8a2b0a]	3727	node->value = mutateExpression( node->value );
[296b2be]	3728
	3729	MUTATE_END( Initializer, node );
	3730	}
	3731
[a8a2b0a]	3732	//--------------------------------------------------------------------------
	3733	// ListInit
[13932f14]	3734	template< typename pass_type >
[ab904dc]	3735	void PassVisitor< pass_type >::visit( ListInit * node ) {
[a8a2b0a]	3736	VISIT_START( node );
[13932f14]	3737
[a8a2b0a]	3738	maybeAccept_impl( node->designations, *this );
	3739	maybeAccept_impl( node->initializers, *this );
[13932f14]	3740
[a8a2b0a]	3741	VISIT_END( node );
[13932f14]	3742	}
	3743
[7870799]	3744	template< typename pass_type >
	3745	void PassVisitor< pass_type >::visit( const ListInit * node ) {
	3746	VISIT_START( node );
	3747
	3748	maybeAccept_impl( node->designations, *this );
	3749	maybeAccept_impl( node->initializers, *this );
	3750
	3751	VISIT_END( node );
	3752	}
	3753
[13932f14]	3754	template< typename pass_type >
[a8a2b0a]	3755	Initializer * PassVisitor< pass_type >::mutate( ListInit * node ) {
	3756	MUTATE_START( node );
	3757
	3758	maybeMutate_impl( node->designations, *this );
	3759	maybeMutate_impl( node->initializers, *this );
	3760
	3761	MUTATE_END( Initializer, node );
[13932f14]	3762	}
[ab904dc]	3763
[a8a2b0a]	3764	//--------------------------------------------------------------------------
	3765	// ConstructorInit
[5ea7a22]	3766	template< typename pass_type >
[a8a2b0a]	3767	void PassVisitor< pass_type >::visit( ConstructorInit * node ) {
	3768	VISIT_START( node );
[5ea7a22]	3769
[a8a2b0a]	3770	maybeAccept_impl( node->ctor, *this );
	3771	maybeAccept_impl( node->dtor, *this );
	3772	maybeAccept_impl( node->init, *this );
[ab904dc]	3773
[a8a2b0a]	3774	VISIT_END( node );
[ab904dc]	3775	}
	3776
[7870799]	3777	template< typename pass_type >
	3778	void PassVisitor< pass_type >::visit( const ConstructorInit * node ) {
	3779	VISIT_START( node );
	3780
	3781	maybeAccept_impl( node->ctor, *this );
	3782	maybeAccept_impl( node->dtor, *this );
	3783	maybeAccept_impl( node->init, *this );
	3784
	3785	VISIT_END( node );
	3786	}
	3787
[ab904dc]	3788	template< typename pass_type >
[a8a2b0a]	3789	Initializer * PassVisitor< pass_type >::mutate( ConstructorInit * node ) {
	3790	MUTATE_START( node );
[ab904dc]	3791
[a8a2b0a]	3792	maybeMutate_impl( node->ctor, *this );
	3793	maybeMutate_impl( node->dtor, *this );
	3794	maybeMutate_impl( node->init, *this );
[ab904dc]	3795
[a8a2b0a]	3796	MUTATE_END( Initializer, node );
[ab904dc]	3797	}
	3798
[a8a2b0a]	3799	//--------------------------------------------------------------------------
	3800	// Attribute
[ab904dc]	3801	template< typename pass_type >
[a8a2b0a]	3802	void PassVisitor< pass_type >::visit( Constant * node ) {
	3803	VISIT_START( node );
	3804
	3805	VISIT_END( node );
[ab904dc]	3806	}
	3807
[7870799]	3808	template< typename pass_type >
	3809	void PassVisitor< pass_type >::visit( const Constant * node ) {
	3810	VISIT_START( node );
	3811
	3812	VISIT_END( node );
	3813	}
	3814
[ab904dc]	3815	template< typename pass_type >
[a8a2b0a]	3816	Constant * PassVisitor< pass_type >::mutate( Constant * node ) {
	3817	MUTATE_START( node );
	3818
	3819	MUTATE_END( Constant, node );
[ab904dc]	3820	}
	3821
[a8a2b0a]	3822	//--------------------------------------------------------------------------
	3823	// Attribute
[ab904dc]	3824	template< typename pass_type >
[a8a2b0a]	3825	void PassVisitor< pass_type >::visit( Attribute * node ) {
	3826	VISIT_START( node );
	3827
	3828	maybeAccept_impl( node->parameters, *this );
	3829
	3830	VISIT_END( node );
[4551a6e]	3831	}
[5ea7a22]	3832
[7870799]	3833	template< typename pass_type >
	3834	void PassVisitor< pass_type >::visit( const Attribute * node ) {
	3835	VISIT_START( node );
	3836
	3837	maybeAccept_impl( node->parameters, *this );
	3838
	3839	VISIT_END( node );
	3840	}
	3841
[5ea7a22]	3842	template< typename pass_type >
	3843	Attribute * PassVisitor< pass_type >::mutate( Attribute * node ) {
[a8a2b0a]	3844	MUTATE_START( node );
	3845
	3846	maybeMutate_impl( node->parameters, *this );
	3847
	3848	MUTATE_END( Attribute, node );
[5ea7a22]	3849	}
[447c356]	3850
[a8a2b0a]	3851	//--------------------------------------------------------------------------
	3852	// TypeSubstitution
[447c356]	3853	template< typename pass_type >
	3854	TypeSubstitution * PassVisitor< pass_type >::mutate( TypeSubstitution * node ) {
	3855	MUTATE_START( node );
	3856
	3857	for ( auto & p : node->typeEnv ) {
	3858	indexerScopedMutate( p.second, *this );
	3859	}
	3860	for ( auto & p : node->varEnv ) {
	3861	indexerScopedMutate( p.second, *this );
	3862	}
	3863
	3864	MUTATE_END( TypeSubstitution, node );
	3865	}
[342146e1]	3866
	3867	#undef VISIT_START
	3868	#undef VISIT_END
	3869
	3870	#undef MUTATE_START
[033ff37]	3871	#undef MUTATE_END

Note: See TracBrowser for help on using the repository browser.

Download in other formats: