Context Navigation

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

Visit:

ADT aaron-thesis arm-eh ast-experimental cleanup-dtors deferred_resn demangler enum forall-pointer-decay jacob/cs343-translation jenkins-sandbox new-ast new-ast-unique-expr new-env no_list persistent-indexer pthread-emulation qualifiedEnum resolv-new with_gc

Last change on this file since c7ad609 was 5964127, checked in by Rob Schluntz <rschlunt@…>, 8 years ago
Expand VISIT/MUTATE_BODY for NullStmt and DeclStmt
Property mode set to `100644`
File size: 67.6 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 ) \
	22	return call_postmutate< type * >( node ); \
	23
	24
[3c398b6]	25	#define VISIT_BODY( node ) \
	26	VISIT_START( node ); \
	27	if( children_guard ) { \
	28	Visitor::visit( node ); \
	29	} \
	30	VISIT_END( node ); \
[13932f14]	31
[ab904dc]	32
[3c398b6]	33	#define MUTATE_BODY( type, node ) \
	34	MUTATE_START( node ); \
	35	if( children_guard ) { \
	36	Mutator::mutate( node ); \
	37	} \
	38	MUTATE_END( type, node ); \
[296b2be]	39
[134322e]	40
	41
	42	template<typename T>
	43	static inline bool empty( T * ptr ) {
	44	return !ptr \|\| ptr->empty();
	45	}
	46
[6ca154b]	47	typedef std::list< Statement * > StmtList_t;
	48	typedef std::list< Declaration * > DeclList_t;
	49
	50	template<typename iterator_t>
	51	static inline void splice( iterator_t it, DeclList_t * decls ) {
	52	std::transform(
	53	decls->begin(),
	54	decls->end(),
	55	it,
	56	[](Declaration * decl) -> auto {
[ba3706f]	57	return new DeclStmt( decl );
[6ca154b]	58	}
	59	);
	60	decls->clear();
	61	}
[134322e]	62
	63	template< typename pass_type >
[07c178f0]	64	inline void acceptAll( std::list< Declaration* > &decls, PassVisitor< pass_type >& visitor ) {
[6ca154b]	65	DeclList_t* beforeDecls = visitor.get_beforeDecls();
	66	DeclList_t* afterDecls = visitor.get_afterDecls();
[522363e]	67	SemanticError errors;
[134322e]	68
[6ca154b]	69	for ( std::list< Declaration* >::iterator i = decls.begin(); ; ++i ) {
	70	// splice in new declarations after previous decl
[d24d4e1]	71	if ( !empty( afterDecls ) ) { decls.splice( i, *afterDecls ); }
[6ca154b]	72
	73	if ( i == decls.end() ) break;
	74
[522363e]	75	try {
	76	// run visitor on declaration
[3c398b6]	77	maybeAccept_impl( *i, visitor );
[522363e]	78	} catch( SemanticError &e ) {
	79	errors.append( e );
	80	}
[6ca154b]	81
	82	// splice in new declarations before current decl
	83	if ( !empty( beforeDecls ) ) { decls.splice( i, *beforeDecls ); }
[134322e]	84	}
[522363e]	85	if ( ! errors.isEmpty() ) {
	86	throw errors;
	87	}
[6ca154b]	88	}
[134322e]	89
[6ca154b]	90	template< typename pass_type >
[07c178f0]	91	inline void mutateAll( std::list< Declaration* > &decls, PassVisitor< pass_type >& mutator ) {
[6ca154b]	92	DeclList_t* beforeDecls = mutator.get_beforeDecls();
	93	DeclList_t* afterDecls = mutator.get_afterDecls();
[522363e]	94	SemanticError errors;
[6ca154b]	95
	96	for ( std::list< Declaration* >::iterator i = decls.begin(); ; ++i ) {
	97	// splice in new declarations after previous decl
[d24d4e1]	98	if ( !empty( afterDecls ) ) { decls.splice( i, *afterDecls ); }
[6ca154b]	99
	100	if ( i == decls.end() ) break;
[522363e]	101	try {
	102	// run mutator on declaration
[3c398b6]	103	maybeMutate_impl( *i, mutator );
[522363e]	104	} catch( SemanticError &e ) {
	105	errors.append( e );
	106	}
[6ca154b]	107
	108	// splice in new declarations before current decl
	109	if ( !empty( beforeDecls ) ) { decls.splice( i, *beforeDecls ); }
	110	}
[522363e]	111	if ( ! errors.isEmpty() ) {
	112	throw errors;
	113	}
[134322e]	114	}
	115
[3c398b6]	116	template< typename TreeType, typename pass_type >
	117	inline void maybeAccept_impl( TreeType * tree, PassVisitor< pass_type > & visitor ) {
	118	if ( ! visitor.get_visit_children() ) return;
	119	if ( tree ) {
	120	tree->accept( visitor );
	121	}
	122	}
	123
	124	template< typename Container, typename pass_type >
	125	inline void maybeAccept_impl( Container & container, PassVisitor< pass_type > & visitor ) {
	126	if ( ! visitor.get_visit_children() ) return;
[e0886db]	127	SemanticError errors;
	128	for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
	129	try {
	130	if ( *i ) {
	131	(*i)->accept( visitor );
	132	}
	133	} catch( SemanticError &e ) {
	134	errors.append( e );
	135	}
	136	}
	137	if ( ! errors.isEmpty() ) {
	138	throw errors;
	139	}
	140	}
	141
[3c398b6]	142	template< typename TreeType, typename pass_type >
	143	inline void maybeMutate_impl( TreeType *& tree, PassVisitor< pass_type > & mutator ) {
	144	if ( ! mutator.get_visit_children() ) return;
	145
	146	if ( tree ) {
	147	tree = strict_dynamic_cast< TreeType * >( tree->acceptMutator( mutator ) );
	148	}
	149	}
	150
	151	template< typename Container, typename pass_type >
	152	inline void maybeMutate_impl( Container & container, PassVisitor< pass_type > & mutator ) {
	153	if ( ! mutator.get_visit_children() ) return;
[e0886db]	154	SemanticError errors;
	155	for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
	156	try {
	157	if ( *i ) {
	158	i = dynamic_cast< typename Container::value_type >( (i)->acceptMutator( mutator ) );
	159	assert( *i );
	160	} // if
	161	} catch( SemanticError &e ) {
	162	errors.append( e );
	163	} // try
	164	} // for
	165	if ( ! errors.isEmpty() ) {
	166	throw errors;
	167	} // if
	168	}
	169
[296b2be]	170	template< typename pass_type >
[6ca154b]	171	template< typename func_t >
	172	void PassVisitor< pass_type >::handleStatementList( std::list< Statement * > & statements, func_t func ) {
[3c398b6]	173	if ( ! get_visit_children() ) return;
[296b2be]	174	SemanticError errors;
	175
[2a7b3ca]	176	// don't want statements from outer CompoundStmts to be added to this CompoundStmt
	177	ValueGuardPtr< StmtList_t > oldBeforeStmts( get_beforeStmts() );
	178	ValueGuardPtr< StmtList_t > oldAfterStmts ( get_afterStmts () );
	179	ValueGuardPtr< DeclList_t > oldBeforeDecls( get_beforeDecls() );
	180	ValueGuardPtr< DeclList_t > oldAfterDecls ( get_afterDecls () );
	181
[134322e]	182	StmtList_t* beforeStmts = get_beforeStmts();
	183	StmtList_t* afterStmts = get_afterStmts();
[6ca154b]	184	DeclList_t* beforeDecls = get_beforeDecls();
	185	DeclList_t* afterDecls = get_afterDecls();
[134322e]	186
[296b2be]	187	for ( std::list< Statement* >::iterator i = statements.begin(); i != statements.end(); ++i ) {
[6ca154b]	188
	189	if ( !empty( afterDecls ) ) { splice( std::inserter( statements, i ), afterDecls ); }
[134322e]	190	if ( !empty( afterStmts ) ) { statements.splice( i, *afterStmts ); }
[6ca154b]	191
[296b2be]	192	try {
[6ca154b]	193	func( *i );
	194	assert(( empty( beforeStmts ) && empty( afterStmts ))
	195	\|\| ( empty( beforeDecls ) && empty( afterDecls )) );
	196
[296b2be]	197	} catch ( SemanticError &e ) {
	198	errors.append( e );
[134322e]	199	}
[6ca154b]	200
	201	if ( !empty( beforeDecls ) ) { splice( std::inserter( statements, i ), beforeDecls ); }
[134322e]	202	if ( !empty( beforeStmts ) ) { statements.splice( i, *beforeStmts ); }
[296b2be]	203	}
[134322e]	204
[6ca154b]	205	if ( !empty( afterDecls ) ) { splice( std::back_inserter( statements ), afterDecls); }
[134322e]	206	if ( !empty( afterStmts ) ) { statements.splice( statements.end(), *afterStmts ); }
	207	if ( !errors.isEmpty() ) { throw errors; }
[296b2be]	208	}
	209
	210	template< typename pass_type >
[6ca154b]	211	void PassVisitor< pass_type >::visitStatementList( std::list< Statement * > & statements ) {
	212	handleStatementList( statements, [this]( Statement * stmt) {
[3c398b6]	213	maybeAccept_impl( stmt, *this );
[6ca154b]	214	});
	215	}
[134322e]	216
[6ca154b]	217	template< typename pass_type >
	218	void PassVisitor< pass_type >::mutateStatementList( std::list< Statement * > & statements ) {
	219	handleStatementList( statements, [this]( Statement *& stmt) {
[3c398b6]	220	maybeMutate_impl( stmt, *this );
[6ca154b]	221	});
[134322e]	222	}
	223
[6ca154b]	224
[134322e]	225	template< typename pass_type >
[6ca154b]	226	template< typename func_t >
	227	Statement * PassVisitor< pass_type >::handleStatement( Statement * stmt, func_t func ) {
[3c398b6]	228	if ( ! get_visit_children() ) return stmt;
	229
[134322e]	230	// don't want statements from outer CompoundStmts to be added to this CompoundStmt
[6ca154b]	231	ValueGuardPtr< TypeSubstitution * > oldEnv ( get_env_ptr () );
	232	ValueGuardPtr< DeclList_t > oldBeforeDecls( get_beforeDecls() );
	233	ValueGuardPtr< DeclList_t > oldAfterDecls ( get_afterDecls () );
	234	ValueGuardPtr< StmtList_t > oldBeforeStmts( get_beforeStmts() );
	235	ValueGuardPtr< StmtList_t > oldAfterStmts ( get_afterStmts () );
[296b2be]	236
[6ca154b]	237	Statement *newStmt = func( stmt );
[134322e]	238
	239	StmtList_t* beforeStmts = get_beforeStmts();
	240	StmtList_t* afterStmts = get_afterStmts();
[6ca154b]	241	DeclList_t* beforeDecls = get_beforeDecls();
	242	DeclList_t* afterDecls = get_afterDecls();
[134322e]	243
[6ca154b]	244	if( empty(beforeStmts) && empty(afterStmts) && empty(beforeDecls) && empty(afterDecls) ) { return newStmt; }
	245	assert(( empty( beforeStmts ) && empty( afterStmts ))
	246	\|\| ( empty( beforeDecls ) && empty( afterDecls )) );
[134322e]	247
[ba3706f]	248	CompoundStmt *compound = new CompoundStmt();
[6ca154b]	249	if( !empty(beforeDecls) ) { splice( std::back_inserter( compound->get_kids() ), beforeDecls ); }
[134322e]	250	if( !empty(beforeStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *beforeStmts ); }
	251	compound->get_kids().push_back( newStmt );
[6ca154b]	252	if( !empty(afterDecls) ) { splice( std::back_inserter( compound->get_kids() ), afterDecls ); }
[134322e]	253	if( !empty(afterStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *afterStmts ); }
	254	return compound;
	255	}
	256
	257	template< typename pass_type >
[6ca154b]	258	Statement * PassVisitor< pass_type >::visitStatement( Statement * stmt ) {
	259	return handleStatement( stmt, [this]( Statement * stmt ) {
[3c398b6]	260	maybeAccept_impl( stmt, *this );
[6ca154b]	261	return stmt;
	262	});
	263	}
