Changeset ba54f7d for src/Common

Timestamp:

Sep 13, 2017, 3:11:24 PM (7 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

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

Children:

c57ded70, db70fe4

Parents:

d130fe8 (diff), 982832e (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg2:software/cfa/cfa-cc

Location:

src/Common

Files:

• PassVisitor.h (modified) (4 diffs)
• PassVisitor.impl.h (modified) (33 diffs)
• PassVisitor.proto.h (modified) (6 diffs)
• utility.h (modified) (1 diff)

src/Common/PassVisitor.h

@@ -7 +7 @@
 #include "SynTree/Mutator.h"
 #include "SynTree/Visitor.h"
+
+#include "SymTab/Indexer.h"
 
 #include "SynTree/Initializer.h"
@@ -265 +267 @@
 
         void set_visit_children( bool& ref ) { bool_ref * ptr = visit_children_impl(pass, 0); if(ptr) ptr->set( ref ); }
+
+        void indexerScopeEnter  ()                             { indexer_impl_enterScope  ( pass, 0       ); }
+        void indexerScopeLeave  ()                             { indexer_impl_leaveScope  ( pass, 0       ); }
+        void indexerAddId       ( DeclarationWithType * node ) { indexer_impl_addId       ( pass, 0, node ); }
+        void indexerAddType     ( NamedTypeDecl       * node ) { indexer_impl_addType     ( pass, 0, node ); }
+        void indexerAddStruct   ( const std::string   & id   ) { indexer_impl_addStruct   ( pass, 0, id   ); }
+        void indexerAddStruct   ( StructDecl          * node ) { indexer_impl_addStruct   ( pass, 0, node ); }
+        void indexerAddStructFwd( StructDecl          * node ) { indexer_impl_addStructFwd( pass, 0, node ); }
+        void indexerAddEnum     ( EnumDecl            * node ) { indexer_impl_addEnum     ( pass, 0, node ); }
+        void indexerAddUnion    ( const std::string   & id   ) { indexer_impl_addUnion    ( pass, 0, id   ); }
+        void indexerAddUnion    ( UnionDecl           * node ) { indexer_impl_addUnion    ( pass, 0, node ); }
+        void indexerAddUnionFwd ( UnionDecl           * node ) { indexer_impl_addUnionFwd ( pass, 0, node ); }
+        void indexerAddTrait    ( TraitDecl           * node ) { indexer_impl_addTrait    ( pass, 0, node ); }
+
+        template< typename TreeType, typename VisitorType >
+        friend inline void indexerScopedAccept( TreeType * tree, VisitorType &visitor );
+
+        template< typename TreeType, typename VisitorType >
+        friend inline void indexerScopedMutate( TreeType *& tree, VisitorType &visitor );
 };
 
@@ -296 +317 @@
 protected:
         WithDeclsToAdd() = default;
-        ~WithDeclsToAdd() = default;
+        ~WithDeclsToAdd() {
+                assert( declsToAddBefore.empty() );
+        }
 
 public:
@@ -351 +374 @@
 };
 
+class WithIndexer {
+protected:
+        WithIndexer() {}
+        ~WithIndexer() {}
+
+public:
+        SymTab::Indexer indexer;
+};
+
 #include "PassVisitor.impl.h"

src/Common/PassVisitor.impl.h

@@ -101 +101 @@
 }
 
+template< typename Container, typename VisitorType >
+inline void maybeAccept( Container &container, VisitorType &visitor ) {
+        SemanticError errors;
+        for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
+                try {
+                        if ( *i ) {
+                                (*i)->accept( visitor );
+                        }
+                } catch( SemanticError &e ) {
+                        e.set_location( (*i)->location );
+                        errors.append( e );
+                }
+        }
+        if ( ! errors.isEmpty() ) {
+                throw errors;
+        }
+}
+
+template< typename Container, typename MutatorType >
+inline void maybeMutateRef( Container &container, MutatorType &mutator ) {
+        SemanticError errors;
+        for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
+                try {
+                        if ( *i ) {
+///                 *i = (*i)->acceptMutator( mutator );
+                                *i = dynamic_cast< typename Container::value_type >( (*i)->acceptMutator( mutator ) );
+                                assert( *i );
+                        } // if
+                } catch( SemanticError &e ) {
+                        e.set_location( (*i)->location );
+                        errors.append( e );
+                } // try
+        } // for
+        if ( ! errors.isEmpty() ) {
+                throw errors;
+        } // if
+}
+
 template< typename pass_type >
 template< typename func_t >
@@ -230 +268 @@
 
 //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-