[134322e]	264
[6ca154b]	265	template< typename pass_type >
	266	Statement * PassVisitor< pass_type >::mutateStatement( Statement * stmt ) {
	267	return handleStatement( stmt, [this]( Statement * stmt ) {
[3c398b6]	268	maybeMutate_impl( stmt, *this );
	269	return stmt;
[6ca154b]	270	});
[296b2be]	271	}
	272
	273	template< typename pass_type >
[6ca154b]	274	template< typename func_t >
	275	Expression * PassVisitor< pass_type >::handleExpression( Expression * expr, func_t func ) {
[3c398b6]	276	if ( ! get_visit_children() ) return expr;
[296b2be]	277	if( !expr ) return nullptr;
	278
[134322e]	279	auto env_ptr = get_env_ptr();
	280	if ( env_ptr && expr->get_env() ) {
	281	*env_ptr = expr->get_env();
[296b2be]	282	}
[6ca154b]	283
[3c398b6]	284	// should env be moved onto the result of the mutate?
[6ca154b]	285	return func( expr );
	286	}
	287
	288	template< typename pass_type >
	289	Expression * PassVisitor< pass_type >::visitExpression( Expression * expr ) {
	290	return handleExpression(expr, [this]( Expression * expr ) {
[3c398b6]	291	maybeAccept_impl( expr, *this );
[6ca154b]	292	return expr;
[d24d4e1]	293	});
[296b2be]	294	}
[ab904dc]	295
[6ca154b]	296	template< typename pass_type >
	297	Expression * PassVisitor< pass_type >::mutateExpression( Expression * expr ) {
	298	return handleExpression(expr, [this]( Expression * expr ) {
[3c398b6]	299	maybeMutate_impl( expr, *this );
	300	return expr;
[6ca154b]	301	});
	302	}
[ab904dc]	303
[3c398b6]	304	template< typename TreeType, typename VisitorType >
	305	inline void indexerScopedAccept( TreeType * tree, VisitorType & visitor ) {
	306	if ( ! visitor.get_visit_children() ) return;
	307	auto guard = makeFuncGuard(
	308	[&visitor]() { visitor.indexerScopeEnter(); },
	309	[&visitor]() { visitor.indexerScopeLeave(); }
	310	);
	311	maybeAccept_impl( tree, visitor );
	312	}
	313
	314	template< typename TreeType, typename MutatorType >
	315	inline void indexerScopedMutate( TreeType *& tree, MutatorType & mutator ) {
	316	if ( ! mutator.get_visit_children() ) return;
	317	auto guard = makeFuncGuard(
	318	[&mutator]() { mutator.indexerScopeEnter(); },
	319	[&mutator]() { mutator.indexerScopeLeave(); }
	320	);
	321	maybeMutate_impl( tree, mutator );
	322	}
	323
[296b2be]	324	//------------------------------------------------------------------------------------------------------------------------------------------------------------------------
[e0886db]	325	//========================================================================================================================================================================
	326	//========================================================================================================================================================================
	327	//========================================================================================================================================================================
	328	//========================================================================================================================================================================
	329	//========================================================================================================================================================================
	330	//------------------------------------------------------------------------------------------------------------------------------------------------------------------------
[13932f14]	331
[33a25f9]	332	// A NOTE ON THE ORDER OF TRAVERSAL
	333	//
	334	// Types and typedefs have their base types visited before they are added to the type table. This is ok, since there is
	335	// no such thing as a recursive type or typedef.
	336	//
	337	// typedef struct { T *x; } T; // never allowed
	338	//
	339	// for structs/unions, it is possible to have recursion, so the decl should be added as if it's incomplete to begin, the
	340	// members are traversed, and then the complete type should be added (assuming the type is completed by this particular
	341	// declaration).
	342	//
	343	// struct T { struct T *x; }; // allowed
	344	//
	345	// It is important to add the complete type to the symbol table after the members/base has been traversed, since that
	346	// traversal may modify the definition of the type and these modifications should be visible when the symbol table is
	347	// queried later in this pass.
	348	//
	349	// TODO: figure out whether recursive contexts are sensible/possible/reasonable.
[e0886db]	350
	351	//--------------------------------------------------------------------------
	352	// ObjectDecl
[13932f14]	353	template< typename pass_type >
[ab904dc]	354	void PassVisitor< pass_type >::visit( ObjectDecl * node ) {
[e0886db]	355	VISIT_START( node );
	356
	357	indexerScopedAccept( node->type , *this );
[3c398b6]	358	maybeAccept_impl ( node->init , *this );
	359	maybeAccept_impl ( node->bitfieldWidth, *this );
	360	maybeAccept_impl ( node->attributes , *this );
[e0886db]	361
[2cb70aa]	362	indexerAddId( node );
[e0886db]	363
	364	VISIT_END( node );
	365	}
	366
	367	template< typename pass_type >
	368	DeclarationWithType * PassVisitor< pass_type >::mutate( ObjectDecl * node ) {
	369	MUTATE_START( node );
	370
	371	indexerScopedMutate( node->type , *this );
[3c398b6]	372	maybeMutate_impl ( node->init , *this );
	373	maybeMutate_impl ( node->bitfieldWidth, *this );
	374	maybeMutate_impl ( node->attributes , *this );
[e0886db]	375
[2cb70aa]	376	indexerAddId( node );
[e0886db]	377
	378	MUTATE_END( DeclarationWithType, node );
[13932f14]	379	}
	380
[e0886db]	381	//--------------------------------------------------------------------------
	382	// FunctionDecl
[13932f14]	383	template< typename pass_type >
[ab904dc]	384	void PassVisitor< pass_type >::visit( FunctionDecl * node ) {
[e0886db]	385	VISIT_START( node );
	386
[2cb70aa]	387	indexerAddId( node );
[e0886db]	388
[7aaec67]	389	maybeAccept_impl( node->withExprs, *this );
[e0886db]	390	{
[2cb70aa]	391	// with clause introduces a level of scope (for the with expression members).
	392	// with clause exprs are added to the indexer before parameters so that parameters
	393	// shadow with exprs and not the other way around.
[e0886db]	394	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[0ac366b]	395	indexerAddWith( node->withExprs, node );
[7aaec67]	396	{
	397	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
	398	// implicit add __func__ identifier as specified in the C manual 6.4.2.2
	399	static ObjectDecl func(
	400	"__func__", noStorageClasses, LinkageSpec::C, nullptr,
	401	new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char ), nullptr, true, false ),
	402	nullptr
	403	);
	404	indexerAddId( &func );
	405	maybeAccept_impl( node->type, *this );
	406	maybeAccept_impl( node->statements, *this );
	407	maybeAccept_impl( node->attributes, *this );
	408	}
[e0886db]	409	}
	410
	411	VISIT_END( node );
	412	}
	413
	414	template< typename pass_type >
	415	DeclarationWithType * PassVisitor< pass_type >::mutate( FunctionDecl * node ) {
	416	MUTATE_START( node );
	417
[2cb70aa]	418	indexerAddId( node );
[e0886db]	419
	420	{
[2cb70aa]	421	// with clause introduces a level of scope (for the with expression members).
	422	// with clause exprs are added to the indexer before parameters so that parameters
	423	// shadow with exprs and not the other way around.
[e0886db]	424	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[0ac366b]	425	indexerAddWith( node->withExprs, node );
[7aaec67]	426	{
	427	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
	428	// implicit add __func__ identifier as specified in the C manual 6.4.2.2
	429	static ObjectDecl func(
	430	"__func__", noStorageClasses, LinkageSpec::C, nullptr,
	431	new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char ), nullptr, true, false ),
	432	nullptr
	433	);
	434	indexerAddId( &func );
	435	maybeMutate_impl( node->type, *this );
	436	maybeMutate_impl( node->statements, *this );
	437	maybeMutate_impl( node->attributes, *this );
	438	}
[e0886db]	439	}
	440
	441	MUTATE_END( DeclarationWithType, node );
[13932f14]	442	}
	443
[e0886db]	444	//--------------------------------------------------------------------------
	445	// StructDecl
[13932f14]	446	template< typename pass_type >
[ab904dc]	447	void PassVisitor< pass_type >::visit( StructDecl * node ) {
[e0886db]	448	VISIT_START( node );
	449
	450	// make up a forward declaration and add it before processing the members
	451	// needs to be on the heap because addStruct saves the pointer
	452	indexerAddStructFwd( node );
	453
	454	{
	455	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[3c398b6]	456	maybeAccept_impl( node->parameters, *this );
	457	maybeAccept_impl( node->members , *this );
[e0886db]	458	}
	459
	460	// this addition replaces the forward declaration
	461	indexerAddStruct( node );
	462
	463	VISIT_END( node );
	464	}
	465
	466	template< typename pass_type >
	467	Declaration * PassVisitor< pass_type >::mutate( StructDecl * node ) {
	468	MUTATE_START( node );
	469
	470	// make up a forward declaration and add it before processing the members
	471	// needs to be on the heap because addStruct saves the pointer
	472	indexerAddStructFwd( node );
	473
	474	{
	475	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[3c398b6]	476	maybeMutate_impl( node->parameters, *this );
	477	maybeMutate_impl( node->members , *this );
[e0886db]	478	}
	479
	480	// this addition replaces the forward declaration
	481	indexerAddStruct( node );
	482
	483	MUTATE_END( Declaration, node );
[13932f14]	484	}
	485
[e0886db]	486	//--------------------------------------------------------------------------
	487	// UnionDecl
[13932f14]	488	template< typename pass_type >
[ab904dc]	489	void PassVisitor< pass_type >::visit( UnionDecl * node ) {
[e0886db]	490	VISIT_START( node );
	491
	492	// make up a forward declaration and add it before processing the members
	493	indexerAddUnionFwd( node );
	494
	495	{
	496	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[3c398b6]	497	maybeAccept_impl( node->parameters, *this );
	498	maybeAccept_impl( node->members , *this );
[e0886db]	499	}
	500
	501	indexerAddUnion( node );
	502
	503	VISIT_END( node );
	504	}
	505
	506	template< typename pass_type >
	507	Declaration * PassVisitor< pass_type >::mutate( UnionDecl * node ) {
	508	MUTATE_START( node );
	509
	510	// make up a forward declaration and add it before processing the members
	511	indexerAddUnionFwd( node );
	512
	513	{
	514	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[3c398b6]	515	maybeMutate_impl( node->parameters, *this );
	516	maybeMutate_impl( node->members , *this );
[e0886db]	517	}
	518
	519	indexerAddUnion( node );
	520
	521	MUTATE_END( Declaration, node );
[13932f14]	522	}
	523
[e0886db]	524	//--------------------------------------------------------------------------
	525	// EnumDecl
[13932f14]	526	template< typename pass_type >
[ab904dc]	527	void PassVisitor< pass_type >::visit( EnumDecl * node ) {
[e0886db]	528	VISIT_START( node );
	529
	530	indexerAddEnum( node );
	531
[33a25f9]	532	// unlike structs, traits, and unions, enums inject their members into the global scope
[3c398b6]	533	maybeAccept_impl( node->parameters, *this );
	534	maybeAccept_impl( node->members , *this );
[e0886db]	535
	536	VISIT_END( node );
[13932f14]	537	}
	538
[e0886db]	539	template< typename pass_type >
	540	Declaration * PassVisitor< pass_type >::mutate( EnumDecl * node ) {
	541	MUTATE_START( node );
	542
	543	indexerAddEnum( node );
	544
[522363e]	545	// unlike structs, traits, and unions, enums inject their members into the global scope
[3c398b6]	546	maybeMutate_impl( node->parameters, *this );
	547	maybeMutate_impl( node->members , *this );
[e0886db]	548
	549	MUTATE_END( Declaration, node );
	550	}
	551
	552	//--------------------------------------------------------------------------
	553	// TraitDecl
[13932f14]	554	template< typename pass_type >
[ab904dc]	555	void PassVisitor< pass_type >::visit( TraitDecl * node ) {
[e0886db]	556	VISIT_START( node );
	557
	558	{
	559	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[3c398b6]	560	maybeAccept_impl( node->parameters, *this );
	561	maybeAccept_impl( node->members , *this );
[e0886db]	562	}
	563
	564	indexerAddTrait( node );
	565
	566	VISIT_END( node );
[13932f14]	567	}
	568
[e0886db]	569	template< typename pass_type >
	570	Declaration * PassVisitor< pass_type >::mutate( TraitDecl * node ) {
	571	MUTATE_START( node );
	572
	573	{
	574	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[3c398b6]	575	maybeMutate_impl( node->parameters, *this );
	576	maybeMutate_impl( node->members , *this );
[e0886db]	577	}
	578
	579	indexerAddTrait( node );
	580
	581	MUTATE_END( Declaration, node );
	582	}
	583
	584	//--------------------------------------------------------------------------
	585	// TypeDecl
[13932f14]	586	template< typename pass_type >
[ab904dc]	587	void PassVisitor< pass_type >::visit( TypeDecl * node ) {
[e0886db]	588	VISIT_START( node );
	589
	590	{
	591	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[3c398b6]	592	maybeAccept_impl( node->parameters, *this );
	593	maybeAccept_impl( node->base , *this );
[e0886db]	594	}
	595
[33a25f9]	596	// see A NOTE ON THE ORDER OF TRAVERSAL, above
	597	// note that assertions come after the type is added to the symtab, since they are not part of the type proper
	598	// and may depend on the type itself
[e0886db]	599	indexerAddType( node );
	600
[3c398b6]	601	maybeAccept_impl( node->assertions, *this );
[e0886db]	602
	603	indexerScopedAccept( node->init, *this );
	604
	605	VISIT_END( node );
	606	}
	607
	608	template< typename pass_type >
[982832e]	609	Declaration * PassVisitor< pass_type >::mutate( TypeDecl * node ) {
[e0886db]	610	MUTATE_START( node );
	611
	612	{
	613	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[3c398b6]	614	maybeMutate_impl( node->parameters, *this );
	615	maybeMutate_impl( node->base , *this );
[e0886db]	616	}
	617
[33a25f9]	618	// see A NOTE ON THE ORDER OF TRAVERSAL, above
	619	// note that assertions come after the type is added to the symtab, since they are not part of the type proper
	620	// and may depend on the type itself
[e0886db]	621	indexerAddType( node );
	622
[3c398b6]	623	maybeMutate_impl( node->assertions, *this );
[e0886db]	624
	625	indexerScopedMutate( node->init, *this );
	626
[982832e]	627	MUTATE_END( Declaration, node );
[13932f14]	628	}
	629
[e0886db]	630	//--------------------------------------------------------------------------
	631	// TypedefDecl
[13932f14]	632	template< typename pass_type >
[ab904dc]	633	void PassVisitor< pass_type >::visit( TypedefDecl * node ) {
[e0886db]	634	VISIT_START( node );
	635
	636	{
	637	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[3c398b6]	638	maybeAccept_impl( node->parameters, *this );
	639	maybeAccept_impl( node->base , *this );
[e0886db]	640	}
	641
	642	indexerAddType( node );
	643
[3c398b6]	644	maybeAccept_impl( node->assertions, *this );
[e0886db]	645
	646	VISIT_END( node );
[13932f14]	647	}
	648
	649	template< typename pass_type >
[e0886db]	650	Declaration * PassVisitor< pass_type >::mutate( TypedefDecl * node ) {
	651	MUTATE_START( node );
	652
	653	{
	654	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[3c398b6]	655	maybeMutate_impl( node->parameters, *this );
	656	maybeMutate_impl( node->base , *this );
[e0886db]	657	}
	658
	659	indexerAddType( node );
	660
[3c398b6]	661	maybeMutate_impl( node->assertions, *this );
[e0886db]	662
	663	MUTATE_END( Declaration, node );
[13932f14]	664	}
	665
[9c1600c]	666	//--------------------------------------------------------------------------
[e0886db]	667	// AsmDecl
[13932f14]	668	template< typename pass_type >
[e0886db]	669	void PassVisitor< pass_type >::visit( AsmDecl * node ) {
[9c1600c]	670	VISIT_START( node );
	671
[3c398b6]	672	maybeAccept_impl( node->stmt, *this );
[9c1600c]	673
	674	VISIT_END( node );
[13932f14]	675	}
	676
[296b2be]	677	template< typename pass_type >
[e0886db]	678	AsmDecl * PassVisitor< pass_type >::mutate( AsmDecl * node ) {
[296b2be]	679	MUTATE_START( node );
	680
[3c398b6]	681	maybeMutate_impl( node->stmt, *this );
[e0886db]	682
	683	MUTATE_END( AsmDecl, node );
	684	}
	685
	686	//--------------------------------------------------------------------------
	687	// CompoundStmt
	688	template< typename pass_type >
	689	void PassVisitor< pass_type >::visit( CompoundStmt * node ) {
	690	VISIT_START( node );
	691	{
	692	auto guard1 = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
	693	auto guard2 = makeFuncGuard( [this]() { call_beginScope(); }, [this]() { call_endScope(); } );
	694	visitStatementList( node->kids );
	695	}
	696	VISIT_END( node );
	697	}
[296b2be]	698
[e0886db]	699	template< typename pass_type >
	700	CompoundStmt * PassVisitor< pass_type >::mutate( CompoundStmt * node ) {
	701	MUTATE_START( node );
	702	{
	703	auto guard1 = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
	704	auto guard2 = makeFuncGuard( [this]() { call_beginScope(); }, [this]() { call_endScope(); } );
	705	mutateStatementList( node->kids );
	706	}
[296b2be]	707	MUTATE_END( CompoundStmt, node );
	708	}
	709
[9c1600c]	710	//--------------------------------------------------------------------------
	711	// ExprStmt
[13932f14]	712	template< typename pass_type >
[ab904dc]	713	void PassVisitor< pass_type >::visit( ExprStmt * node ) {
[9c1600c]	714	VISIT_START( node );
	715
[e0886db]	716	visitExpression( node->expr );
[9c1600c]	717
	718	VISIT_END( node );
[13932f14]	719	}
	720
[296b2be]	721	template< typename pass_type >
	722	Statement * PassVisitor< pass_type >::mutate( ExprStmt * node ) {
	723	MUTATE_START( node );
	724
[e0886db]	725	node->expr = mutateExpression( node->expr );
[296b2be]	726
	727	MUTATE_END( Statement, node );
	728	}
	729
[6ca154b]	730	//--------------------------------------------------------------------------
	731	// AsmStmt
[13932f14]	732	template< typename pass_type >
[ab904dc]	733	void PassVisitor< pass_type >::visit( AsmStmt * node ) {
[bc6f918]	734	VISIT_START( node )
	735
	736	maybeAccept_impl( node->instruction, *this );
	737	maybeAccept_impl( node->output, *this );
	738	maybeAccept_impl( node->input, *this );
	739	maybeAccept_impl( node->clobber, *this );
	740
	741	VISIT_END( node );
[13932f14]	742	}
	743
[6ca154b]	744	template< typename pass_type >
	745	Statement * PassVisitor< pass_type >::mutate( AsmStmt * node ) {
[bc6f918]	746	MUTATE_START( node );
	747
	748	maybeMutate_impl( node->instruction, *this );
	749	maybeMutate_impl( node->output, *this );
	750	maybeMutate_impl( node->input, *this );
	751	maybeMutate_impl( node->clobber, *this );
	752
	753	MUTATE_END( Statement, node );
[6ca154b]	754	}
	755
[9c1600c]	756	//--------------------------------------------------------------------------
	757	// IfStmt
[13932f14]	758	template< typename pass_type >
[ab904dc]	759	void PassVisitor< pass_type >::visit( IfStmt * node ) {
[4551a6e]	760	VISIT_START( node );
[33a25f9]	761	{
	762	// if statements introduce a level of scope (for the initialization)
	763	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[3c398b6]	764	maybeAccept_impl( node->get_initialization(), *this );
	765	visitExpression ( node->condition );
[33a25f9]	766	node->thenPart = visitStatement( node->thenPart );
	767	node->elsePart = visitStatement( node->elsePart );
	768	}
[9c1600c]	769	VISIT_END( node );
[13932f14]	770	}
	771
[296b2be]	772	template< typename pass_type >
	773	Statement * PassVisitor< pass_type >::mutate( IfStmt * node ) {
[4551a6e]	774	MUTATE_START( node );
[e0886db]	775	{
[33a25f9]	776	// if statements introduce a level of scope (for the initialization)
[e0886db]	777	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[3c398b6]	778	maybeMutate_impl( node->get_initialization(), *this );
[e0886db]	779	node->condition = mutateExpression( node->condition );
	780	node->thenPart = mutateStatement ( node->thenPart );
	781	node->elsePart = mutateStatement ( node->elsePart );
	782	}
[296b2be]	783	MUTATE_END( Statement, node );
	784	}
	785
[9c1600c]	786	//--------------------------------------------------------------------------
	787	// WhileStmt
[13932f14]	788	template< typename pass_type >
[ab904dc]	789	void PassVisitor< pass_type >::visit( WhileStmt * node ) {
[4551a6e]	790	VISIT_START( node );
[9c1600c]	791
[e0886db]	792	visitExpression( node->condition );
	793	node->body = visitStatement( node->body );
[9c1600c]	794
	795	VISIT_END( node );
[13932f14]	796	}
	797
[296b2be]	798	template< typename pass_type >
	799	Statement * PassVisitor< pass_type >::mutate( WhileStmt * node ) {
[4551a6e]	800	MUTATE_START( node );
[296b2be]	801
[e0886db]	802	node->condition = mutateExpression( node->condition );
	803	node->body = mutateStatement ( node->body );
[296b2be]	804
	805	MUTATE_END( Statement, node );
	806	}
	807
[9c1600c]	808	//--------------------------------------------------------------------------
[6ca154b]	809	// ForStmt
[13932f14]	810	template< typename pass_type >
[ab904dc]	811	void PassVisitor< pass_type >::visit( ForStmt * node ) {
[4551a6e]	812	VISIT_START( node );
[e0886db]	813	{
[33a25f9]	814	// for statements introduce a level of scope (for the initialization)
[e0886db]	815	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[3c398b6]	816	maybeAccept_impl( node->initialization, *this );
[e0886db]	817	visitExpression( node->condition );
	818	visitExpression( node->increment );
	819	node->body = visitStatement( node->body );
	820	}
[9c1600c]	821	VISIT_END( node );
[13932f14]	822	}
	823
[296b2be]	824	template< typename pass_type >
	825	Statement * PassVisitor< pass_type >::mutate( ForStmt * node ) {
[4551a6e]	826	MUTATE_START( node );
[e0886db]	827	{
[33a25f9]	828	// for statements introduce a level of scope (for the initialization)
[e0886db]	829	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[3c398b6]	830	maybeMutate_impl( node->initialization, *this );
[e0886db]	831	node->condition = mutateExpression( node->condition );
	832	node->increment = mutateExpression( node->increment );
	833	node->body = mutateStatement ( node->body );
	834	}
[296b2be]	835	MUTATE_END( Statement, node );
	836	}
	837
[9c1600c]	838	//--------------------------------------------------------------------------
	839	// SwitchStmt
[13932f14]	840	template< typename pass_type >
[ab904dc]	841	void PassVisitor< pass_type >::visit( SwitchStmt * node ) {
[4551a6e]	842	VISIT_START( node );
[9c1600c]	843
[e0886db]	844	visitExpression ( node->condition );
	845	visitStatementList( node->statements );
[9c1600c]	846
	847	VISIT_END( node );
[13932f14]	848	}
	849
[296b2be]	850	template< typename pass_type >
	851	Statement * PassVisitor< pass_type >::mutate( SwitchStmt * node ) {
[4551a6e]	852	MUTATE_START( node );
	853
[e0886db]	854	node->condition = mutateExpression( node->condition );
	855	mutateStatementList( node->statements );
[4551a6e]	856
[296b2be]	857	MUTATE_END( Statement, node );
	858	}
	859
[9c1600c]	860	//--------------------------------------------------------------------------
[35df560]	861	// CaseStmt
[13932f14]	862	template< typename pass_type >
[ab904dc]	863	void PassVisitor< pass_type >::visit( CaseStmt * node ) {
[4551a6e]	864	VISIT_START( node );
	865
[e0886db]	866	visitExpression ( node->condition );
	867	visitStatementList( node->stmts );
[4551a6e]	868
[9c1600c]	869	VISIT_END( node );
[13932f14]	870	}
	871
[296b2be]	872	template< typename pass_type >
	873	Statement * PassVisitor< pass_type >::mutate( CaseStmt * node ) {
[4551a6e]	874	MUTATE_START( node );
	875
[e0886db]	876	node->condition = mutateExpression( node->condition );
	877	mutateStatementList( node->stmts );
[4551a6e]	878
[296b2be]	879	MUTATE_END( Statement, node );
	880	}
	881