+//========================================================================================================================================================================
+//========================================================================================================================================================================
+//========================================================================================================================================================================
+//========================================================================================================================================================================
+//========================================================================================================================================================================
+//------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+
+//--------------------------------------------------------------------------
+// ObjectDecl
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( ObjectDecl * node ) {
-        VISIT_BODY( node );
-}
-
+        VISIT_START( node );
+
+        indexerScopedAccept( node->type         , *this );
+        maybeAccept        ( node->init         , *this );
+        maybeAccept        ( node->bitfieldWidth, *this );
+
+        if ( node->name != "" ) {
+                indexerAddId( node );
+        }
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+DeclarationWithType * PassVisitor< pass_type >::mutate( ObjectDecl * node ) {
+        MUTATE_START( node );
+
+        indexerScopedMutate( node->type         , *this );
+        maybeMutateRef     ( node->init         , *this );
+        maybeMutateRef     ( node->bitfieldWidth, *this );
+
+        if ( node->name != "" ) {
+                indexerAddId( node );
+        }
+
+        MUTATE_END( DeclarationWithType, node );
+}
+
+//--------------------------------------------------------------------------
+// FunctionDecl
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( FunctionDecl * node ) {
-        VISIT_BODY( node );
-}
-
+        VISIT_START( node );
+
+        if ( node->name != "" ) {
+                indexerAddId( node );
+        }
+
+        {
+                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                maybeAccept( node->type, *this );
+                maybeAccept( node->statements, *this );
+        }
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+DeclarationWithType * PassVisitor< pass_type >::mutate( FunctionDecl * node ) {
+        MUTATE_START( node );
+
+        if ( node->name != "" ) {
+                indexerAddId( node );
+        }
+
+        {
+                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                maybeMutateRef( node->type, *this );
+                maybeMutateRef( node->statements, *this );
+        }
+
+        MUTATE_END( DeclarationWithType, node );
+}
+
+//--------------------------------------------------------------------------
+// StructDecl
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( StructDecl * node ) {
-        VISIT_BODY( node );
-}
-
+        VISIT_START( node );
+
+        // make up a forward declaration and add it before processing the members
+        // needs to be on the heap because addStruct saves the pointer
+        indexerAddStructFwd( node );
+
+        {
+                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                maybeAccept( node->parameters, *this );
+                maybeAccept( node->members   , *this );
+        }
+
+        // this addition replaces the forward declaration
+        indexerAddStruct( node );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Declaration * PassVisitor< pass_type >::mutate( StructDecl * node ) {
+        MUTATE_START( node );
+
+        // make up a forward declaration and add it before processing the members
+        // needs to be on the heap because addStruct saves the pointer
+        indexerAddStructFwd( node );
+
+        {
+                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                maybeMutateRef( node->parameters, *this );
+                maybeMutateRef( node->members   , *this );
+        }
+
+        // this addition replaces the forward declaration
+        indexerAddStruct( node );
+
+        MUTATE_END( Declaration, node );
+}
+
+//--------------------------------------------------------------------------
+// UnionDecl
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( UnionDecl * node ) {
-        VISIT_BODY( node );
-}
-
+        VISIT_START( node );
+
+        // make up a forward declaration and add it before processing the members
+        indexerAddUnionFwd( node );
+
+        {
+                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                maybeAccept( node->parameters, *this );
+                maybeAccept( node->members   , *this );
+        }
+
+        indexerAddUnion( node );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Declaration * PassVisitor< pass_type >::mutate( UnionDecl * node ) {
+        MUTATE_START( node );
+
+        // make up a forward declaration and add it before processing the members
+        indexerAddUnionFwd( node );
+
+        {
+                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                maybeMutateRef( node->parameters, *this );
+                maybeMutateRef( node->members   , *this );
+        }
+
+        indexerAddUnion( node );
+
+        MUTATE_END( Declaration, node );
+}
+
+//--------------------------------------------------------------------------
+// EnumDecl
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( EnumDecl * node ) {
-        VISIT_BODY( node );
-}
-
+        VISIT_START( node );
+
+        indexerAddEnum( node );
+
+        // unlike structs, contexts, and unions, enums inject their members into the global scope
+        maybeAccept( node->parameters, *this );
+        maybeAccept( node->members   , *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Declaration * PassVisitor< pass_type >::mutate( EnumDecl * node ) {
+        MUTATE_START( node );
+
+        indexerAddEnum( node );
+
+        // unlike structs, contexts, and unions, enums inject their members into the global scope
+        maybeMutateRef( node->parameters, *this );
+        maybeMutateRef( node->members   , *this );
+
+        MUTATE_END( Declaration, node );
+}
+
+//--------------------------------------------------------------------------
+// TraitDecl
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( TraitDecl * node ) {
-        VISIT_BODY( node );
-}
-
+        VISIT_START( node );
+
+        {
+                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                maybeAccept( node->parameters, *this );
+                maybeAccept( node->members   , *this );
+        }
+
+        indexerAddTrait( node );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Declaration * PassVisitor< pass_type >::mutate( TraitDecl * node ) {
+        MUTATE_START( node );
+
+        {
+                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                maybeMutateRef( node->parameters, *this );
+                maybeMutateRef( node->members   , *this );
+        }
+
+        indexerAddTrait( node );
+
+        MUTATE_END( Declaration, node );
+}
+
+//--------------------------------------------------------------------------
+// TypeDecl
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( TypeDecl * node ) {
-        VISIT_BODY( node );
-}
-
+        VISIT_START( node );
+
+        {
+                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                maybeAccept( node->parameters, *this );
+                maybeAccept( node->base      , *this );
+        }
+
+        indexerAddType( node );
+
+        maybeAccept( node->assertions, *this );
+
+        indexerScopedAccept( node->init, *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Declaration * PassVisitor< pass_type >::mutate( TypeDecl * node ) {
+        MUTATE_START( node );
+
+        {
+                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                maybeMutateRef( node->parameters, *this );
+                maybeMutateRef( node->base      , *this );
+        }
+
+        indexerAddType( node );
+
+        maybeMutateRef( node->assertions, *this );
+
+        indexerScopedMutate( node->init, *this );
+
+        MUTATE_END( Declaration, node );
+}
+
+//--------------------------------------------------------------------------
+// TypedefDecl
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( TypedefDecl * node ) {
-        VISIT_BODY( node );
-}
-
+        VISIT_START( node );
+
+        {
+                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                maybeAccept( node->parameters, *this );
+                maybeAccept( node->base      , *this );
+        }
+
+        indexerAddType( node );
+
+        maybeAccept( node->assertions, *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Declaration * PassVisitor< pass_type >::mutate( TypedefDecl * node ) {
+        MUTATE_START( node );
+
+        {
+                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                maybeMutateRef     ( node->parameters, *this );
+                maybeMutateRef( node->base      , *this );
+        }
+
+        indexerAddType( node );
+
+        maybeMutateRef( node->assertions, *this );
+
+        MUTATE_END( Declaration, node );
+}
+
+//--------------------------------------------------------------------------
+// AsmDecl
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( AsmDecl * node ) {
-        VISIT_BODY( node );
+        VISIT_START( node );
+
+        maybeAccept( node->stmt, *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+AsmDecl * PassVisitor< pass_type >::mutate( AsmDecl * node ) {
+        MUTATE_START( node );
+
+        maybeMutateRef( node->stmt, *this );
+
+        MUTATE_END( AsmDecl, node );
 }
 
@@ -281 +585 @@
 void PassVisitor< pass_type >::visit( CompoundStmt * node ) {
         VISIT_START( node );
-        call_beginScope();
-
-        visitStatementList( node->get_kids() );
-
-        call_endScope();
+        {
+                auto guard1 = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                auto guard2 = makeFuncGuard( [this]() { call_beginScope();   }, [this]() { call_endScope();     } );
+                visitStatementList( node->kids );
+        }
         VISIT_END( node );
 }
@@ -292 +596 @@
 CompoundStmt * PassVisitor< pass_type >::mutate( CompoundStmt * node ) {
         MUTATE_START( node );
-        call_beginScope();
-
-        mutateStatementList( node->get_kids() );
-
-        call_endScope();
+        {
+                auto guard1 = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                auto guard2 = makeFuncGuard( [this]() { call_beginScope();   }, [this]() { call_endScope();     } );
+                mutateStatementList( node->kids );
+        }
         MUTATE_END( CompoundStmt, node );
 }
@@ -306 +610 @@
         VISIT_START( node );
 
-        visitExpression( node->get_expr() );
+        visitExpression( node->expr );
 
         VISIT_END( node );
@@ -315 +619 @@
         MUTATE_START( node );
 
-        node->set_expr( mutateExpression( node->get_expr() ) );
+        node->expr = mutateExpression( node->expr );
 
         MUTATE_END( Statement, node );
@@ -338 +642 @@
         VISIT_START( node );
 
-        visitExpression( node->get_condition() );
-        node->set_thenPart ( visitStatement( node->get_thenPart() ) );
-        node->set_elsePart ( visitStatement( node->get_elsePart() ) );
+        visitExpression( node->condition );
+        node->thenPart = visitStatement( node->thenPart );
+        node->elsePart = visitStatement( node->elsePart );
 
         VISIT_END( node );
@@ -348 +652 @@
 Statement * PassVisitor< pass_type >::mutate( IfStmt * node ) {
         MUTATE_START( node );
-
-        node->set_condition( mutateExpression( node->get_condition() ) );
-        node->set_thenPart ( mutateStatement ( node->get_thenPart()  ) );
-        node->set_elsePart ( mutateStatement ( node->get_elsePart()  ) );
-
+        {
+                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                node->condition = mutateExpression( node->condition );
+                node->thenPart  = mutateStatement ( node->thenPart  );
+                node->elsePart  = mutateStatement ( node->elsePart  );
+        }
         MUTATE_END( Statement, node );
 }
@@ -362 +667 @@
         VISIT_START( node );
 
-        visitExpression( node->get_condition() );
-        node->set_body( visitStatement( node->get_body() ) );
+        visitExpression( node->condition );
+        node->body = visitStatement( node->body );
 
         VISIT_END( node );
@@ -372 +677 @@
         MUTATE_START( node );
 
-        node->set_condition( mutateExpression( node->get_condition() ) );
-        node->set_body( mutateStatement( node->get_body() ) );
+        node->condition = mutateExpression( node->condition );
+        node->body      = mutateStatement ( node->body      );
 
         MUTATE_END( Statement, node );
@@ -383 +688 @@
 void PassVisitor< pass_type >::visit( ForStmt * node ) {
         VISIT_START( node );
-
-        acceptAll( node->get_initialization(), *this );
-        visitExpression( node->get_condition() );
-        visitExpression( node->get_increment() );
-        node->set_body( visitStatement( node->get_body() ) );
-
+        {
+                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                maybeAccept( node->initialization, *this );
+                visitExpression( node->condition );
+                visitExpression( node->increment );
+                node->body = visitStatement( node->body );
+        }
         VISIT_END( node );
 }
@@ -395 +701 @@
 Statement * PassVisitor< pass_type >::mutate( ForStmt * node ) {
         MUTATE_START( node );
-
-        mutateAll( node->get_initialization(), *this );
-        node->set_condition( mutateExpression( node->get_condition() ) );
-        node->set_increment( mutateExpression( node->get_increment() ) );
-        node->set_body( mutateStatement( node->get_body() ) );
-
+        {
+                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                maybeMutateRef( node->initialization, *this );
+                node->condition = mutateExpression( node->condition );
+                node->increment = mutateExpression( node->increment );
+                node->body      = mutateStatement ( node->body      );
+        }
         MUTATE_END( Statement, node );
 }
@@ -410 +717 @@
         VISIT_START( node );
 
-        visitExpression( node->get_condition() );
-        visitStatementList( node->get_statements() );
+        visitExpression   ( node->condition  );
+        visitStatementList( node->statements );
 
         VISIT_END( node );
@@ -420 +727 @@
         MUTATE_START( node );
 
-        node->set_condition( mutateExpression( node->get_condition() ) );
-        mutateStatementList( node->get_statements() );
+        node->condition = mutateExpression( node->condition );
+        mutateStatementList( node->statements );
 
         MUTATE_END( Statement, node );
@@ -432 +739 @@
         VISIT_START( node );
 
-        visitExpression( node->get_condition() );
-        visitStatementList( node->get_statements() );
+        visitExpression   ( node->condition );
+        visitStatementList( node->stmts     );
 
         VISIT_END( node );
@@ -442 +749 @@
         MUTATE_START( node );
 
-        node->set_condition(  mutateExpression( node->get_condition() ) );
-        mutateStatementList( node->get_statements() );
+        node->condition = mutateExpression( node->condition );
+        mutateStatementList( node->stmts );
 
         MUTATE_END( Statement, node );
@@ -466 +773 @@
         VISIT_START( node );
 
-        visitExpression( node->get_expr() );
+        visitExpression( node->expr );
 
         VISIT_END( node );
@@ -475 +782 @@
         MUTATE_START( node );
 
-        node->set_expr( mutateExpression( node->get_expr() ) );
+        node->expr = mutateExpression( node->expr );
 
         MUTATE_END( Statement, node );
@@ -499 +806 @@
         VISIT_START( node );
 
-        maybeAccept( node->get_block(), *this );
-        acceptAll( node->get_catchers(), *this );
-        maybeAccept( node->get_finally(), *this );
+        maybeAccept( node->block       , *this );
+        maybeAccept( node->handlers    , *this );
+        maybeAccept( node->finallyBlock, *this );
 
         VISIT_END( node );
@@ -510 +817 @@
         MUTATE_START( node );
 
-        node->set_block(  maybeMutate( node->get_block(), *this ) );
-        mutateAll( node->get_catchers(), *this );
-        node->set_finally( maybeMutate( node->get_finally(), *this ) );
+        maybeMutateRef( node->block       , *this );
+        maybeMutateRef( node->handlers    , *this );
+        maybeMutateRef( node->finallyBlock, *this );
 
         MUTATE_END( Statement, node );
@@ -522 +829 @@
 void PassVisitor< pass_type >::visit( CatchStmt * node ) {
         VISIT_START( node );
-
-        maybeAccept( node->get_decl(), *this );
-        node->set_cond( visitExpression( node->get_cond() ) );
-        node->set_body( visitStatement( node->get_body() ) );
-
+        {
+                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                maybeAccept( node->decl, *this );
+                node->cond = visitExpression( node->cond );
+                node->body = visitStatement ( node->body );
+        }
         VISIT_END( node );
 }
@@ -533 +841 @@
 Statement * PassVisitor< pass_type >::mutate( CatchStmt * node ) {
         MUTATE_START( node );
-
-        node->set_decl( maybeMutate( node->get_decl(), *this ) );
-        node->set_cond( mutateExpression( node->get_cond() ) );
-        node->set_body( mutateStatement( node->get_body() ) );
-
+        {
+                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                maybeMutateRef( node->decl, *this );
+                node->cond = mutateExpression( node->cond );
+                node->body = mutateStatement ( node->body );
+        }
         MUTATE_END( Statement, node );
 }
@@ -605 +914 @@
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( ApplicationExpr * node ) {
-        VISIT_BODY( node );
+        VISIT_START( node );
+
+        indexerScopedAccept( node->result  , *this );
+        maybeAccept        ( node->function, *this );
+        maybeAccept        ( node->args    , *this );
+
+        VISIT_END( node );
 }
 
 template< typename pass_type >
 Expression * PassVisitor< pass_type >::mutate( ApplicationExpr * node ) {
-        MUTATE_BODY( Expression, node );
+        MUTATE_START( node );
+
+        indexerScopedMutate( node->env     , *this );
+        indexerScopedMutate( node->result  , *this );
+        maybeMutateRef     ( node->function, *this );
+        maybeMutateRef     ( node->args    , *this );
+
+        MUTATE_END( Expression, node );
 }
 
@@ -620 +942 @@
 
         // maybeAccept( node->get_env(), *this );
-        maybeAccept( node->get_result(), *this );
-
-        for ( auto expr : node->get_args() ) {
+        indexerScopedAccept( node->result, *this );
+
+        for ( auto expr : node->args ) {
                 visitExpression( expr );
         }
@@ -633 +955 @@
         MUTATE_START( node );
 
-        node->set_env( maybeMutate( node->get_env(), *this ) );
-        node->set_result( maybeMutate( node->get_result(), *this ) );
-
-        for ( auto& expr : node->get_args() ) {
+        indexerScopedMutate( node->env   , *this );
+        indexerScopedMutate( node->result, *this );
+
+        for ( auto& expr : node->args ) {
                 expr = mutateExpression( expr );
         }
@@ -643 +965 @@
 }
 
+//--------------------------------------------------------------------------
+// NameExpr
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( NameExpr * node ) {
-        VISIT_BODY( node );
-}
-
+        VISIT_START( node );
+
+        indexerScopedAccept( node->result, *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( NameExpr * node ) {
+        MUTATE_START( node );
+
+        indexerScopedMutate( node->env   , *this );
+        indexerScopedMutate( node->result, *this );
+
+        MUTATE_END( Expression, node );
+}
+
+//--------------------------------------------------------------------------
+// CastExpr
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( CastExpr * node ) {
-        VISIT_BODY( node );
-}
-
+        VISIT_START( node );
+
+        indexerScopedAccept( node->result, *this );
+        maybeAccept        ( node->arg   , *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( CastExpr * node ) {
+        MUTATE_START( node );
+
+        indexerScopedMutate( node->env   , *this );
+        indexerScopedMutate( node->result, *this );
+        maybeMutateRef     ( node->arg   , *this );
+
+        MUTATE_END( Expression, node );
+}
+
+//--------------------------------------------------------------------------
+// VirtualCastExpr
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( VirtualCastExpr * node ) {
-        VISIT_BODY( node );
-}
-
+        VISIT_START( node );
+
+        indexerScopedAccept( node->result, *this );
+        maybeAccept( node->arg, *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( VirtualCastExpr * node ) {
+        MUTATE_START( node );
+
+        indexerScopedMutate( node->env   , *this );
+        indexerScopedMutate( node->result, *this );
+        maybeMutateRef     ( node->arg   , *this );
+
+        MUTATE_END( Expression, node );
+}
+
+//--------------------------------------------------------------------------
+// AddressExpr
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( AddressExpr * node ) {
-        VISIT_BODY( node );
-}
-
+        VISIT_START( node );
+
+        indexerScopedAccept( node->result, *this );
+        maybeAccept        ( node->arg   , *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( AddressExpr * node ) {
+        MUTATE_START( node );
+
+        indexerScopedMutate( node->env   , *this );
+        indexerScopedMutate( node->result, *this );
+        maybeMutateRef     ( node->arg   , *this );
+
+        MUTATE_END( Expression, node );
+}
+
+//--------------------------------------------------------------------------
+// LabelAddressExpr
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( LabelAddressExpr * node ) {
-        VISIT_BODY( node );
-}
-
+        VISIT_START( node );
+
+        indexerScopedAccept( node->result, *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( LabelAddressExpr * node ) {
+        MUTATE_START( node );
+
+        indexerScopedMutate( node->env   , *this );
+        indexerScopedMutate( node->result, *this );
+
+        MUTATE_END( Expression, node );
+}
+
+//--------------------------------------------------------------------------
+// UntypedMemberExpr
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( UntypedMemberExpr * node ) {
-        VISIT_BODY( node );
-}
-
+        VISIT_START( node );
+
+        indexerScopedAccept( node->result   , *this );
+        maybeAccept        ( node->aggregate, *this );
+        maybeAccept        ( node->member   , *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( UntypedMemberExpr * node ) {
+        MUTATE_START( node );
+
+        indexerScopedMutate( node->env      , *this );
+        indexerScopedMutate( node->result   , *this );
+        maybeMutateRef     ( node->aggregate, *this );
+        maybeMutateRef     ( node->member   , *this );
+
+        MUTATE_END( Expression, node );
+}
+
+//--------------------------------------------------------------------------
+// MemberExpr
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( MemberExpr * node ) {
-        VISIT_BODY( node );
-}
-
+        VISIT_START( node );
+
+        indexerScopedAccept( node->result   , *this );
+        maybeAccept        ( node->aggregate, *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( MemberExpr * node ) {
+        MUTATE_START( node );
+
+        indexerScopedMutate( node->env      , *this );
+        indexerScopedMutate( node->result   , *this );
+        maybeMutateRef     ( node->aggregate, *this );
+
+        MUTATE_END( Expression, node );
+}
+
+//--------------------------------------------------------------------------
+// VariableExpr
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( VariableExpr * node ) {
-        VISIT_BODY( node );
-}
-
+        VISIT_START( node );
+
+        indexerScopedAccept( node->result, *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( VariableExpr * node ) {
+        MUTATE_START( node );
+
+        indexerScopedMutate( node->env   , *this );
+        indexerScopedMutate( node->result, *this );
+
+        MUTATE_END( Expression, node );
+}
+
+//--------------------------------------------------------------------------
+// ConstantExpr
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( ConstantExpr * node ) {
-        VISIT_BODY( node );
-}
-
+        VISIT_START( node );
+
+        indexerScopedAccept( node->result   , *this );
+        maybeAccept        ( &node->constant, *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( ConstantExpr * node ) {
+        MUTATE_START( node );
+
+        indexerScopedMutate( node->env   , *this );
+        indexerScopedMutate( node->result, *this );
+        node->constant = *maybeMutate( &node->constant, *this );
+
+        MUTATE_END( Expression, node );
+}
+
+//--------------------------------------------------------------------------
+// SizeofExpr
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( SizeofExpr * node ) {
-        VISIT_BODY( node );
-}
-
+        VISIT_START( node );
+
+        indexerScopedAccept( node->result, *this );
+        if ( node->get_isType() ) {
+                maybeAccept( node->type, *this );
+        } else {
+                maybeAccept( node->expr, *this );
+        }
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( SizeofExpr * node ) {
+        MUTATE_START( node );
+
+        indexerScopedMutate( node->env   , *this );
+        indexerScopedMutate( node->result, *this );
+        if ( node->get_isType() ) {
+                maybeMutateRef( node->type, *this );
+        } else {
+                maybeMutateRef( node->expr, *this );
+        }
+
+        MUTATE_END( Expression, node );
+}
+
+//--------------------------------------------------------------------------
+// AlignofExpr
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( AlignofExpr * node ) {
-        VISIT_BODY( node );
-}
-
+        VISIT_START( node );
+
+        indexerScopedAccept( node->result, *this );
+        if ( node->get_isType() ) {
+                maybeAccept( node->type, *this );
+        } else {
+                maybeAccept( node->expr, *this );
+        }
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( AlignofExpr * node ) {
+        MUTATE_START( node );
+
+        indexerScopedMutate( node->env   , *this );
+        indexerScopedMutate( node->result, *this );
+        if ( node->get_isType() ) {
+                maybeMutateRef( node->type, *this );
+        } else {
+                maybeMutateRef( node->expr, *this );
+        }
+
+        MUTATE_END( Expression, node );
+}
+
+//--------------------------------------------------------------------------
+// UntypedOffsetofExpr
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( UntypedOffsetofExpr * node ) {
-        VISIT_BODY( node );
-}
-
+        VISIT_START( node );
+
+        indexerScopedAccept( node->result, *this );
+        maybeAccept        ( node->type  , *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( UntypedOffsetofExpr * node ) {
+        MUTATE_START( node );
+
+        indexerScopedMutate( node->env   , *this );
+        indexerScopedMutate( node->result, *this );
+        maybeMutateRef     ( node->type  , *this );
+
+        MUTATE_END( Expression, node );
+}
+
+//--------------------------------------------------------------------------
+// OffsetofExpr
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( OffsetofExpr * node ) {
-        VISIT_BODY( node );
-}
-
+        VISIT_START( node );
+
+        indexerScopedAccept( node->result, *this );
+        maybeAccept        ( node->type  , *this );
+        maybeAccept        ( node->member, *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( OffsetofExpr * node ) {
+        MUTATE_START( node );
+
+        indexerScopedMutate( node->env   , *this );
+        indexerScopedMutate( node->result, *this );
+        maybeMutateRef     ( node->type  , *this );
+        maybeMutateRef     ( node->member, *this );
+
+        MUTATE_END( Expression, node );
+}
+
+//--------------------------------------------------------------------------
+// OffsetPackExpr
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( OffsetPackExpr * node ) {
-        VISIT_BODY( node );
-}
-
+        VISIT_START( node );
+
+        indexerScopedAccept( node->result, *this );
+        maybeAccept        ( node->type  , *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( OffsetPackExpr * node ) {
+        MUTATE_START( node );
+
+        indexerScopedMutate( node->env   , *this );
+        indexerScopedMutate( node->result, *this );
+        maybeMutateRef     ( node->type  , *this );
+
+        MUTATE_END( Expression, node );
+}
+
+//--------------------------------------------------------------------------
+// AttrExpr
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( AttrExpr * node ) {
-        VISIT_BODY( node );
-}
-
+        VISIT_START( node );
+
+        indexerScopedAccept( node->result, *this );
+        if ( node->get_isType() ) {
+                maybeAccept( node->type, *this );
+        } else {
+                maybeAccept( node->expr, *this );
+        }
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( AttrExpr * node ) {
+        MUTATE_START( node );
+
+        indexerScopedMutate( node->env   , *this );
+        indexerScopedMutate( node->result, *this );
+        if ( node->get_isType() ) {
+                maybeMutateRef( node->type, *this );
+        } else {
+                maybeMutateRef( node->expr, *this );
+        }
+
+        MUTATE_END( Expression, node );
+}
+
+//--------------------------------------------------------------------------
+// LogicalExpr
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( LogicalExpr * node ) {
-        VISIT_BODY( node );
-}
-
+        VISIT_START( node );
+
+        indexerScopedAccept( node->result, *this );
+        maybeAccept        ( node->arg1  , *this );
+        maybeAccept        ( node->arg2  , *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( LogicalExpr * node ) {
+        MUTATE_START( node );
+
+        indexerScopedMutate( node->env   , *this );
+        indexerScopedMutate( node->result, *this );
+        maybeMutateRef     ( node->arg1  , *this );
+        maybeMutateRef     ( node->arg2  , *this );
+
+        MUTATE_END( Expression, node );
+}
+
+//--------------------------------------------------------------------------
+// ConditionalExpr
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( ConditionalExpr * node ) {
-        VISIT_BODY( node );
-}
-
+        VISIT_START( node );
+
+        indexerScopedAccept( node->result, *this );
+        maybeAccept        ( node->arg1  , *this );
+        maybeAccept        ( node->arg2  , *this );
+        maybeAccept        ( node->arg3  , *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( ConditionalExpr * node ) {
+        MUTATE_START( node );
+
+        indexerScopedMutate( node->env   , *this );
+        indexerScopedMutate( node->result, *this );
+        maybeMutateRef     ( node->arg1  , *this );
+        maybeMutateRef     ( node->arg2  , *this );
+        maybeMutateRef     ( node->arg3  , *this );
+
+        MUTATE_END( Expression, node );
+}
+
+//--------------------------------------------------------------------------
+// CommaExpr
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( CommaExpr * node ) {
-        VISIT_BODY( node );
-}
-
+        VISIT_START( node );
+
+        indexerScopedAccept( node->result, *this );
+        maybeAccept        ( node->arg1  , *this );
+        maybeAccept        ( node->arg2  , *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( CommaExpr * node ) {
+        MUTATE_START( node );
+
+        indexerScopedMutate( node->env   , *this );
+        indexerScopedMutate( node->result, *this );
+        maybeMutateRef     ( node->arg1  , *this );
+        maybeMutateRef     ( node->arg2  , *this );
+
+        MUTATE_END( Expression, node );
+}
+
+//--------------------------------------------------------------------------
+// TypeExpr
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( TypeExpr * node ) {
-        VISIT_BODY( node );
-}
-
+        VISIT_START( node );
+
+        indexerScopedAccept( node->result, *this );
+        maybeAccept        ( node->type, *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( TypeExpr * node ) {
+        MUTATE_START( node );
+
+        indexerScopedMutate( node->env   , *this );
+        indexerScopedMutate( node->result, *this );
+        maybeMutateRef     ( node->type  , *this );
+
+        MUTATE_END( Expression, node );
+}
+
+//--------------------------------------------------------------------------
+// AsmExpr
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( AsmExpr * node ) {
-        VISIT_BODY( node );
-}
-
+        VISIT_START( node );
+
+        indexerScopedAccept( node->result    , *this );
+        maybeAccept        ( node->inout     , *this );
+        maybeAccept        ( node->constraint, *this );
+        maybeAccept        ( node->operand   , *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( AsmExpr * node ) {
+        MUTATE_START( node );
+
+        indexerScopedMutate( node->env       , *this );
+        indexerScopedMutate( node->result    , *this );
+        maybeMutateRef     ( node->inout     , *this );
+        maybeMutateRef     ( node->constraint, *this );
+        maybeMutateRef     ( node->operand   , *this );
+
+        MUTATE_END( Expression, node );
+}
+
+//--------------------------------------------------------------------------
+// ImplicitCopyCtorExpr
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( ImplicitCopyCtorExpr * node ) {
-        VISIT_BODY( node );
-}
-
+        VISIT_START( node );
+
+        indexerScopedAccept( node->result     , *this );
+        maybeAccept        ( node->callExpr   , *this );
+        maybeAccept        ( node->tempDecls  , *this );
+        maybeAccept        ( node->returnDecls, *this );
+        maybeAccept        ( node->dtors      , *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( ImplicitCopyCtorExpr * node ) {
+        MUTATE_START( node );
+
+        indexerScopedMutate( node->env        , *this );
+        indexerScopedMutate( node->result     , *this );
+        maybeMutateRef     ( node->callExpr   , *this );
+        maybeMutateRef     ( node->tempDecls  , *this );
+        maybeMutateRef     ( node->returnDecls, *this );
+        maybeMutateRef     ( node->dtors      , *this );
+
+        MUTATE_END( Expression, node );
+}
+
+//--------------------------------------------------------------------------
+// ConstructorExpr
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( ConstructorExpr * node ) {
-        VISIT_BODY( node );
-}
-
+        VISIT_START( node );
+
+        indexerScopedAccept( node->result  , *this );
+        maybeAccept        ( node->callExpr, *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( ConstructorExpr * node ) {
+        MUTATE_START( node );
+
+        indexerScopedMutate( node->env     , *this );
+        indexerScopedMutate( node->result  , *this );
+        maybeMutateRef     ( node->callExpr, *this );
+
+        MUTATE_END( Expression, node );
+}
+
+//--------------------------------------------------------------------------
+// CompoundLiteralExpr
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( CompoundLiteralExpr * node ) {
-        VISIT_BODY( node );
-}
-
+        VISIT_START( node );
+
+        indexerScopedAccept( node->result     , *this );
+        maybeAccept        ( node->initializer, *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( CompoundLiteralExpr * node ) {
+        MUTATE_START( node );
+
+        indexerScopedMutate( node->env        , *this );
+        indexerScopedMutate( node->result     , *this );
+        maybeMutateRef     ( node->initializer, *this );
+
+        MUTATE_END( Expression, node );
+}
+
+//--------------------------------------------------------------------------
+// RangeExpr
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( RangeExpr * node ) {
-        VISIT_BODY( node );
-}
-
+        VISIT_START( node );
+
+        indexerScopedAccept( node->result, *this );
+        maybeAccept        ( node->low   , *this );
+        maybeAccept        ( node->high  , *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( RangeExpr * node ) {
+        MUTATE_START( node );
+
+        indexerScopedMutate( node->env   , *this );
+        indexerScopedMutate( node->result, *this );
+        maybeMutateRef     ( node->low   , *this );
+        maybeMutateRef     ( node->high  , *this );
+
+        MUTATE_END( Expression, node );
+}
+
+//--------------------------------------------------------------------------
+// UntypedTupleExpr
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( UntypedTupleExpr * node ) {
-        VISIT_BODY( node );
-}
-
+        VISIT_START( node );
+
+        indexerScopedAccept( node->result, *this );
+        maybeAccept        ( node->exprs , *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( UntypedTupleExpr * node ) {
+        MUTATE_START( node );
+
+        indexerScopedMutate( node->env   , *this );
+        indexerScopedMutate( node->result, *this );
+        maybeMutateRef     ( node->exprs , *this );
+
+        MUTATE_END( Expression, node );
+}
+
+//--------------------------------------------------------------------------
+// TupleExpr
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( TupleExpr * node ) {
-        VISIT_BODY( node );
-}
-
+        VISIT_START( node );
+
+        indexerScopedAccept( node->result, *this );
+        maybeAccept          ( node->exprs , *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( TupleExpr * node ) {
+        MUTATE_START( node );
+
+        indexerScopedMutate( node->env   , *this );
+        indexerScopedMutate( node->result, *this );
+        maybeMutateRef     ( node->exprs , *this );
+
+        MUTATE_END( Expression, node );
+}
+
+//--------------------------------------------------------------------------
+// TupleIndexExpr
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( TupleIndexExpr * node ) {
-        VISIT_BODY( node );
-}
-
+        VISIT_START( node );
+
+        indexerScopedAccept( node->result, *this );
+        maybeAccept        ( node->tuple , *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( TupleIndexExpr * node ) {
+        MUTATE_START( node );
+
+        indexerScopedMutate( node->env   , *this );
+        indexerScopedMutate( node->result, *this );
+        maybeMutateRef     ( node->tuple , *this );
+
+        MUTATE_END( Expression, node );
+}
+
+//--------------------------------------------------------------------------
+// TupleAssignExpr
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( TupleAssignExpr * node ) {
-        VISIT_BODY( node );
-}
-
-//--------------------------------------------------------------------------
-// UntypedExpr
+        VISIT_START( node );
+
+        indexerScopedAccept( node->result  , *this );
+        maybeAccept        ( node->stmtExpr, *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( TupleAssignExpr * node ) {
+        MUTATE_START( node );
+
+        indexerScopedMutate( node->env     , *this );
+        indexerScopedMutate( node->result  , *this );
+        maybeMutateRef     ( node->stmtExpr, *this );
+
+        MUTATE_END( Expression, node );
+}
+
+//--------------------------------------------------------------------------
+// StmtExpr
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( StmtExpr * node ) {
@@ -794 +1662 @@
         ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () );
 
-        Visitor::visit( node );
+        indexerScopedAccept( node->result     , *this );
+        maybeAccept        ( node->statements , *this );
+        maybeAccept        ( node->returnDecls, *this );
+        maybeAccept        ( node->dtors      , *this );
 
         VISIT_END( node );
@@ -808 +1679 @@
         ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () );
 
-        Mutator::mutate( node );
-
-        MUTATE_END( Expression, node );
-}
-
+        indexerScopedMutate( node->result     , *this );
+        maybeMutateRef     ( node->statements , *this );
+        maybeMutateRef     ( node->returnDecls, *this );
+        maybeMutateRef     ( node->dtors      , *this );
+
+        MUTATE_END( Expression, node );
+}
+
+//--------------------------------------------------------------------------
+// UniqueExpr
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( UniqueExpr * node ) {
-        VISIT_BODY( node );
+        VISIT_START( node );
+
+        indexerScopedAccept( node->result, *this );
+        maybeAccept        ( node->expr  , *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( UniqueExpr * node ) {
+        MUTATE_START( node );
+
+        indexerScopedMutate( node->env   , *this );
+        indexerScopedMutate( node->result, *this );
+        maybeMutateRef     ( node->expr  , *this );
+
+        MUTATE_END( Expression, node );
 }
 
@@ -848 +1740 @@
 }
 
+//--------------------------------------------------------------------------
+// StructInstType
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( StructInstType * node ) {
-        VISIT_BODY( node );
-}
-
+        VISIT_START( node );
+
+        indexerAddStruct( node->name );
+
+        {
+                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                maybeAccept( node->forall    , *this );
+                maybeAccept( node->parameters, *this );
+        }
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Type * PassVisitor< pass_type >::mutate( StructInstType * node ) {
+        MUTATE_START( node );
+
+        indexerAddStruct( node->name );
+
+        {
+                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                maybeMutateRef( node->forall    , *this );
+                maybeMutateRef( node->parameters, *this );
+        }
+
+        MUTATE_END( Type, node );
+}
+
+//--------------------------------------------------------------------------
+// UnionInstType
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( UnionInstType * node ) {
-        VISIT_BODY( node );
-}
-
+        VISIT_START( node );
+
+        indexerAddStruct( node->name );
+
+        {
+                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                maybeAccept( node->forall    , *this );
+                maybeAccept( node->parameters, *this );
+        }
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Type * PassVisitor< pass_type >::mutate( UnionInstType * node ) {
+        MUTATE_START( node );
+
+        indexerAddStruct( node->name );
+
+        {
+                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                maybeMutateRef( node->forall    , *this );
+                maybeMutateRef( node->parameters, *this );
+        }
+
+        MUTATE_END( Type, node );
+}
+
+//--------------------------------------------------------------------------
+// EnumInstType
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( EnumInstType * node ) {
@@ -864 +1812 @@
 
 template< typename pass_type >
+Type * PassVisitor< pass_type >::mutate( EnumInstType * node ) {
+        MUTATE_BODY( Type, node );
+}
+
+//--------------------------------------------------------------------------
+// TraitInstType
+template< typename pass_type >
 void PassVisitor< pass_type >::visit( TraitInstType * node ) {
-        VISIT_BODY( node );
-}
-
+        VISIT_START( node );
+
+        maybeAccept( node->forall    , *this );
+        maybeAccept( node->parameters, *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Type * PassVisitor< pass_type >::mutate( TraitInstType * node ) {
+        MUTATE_START( node );
+
+        maybeMutateRef( node->forall    , *this );
+        maybeMutateRef( node->parameters, *this );
+
+        MUTATE_END( Type, node );
+}
+
+//--------------------------------------------------------------------------
+// TypeInstType
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( TypeInstType * node ) {
@@ -904 +1876 @@
 
 //--------------------------------------------------------------------------
-// UntypedExpr
+// SingleInit
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( SingleInit * node ) {
@@ -944 +1916 @@
 
 //---------------------------------------------------------------------------------------------------------------
-
-template< typename pass_type >
-DeclarationWithType * PassVisitor< pass_type >::mutate( ObjectDecl * node ) {
-        MUTATE_BODY( DeclarationWithType, node );
-}
-
-template< typename pass_type >
-DeclarationWithType * PassVisitor< pass_type >::mutate( FunctionDecl * node ) {
-        MUTATE_BODY( DeclarationWithType, node );
-}
-
-template< typename pass_type >
-Declaration * PassVisitor< pass_type >::mutate( StructDecl * node ) {
-        MUTATE_BODY( Declaration, node );
-}
-
-template< typename pass_type >
-Declaration * PassVisitor< pass_type >::mutate( UnionDecl * node ) {
-        MUTATE_BODY( Declaration, node );
-}
-
-template< typename pass_type >
-Declaration * PassVisitor< pass_type >::mutate( EnumDecl * node ) {
-        MUTATE_BODY( Declaration, node );
-}
-
-template< typename pass_type >
-Declaration * PassVisitor< pass_type >::mutate( TraitDecl * node ) {
-        MUTATE_BODY( Declaration, node );
-}
-
-template< typename pass_type >
-Declaration * PassVisitor< pass_type >::mutate( TypeDecl * node ) {
-        MUTATE_BODY( Declaration, node );
-}
-
-template< typename pass_type >
-Declaration * PassVisitor< pass_type >::mutate( TypedefDecl * node ) {
-        MUTATE_BODY( Declaration, node );
-}
-
-template< typename pass_type >
-AsmDecl * PassVisitor< pass_type >::mutate( AsmDecl * node ) {
-        MUTATE_BODY( AsmDecl, node );
-}
-
-template< typename pass_type >
-Expression * PassVisitor< pass_type >::mutate( NameExpr * node ) {
-        MUTATE_BODY( Expression, node );
-}
-
-template< typename pass_type >
-Expression * PassVisitor< pass_type >::mutate( AddressExpr * node ) {
-        MUTATE_BODY( Expression, node );
-}
-
-template< typename pass_type >
-Expression * PassVisitor< pass_type >::mutate( LabelAddressExpr * node ) {
-        MUTATE_BODY( Expression, node );
-}
-
-template< typename pass_type >
-Expression * PassVisitor< pass_type >::mutate( CastExpr * node ) {
-        MUTATE_BODY( Expression, node );
-}
-
-template< typename pass_type >
-Expression * PassVisitor< pass_type >::mutate( VirtualCastExpr * node ) {
-        MUTATE_BODY( Expression, node );
-}
-
-template< typename pass_type >
-Expression * PassVisitor< pass_type >::mutate( UntypedMemberExpr * node ) {
-        MUTATE_BODY( Expression, node );
-}
-
-template< typename pass_type >
-Expression * PassVisitor< pass_type >::mutate( MemberExpr * node ) {
-        MUTATE_BODY( Expression, node );
-}
-
-template< typename pass_type >
-Expression * PassVisitor< pass_type >::mutate( VariableExpr * node ) {
-        MUTATE_BODY( Expression, node );
-}
-
-template< typename pass_type >
-Expression * PassVisitor< pass_type >::mutate( ConstantExpr * node ) {
-        MUTATE_BODY( Expression, node );
-}
-
-template< typename pass_type >
-Expression * PassVisitor< pass_type >::mutate( SizeofExpr * node ) {
-        MUTATE_BODY( Expression, node );
-}
-
-template< typename pass_type >
-Expression * PassVisitor< pass_type >::mutate( AlignofExpr * node ) {
-        MUTATE_BODY( Expression, node );
-}
-
-template< typename pass_type >
-Expression * PassVisitor< pass_type >::mutate( UntypedOffsetofExpr * node ) {
-        MUTATE_BODY( Expression, node );
-}
-
-template< typename pass_type >
-Expression * PassVisitor< pass_type >::mutate( OffsetofExpr * node ) {
-        MUTATE_BODY( Expression, node );
-}
-
-template< typename pass_type >
-Expression * PassVisitor< pass_type >::mutate( OffsetPackExpr * node ) {
-        MUTATE_BODY( Expression, node );
-}
-
-template< typename pass_type >
-Expression * PassVisitor< pass_type >::mutate( AttrExpr * node ) {
-        MUTATE_BODY( Expression, node );
-}
-
-template< typename pass_type >
-Expression * PassVisitor< pass_type >::mutate( LogicalExpr * node ) {
-        MUTATE_BODY( Expression, node );
-}
-
-template< typename pass_type >
-Expression * PassVisitor< pass_type >::mutate( ConditionalExpr * node ) {
-        MUTATE_BODY( Expression, node );
-}
-
-template< typename pass_type >
-Expression * PassVisitor< pass_type >::mutate( CommaExpr * node ) {
-        MUTATE_BODY( Expression, node );
-}
-
-template< typename pass_type >
-Expression * PassVisitor< pass_type >::mutate( TypeExpr * node ) {
-        MUTATE_BODY( Expression, node );
-}
-
-template< typename pass_type >
-Expression * PassVisitor< pass_type >::mutate( AsmExpr * node ) {
-        MUTATE_BODY( Expression, node );
-}
-
-template< typename pass_type >
-Expression * PassVisitor< pass_type >::mutate( ImplicitCopyCtorExpr * node ) {
-        MUTATE_BODY( Expression, node );
-}
-
-template< typename pass_type >
-Expression * PassVisitor< pass_type >::mutate( ConstructorExpr * node ) {
-        MUTATE_BODY( Expression, node );
-}
-
-template< typename pass_type >
-Expression * PassVisitor< pass_type >::mutate( CompoundLiteralExpr * node ) {
-        MUTATE_BODY( Expression, node );
-}
-
-template< typename pass_type >
-Expression * PassVisitor< pass_type >::mutate( RangeExpr * node ) {
-        MUTATE_BODY( Expression, node );
-}
-
-template< typename pass_type >
-Expression * PassVisitor< pass_type >::mutate( UntypedTupleExpr * node ) {
-        MUTATE_BODY( Expression, node );
-}
-
-template< typename pass_type >
-Expression * PassVisitor< pass_type >::mutate( TupleExpr * node ) {
-        MUTATE_BODY( Expression, node );
-}
-
-template< typename pass_type >
-Expression * PassVisitor< pass_type >::mutate( TupleIndexExpr * node ) {
-        MUTATE_BODY( Expression, node );
-}
-
-template< typename pass_type >
-Expression * PassVisitor< pass_type >::mutate( TupleAssignExpr * node ) {
-        MUTATE_BODY( Expression, node );
-}
-
-template< typename pass_type >
-Expression * PassVisitor< pass_type >::mutate( UniqueExpr * node ) {
-        MUTATE_BODY( Expression, node );
-}
-
 template< typename pass_type >
 Type * PassVisitor< pass_type >::mutate( VoidType * node ) {
@@ -1166 +1947 @@
 
 template< typename pass_type >
-Type * PassVisitor< pass_type >::mutate( StructInstType * node ) {
-        MUTATE_BODY( Type, node );
-}
-
-template< typename pass_type >
-Type * PassVisitor< pass_type >::mutate( UnionInstType * node ) {
-        MUTATE_BODY( Type, node );
-}
-
-template< typename pass_type >
-Type * PassVisitor< pass_type >::mutate( EnumInstType * node ) {
-        MUTATE_BODY( Type, node );
-}
-
-template< typename pass_type >
-Type * PassVisitor< pass_type >::mutate( TraitInstType * node ) {
-        MUTATE_BODY( Type, node );
-}
-
-template< typename pass_type >
 Type * PassVisitor< pass_type >::mutate( TypeInstType * node ) {
         MUTATE_BODY( Type, node );

src/Common/PassVisitor.proto.h

@@ -41 +41 @@
 };
 
-
 class bool_ref {
 public:
@@ -59 +58 @@
         bool * m_ref;
 };
+
+template< typename TreeType, typename VisitorType >
+inline void indexerScopedAccept( TreeType * tree, VisitorType & visitor ) {
+        auto guard = makeFuncGuard(
+                [&visitor]() { visitor.indexerScopeEnter(); },
+                [&visitor]() { visitor.indexerScopeLeave(); }
+        );
+        maybeAccept( tree, visitor );
+}
+
+template< typename TreeType, typename MutatorType >
+inline void indexerScopedMutate( TreeType *& tree, MutatorType & mutator ) {
+        auto guard = makeFuncGuard(
+                [&mutator]() { mutator.indexerScopeEnter(); },
+                [&mutator]() { mutator.indexerScopeLeave(); }
+        );
+        tree = maybeMutate( tree, mutator );
+}
+
+template< typename TreeType, typename MutatorType >
+inline void maybeMutateRef( TreeType *& tree, MutatorType & mutator ) {
+        tree = maybeMutate( tree, mutator );
+}
 
 //-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
@@ -93 +115 @@
 static inline void postvisit_impl( __attribute__((unused)) pass_type& pass, __attribute__((unused)) node_type * node, __attribute__((unused)) long unused ) {}
 
+//---------------------------------------------------------
 // Mutate
 template<typename pass_type, typename node_type>
@@ -111 +134 @@
 static inline return_type postmutate_impl( __attribute__((unused)) pass_type& pass, node_type * node, __attribute__((unused)) long unused ) { return node; }
 
+//---------------------------------------------------------
 // Begin/End scope
 template<typename pass_type>
@@ -129 +153 @@
 static inline void end_scope_impl( __attribute__((unused)) pass_type& pass, __attribute__((unused)) long unused ) {}
 
+//---------------------------------------------------------
 // Fields
 #define FIELD_PTR( type, name )                                                                                                        \
@@ -145 +170 @@
 FIELD_PTR( at_cleanup_t, at_cleanup )
 FIELD_PTR( PassVisitor<pass_type> * const, visitor )
+
+//---------------------------------------------------------
+// Indexer
+template<typename pass_type>
+static inline auto indexer_impl_enterScope( pass_type & pass, int ) -> decltype( pass.indexer.enterScope(), void() ) {
+        pass.indexer.enterScope();
+}
+
+template<typename pass_type>
+static inline auto indexer_impl_enterScope( pass_type &, int ) {}
+
+template<typename pass_type>
+static inline auto indexer_impl_leaveScope( pass_type & pass, int ) -> decltype( pass.indexer.leaveScope(), void() ) {
+        pass.indexer.leaveScope();
+}
+
+template<typename pass_type>
+static inline auto indexer_impl_leaveScope( pass_type &, int ) {}
+
+
+#define INDEXER_FUNC( func, type )                                                                                             \
+template<typename pass_type>                                                                                                   \
+static inline auto indexer_impl_##func ( pass_type & pass, int, type arg ) -> decltype( pass.indexer.func( arg ), void() ) {   \
+        pass.indexer.func( arg );                                                                                                \
+}                                                                                                                              \
+                                                                                                                               \
+template<typename pass_type>                                                                                                   \
+static inline void indexer_impl_##func ( pass_type &, long, type ) {}                                                          \
+
+INDEXER_FUNC( addId     , DeclarationWithType * );
+INDEXER_FUNC( addType   , NamedTypeDecl *       );
+INDEXER_FUNC( addStruct , StructDecl *          );
+INDEXER_FUNC( addEnum   , EnumDecl *            );
+INDEXER_FUNC( addUnion  , UnionDecl *           );
+INDEXER_FUNC( addTrait  , TraitDecl *           );
+
+
+template<typename pass_type>
+static inline auto indexer_impl_addStructFwd( pass_type & pass, int, StructDecl * decl ) -> decltype( pass.indexer.addStruct( decl ), void() ) {
+        StructDecl * fwd = new StructDecl( decl->name );
+        cloneAll( decl->parameters, fwd->parameters );
+        pass.indexer.addStruct( fwd );
+}
+
+template<typename pass_type>
+static inline auto indexer_impl_addStructFwd( pass_type &, int, StructDecl * ) {}
+
+template<typename pass_type>
+static inline auto indexer_impl_addUnionFwd( pass_type & pass, int, UnionDecl * decl ) -> decltype( pass.indexer.addUnion( decl ), void() ) {
+        UnionDecl * fwd = new UnionDecl( decl->name );
+        cloneAll( decl->parameters, fwd->parameters );
+        pass.indexer.addUnion( fwd );
+}
+
+template<typename pass_type>
+static inline auto indexer_impl_addUnionFwd( pass_type &, int, UnionDecl * ) {}
+
+template<typename pass_type>
+static inline auto indexer_impl_addStruct( pass_type & pass, int, const std::string & str ) -> decltype( pass.indexer.addStruct( str ), void() ) {
+        if ( ! pass.indexer.lookupStruct( str ) ) {
+                pass.indexer.addStruct( str );
+        }
+}
+
+template<typename pass_type>
+static inline auto indexer_impl_addStruct( pass_type &, int, const std::string & ) {}
+
+template<typename pass_type>
+static inline auto indexer_impl_addUnion( pass_type & pass, int, const std::string & str ) -> decltype( pass.indexer.addUnion( str ), void() ) {
+        if ( ! pass.indexer.lookupUnion( str ) ) {
+                pass.indexer.addUnion( str );
+        }
+}
+
+template<typename pass_type>
+static inline auto indexer_impl_addUnion( pass_type &, int, const std::string & ) {}

src/Common/utility.h

@@ -277 +277 @@
         ~ValueGuardPtr() { if( ref ) *ref = old; }
 };
+
+template< typename aT >
+struct FuncGuard {
+        aT m_after;
+
+        template< typename bT >
+        FuncGuard( bT before, aT after ) : m_after( after ) {
+                before();
+        }
+
+        ~FuncGuard() {
+                m_after();
+        }
+};
+
+template< typename bT, typename aT >
+FuncGuard<aT> makeFuncGuard( bT && before, aT && after ) {
+        return FuncGuard<aT>( std::forward<bT>(before), std::forward<aT>(after) );
+}
 
 template< typename T >