[6ca154b]	882	//--------------------------------------------------------------------------
	883	// BranchStmt
[13932f14]	884	template< typename pass_type >
[ab904dc]	885	void PassVisitor< pass_type >::visit( BranchStmt * node ) {
[33c0ce8]	886	VISIT_START( node );
	887	VISIT_END( node );
[13932f14]	888	}
	889
[6ca154b]	890	template< typename pass_type >
	891	Statement * PassVisitor< pass_type >::mutate( BranchStmt * node ) {
[33c0ce8]	892	MUTATE_START( node );
	893	MUTATE_END( Statement, node );
[6ca154b]	894	}
	895
[9c1600c]	896	//--------------------------------------------------------------------------
	897	// ReturnStmt
[13932f14]	898	template< typename pass_type >
[ab904dc]	899	void PassVisitor< pass_type >::visit( ReturnStmt * node ) {
[9c1600c]	900	VISIT_START( node );
	901
[e0886db]	902	visitExpression( node->expr );
[9c1600c]	903
	904	VISIT_END( node );
[13932f14]	905	}
	906
[296b2be]	907	template< typename pass_type >
	908	Statement * PassVisitor< pass_type >::mutate( ReturnStmt * node ) {
	909	MUTATE_START( node );
	910
[e0886db]	911	node->expr = mutateExpression( node->expr );
[296b2be]	912
	913	MUTATE_END( Statement, node );
	914	}
	915
[6e09f211]	916	//--------------------------------------------------------------------------
	917	// ThrowStmt
	918
	919	template< typename pass_type >
	920	void PassVisitor< pass_type >::visit( ThrowStmt * node ) {
[33c0ce8]	921	VISIT_START( node );
	922
	923	maybeAccept_impl( node->expr, *this );
	924	maybeAccept_impl( node->target, *this );
	925
	926	VISIT_END( node );
[6e09f211]	927	}
	928
	929	template< typename pass_type >
	930	Statement * PassVisitor< pass_type >::mutate( ThrowStmt * node ) {
[33c0ce8]	931	MUTATE_START( node );
	932
	933	maybeMutate_impl( node->expr, *this );
	934	maybeMutate_impl( node->target, *this );
	935
	936	MUTATE_END( Statement, node );
[6e09f211]	937	}
	938
[9c1600c]	939	//--------------------------------------------------------------------------
	940	// TryStmt
[13932f14]	941	template< typename pass_type >
[ab904dc]	942	void PassVisitor< pass_type >::visit( TryStmt * node ) {
[9c1600c]	943	VISIT_START( node );
	944
[3c398b6]	945	maybeAccept_impl( node->block , *this );
	946	maybeAccept_impl( node->handlers , *this );
	947	maybeAccept_impl( node->finallyBlock, *this );
[9c1600c]	948
	949	VISIT_END( node );
[13932f14]	950	}
	951
[296b2be]	952	template< typename pass_type >
	953	Statement * PassVisitor< pass_type >::mutate( TryStmt * node ) {
	954	MUTATE_START( node );
	955
[3c398b6]	956	maybeMutate_impl( node->block , *this );
	957	maybeMutate_impl( node->handlers , *this );
	958	maybeMutate_impl( node->finallyBlock, *this );
[4551a6e]	959
[296b2be]	960	MUTATE_END( Statement, node );
	961	}
	962
[9c1600c]	963	//--------------------------------------------------------------------------
	964	// CatchStmt
[13932f14]	965	template< typename pass_type >
[ab904dc]	966	void PassVisitor< pass_type >::visit( CatchStmt * node ) {
[9c1600c]	967	VISIT_START( node );
[e0886db]	968	{
[33a25f9]	969	// catch statements introduce a level of scope (for the caught exception)
[e0886db]	970	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[3c398b6]	971	maybeAccept_impl( node->decl, *this );
[e0886db]	972	node->cond = visitExpression( node->cond );
	973	node->body = visitStatement ( node->body );
	974	}
[9c1600c]	975	VISIT_END( node );
[13932f14]	976	}
	977
[296b2be]	978	template< typename pass_type >
	979	Statement * PassVisitor< pass_type >::mutate( CatchStmt * node ) {
	980	MUTATE_START( node );
[e0886db]	981	{
[33a25f9]	982	// catch statements introduce a level of scope (for the caught exception)
[e0886db]	983	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[3c398b6]	984	maybeMutate_impl( node->decl, *this );
[e0886db]	985	node->cond = mutateExpression( node->cond );
	986	node->body = mutateStatement ( node->body );
	987	}
[296b2be]	988	MUTATE_END( Statement, node );
	989	}
	990
[2065609]	991	//--------------------------------------------------------------------------
	992	// FinallyStmt
[13932f14]	993	template< typename pass_type >
[ab904dc]	994	void PassVisitor< pass_type >::visit( FinallyStmt * node ) {
[11b7028]	995	VISIT_START( node );
	996
	997	maybeAccept_impl( node->block, *this );
	998
	999	VISIT_END( node );
[13932f14]	1000	}
	1001
[2065609]	1002	template< typename pass_type >
	1003	Statement * PassVisitor< pass_type >::mutate( FinallyStmt * node ) {
[11b7028]	1004	MUTATE_START( node );
	1005
	1006	maybeMutate_impl( node->block, *this );
	1007
	1008	MUTATE_END( Statement, node );
[2065609]	1009	}
	1010
	1011	//--------------------------------------------------------------------------
	1012	// WaitForStmt
	1013	template< typename pass_type >
	1014	void PassVisitor< pass_type >::visit( WaitForStmt * node ) {
[834b892]	1015	VISIT_START( node );
	1016
	1017	for( auto & clause : node->clauses ) {
	1018	maybeAccept_impl( clause.target.function, *this );
	1019	maybeAccept_impl( clause.target.arguments, *this );
	1020
	1021	maybeAccept_impl( clause.statement, *this );
	1022	maybeAccept_impl( clause.condition, *this );
	1023	}
	1024
	1025	maybeAccept_impl( node->timeout.time, *this );
	1026	maybeAccept_impl( node->timeout.statement, *this );
	1027	maybeAccept_impl( node->timeout.condition, *this );
	1028	maybeAccept_impl( node->orelse.statement, *this );
	1029	maybeAccept_impl( node->orelse.condition, *this );
	1030
	1031	VISIT_END( node );
[2065609]	1032	}
	1033
	1034	template< typename pass_type >
	1035	Statement * PassVisitor< pass_type >::mutate( WaitForStmt * node ) {
[834b892]	1036	MUTATE_START( node );
	1037
	1038	for( auto & clause : node->clauses ) {
	1039	maybeMutate_impl( clause.target.function, *this );
	1040	maybeMutate_impl( clause.target.arguments, *this );
	1041
	1042	maybeMutate_impl( clause.statement, *this );
	1043	maybeMutate_impl( clause.condition, *this );
	1044	}
	1045
	1046	maybeMutate_impl( node->timeout.time, *this );
	1047	maybeMutate_impl( node->timeout.statement, *this );
	1048	maybeMutate_impl( node->timeout.condition, *this );
	1049	maybeMutate_impl( node->orelse.statement, *this );
	1050	maybeMutate_impl( node->orelse.condition, *this );
	1051
	1052	MUTATE_END( Statement, node );
[2065609]	1053	}
	1054
[d8893ca]	1055
	1056
[61255ad]	1057	//--------------------------------------------------------------------------
	1058	// NullStmt
	1059	template< typename pass_type >
	1060	void PassVisitor< pass_type >::visit( WithStmt * node ) {
[d8893ca]	1061	VISIT_START( node );
	1062	maybeAccept_impl( node->exprs, *this );
	1063	{
	1064	// catch statements introduce a level of scope (for the caught exception)
	1065	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[0ac366b]	1066	indexerAddWith( node->exprs, node );
[d8893ca]	1067	maybeAccept_impl( node->stmt, *this );
	1068	}
	1069	VISIT_END( node );
[61255ad]	1070	}
	1071
	1072	template< typename pass_type >
	1073	Statement * PassVisitor< pass_type >::mutate( WithStmt * node ) {
[d8893ca]	1074	MUTATE_START( node );
	1075	maybeMutate_impl( node->exprs, *this );
	1076	{
	1077	// catch statements introduce a level of scope (for the caught exception)
	1078	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[0ac366b]	1079	indexerAddWith( node->exprs, node );
[d8893ca]	1080	maybeMutate_impl( node->stmt, *this );
	1081	}
	1082	MUTATE_END( Statement, node );
[61255ad]	1083	}
	1084
[2065609]	1085	//--------------------------------------------------------------------------
	1086	// NullStmt
[13932f14]	1087	template< typename pass_type >
[ab904dc]	1088	void PassVisitor< pass_type >::visit( NullStmt * node ) {
[5964127]	1089	VISIT_START( node );
	1090	VISIT_END( node );
[13932f14]	1091	}
	1092
[2065609]	1093	template< typename pass_type >
	1094	NullStmt * PassVisitor< pass_type >::mutate( NullStmt * node ) {
[5964127]	1095	MUTATE_START( node );
	1096	MUTATE_END( NullStmt, node );
[2065609]	1097	}
	1098
	1099	//--------------------------------------------------------------------------
	1100	// DeclStmt
[13932f14]	1101	template< typename pass_type >
[ab904dc]	1102	void PassVisitor< pass_type >::visit( DeclStmt * node ) {
[5964127]	1103	VISIT_START( node );
	1104
	1105	maybeAccept_impl( node->decl, *this );
	1106
	1107	VISIT_END( node );
[13932f14]	1108	}
	1109
[2065609]	1110	template< typename pass_type >
	1111	Statement * PassVisitor< pass_type >::mutate( DeclStmt * node ) {
[5964127]	1112	MUTATE_START( node );
	1113
	1114	maybeMutate_impl( node->decl, *this );
	1115
	1116	MUTATE_END( Statement, node );
[2065609]	1117	}
	1118
	1119	//--------------------------------------------------------------------------
	1120	// ImplicitCtorDtorStmt
[13932f14]	1121	template< typename pass_type >
[ab904dc]	1122	void PassVisitor< pass_type >::visit( ImplicitCtorDtorStmt * node ) {
[4551a6e]	1123	VISIT_BODY( node );
[13932f14]	1124	}
	1125
[2065609]	1126	template< typename pass_type >
	1127	Statement * PassVisitor< pass_type >::mutate( ImplicitCtorDtorStmt * node ) {
	1128	MUTATE_BODY( Statement, node );
	1129	}
	1130
	1131	//--------------------------------------------------------------------------
	1132	// ApplicationExpr
[13932f14]	1133	template< typename pass_type >
[ab904dc]	1134	void PassVisitor< pass_type >::visit( ApplicationExpr * node ) {
[e0886db]	1135	VISIT_START( node );
	1136
	1137	indexerScopedAccept( node->result , *this );
[3c398b6]	1138	maybeAccept_impl ( node->function, *this );
	1139	maybeAccept_impl ( node->args , *this );
[e0886db]	1140
	1141	VISIT_END( node );
[13932f14]	1142	}
	1143
[2065609]	1144	template< typename pass_type >
	1145	Expression * PassVisitor< pass_type >::mutate( ApplicationExpr * node ) {
[e0886db]	1146	MUTATE_START( node );
	1147
	1148	indexerScopedMutate( node->env , *this );
	1149	indexerScopedMutate( node->result , *this );
[3c398b6]	1150	maybeMutate_impl ( node->function, *this );
	1151	maybeMutate_impl ( node->args , *this );
[e0886db]	1152
	1153	MUTATE_END( Expression, node );
[2065609]	1154	}
	1155
[9c1600c]	1156	//--------------------------------------------------------------------------
	1157	// UntypedExpr
[13932f14]	1158	template< typename pass_type >
[ab904dc]	1159	void PassVisitor< pass_type >::visit( UntypedExpr * node ) {
[9c1600c]	1160	VISIT_START( node );
	1161
[3c398b6]	1162	// maybeAccept_impl( node->get_env(), *this );
[e0886db]	1163	indexerScopedAccept( node->result, *this );
[2a7b3ca]	1164
[e0886db]	1165	for ( auto expr : node->args ) {
[9c1600c]	1166	visitExpression( expr );
	1167	}
	1168
	1169	VISIT_END( node );
[13932f14]	1170	}
	1171
[296b2be]	1172	template< typename pass_type >
	1173	Expression * PassVisitor< pass_type >::mutate( UntypedExpr * node ) {
	1174	MUTATE_START( node );
	1175
[e0886db]	1176	indexerScopedMutate( node->env , *this );
	1177	indexerScopedMutate( node->result, *this );
[2a7b3ca]	1178
[e0886db]	1179	for ( auto& expr : node->args ) {
[296b2be]	1180	expr = mutateExpression( expr );
	1181	}
	1182
	1183	MUTATE_END( Expression, node );
	1184	}
	1185
[e0886db]	1186	//--------------------------------------------------------------------------
	1187	// NameExpr
[13932f14]	1188	template< typename pass_type >
[ab904dc]	1189	void PassVisitor< pass_type >::visit( NameExpr * node ) {
[e0886db]	1190	VISIT_START( node );
	1191
	1192	indexerScopedAccept( node->result, *this );
	1193
	1194	VISIT_END( node );
[13932f14]	1195	}
	1196
	1197	template< typename pass_type >
[e0886db]	1198	Expression * PassVisitor< pass_type >::mutate( NameExpr * node ) {
	1199	MUTATE_START( node );
	1200
	1201	indexerScopedMutate( node->env , *this );
	1202	indexerScopedMutate( node->result, *this );
	1203
	1204	MUTATE_END( Expression, node );
[13932f14]	1205	}
	1206
[e0886db]	1207	//--------------------------------------------------------------------------
	1208	// CastExpr
[a5f0529]	1209	template< typename pass_type >
[e0886db]	1210	void PassVisitor< pass_type >::visit( CastExpr * node ) {
	1211	VISIT_START( node );
	1212
	1213	indexerScopedAccept( node->result, *this );
[3c398b6]	1214	maybeAccept_impl ( node->arg , *this );
[e0886db]	1215
	1216	VISIT_END( node );
[a5f0529]	1217	}
	1218
[13932f14]	1219	template< typename pass_type >
[e0886db]	1220	Expression * PassVisitor< pass_type >::mutate( CastExpr * node ) {
	1221	MUTATE_START( node );
	1222
	1223	indexerScopedMutate( node->env , *this );
	1224	indexerScopedMutate( node->result, *this );
[3c398b6]	1225	maybeMutate_impl ( node->arg , *this );
[e0886db]	1226
	1227	MUTATE_END( Expression, node );
[13932f14]	1228	}
	1229
[e0886db]	1230	//--------------------------------------------------------------------------
	1231	// VirtualCastExpr
[13932f14]	1232	template< typename pass_type >
[e0886db]	1233	void PassVisitor< pass_type >::visit( VirtualCastExpr * node ) {
	1234	VISIT_START( node );
	1235
	1236	indexerScopedAccept( node->result, *this );
[3c398b6]	1237	maybeAccept_impl( node->arg, *this );
[e0886db]	1238
	1239	VISIT_END( node );
[13932f14]	1240	}
	1241
	1242	template< typename pass_type >
[e0886db]	1243	Expression * PassVisitor< pass_type >::mutate( VirtualCastExpr * node ) {
	1244	MUTATE_START( node );
	1245
	1246	indexerScopedMutate( node->env , *this );
	1247	indexerScopedMutate( node->result, *this );
[3c398b6]	1248	maybeMutate_impl ( node->arg , *this );
[e0886db]	1249
	1250	MUTATE_END( Expression, node );
[13932f14]	1251	}
	1252
[e0886db]	1253	//--------------------------------------------------------------------------
	1254	// AddressExpr
[13932f14]	1255	template< typename pass_type >
[e0886db]	1256	void PassVisitor< pass_type >::visit( AddressExpr * node ) {
	1257	VISIT_START( node );
	1258
	1259	indexerScopedAccept( node->result, *this );
[3c398b6]	1260	maybeAccept_impl ( node->arg , *this );
[e0886db]	1261
	1262	VISIT_END( node );
[13932f14]	1263	}
	1264
	1265	template< typename pass_type >
[e0886db]	1266	Expression * PassVisitor< pass_type >::mutate( AddressExpr * node ) {
	1267	MUTATE_START( node );
	1268
	1269	indexerScopedMutate( node->env , *this );
	1270	indexerScopedMutate( node->result, *this );
[3c398b6]	1271	maybeMutate_impl ( node->arg , *this );
[e0886db]	1272
	1273	MUTATE_END( Expression, node );
	1274	}
	1275
	1276	//--------------------------------------------------------------------------
	1277	// LabelAddressExpr
	1278	template< typename pass_type >
	1279	void PassVisitor< pass_type >::visit( LabelAddressExpr * node ) {
	1280	VISIT_START( node );
	1281
	1282	indexerScopedAccept( node->result, *this );
	1283
	1284	VISIT_END( node );
	1285	}
	1286
	1287	template< typename pass_type >
	1288	Expression * PassVisitor< pass_type >::mutate( LabelAddressExpr * node ) {
	1289	MUTATE_START( node );
	1290
	1291	indexerScopedMutate( node->env , *this );
	1292	indexerScopedMutate( node->result, *this );
	1293
	1294	MUTATE_END( Expression, node );
	1295	}
	1296
	1297	//--------------------------------------------------------------------------
	1298	// UntypedMemberExpr
	1299	template< typename pass_type >
	1300	void PassVisitor< pass_type >::visit( UntypedMemberExpr * node ) {
	1301	VISIT_START( node );
	1302
	1303	indexerScopedAccept( node->result , *this );
[3c398b6]	1304	maybeAccept_impl ( node->aggregate, *this );
	1305	maybeAccept_impl ( node->member , *this );
[e0886db]	1306
	1307	VISIT_END( node );
[13932f14]	1308	}
	1309
[e0886db]	1310	template< typename pass_type >
	1311	Expression * PassVisitor< pass_type >::mutate( UntypedMemberExpr * node ) {
	1312	MUTATE_START( node );
	1313
	1314	indexerScopedMutate( node->env , *this );
	1315	indexerScopedMutate( node->result , *this );
[3c398b6]	1316	maybeMutate_impl ( node->aggregate, *this );
	1317	maybeMutate_impl ( node->member , *this );
[e0886db]	1318
	1319	MUTATE_END( Expression, node );
	1320	}
	1321
	1322	//--------------------------------------------------------------------------
	1323	// MemberExpr
	1324	template< typename pass_type >
	1325	void PassVisitor< pass_type >::visit( MemberExpr * node ) {
	1326	VISIT_START( node );
	1327
	1328	indexerScopedAccept( node->result , *this );
[3c398b6]	1329	maybeAccept_impl ( node->aggregate, *this );
[e0886db]	1330
	1331	VISIT_END( node );
	1332	}
	1333
	1334	template< typename pass_type >
	1335	Expression * PassVisitor< pass_type >::mutate( MemberExpr * node ) {
	1336	MUTATE_START( node );
	1337
	1338	indexerScopedMutate( node->env , *this );
	1339	indexerScopedMutate( node->result , *this );
[3c398b6]	1340	maybeMutate_impl ( node->aggregate, *this );
[e0886db]	1341
	1342	MUTATE_END( Expression, node );
	1343	}
	1344
	1345	//--------------------------------------------------------------------------
	1346	// VariableExpr
	1347	template< typename pass_type >
	1348	void PassVisitor< pass_type >::visit( VariableExpr * node ) {
	1349	VISIT_START( node );
	1350
	1351	indexerScopedAccept( node->result, *this );
	1352
	1353	VISIT_END( node );
	1354	}
	1355
	1356	template< typename pass_type >
	1357	Expression * PassVisitor< pass_type >::mutate( VariableExpr * node ) {
	1358	MUTATE_START( node );
	1359
	1360	indexerScopedMutate( node->env , *this );
	1361	indexerScopedMutate( node->result, *this );
	1362
	1363	MUTATE_END( Expression, node );
	1364	}
	1365
	1366	//--------------------------------------------------------------------------
	1367	// ConstantExpr
[13932f14]	1368	template< typename pass_type >
[ab904dc]	1369	void PassVisitor< pass_type >::visit( ConstantExpr * node ) {
[e0886db]	1370	VISIT_START( node );
	1371
	1372	indexerScopedAccept( node->result , *this );
[3c398b6]	1373	maybeAccept_impl ( &node->constant, *this );
[e0886db]	1374
	1375	VISIT_END( node );
[13932f14]	1376	}
	1377
[e0886db]	1378	template< typename pass_type >
	1379	Expression * PassVisitor< pass_type >::mutate( ConstantExpr * node ) {
	1380	MUTATE_START( node );
	1381
	1382	indexerScopedMutate( node->env , *this );
	1383	indexerScopedMutate( node->result, *this );
[3c398b6]	1384	Constant * ptr = &node->constant;
	1385	maybeMutate_impl( ptr, *this );
	1386	node->constant = *ptr;
[e0886db]	1387
	1388	MUTATE_END( Expression, node );
	1389	}
	1390
	1391	//--------------------------------------------------------------------------
	1392	// SizeofExpr
[13932f14]	1393	template< typename pass_type >
[ab904dc]	1394	void PassVisitor< pass_type >::visit( SizeofExpr * node ) {
[e0886db]	1395	VISIT_START( node );
	1396
	1397	indexerScopedAccept( node->result, *this );
	1398	if ( node->get_isType() ) {
[3c398b6]	1399	maybeAccept_impl( node->type, *this );
[e0886db]	1400	} else {
[3c398b6]	1401	maybeAccept_impl( node->expr, *this );
[e0886db]	1402	}
	1403
	1404	VISIT_END( node );
[13932f14]	1405	}
	1406
[e0886db]	1407	template< typename pass_type >
	1408	Expression * PassVisitor< pass_type >::mutate( SizeofExpr * node ) {
	1409	MUTATE_START( node );
	1410
	1411	indexerScopedMutate( node->env , *this );
	1412	indexerScopedMutate( node->result, *this );
	1413	if ( node->get_isType() ) {
[3c398b6]	1414	maybeMutate_impl( node->type, *this );
[e0886db]	1415	} else {
[3c398b6]	1416	maybeMutate_impl( node->expr, *this );
[e0886db]	1417	}
	1418
	1419	MUTATE_END( Expression, node );
	1420	}
	1421
	1422	//--------------------------------------------------------------------------
	1423	// AlignofExpr
[13932f14]	1424	template< typename pass_type >
[ab904dc]	1425	void PassVisitor< pass_type >::visit( AlignofExpr * node ) {
[e0886db]	1426	VISIT_START( node );
	1427
	1428	indexerScopedAccept( node->result, *this );
	1429	if ( node->get_isType() ) {
[3c398b6]	1430	maybeAccept_impl( node->type, *this );
[e0886db]	1431	} else {
[3c398b6]	1432	maybeAccept_impl( node->expr, *this );
[e0886db]	1433	}
	1434
	1435	VISIT_END( node );
[13932f14]	1436	}
	1437
[e0886db]	1438	template< typename pass_type >
	1439	Expression * PassVisitor< pass_type >::mutate( AlignofExpr * node ) {
	1440	MUTATE_START( node );
	1441
	1442	indexerScopedMutate( node->env , *this );
	1443	indexerScopedMutate( node->result, *this );
	1444	if ( node->get_isType() ) {
[3c398b6]	1445	maybeMutate_impl( node->type, *this );
[e0886db]	1446	} else {
[3c398b6]	1447	maybeMutate_impl( node->expr, *this );
[e0886db]	1448	}
	1449
	1450	MUTATE_END( Expression, node );
	1451	}
	1452
	1453	//--------------------------------------------------------------------------
	1454	// UntypedOffsetofExpr
[13932f14]	1455	template< typename pass_type >
[ab904dc]	1456	void PassVisitor< pass_type >::visit( UntypedOffsetofExpr * node ) {
[e0886db]	1457	VISIT_START( node );
	1458
	1459	indexerScopedAccept( node->result, *this );
[3c398b6]	1460	maybeAccept_impl ( node->type , *this );
[e0886db]	1461
	1462	VISIT_END( node );
[13932f14]	1463	}
	1464
[e0886db]	1465	template< typename pass_type >
	1466	Expression * PassVisitor< pass_type >::mutate( UntypedOffsetofExpr * node ) {
	1467	MUTATE_START( node );
	1468
	1469	indexerScopedMutate( node->env , *this );
	1470	indexerScopedMutate( node->result, *this );
[3c398b6]	1471	maybeMutate_impl ( node->type , *this );
[e0886db]	1472
	1473	MUTATE_END( Expression, node );
	1474	}
	1475
	1476	//--------------------------------------------------------------------------
	1477	// OffsetofExpr
[13932f14]	1478	template< typename pass_type >
[ab904dc]	1479	void PassVisitor< pass_type >::visit( OffsetofExpr * node ) {
[e0886db]	1480	VISIT_START( node );
	1481
	1482	indexerScopedAccept( node->result, *this );
[3c398b6]	1483	maybeAccept_impl ( node->type , *this );
	1484	maybeAccept_impl ( node->member, *this );
[e0886db]	1485
	1486	VISIT_END( node );
[13932f14]	1487	}
	1488
[e0886db]	1489	template< typename pass_type >
	1490	Expression * PassVisitor< pass_type >::mutate( OffsetofExpr * node ) {
	1491	MUTATE_START( node );
	1492
	1493	indexerScopedMutate( node->env , *this );
	1494	indexerScopedMutate( node->result, *this );
[3c398b6]	1495	maybeMutate_impl ( node->type , *this );
	1496	maybeMutate_impl ( node->member, *this );
[e0886db]	1497
	1498	MUTATE_END( Expression, node );
	1499	}
	1500
	1501	//--------------------------------------------------------------------------
	1502	// OffsetPackExpr
[13932f14]	1503	template< typename pass_type >
[ab904dc]	1504	void PassVisitor< pass_type >::visit( OffsetPackExpr * node ) {
[e0886db]	1505	VISIT_START( node );
	1506
	1507	indexerScopedAccept( node->result, *this );
[3c398b6]	1508	maybeAccept_impl ( node->type , *this );
[e0886db]	1509
	1510	VISIT_END( node );
[13932f14]	1511	}
	1512
[e0886db]	1513	template< typename pass_type >
	1514	Expression * PassVisitor< pass_type >::mutate( OffsetPackExpr * node ) {
	1515	MUTATE_START( node );
	1516
	1517	indexerScopedMutate( node->env , *this );
	1518	indexerScopedMutate( node->result, *this );
[3c398b6]	1519	maybeMutate_impl ( node->type , *this );
[e0886db]	1520
	1521	MUTATE_END( Expression, node );
	1522	}
	1523
	1524	//--------------------------------------------------------------------------
	1525	// AttrExpr
[13932f14]	1526	template< typename pass_type >
[ab904dc]	1527	void PassVisitor< pass_type >::visit( AttrExpr * node ) {
[e0886db]	1528	VISIT_START( node );
	1529
	1530	indexerScopedAccept( node->result, *this );
	1531	if ( node->get_isType() ) {
[3c398b6]	1532	maybeAccept_impl( node->type, *this );
[e0886db]	1533	} else {
[3c398b6]	1534	maybeAccept_impl( node->expr, *this );
[e0886db]	1535	}
	1536
	1537	VISIT_END( node );
	1538	}
	1539
	1540	template< typename pass_type >
	1541	Expression * PassVisitor< pass_type >::mutate( AttrExpr * node ) {
	1542	MUTATE_START( node );
	1543
	1544	indexerScopedMutate( node->env , *this );
	1545	indexerScopedMutate( node->result, *this );
	1546	if ( node->get_isType() ) {
[3c398b6]	1547	maybeMutate_impl( node->type, *this );
[e0886db]	1548	} else {
[3c398b6]	1549	maybeMutate_impl( node->expr, *this );
[e0886db]	1550	}
	1551
	1552	MUTATE_END( Expression, node );
[13932f14]	1553	}
	1554
[e0886db]	1555	//--------------------------------------------------------------------------
	1556	// LogicalExpr
[13932f14]	1557	template< typename pass_type >
[ab904dc]	1558	void PassVisitor< pass_type >::visit( LogicalExpr * node ) {
[e0886db]	1559	VISIT_START( node );
	1560
	1561	indexerScopedAccept( node->result, *this );
[3c398b6]	1562	maybeAccept_impl ( node->arg1 , *this );
	1563	maybeAccept_impl ( node->arg2 , *this );
[e0886db]	1564
	1565	VISIT_END( node );
	1566	}
	1567
	1568	template< typename pass_type >
	1569	Expression * PassVisitor< pass_type >::mutate( LogicalExpr * node ) {
	1570	MUTATE_START( node );
	1571
	1572	indexerScopedMutate( node->env , *this );
	1573	indexerScopedMutate( node->result, *this );
[3c398b6]	1574	maybeMutate_impl ( node->arg1 , *this );
	1575	maybeMutate_impl ( node->arg2 , *this );
[e0886db]	1576
	1577	MUTATE_END( Expression, node );
[13932f14]	1578	}
	1579
[e0886db]	1580	//--------------------------------------------------------------------------
	1581	// ConditionalExpr
[13932f14]	1582	template< typename pass_type >
[ab904dc]	1583	void PassVisitor< pass_type >::visit( ConditionalExpr * node ) {
[e0886db]	1584	VISIT_START( node );
	1585
	1586	indexerScopedAccept( node->result, *this );
[3c398b6]	1587	maybeAccept_impl ( node->arg1 , *this );
	1588	maybeAccept_impl ( node->arg2 , *this );
	1589	maybeAccept_impl ( node->arg3 , *this );
[e0886db]	1590
	1591	VISIT_END( node );
[13932f14]	1592	}
	1593
[e0886db]	1594	template< typename pass_type >
	1595	Expression * PassVisitor< pass_type >::mutate( ConditionalExpr * node ) {
	1596	MUTATE_START( node );
	1597
	1598	indexerScopedMutate( node->env , *this );
	1599	indexerScopedMutate( node->result, *this );
[3c398b6]	1600	maybeMutate_impl ( node->arg1 , *this );
	1601	maybeMutate_impl ( node->arg2 , *this );
	1602	maybeMutate_impl ( node->arg3 , *this );
[e0886db]	1603
	1604	MUTATE_END( Expression, node );
	1605	}
	1606
	1607	//--------------------------------------------------------------------------
	1608	// CommaExpr
[13932f14]	1609	template< typename pass_type >
[ab904dc]	1610	void PassVisitor< pass_type >::visit( CommaExpr * node ) {
[e0886db]	1611	VISIT_START( node );
	1612
	1613	indexerScopedAccept( node->result, *this );
[3c398b6]	1614	maybeAccept_impl ( node->arg1 , *this );
	1615	maybeAccept_impl ( node->arg2 , *this );
[e0886db]	1616
	1617	VISIT_END( node );
	1618	}
	1619
	1620	template< typename pass_type >
	1621	Expression * PassVisitor< pass_type >::mutate( CommaExpr * node ) {
	1622	MUTATE_START( node );
	1623
	1624	indexerScopedMutate( node->env , *this );
	1625	indexerScopedMutate( node->result, *this );
[3c398b6]	1626	maybeMutate_impl ( node->arg1 , *this );
	1627	maybeMutate_impl ( node->arg2 , *this );
[e0886db]	1628
	1629	MUTATE_END( Expression, node );
[13932f14]	1630	}
	1631
[e0886db]	1632	//--------------------------------------------------------------------------
	1633	// TypeExpr
[13932f14]	1634	template< typename pass_type >
[ab904dc]	1635	void PassVisitor< pass_type >::visit( TypeExpr * node ) {
[e0886db]	1636	VISIT_START( node );
	1637
	1638	indexerScopedAccept( node->result, *this );
[3c398b6]	1639	maybeAccept_impl ( node->type, *this );
[e0886db]	1640
	1641	VISIT_END( node );
[13932f14]	1642	}
	1643
[e0886db]	1644	template< typename pass_type >
	1645	Expression * PassVisitor< pass_type >::mutate( TypeExpr * node ) {
	1646	MUTATE_START( node );
	1647
	1648	indexerScopedMutate( node->env , *this );
	1649	indexerScopedMutate( node->result, *this );
[3c398b6]	1650	maybeMutate_impl ( node->type , *this );
[e0886db]	1651
	1652	MUTATE_END( Expression, node );
	1653	}
	1654
	1655	//--------------------------------------------------------------------------
	1656	// AsmExpr
[13932f14]	1657	template< typename pass_type >
[ab904dc]	1658	void PassVisitor< pass_type >::visit( AsmExpr * node ) {
[e0886db]	1659	VISIT_START( node );
	1660
	1661	indexerScopedAccept( node->result , *this );
[3c398b6]	1662	maybeAccept_impl ( node->inout , *this );
	1663	maybeAccept_impl ( node->constraint, *this );
	1664	maybeAccept_impl ( node->operand , *this );
[e0886db]	1665
	1666	VISIT_END( node );
[13932f14]	1667	}
	1668
[e0886db]	1669	template< typename pass_type >
	1670	Expression * PassVisitor< pass_type >::mutate( AsmExpr * node ) {
	1671	MUTATE_START( node );
	1672
	1673	indexerScopedMutate( node->env , *this );
	1674	indexerScopedMutate( node->result , *this );
[3c398b6]	1675	maybeMutate_impl ( node->inout , *this );
	1676	maybeMutate_impl ( node->constraint, *this );
	1677	maybeMutate_impl ( node->operand , *this );
[e0886db]	1678
	1679	MUTATE_END( Expression, node );
	1680	}
	1681
	1682	//--------------------------------------------------------------------------
	1683	// ImplicitCopyCtorExpr
[13932f14]	1684	template< typename pass_type >
[ab904dc]	1685	void PassVisitor< pass_type >::visit( ImplicitCopyCtorExpr * node ) {
[e0886db]	1686	VISIT_START( node );
	1687
	1688	indexerScopedAccept( node->result , *this );
[3c398b6]	1689	maybeAccept_impl ( node->callExpr , *this );
	1690	maybeAccept_impl ( node->tempDecls , *this );
	1691	maybeAccept_impl ( node->returnDecls, *this );
	1692	maybeAccept_impl ( node->dtors , *this );
[e0886db]	1693
	1694	VISIT_END( node );
	1695	}
	1696
	1697	template< typename pass_type >
	1698	Expression * PassVisitor< pass_type >::mutate( ImplicitCopyCtorExpr * node ) {
	1699	MUTATE_START( node );
	1700
	1701	indexerScopedMutate( node->env , *this );
	1702	indexerScopedMutate( node->result , *this );
[3c398b6]	1703	maybeMutate_impl ( node->callExpr , *this );
	1704	maybeMutate_impl ( node->tempDecls , *this );
	1705	maybeMutate_impl ( node->returnDecls, *this );
	1706	maybeMutate_impl ( node->dtors , *this );
[e0886db]	1707
	1708	MUTATE_END( Expression, node );
[13932f14]	1709	}
	1710
[e0886db]	1711	//--------------------------------------------------------------------------
	1712	// ConstructorExpr
[13932f14]	1713	template< typename pass_type >
[ab904dc]	1714	void PassVisitor< pass_type >::visit( ConstructorExpr * node ) {
[e0886db]	1715	VISIT_START( node );
	1716
	1717	indexerScopedAccept( node->result , *this );
[3c398b6]	1718	maybeAccept_impl ( node->callExpr, *this );
[e0886db]	1719
	1720	VISIT_END( node );
	1721	}
	1722
	1723	template< typename pass_type >
	1724	Expression * PassVisitor< pass_type >::mutate( ConstructorExpr * node ) {
	1725	MUTATE_START( node );
	1726
	1727	indexerScopedMutate( node->env , *this );
	1728	indexerScopedMutate( node->result , *this );
[3c398b6]	1729	maybeMutate_impl ( node->callExpr, *this );
[e0886db]	1730
	1731	MUTATE_END( Expression, node );
[13932f14]	1732	}
	1733
[e0886db]	1734	//--------------------------------------------------------------------------
	1735	// CompoundLiteralExpr
[13932f14]	1736	template< typename pass_type >
[ab904dc]	1737	void PassVisitor< pass_type >::visit( CompoundLiteralExpr * node ) {
[e0886db]	1738	VISIT_START( node );
	1739
	1740	indexerScopedAccept( node->result , *this );
[3c398b6]	1741	maybeAccept_impl ( node->initializer, *this );
[e0886db]	1742
	1743	VISIT_END( node );
[13932f14]	1744	}
	1745
[e0886db]	1746	template< typename pass_type >
	1747	Expression * PassVisitor< pass_type >::mutate( CompoundLiteralExpr * node ) {
	1748	MUTATE_START( node );
	1749
	1750	indexerScopedMutate( node->env , *this );
	1751	indexerScopedMutate( node->result , *this );
[3c398b6]	1752	maybeMutate_impl ( node->initializer, *this );
[e0886db]	1753
	1754	MUTATE_END( Expression, node );
	1755	}
	1756
	1757	//--------------------------------------------------------------------------
	1758	// RangeExpr
[13932f14]	1759	template< typename pass_type >
[ab904dc]	1760	void PassVisitor< pass_type >::visit( RangeExpr * node ) {
[e0886db]	1761	VISIT_START( node );
	1762
	1763	indexerScopedAccept( node->result, *this );
[3c398b6]	1764	maybeAccept_impl ( node->low , *this );
	1765	maybeAccept_impl ( node->high , *this );
[e0886db]	1766
	1767	VISIT_END( node );
[13932f14]	1768	}
	1769
[e0886db]	1770	template< typename pass_type >
	1771	Expression * PassVisitor< pass_type >::mutate( RangeExpr * node ) {
	1772	MUTATE_START( node );
	1773
	1774	indexerScopedMutate( node->env , *this );
	1775	indexerScopedMutate( node->result, *this );
[3c398b6]	1776	maybeMutate_impl ( node->low , *this );
	1777	maybeMutate_impl ( node->high , *this );
[e0886db]	1778
	1779	MUTATE_END( Expression, node );
	1780	}
	1781
	1782	//--------------------------------------------------------------------------
	1783	// UntypedTupleExpr
[13932f14]	1784	template< typename pass_type >
[ab904dc]	1785	void PassVisitor< pass_type >::visit( UntypedTupleExpr * node ) {
[e0886db]	1786	VISIT_START( node );
	1787
	1788	indexerScopedAccept( node->result, *this );
[3c398b6]	1789	maybeAccept_impl ( node->exprs , *this );
[e0886db]	1790
	1791	VISIT_END( node );
	1792	}
	1793
	1794	template< typename pass_type >
	1795	Expression * PassVisitor< pass_type >::mutate( UntypedTupleExpr * node ) {
	1796	MUTATE_START( node );
	1797
	1798	indexerScopedMutate( node->env , *this );
	1799	indexerScopedMutate( node->result, *this );
[3c398b6]	1800	maybeMutate_impl ( node->exprs , *this );
[e0886db]	1801
	1802	MUTATE_END( Expression, node );
	1803	}
	1804
	1805	//--------------------------------------------------------------------------
	1806	// TupleExpr
	1807	template< typename pass_type >
	1808	void PassVisitor< pass_type >::visit( TupleExpr * node ) {
	1809	VISIT_START( node );
	1810
	1811	indexerScopedAccept( node->result, *this );
[3c398b6]	1812	maybeAccept_impl ( node->exprs , *this );
[e0886db]	1813
	1814	VISIT_END( node );
	1815	}
	1816
	1817	template< typename pass_type >
	1818	Expression * PassVisitor< pass_type >::mutate( TupleExpr * node ) {
	1819	MUTATE_START( node );
	1820
	1821	indexerScopedMutate( node->env , *this );
	1822	indexerScopedMutate( node->result, *this );
[3c398b6]	1823	maybeMutate_impl ( node->exprs , *this );
[e0886db]	1824
	1825	MUTATE_END( Expression, node );
	1826	}
	1827
	1828	//--------------------------------------------------------------------------
	1829	// TupleIndexExpr
	1830	template< typename pass_type >
	1831	void PassVisitor< pass_type >::visit( TupleIndexExpr * node ) {
	1832	VISIT_START( node );
	1833
	1834	indexerScopedAccept( node->result, *this );
[3c398b6]	1835	maybeAccept_impl ( node->tuple , *this );
[e0886db]	1836
	1837	VISIT_END( node );
	1838	}
	1839
	1840	template< typename pass_type >
	1841	Expression * PassVisitor< pass_type >::mutate( TupleIndexExpr * node ) {
	1842	MUTATE_START( node );
	1843
	1844	indexerScopedMutate( node->env , *this );
	1845	indexerScopedMutate( node->result, *this );
[3c398b6]	1846	maybeMutate_impl ( node->tuple , *this );
[e0886db]	1847
	1848	MUTATE_END( Expression, node );
	1849	}
	1850
	1851	//--------------------------------------------------------------------------
	1852	// TupleAssignExpr
	1853	template< typename pass_type >
	1854	void PassVisitor< pass_type >::visit( TupleAssignExpr * node ) {
	1855	VISIT_START( node );
	1856
	1857	indexerScopedAccept( node->result , *this );
[3c398b6]	1858	maybeAccept_impl ( node->stmtExpr, *this );
[e0886db]	1859
	1860	VISIT_END( node );
[13932f14]	1861	}
	1862
	1863	template< typename pass_type >
[e0886db]	1864	Expression * PassVisitor< pass_type >::mutate( TupleAssignExpr * node ) {
	1865	MUTATE_START( node );
[13932f14]	1866
[e0886db]	1867	indexerScopedMutate( node->env , *this );
	1868	indexerScopedMutate( node->result , *this );
[3c398b6]	1869	maybeMutate_impl ( node->stmtExpr, *this );
[13932f14]	1870
[e0886db]	1871	MUTATE_END( Expression, node );
[13932f14]	1872	}
	1873
[9c1600c]	1874	//--------------------------------------------------------------------------
[e0886db]	1875	// StmtExpr
[13932f14]	1876	template< typename pass_type >
[ab904dc]	1877	void PassVisitor< pass_type >::visit( StmtExpr * node ) {
[9c1600c]	1878	VISIT_START( node );
	1879
	1880	// don't want statements from outer CompoundStmts to be added to this StmtExpr
	1881	ValueGuardPtr< TypeSubstitution * > oldEnv ( get_env_ptr() );
	1882	ValueGuardPtr< std::list< Statement* > > oldBeforeStmts( get_beforeStmts() );
	1883	ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () );
	1884
[e0886db]	1885	indexerScopedAccept( node->result , *this );
[3c398b6]	1886	maybeAccept_impl ( node->statements , *this );
	1887	maybeAccept_impl ( node->returnDecls, *this );
	1888	maybeAccept_impl ( node->dtors , *this );
[9c1600c]	1889
	1890	VISIT_END( node );
[13932f14]	1891	}
	1892
[296b2be]	1893	template< typename pass_type >
	1894	Expression * PassVisitor< pass_type >::mutate( StmtExpr * node ) {
	1895	MUTATE_START( node );
[4551a6e]	1896
[296b2be]	1897	// don't want statements from outer CompoundStmts to be added to this StmtExpr
[134322e]	1898	ValueGuardPtr< TypeSubstitution * > oldEnv ( get_env_ptr() );
	1899	ValueGuardPtr< std::list< Statement* > > oldBeforeStmts( get_beforeStmts() );
	1900	ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () );
[296b2be]	1901
[e0886db]	1902	indexerScopedMutate( node->result , *this );
[3c398b6]	1903	maybeMutate_impl ( node->statements , *this );
	1904	maybeMutate_impl ( node->returnDecls, *this );
	1905	maybeMutate_impl ( node->dtors , *this );
[296b2be]	1906
	1907	MUTATE_END( Expression, node );
	1908	}
	1909
[e0886db]	1910	//--------------------------------------------------------------------------
	1911	// UniqueExpr
[13932f14]	1912	template< typename pass_type >
[ab904dc]	1913	void PassVisitor< pass_type >::visit( UniqueExpr * node ) {
[e0886db]	1914	VISIT_START( node );
	1915
	1916	indexerScopedAccept( node->result, *this );
[3c398b6]	1917	maybeAccept_impl ( node->expr , *this );
[e0886db]	1918
	1919	VISIT_END( node );
	1920	}
	1921
	1922	template< typename pass_type >
	1923	Expression * PassVisitor< pass_type >::mutate( UniqueExpr * node ) {
	1924	MUTATE_START( node );
	1925
	1926	indexerScopedMutate( node->env , *this );
	1927	indexerScopedMutate( node->result, *this );
[3c398b6]	1928	maybeMutate_impl ( node->expr , *this );
[e0886db]	1929
	1930	MUTATE_END( Expression, node );
[13932f14]	1931	}
	1932
[73367a8]	1933	//--------------------------------------------------------------------------
	1934	// UntypedInitExpr
	1935	template< typename pass_type >
	1936	void PassVisitor< pass_type >::visit( UntypedInitExpr * node ) {
	1937	VISIT_START( node );
	1938
	1939	indexerScopedAccept( node->result, *this );
	1940	maybeAccept_impl ( node->expr , *this );
	1941	// not currently visiting initAlts, but this doesn't matter since this node is only used in the resolver.
	1942
	1943	VISIT_END( node );
	1944	}
	1945
	1946	template< typename pass_type >
	1947	Expression * PassVisitor< pass_type >::mutate( UntypedInitExpr * node ) {
	1948	MUTATE_START( node );
	1949
	1950	indexerScopedMutate( node->env , *this );
	1951	indexerScopedMutate( node->result, *this );
	1952	maybeMutate_impl ( node->expr , *this );
	1953	// not currently visiting initAlts, but this doesn't matter since this node is only used in the resolver.
	1954
	1955	MUTATE_END( Expression, node );
	1956	}
	1957
	1958	//--------------------------------------------------------------------------
	1959	// InitExpr
	1960	template< typename pass_type >
	1961	void PassVisitor< pass_type >::visit( InitExpr * node ) {
	1962	VISIT_START( node );
	1963
	1964	indexerScopedAccept( node->result, *this );
	1965	maybeAccept_impl ( node->expr , *this );
	1966	maybeAccept_impl ( node->designation, *this );
	1967
	1968	VISIT_END( node );
	1969	}
	1970
	1971	template< typename pass_type >
	1972	Expression * PassVisitor< pass_type >::mutate( InitExpr * node ) {
	1973	MUTATE_START( node );
	1974
	1975	indexerScopedMutate( node->env , *this );
	1976	indexerScopedMutate( node->result, *this );
	1977	maybeMutate_impl ( node->expr , *this );
	1978	maybeMutate_impl ( node->designation, *this );
	1979
	1980	MUTATE_END( Expression, node );
	1981	}
	1982
[44b4114]	1983	//--------------------------------------------------------------------------
	1984	// DeletedExpr
	1985	template< typename pass_type >
	1986	void PassVisitor< pass_type >::visit( DeletedExpr * node ) {
	1987	VISIT_START( node );
	1988
	1989	indexerScopedAccept( node->result, *this );
	1990	maybeAccept_impl( node->expr, *this );
	1991	// don't visit deleteStmt, because it is a pointer to somewhere else in the tree.
	1992
	1993	VISIT_END( node );
	1994	}
	1995
	1996	template< typename pass_type >
	1997	Expression * PassVisitor< pass_type >::mutate( DeletedExpr * node ) {
	1998	MUTATE_START( node );
	1999
	2000	indexerScopedMutate( node->env, *this );
	2001	indexerScopedMutate( node->result, *this );
	2002	maybeMutate_impl( node->expr, *this );
	2003
	2004	MUTATE_END( Expression, node );
	2005	}
	2006
	2007
[13932f14]	2008	template< typename pass_type >
[ab904dc]	2009	void PassVisitor< pass_type >::visit( VoidType * node ) {
[4551a6e]	2010	VISIT_BODY( node );
[13932f14]	2011	}
	2012
	2013	template< typename pass_type >
[ab904dc]	2014	void PassVisitor< pass_type >::visit( BasicType * node ) {
[4551a6e]	2015	VISIT_BODY( node );
[13932f14]	2016	}
	2017
	2018	template< typename pass_type >
[ab904dc]	2019	void PassVisitor< pass_type >::visit( PointerType * node ) {
[4551a6e]	2020	VISIT_BODY( node );
[13932f14]	2021	}
	2022
	2023	template< typename pass_type >
[ab904dc]	2024	void PassVisitor< pass_type >::visit( ArrayType * node ) {
[4551a6e]	2025	VISIT_BODY( node );
[13932f14]	2026	}
	2027
[6b9b047]	2028	template< typename pass_type >
	2029	void PassVisitor< pass_type >::visit( ReferenceType * node ) {
	2030	VISIT_BODY( node );
	2031	}
	2032
[13932f14]	2033	template< typename pass_type >
[ab904dc]	2034	void PassVisitor< pass_type >::visit( FunctionType * node ) {
[4551a6e]	2035	VISIT_BODY( node );
[13932f14]	2036	}
	2037
[e0886db]	2038	//--------------------------------------------------------------------------
	2039	// StructInstType
[13932f14]	2040	template< typename pass_type >
[ab904dc]	2041	void PassVisitor< pass_type >::visit( StructInstType * node ) {
[e0886db]	2042	VISIT_START( node );
	2043
	2044	indexerAddStruct( node->name );
	2045
	2046	{
	2047	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[3c398b6]	2048	maybeAccept_impl( node->forall , *this );
	2049	maybeAccept_impl( node->parameters, *this );
[e0886db]	2050	}
	2051
	2052	VISIT_END( node );
	2053	}
	2054
	2055	template< typename pass_type >
	2056	Type * PassVisitor< pass_type >::mutate( StructInstType * node ) {
	2057	MUTATE_START( node );
	2058
	2059	indexerAddStruct( node->name );
	2060
	2061	{
	2062	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[3c398b6]	2063	maybeMutate_impl( node->forall , *this );
	2064	maybeMutate_impl( node->parameters, *this );
[e0886db]	2065	}
	2066
	2067	MUTATE_END( Type, node );
[13932f14]	2068	}
	2069
[e0886db]	2070	//--------------------------------------------------------------------------
	2071	// UnionInstType
[13932f14]	2072	template< typename pass_type >
[ab904dc]	2073	void PassVisitor< pass_type >::visit( UnionInstType * node ) {
[e0886db]	2074	VISIT_START( node );
	2075
	2076	indexerAddStruct( node->name );
	2077
	2078	{
	2079	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[3c398b6]	2080	maybeAccept_impl( node->forall , *this );
	2081	maybeAccept_impl( node->parameters, *this );
[e0886db]	2082	}
	2083
	2084	VISIT_END( node );
	2085	}
	2086
	2087	template< typename pass_type >
	2088	Type * PassVisitor< pass_type >::mutate( UnionInstType * node ) {
	2089	MUTATE_START( node );
	2090
	2091	indexerAddStruct( node->name );
	2092
	2093	{
	2094	auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
[3c398b6]	2095	maybeMutate_impl( node->forall , *this );
	2096	maybeMutate_impl( node->parameters, *this );
[e0886db]	2097	}
	2098
	2099	MUTATE_END( Type, node );
[13932f14]	2100	}
	2101
[e0886db]	2102	//--------------------------------------------------------------------------
	2103	// EnumInstType
[13932f14]	2104	template< typename pass_type >
[ab904dc]	2105	void PassVisitor< pass_type >::visit( EnumInstType * node ) {
[4551a6e]	2106	VISIT_BODY( node );
[13932f14]	2107	}
	2108
[e0886db]	2109	template< typename pass_type >
	2110	Type * PassVisitor< pass_type >::mutate( EnumInstType * node ) {
	2111	MUTATE_BODY( Type, node );
	2112	}
	2113
	2114	//--------------------------------------------------------------------------
	2115	// TraitInstType
[13932f14]	2116	template< typename pass_type >
[ab904dc]	2117	void PassVisitor< pass_type >::visit( TraitInstType * node ) {
[e0886db]	2118	VISIT_START( node );
	2119
[3c398b6]	2120	maybeAccept_impl( node->forall , *this );
	2121	maybeAccept_impl( node->parameters, *this );
[e0886db]	2122
	2123	VISIT_END( node );
	2124	}
	2125
	2126	template< typename pass_type >
	2127	Type * PassVisitor< pass_type >::mutate( TraitInstType * node ) {
	2128	MUTATE_START( node );
	2129
[3c398b6]	2130	maybeMutate_impl( node->forall , *this );
	2131	maybeMutate_impl( node->parameters, *this );
[e0886db]	2132
	2133	MUTATE_END( Type, node );
[13932f14]	2134	}
	2135
[e0886db]	2136	//--------------------------------------------------------------------------
	2137	// TypeInstType
[13932f14]	2138	template< typename pass_type >
[ab904dc]	2139	void PassVisitor< pass_type >::visit( TypeInstType * node ) {
[4551a6e]	2140	VISIT_BODY( node );
[13932f14]	2141	}
	2142
	2143	template< typename pass_type >
[ab904dc]	2144	void PassVisitor< pass_type >::visit( TupleType * node ) {
[4551a6e]	2145	VISIT_BODY( node );
[13932f14]	2146	}
	2147
	2148	template< typename pass_type >
[ab904dc]	2149	void PassVisitor< pass_type >::visit( TypeofType * node ) {
[4551a6e]	2150	VISIT_BODY( node );
[13932f14]	2151	}
	2152
	2153	template< typename pass_type >
[ab904dc]	2154	void PassVisitor< pass_type >::visit( AttrType * node ) {
[4551a6e]	2155	VISIT_BODY( node );
[13932f14]	2156	}
	2157
	2158	template< typename pass_type >
[ab904dc]	2159	void PassVisitor< pass_type >::visit( VarArgsType * node ) {
[4551a6e]	2160	VISIT_BODY( node );
[13932f14]	2161	}
	2162
	2163	template< typename pass_type >
[ab904dc]	2164	void PassVisitor< pass_type >::visit( ZeroType * node ) {
[4551a6e]	2165	VISIT_BODY( node );
[13932f14]	2166	}
	2167
	2168	template< typename pass_type >
[ab904dc]	2169	void PassVisitor< pass_type >::visit( OneType * node ) {
[4551a6e]	2170	VISIT_BODY( node );
[13932f14]	2171	}
	2172
[b11d8e2]	2173	template< typename pass_type >
	2174	void PassVisitor< pass_type >::visit( Designation * node ) {
	2175	VISIT_START( node );
	2176
[3c398b6]	2177	maybeAccept_impl( node->get_designators(), *this );
[b11d8e2]	2178
	2179	VISIT_END( node );
	2180	}
	2181
	2182	template< typename pass_type >
	2183	Designation * PassVisitor< pass_type >::mutate( Designation * node ) {
	2184	MUTATE_START( node );
	2185
[3c398b6]	2186	maybeMutate_impl( node->get_designators(), *this );
[b11d8e2]	2187
	2188	MUTATE_END( Designation, node );
	2189	}
	2190
[9c1600c]	2191	//--------------------------------------------------------------------------
[e0886db]	2192	// SingleInit
[13932f14]	2193	template< typename pass_type >
[ab904dc]	2194	void PassVisitor< pass_type >::visit( SingleInit * node ) {
[9c1600c]	2195	VISIT_START( node );
	2196
	2197	visitExpression( node->get_value() );
	2198
	2199	VISIT_END( node );
[13932f14]	2200	}
	2201
[296b2be]	2202	template< typename pass_type >
	2203	Initializer * PassVisitor< pass_type >::mutate( SingleInit * node ) {
	2204	MUTATE_START( node );
	2205
	2206	node->set_value( mutateExpression( node->get_value() ) );
	2207
	2208	MUTATE_END( Initializer, node );
	2209	}
	2210
[13932f14]	2211	template< typename pass_type >
[ab904dc]	2212	void PassVisitor< pass_type >::visit( ListInit * node ) {
[4551a6e]	2213	VISIT_BODY( node );
[13932f14]	2214	}
	2215
	2216	template< typename pass_type >
[ab904dc]	2217	void PassVisitor< pass_type >::visit( ConstructorInit * node ) {
[4551a6e]	2218	VISIT_BODY( node );
[13932f14]	2219	}
	2220
	2221	template< typename pass_type >
[ab904dc]	2222	void PassVisitor< pass_type >::visit( Subrange * node ) {
[4551a6e]	2223	VISIT_BODY( node );
[13932f14]	2224	}
	2225
	2226	template< typename pass_type >
[ab904dc]	2227	void PassVisitor< pass_type >::visit( Constant * node ) {
[4551a6e]	2228	VISIT_BODY( node );
[13932f14]	2229	}
[ab904dc]	2230
[5ea7a22]	2231	template< typename pass_type >
	2232	void PassVisitor< pass_type >::visit( Attribute * node ) {
	2233	VISIT_BODY( node );
	2234	}
	2235
[ab904dc]	2236	//---------------------------------------------------------------------------------------------------------------
	2237	template< typename pass_type >
	2238	Type * PassVisitor< pass_type >::mutate( VoidType * node ) {
	2239	MUTATE_BODY( Type, node );
	2240	}
	2241
	2242	template< typename pass_type >
	2243	Type * PassVisitor< pass_type >::mutate( BasicType * node ) {
	2244	MUTATE_BODY( Type, node );
	2245	}
	2246
	2247	template< typename pass_type >
	2248	Type * PassVisitor< pass_type >::mutate( PointerType * node ) {
	2249	MUTATE_BODY( Type, node );
	2250	}
	2251
	2252	template< typename pass_type >
	2253	Type * PassVisitor< pass_type >::mutate( ArrayType * node ) {
	2254	MUTATE_BODY( Type, node );
	2255	}
	2256
	2257	template< typename pass_type >
[6b9b047]	2258	Type * PassVisitor< pass_type >::mutate( ReferenceType * node ) {
	2259	MUTATE_BODY( Type, node );
	2260	}
	2261
	2262	template< typename pass_type >
[ab904dc]	2263	Type * PassVisitor< pass_type >::mutate( FunctionType * node ) {
	2264	MUTATE_BODY( Type, node );
	2265	}
	2266
	2267	template< typename pass_type >
	2268	Type * PassVisitor< pass_type >::mutate( TypeInstType * node ) {
	2269	MUTATE_BODY( Type, node );
	2270	}
	2271
	2272	template< typename pass_type >
	2273	Type * PassVisitor< pass_type >::mutate( TupleType * node ) {
	2274	MUTATE_BODY( Type, node );
	2275	}
	2276
	2277	template< typename pass_type >
	2278	Type * PassVisitor< pass_type >::mutate( TypeofType * node ) {
	2279	MUTATE_BODY( Type, node );
	2280	}
	2281
	2282	template< typename pass_type >
	2283	Type * PassVisitor< pass_type >::mutate( AttrType * node ) {
	2284	MUTATE_BODY( Type, node );
	2285	}
	2286
	2287	template< typename pass_type >
	2288	Type * PassVisitor< pass_type >::mutate( VarArgsType * node ) {
	2289	MUTATE_BODY( Type, node );
	2290	}
	2291
	2292	template< typename pass_type >
	2293	Type * PassVisitor< pass_type >::mutate( ZeroType * node ) {
	2294	MUTATE_BODY( Type, node );
	2295	}
	2296
	2297	template< typename pass_type >
	2298	Type * PassVisitor< pass_type >::mutate( OneType * node ) {
	2299	MUTATE_BODY( Type, node );
	2300	}
	2301
	2302	template< typename pass_type >
	2303	Initializer * PassVisitor< pass_type >::mutate( ListInit * node ) {
	2304	MUTATE_BODY( Initializer, node );
	2305	}
	2306
	2307	template< typename pass_type >
	2308	Initializer * PassVisitor< pass_type >::mutate( ConstructorInit * node ) {
	2309	MUTATE_BODY( Initializer, node );
	2310	}
	2311
	2312	template< typename pass_type >
	2313	Subrange * PassVisitor< pass_type >::mutate( Subrange * node ) {
	2314	MUTATE_BODY( Subrange, node );
	2315	}
	2316
	2317	template< typename pass_type >
	2318	Constant * PassVisitor< pass_type >::mutate( Constant * node ) {
	2319	MUTATE_BODY( Constant, node );
[4551a6e]	2320	}
[5ea7a22]	2321
	2322	template< typename pass_type >
	2323	Attribute * PassVisitor< pass_type >::mutate( Attribute * node ) {
	2324	MUTATE_BODY( Attribute, node );
	2325	}
[447c356]	2326
	2327	template< typename pass_type >
	2328	TypeSubstitution * PassVisitor< pass_type >::mutate( TypeSubstitution * node ) {
	2329	MUTATE_START( node );
	2330
	2331	for ( auto & p : node->typeEnv ) {
	2332	indexerScopedMutate( p.second, *this );
	2333	}
	2334	for ( auto & p : node->varEnv ) {
	2335	indexerScopedMutate( p.second, *this );
	2336	}
	2337
	2338	MUTATE_END( TypeSubstitution, node );
	2339	}

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

Download in other formats: