Changes in / [7f66cec:f8d05ee]

Location:

src

Files:

• AST/Copy.hpp (modified) (1 diff)
• AST/GenericSubstitution.cpp (modified) (1 diff)
• AST/Pass.hpp (modified) (7 diffs)
• AST/Pass.impl.hpp (modified) (115 diffs)
• AST/Pass.proto.hpp (modified) (14 diffs)
• AST/Type.cpp (modified) (5 diffs)
• AST/TypeEnvironment.cpp (modified) (11 diffs)
• AST/TypeSubstitution.cpp (modified) (1 diff)
• AST/TypeSubstitution.hpp (modified) (3 diffs)
• Common/Eval.cc (modified) (1 diff)
• InitTweak/InitTweak.cc (modified) (2 diffs)
• ResolvExpr/CandidateFinder.cpp (modified) (1 diff)
• ResolvExpr/CastCost.cc (modified) (1 diff)
• ResolvExpr/CommonType.cc (modified) (1 diff)
• ResolvExpr/ConversionCost.cc (modified) (2 diffs)
• ResolvExpr/PolyCost.cc (modified) (1 diff)
• ResolvExpr/PtrsAssignable.cc (modified) (1 diff)
• ResolvExpr/PtrsCastable.cc (modified) (1 diff)
• ResolvExpr/Resolver.cc (modified) (1 diff)
• ResolvExpr/SpecCost.cc (modified) (1 diff)
• ResolvExpr/Unify.cc (modified) (1 diff)
• SymTab/FixFunction.cc (modified) (1 diff)
• SymTab/Mangler.cc (modified) (2 diffs)
• Tuples/Explode.cc (modified) (1 diff)
• Tuples/Tuples.cc (modified) (1 diff)

src/AST/Copy.hpp

@@ -121 +121 @@
         Pass< DeepCopyCore > dc;
         node_t const * newRoot = localRoot->accept( dc );
-        dc.pass.readonlyUpdates();
+        dc.core.readonlyUpdates();
         return const_cast< node_t * >( newRoot );
 }

src/AST/GenericSubstitution.cpp

@@ -62 +62 @@
         Pass<GenericSubstitutionBuilder> builder;
         maybe_accept( ty, builder );
-        return std::move(builder.pass.sub);
+        return std::move(builder.core.sub);
 }
 

src/AST/Pass.hpp

@@ -66 +66 @@
 // | WithForallSubstitutor - maintains links between TypeInstType and TypeDecl under mutation
 //-------------------------------------------------------------------------------------------------
-template< typename pass_t >
+template< typename core_t >
 class Pass final : public ast::Visitor {
 public:
+        using core_type = core_t;
+        using type = Pass<core_t>;
+
         /// Forward any arguments to the pass constructor
         /// Propagate 'this' if necessary
         template< typename... Args >
         Pass( Args &&... args)
-                : pass( std::forward<Args>( args )... )
+                : core( std::forward<Args>( args )... )
         {
                 // After the pass is constructed, check if it wants the have a pointer to the wrapping visitor
-                typedef Pass<pass_t> this_t;
-                this_t * const * visitor = __pass::visitor(pass, 0);
+                type * const * visitor = __pass::visitor(core, 0);
                 if(visitor) {
-                        *const_cast<this_t **>( visitor ) = this;
+                        *const_cast<type **>( visitor ) = this;
                 }
         }
@@ -88 +90 @@
         template< typename... Args >
         static void run( std::list< ptr<Decl> > & decls, Args &&... args ) {
-                Pass<pass_t> visitor( std::forward<Args>( args )... );
+                Pass<core_t> visitor( std::forward<Args>( args )... );
                 accept_all( decls, visitor );
         }
 
         /// Storage for the actual pass
-        pass_t pass;
+        core_t core;
 
         /// Visit function declarations
@@ -189 +191 @@
         const ast::TypeSubstitution * visit( const ast::TypeSubstitution     * ) override final;
 
-        template<typename pass_type>
-        friend void accept_all( std::list< ptr<Decl> > & decls, Pass<pass_type>& visitor );
+        template<typename core_type>
+        friend void accept_all( std::list< ptr<Decl> > & decls, Pass<core_type>& visitor );
 private:
 
-        bool __visit_children() { __pass::bool_ref * ptr = __pass::visit_children(pass, 0); return ptr ? *ptr : true; }
+        bool __visit_children() { __pass::bool_ref * ptr = __pass::visit_children(core, 0); return ptr ? *ptr : true; }
 
 private:
@@ -224 +226 @@
         /// Internal RAII guard for symbol table features
         struct guard_symtab {
-                guard_symtab( Pass<pass_t> & pass ): pass( pass ) { __pass::symtab::enter(pass.pass, 0); }
-                ~guard_symtab()                                   { __pass::symtab::leave(pass.pass, 0); }
-                Pass<pass_t> & pass;
+                guard_symtab( Pass<core_t> & pass ): pass( pass ) { __pass::symtab::enter(pass.core, 0); }
+                ~guard_symtab()                                   { __pass::symtab::leave(pass.core, 0); }
+                Pass<core_t> & pass;
         };
 
         /// Internal RAII guard for scope features
         struct guard_scope {
-                guard_scope( Pass<pass_t> & pass ): pass( pass ) { __pass::scope::enter(pass.pass, 0); }
-                ~guard_scope()                                   { __pass::scope::leave(pass.pass, 0); }
-                Pass<pass_t> & pass;
+                guard_scope( Pass<core_t> & pass ): pass( pass ) { __pass::scope::enter(pass.core, 0); }
+                ~guard_scope()                                   { __pass::scope::leave(pass.core, 0); }
+                Pass<core_t> & pass;
         };
 
         /// Internal RAII guard for forall substitutions
         struct guard_forall_subs {
-                guard_forall_subs( Pass<pass_t> & pass, const ParameterizedType * type )
-                : pass( pass ), type( type ) { __pass::forall::enter(pass.pass, 0, type ); }
-                ~guard_forall_subs()         { __pass::forall::leave(pass.pass, 0, type ); }
-                Pass<pass_t> & pass;
+                guard_forall_subs( Pass<core_t> & pass, const ParameterizedType * type )
+                : pass( pass ), type( type ) { __pass::forall::enter(pass.core, 0, type ); }
+                ~guard_forall_subs()         { __pass::forall::leave(pass.core, 0, type ); }
+                Pass<core_t> & pass;
                 const ParameterizedType * type;
         };
@@ -250 +252 @@
 
 /// Apply a pass to an entire translation unit
-template<typename pass_t>
-void accept_all( std::list< ast::ptr<ast::Decl> > &, ast::Pass<pass_t> & visitor );
+template<typename core_t>
+void accept_all( std::list< ast::ptr<ast::Decl> > &, ast::Pass<core_t> & visitor );
 
 //-------------------------------------------------------------------------------------------------
@@ -291 +293 @@
         };
 
-        template< typename pass_t>
-        friend auto __pass::at_cleanup( pass_t & pass, int ) -> decltype( &pass.at_cleanup );
+        template< typename core_t>
+        friend auto __pass::at_cleanup( core_t & core, int ) -> decltype( &core.at_cleanup );
 public:
 
@@ -328 +330 @@
 
 /// Used to get a pointer to the pass with its wrapped type
-template<typename pass_t>
+template<typename core_t>
 struct WithVisitorRef {
-        Pass<pass_t> * const visitor = nullptr;
+        Pass<core_t> * const visitor = nullptr;
 };
 

src/AST/Pass.impl.hpp

@@ -25 +25 @@
         using namespace ast; \
         /* back-up the visit children */ \
-        __attribute__((unused)) ast::__pass::visit_children_guard guard1( ast::__pass::visit_children(pass, 0) ); \
+        __attribute__((unused)) ast::__pass::visit_children_guard guard1( ast::__pass::visit_children(core, 0) ); \
         /* setup the scope for passes that want to run code at exit */ \
-        __attribute__((unused)) ast::__pass::guard_value          guard2( ast::__pass::at_cleanup    (pass, 0) ); \
+        __attribute__((unused)) ast::__pass::guard_value          guard2( ast::__pass::at_cleanup    (core, 0) ); \
         /* begin tracing memory allocation if requested by this pass */ \
-        __pass::beginTrace( pass, 0 ); \
+        __pass::beginTrace( core, 0 ); \
         /* call the implementation of the previsit of this pass */ \
-        __pass::previsit( pass, node, 0 );
+        __pass::previsit( core, node, 0 );
 
 #define VISIT( code... ) \
@@ -42 +42 @@
 #define VISIT_END( type, node ) \
         /* call the implementation of the postvisit of this pass */ \
-        auto __return = __pass::postvisit( pass, node, 0 ); \
+        auto __return = __pass::postvisit( core, node, 0 ); \
         assertf(__return, "post visit should never return null"); \
         /* end tracing memory allocation if requested by this pass */ \
-        __pass::endTrace( pass, 0 ); \
+        __pass::endTrace( core, 0 ); \
         return __return;
 
@@ -123 +123 @@
         }
 
-        template< typename pass_t >
+        template< typename core_t >
         template< typename node_t >
-        auto ast::Pass< pass_t >::call_accept( const node_t * node )
+        auto ast::Pass< core_t >::call_accept( const node_t * node )
                 -> typename std::enable_if<
                                 !std::is_base_of<ast::Expr, node_t>::value &&
@@ -141 +141 @@
         }
 
-        template< typename pass_t >
-        const ast::Expr * ast::Pass< pass_t >::call_accept( const ast::Expr * expr ) {
+        template< typename core_t >
+        const ast::Expr * ast::Pass< core_t >::call_accept( const ast::Expr * expr ) {
                 __pedantic_pass_assert( __visit_children() );
                 __pedantic_pass_assert( expr );
 
-                const ast::TypeSubstitution ** env_ptr = __pass::env( pass, 0);
+                const ast::TypeSubstitution ** env_ptr = __pass::env( core, 0);
                 if ( env_ptr && expr->env ) {
                         *env_ptr = expr->env;
@@ -154 +154 @@
         }
 
-        template< typename pass_t >
-        const ast::Stmt * ast::Pass< pass_t >::call_accept( const ast::Stmt * stmt ) {
+        template< typename core_t >
+        const ast::Stmt * ast::Pass< core_t >::call_accept( const ast::Stmt * stmt ) {
                 __pedantic_pass_assert( __visit_children() );
                 __pedantic_pass_assert( stmt );
@@ -163 +163 @@
 
                 // get the stmts/decls that will need to be spliced in
-                auto stmts_before = __pass::stmtsToAddBefore( pass, 0);
-                auto stmts_after  = __pass::stmtsToAddAfter ( pass, 0);
-                auto decls_before = __pass::declsToAddBefore( pass, 0);
-                auto decls_after  = __pass::declsToAddAfter ( pass, 0);
+                auto stmts_before = __pass::stmtsToAddBefore( core, 0);
+                auto stmts_after  = __pass::stmtsToAddAfter ( core, 0);
+                auto decls_before = __pass::declsToAddBefore( core, 0);
+                auto decls_after  = __pass::declsToAddAfter ( core, 0);
 
                 // These may be modified by subnode but most be restored once we exit this statemnet.
-                ValueGuardPtr< const ast::TypeSubstitution * > __old_env         ( __pass::env( pass, 0) );
+                ValueGuardPtr< const ast::TypeSubstitution * > __old_env         ( __pass::env( core, 0) );
                 ValueGuardPtr< typename std::remove_pointer< decltype(stmts_before) >::type > __old_decls_before( stmts_before );
                 ValueGuardPtr< typename std::remove_pointer< decltype(stmts_after ) >::type > __old_decls_after ( stmts_after  );
@@ -205 +205 @@
         }
 
-        template< typename pass_t >
+        template< typename core_t >
         template< template <class...> class container_t >
-        container_t< ptr<Stmt> > ast::Pass< pass_t >::call_accept( const container_t< ptr<Stmt> > & statements ) {
+        container_t< ptr<Stmt> > ast::Pass< core_t >::call_accept( const container_t< ptr<Stmt> > & statements ) {
                 __pedantic_pass_assert( __visit_children() );
                 if( statements.empty() ) return {};
@@ -218 +218 @@
 
                 // get the stmts/decls that will need to be spliced in
-                auto stmts_before = __pass::stmtsToAddBefore( pass, 0);
-                auto stmts_after  = __pass::stmtsToAddAfter ( pass, 0);
-                auto decls_before = __pass::declsToAddBefore( pass, 0);
-                auto decls_after  = __pass::declsToAddAfter ( pass, 0);
+                auto stmts_before = __pass::stmtsToAddBefore( core, 0);
+                auto stmts_after  = __pass::stmtsToAddAfter ( core, 0);
+                auto decls_before = __pass::declsToAddBefore( core, 0);
+                auto decls_after  = __pass::declsToAddAfter ( core, 0);
 
                 // These may be modified by subnode but most be restored once we exit this statemnet.
@@ -271 +271 @@
         }
 
-        template< typename pass_t >
+        template< typename core_t >
         template< template <class...> class container_t, typename node_t >
-        container_t< ast::ptr<node_t> > ast::Pass< pass_t >::call_accept( const container_t< ast::ptr<node_t> > & container ) {
+        container_t< ast::ptr<node_t> > ast::Pass< core_t >::call_accept( const container_t< ast::ptr<node_t> > & container ) {
                 __pedantic_pass_assert( __visit_children() );
                 if( container.empty() ) return {};
@@ -302 +302 @@
         }
 
-        template< typename pass_t >
+        template< typename core_t >
         template<typename node_t, typename parent_t, typename child_t>
-        void ast::Pass< pass_t >::maybe_accept(
+        void ast::Pass< core_t >::maybe_accept(
                 const node_t * & parent,
                 child_t parent_t::*child
@@ -327 +327 @@
 
 
-        template< typename pass_t >
+        template< typename core_t >
         template< typename node_t >
-        void ast::Pass< pass_t >::mutate_forall( const node_t *& node ) {
-                if ( auto subs = __pass::forall::subs( pass, 0 ) ) {
+        void ast::Pass< core_t >::mutate_forall( const node_t *& node ) {
+                if ( auto subs = __pass::forall::subs( core, 0 ) ) {
                         // tracking TypeDecl substitution, full clone
                         if ( node->forall.empty() ) return;
@@ -352 +352 @@
 //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
-template< typename pass_t >
-inline void ast::accept_all( std::list< ast::ptr<ast::Decl> > & decls, ast::Pass< pass_t > & visitor ) {
+template< typename core_t >
+inline void ast::accept_all( std::list< ast::ptr<ast::Decl> > & decls, ast::Pass< core_t > & visitor ) {
         // We are going to aggregate errors for all these statements
         SemanticErrorException errors;
@@ -361 +361 @@
 
         // get the stmts/decls that will need to be spliced in
-        auto decls_before = __pass::declsToAddBefore( visitor.pass, 0);
-        auto decls_after  = __pass::declsToAddAfter ( visitor.pass, 0);
+        auto decls_before = __pass::declsToAddBefore( visitor.core, 0);
+        auto decls_after  = __pass::declsToAddAfter ( visitor.core, 0);
 
         // update pass statitistics
@@ -411 +411 @@
 //--------------------------------------------------------------------------
 // ObjectDecl
-template< typename pass_t >
-const ast::DeclWithType * ast::Pass< pass_t >::visit( const ast::ObjectDecl * node ) {
+template< typename core_t >
+const ast::DeclWithType * ast::Pass< core_t >::visit( const ast::ObjectDecl * node ) {
         VISIT_START( node );
 
@@ -425 +425 @@
         )
 
-        __pass::symtab::addId( pass, 0, node );
+        __pass::symtab::addId( core, 0, node );
 
         VISIT_END( DeclWithType, node );
@@ -432 +432 @@
 //--------------------------------------------------------------------------
 // FunctionDecl
-template< typename pass_t >
-const ast::DeclWithType * ast::Pass< pass_t >::visit( const ast::FunctionDecl * node ) {
-        VISIT_START( node );
-
-        __pass::symtab::addId( pass, 0, node );
+template< typename core_t >
+const ast::DeclWithType * ast::Pass< core_t >::visit( const ast::FunctionDecl * node ) {
+        VISIT_START( node );
+
+        __pass::symtab::addId( core, 0, node );
 
         VISIT(maybe_accept( node, &FunctionDecl::withExprs );)
@@ -444 +444 @@
                 // shadow with exprs and not the other way around.
                 guard_symtab guard { *this };
-                __pass::symtab::addWith( pass, 0, node->withExprs, node );
+                __pass::symtab::addWith( core, 0, node->withExprs, node );
                 {
                         guard_symtab guard { *this };
@@ -455 +455 @@
                                 }
                         } };
-                        __pass::symtab::addId( pass, 0, func );
+                        __pass::symtab::addId( core, 0, func );
                         VISIT(
                                 maybe_accept( node, &FunctionDecl::type );
@@ -473 +473 @@
 //--------------------------------------------------------------------------
 // StructDecl
-template< typename pass_t >
-const ast::Decl * ast::Pass< pass_t >::visit( const ast::StructDecl * node ) {
+template< typename core_t >
+const ast::Decl * ast::Pass< core_t >::visit( const ast::StructDecl * 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
-        __pass::symtab::addStructFwd( pass, 0, node );
+        __pass::symtab::addStructFwd( core, 0, node );
 
         VISIT({
@@ -488 +488 @@
 
         // this addition replaces the forward declaration
-        __pass::symtab::addStruct( pass, 0, node );
+        __pass::symtab::addStruct( core, 0, node );
 
         VISIT_END( Decl, node );
@@ -495 +495 @@
 //--------------------------------------------------------------------------
 // UnionDecl
-template< typename pass_t >
-const ast::Decl * ast::Pass< pass_t >::visit( const ast::UnionDecl * node ) {
+template< typename core_t >
+const ast::Decl * ast::Pass< core_t >::visit( const ast::UnionDecl * node ) {
         VISIT_START( node );
 
         // make up a forward declaration and add it before processing the members
-        __pass::symtab::addUnionFwd( pass, 0, node );
+        __pass::symtab::addUnionFwd( core, 0, node );
 
         VISIT({
@@ -508 +508 @@
         })
 
-        __pass::symtab::addUnion( pass, 0, node );
+        __pass::symtab::addUnion( core, 0, node );
 
         VISIT_END( Decl, node );
@@ -515 +515 @@
 //--------------------------------------------------------------------------
 // EnumDecl
-template< typename pass_t >
-const ast::Decl * ast::Pass< pass_t >::visit( const ast::EnumDecl * node ) {
-        VISIT_START( node );
-
-        __pass::symtab::addEnum( pass, 0, node );
+template< typename core_t >
+const ast::Decl * ast::Pass< core_t >::visit( const ast::EnumDecl * node ) {
+        VISIT_START( node );
+
+        __pass::symtab::addEnum( core, 0, node );
 
         VISIT(
@@ -532 +532 @@
 //--------------------------------------------------------------------------
 // TraitDecl
-template< typename pass_t >
-const ast::Decl * ast::Pass< pass_t >::visit( const ast::TraitDecl * node ) {
+template< typename core_t >
+const ast::Decl * ast::Pass< core_t >::visit( const ast::TraitDecl * node ) {
         VISIT_START( node );
 
@@ -542 +542 @@
         })
 
-        __pass::symtab::addTrait( pass, 0, node );
+        __pass::symtab::addTrait( core, 0, node );
 
         VISIT_END( Decl, node );
@@ -549 +549 @@
 //--------------------------------------------------------------------------
 // TypeDecl
-template< typename pass_t >
-const ast::Decl * ast::Pass< pass_t >::visit( const ast::TypeDecl * node ) {
+template< typename core_t >
+const ast::Decl * ast::Pass< core_t >::visit( const ast::TypeDecl * node ) {
         VISIT_START( node );
 
@@ -562 +562 @@
         // note that assertions come after the type is added to the symtab, since they are not part of the type proper
         // and may depend on the type itself
-        __pass::symtab::addType( pass, 0, node );
+        __pass::symtab::addType( core, 0, node );
 
         VISIT(
@@ -578 +578 @@
 //--------------------------------------------------------------------------
 // TypedefDecl
-template< typename pass_t >
-const ast::Decl * ast::Pass< pass_t >::visit( const ast::TypedefDecl * node ) {
+template< typename core_t >
+const ast::Decl * ast::Pass< core_t >::visit( const ast::TypedefDecl * node ) {
         VISIT_START( node );
 
@@ -588 +588 @@
         })
 
-        __pass::symtab::addType( pass, 0, node );
+        __pass::symtab::addType( core, 0, node );
 
         VISIT( maybe_accept( node, &TypedefDecl::assertions ); )
@@ -597 +597 @@
 //--------------------------------------------------------------------------
 // AsmDecl
-template< typename pass_t >
-const ast::AsmDecl * ast::Pass< pass_t >::visit( const ast::AsmDecl * node ) {
+template< typename core_t >
+const ast::AsmDecl * ast::Pass< core_t >::visit( const ast::AsmDecl * node ) {
         VISIT_START( node );
 
@@ -610 +610 @@
 //--------------------------------------------------------------------------
 // StaticAssertDecl
-template< typename pass_t >
-const ast::StaticAssertDecl * ast::Pass< pass_t >::visit( const ast::StaticAssertDecl * node ) {
+template< typename core_t >
+const ast::StaticAssertDecl * ast::Pass< core_t >::visit( const ast::StaticAssertDecl * node ) {
         VISIT_START( node );
 
@@ -624 +624 @@
 //--------------------------------------------------------------------------
 // CompoundStmt
-template< typename pass_t >
-const ast::CompoundStmt * ast::Pass< pass_t >::visit( const ast::CompoundStmt * node ) {
+template< typename core_t >
+const ast::CompoundStmt * ast::Pass< core_t >::visit( const ast::CompoundStmt * node ) {
         VISIT_START( node );
         VISIT({
                 // do not enter a new scope if inFunction is true - needs to check old state before the assignment
                 auto guard1 = makeFuncGuard( [this, inFunctionCpy = this->inFunction]() {
-                        if ( ! inFunctionCpy ) __pass::symtab::enter(pass, 0);
+                        if ( ! inFunctionCpy ) __pass::symtab::enter(core, 0);
                 }, [this, inFunctionCpy = this->inFunction]() {
-                        if ( ! inFunctionCpy ) __pass::symtab::leave(pass, 0);
+                        if ( ! inFunctionCpy ) __pass::symtab::leave(core, 0);
                 });
                 ValueGuard< bool > guard2( inFunction );
@@ -644 +644 @@
 //--------------------------------------------------------------------------
 // ExprStmt
-template< typename pass_t >
-const ast::Stmt * ast::Pass< pass_t >::visit( const ast::ExprStmt * node ) {
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::ExprStmt * node ) {
         VISIT_START( node );
 
@@ -657 +657 @@
 //--------------------------------------------------------------------------
 // AsmStmt
-template< typename pass_t >
-const ast::Stmt * ast::Pass< pass_t >::visit( const ast::AsmStmt * node ) {
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::AsmStmt * node ) {
         VISIT_START( node )
 
@@ -673 +673 @@
 //--------------------------------------------------------------------------
 // DirectiveStmt
-template< typename pass_t >
-const ast::Stmt * ast::Pass< pass_t >::visit( const ast::DirectiveStmt * node ) {
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::DirectiveStmt * node ) {
         VISIT_START( node )
 
@@ -682 +682 @@
 //--------------------------------------------------------------------------
 // IfStmt
-template< typename pass_t >
-const ast::Stmt * ast::Pass< pass_t >::visit( const ast::IfStmt * node ) {
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::IfStmt * node ) {
         VISIT_START( node );
 
@@ -700 +700 @@
 //--------------------------------------------------------------------------
 // WhileStmt
-template< typename pass_t >
-const ast::Stmt * ast::Pass< pass_t >::visit( const ast::WhileStmt * node ) {
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::WhileStmt * node ) {
         VISIT_START( node );
 
@@ -717 +717 @@
 //--------------------------------------------------------------------------
 // ForStmt
-template< typename pass_t >
-const ast::Stmt * ast::Pass< pass_t >::visit( const ast::ForStmt * node ) {
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::ForStmt * node ) {
         VISIT_START( node );
 
@@ -735 +735 @@
 //--------------------------------------------------------------------------
 // SwitchStmt
-template< typename pass_t >
-const ast::Stmt * ast::Pass< pass_t >::visit( const ast::SwitchStmt * node ) {
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::SwitchStmt * node ) {
         VISIT_START( node );
 
@@ -749 +749 @@
 //--------------------------------------------------------------------------
 // CaseStmt
-template< typename pass_t >
-const ast::Stmt * ast::Pass< pass_t >::visit( const ast::CaseStmt * node ) {
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::CaseStmt * node ) {
         VISIT_START( node );
 
@@ -763 +763 @@
 //--------------------------------------------------------------------------
 // BranchStmt
-template< typename pass_t >
-const ast::Stmt * ast::Pass< pass_t >::visit( const ast::BranchStmt * node ) {
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::BranchStmt * node ) {
         VISIT_START( node );
         VISIT_END( Stmt, node );
@@ -771 +771 @@
 //--------------------------------------------------------------------------
 // ReturnStmt
-template< typename pass_t >
-const ast::Stmt * ast::Pass< pass_t >::visit( const ast::ReturnStmt * node ) {
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::ReturnStmt * node ) {
         VISIT_START( node );
 
@@ -784 +784 @@
 //--------------------------------------------------------------------------
 // ThrowStmt
-template< typename pass_t >
-const ast::Stmt * ast::Pass< pass_t >::visit( const ast::ThrowStmt * node ) {
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::ThrowStmt * node ) {
         VISIT_START( node );
 
@@ -798 +798 @@
 //--------------------------------------------------------------------------
 // TryStmt
-template< typename pass_t >
-const ast::Stmt * ast::Pass< pass_t >::visit( const ast::TryStmt * node ) {
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::TryStmt * node ) {
         VISIT_START( node );
 
@@ -813 +813 @@
 //--------------------------------------------------------------------------
 // CatchStmt
-template< typename pass_t >
-const ast::Stmt * ast::Pass< pass_t >::visit( const ast::CatchStmt * node ) {
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::CatchStmt * node ) {
         VISIT_START( node );
 
@@ -830 +830 @@
 //--------------------------------------------------------------------------
 // FinallyStmt
-template< typename pass_t >
-const ast::Stmt * ast::Pass< pass_t >::visit( const ast::FinallyStmt * node ) {
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::FinallyStmt * node ) {
         VISIT_START( node );
 
@@ -843 +843 @@
 //--------------------------------------------------------------------------
 // FinallyStmt
-template< typename pass_t >
-const ast::Stmt * ast::Pass< pass_t >::visit( const ast::SuspendStmt * node ) {
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::SuspendStmt * node ) {
         VISIT_START( node );
 
@@ -856 +856 @@
 //--------------------------------------------------------------------------
 // WaitForStmt
-template< typename pass_t >
-const ast::Stmt * ast::Pass< pass_t >::visit( const ast::WaitForStmt * node ) {
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::WaitForStmt * node ) {
         VISIT_START( node );
                 // for( auto & clause : node->clauses ) {
@@ -925 +925 @@
 //--------------------------------------------------------------------------
 // WithStmt
-template< typename pass_t >
-const ast::Decl * ast::Pass< pass_t >::visit( const ast::WithStmt * node ) {
+template< typename core_t >
+const ast::Decl * ast::Pass< core_t >::visit( const ast::WithStmt * node ) {
         VISIT_START( node );
 
@@ -934 +934 @@
                         // catch statements introduce a level of scope (for the caught exception)
                         guard_symtab guard { *this };
-                        __pass::symtab::addWith( pass, 0, node->exprs, node );
+                        __pass::symtab::addWith( core, 0, node->exprs, node );
                         maybe_accept( node, &WithStmt::stmt );
                 }
@@ -943 +943 @@
 //--------------------------------------------------------------------------
 // NullStmt
-template< typename pass_t >
-const ast::NullStmt * ast::Pass< pass_t >::visit( const ast::NullStmt * node ) {
+template< typename core_t >
+const ast::NullStmt * ast::Pass< core_t >::visit( const ast::NullStmt * node ) {
         VISIT_START( node );
         VISIT_END( NullStmt, node );
@@ -951 +951 @@
 //--------------------------------------------------------------------------
 // DeclStmt
-template< typename pass_t >
-const ast::Stmt * ast::Pass< pass_t >::visit( const ast::DeclStmt * node ) {
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::DeclStmt * node ) {
         VISIT_START( node );
 
@@ -964 +964 @@
 //--------------------------------------------------------------------------
 // ImplicitCtorDtorStmt
-template< typename pass_t >
-const ast::Stmt * ast::Pass< pass_t >::visit( const ast::ImplicitCtorDtorStmt * node ) {
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::ImplicitCtorDtorStmt * node ) {
         VISIT_START( node );
 
@@ -979 +979 @@
 //--------------------------------------------------------------------------
 // ApplicationExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::ApplicationExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::ApplicationExpr * node ) {
         VISIT_START( node );
 
@@ -997 +997 @@
 //--------------------------------------------------------------------------
 // UntypedExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::UntypedExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedExpr * node ) {
         VISIT_START( node );
 
@@ -1015 +1015 @@
 //--------------------------------------------------------------------------
 // NameExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::NameExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::NameExpr * node ) {
         VISIT_START( node );
 
@@ -1029 +1029 @@
 //--------------------------------------------------------------------------
 // CastExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::CastExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::CastExpr * node ) {
         VISIT_START( node );
 
@@ -1045 +1045 @@
 //--------------------------------------------------------------------------
 // KeywordCastExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::KeywordCastExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::KeywordCastExpr * node ) {
         VISIT_START( node );
 
@@ -1061 +1061 @@
 //--------------------------------------------------------------------------
 // VirtualCastExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::VirtualCastExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::VirtualCastExpr * node ) {
         VISIT_START( node );
 
@@ -1077 +1077 @@
 //--------------------------------------------------------------------------
 // AddressExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::AddressExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::AddressExpr * node ) {
         VISIT_START( node );
 
@@ -1093 +1093 @@
 //--------------------------------------------------------------------------
 // LabelAddressExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::LabelAddressExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::LabelAddressExpr * node ) {
         VISIT_START( node );
 
@@ -1107 +1107 @@
 //--------------------------------------------------------------------------
 // UntypedMemberExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::UntypedMemberExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedMemberExpr * node ) {
         VISIT_START( node );
 
@@ -1124 +1124 @@
 //--------------------------------------------------------------------------
 // MemberExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::MemberExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::MemberExpr * node ) {
         VISIT_START( node );
 
@@ -1140 +1140 @@
 //--------------------------------------------------------------------------
 // VariableExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::VariableExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::VariableExpr * node ) {
         VISIT_START( node );
 
@@ -1154 +1154 @@
 //--------------------------------------------------------------------------
 // ConstantExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::ConstantExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::ConstantExpr * node ) {
         VISIT_START( node );
 
@@ -1168 +1168 @@
 //--------------------------------------------------------------------------
 // SizeofExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::SizeofExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::SizeofExpr * node ) {
         VISIT_START( node );
 
@@ -1188 +1188 @@
 //--------------------------------------------------------------------------
 // AlignofExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::AlignofExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::AlignofExpr * node ) {
         VISIT_START( node );
 
@@ -1208 +1208 @@
 //--------------------------------------------------------------------------
 // UntypedOffsetofExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::UntypedOffsetofExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedOffsetofExpr * node ) {
         VISIT_START( node );
 
@@ -1224 +1224 @@
 //--------------------------------------------------------------------------
 // OffsetofExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::OffsetofExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::OffsetofExpr * node ) {
         VISIT_START( node );
 
@@ -1240 +1240 @@
 //--------------------------------------------------------------------------
 // OffsetPackExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::OffsetPackExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::OffsetPackExpr * node ) {
         VISIT_START( node );
 
@@ -1256 +1256 @@
 //--------------------------------------------------------------------------
 // LogicalExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::LogicalExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::LogicalExpr * node ) {
         VISIT_START( node );
 
@@ -1273 +1273 @@
 //--------------------------------------------------------------------------
 // ConditionalExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::ConditionalExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::ConditionalExpr * node ) {
         VISIT_START( node );
 
@@ -1291 +1291 @@
 //--------------------------------------------------------------------------
 // CommaExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::CommaExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::CommaExpr * node ) {
         VISIT_START( node );
 
@@ -1308 +1308 @@
 //--------------------------------------------------------------------------
 // TypeExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::TypeExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::TypeExpr * node ) {
         VISIT_START( node );
 
@@ -1324 +1324 @@
 //--------------------------------------------------------------------------
 // AsmExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::AsmExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::AsmExpr * node ) {
         VISIT_START( node );
 
@@ -1341 +1341 @@
 //--------------------------------------------------------------------------
 // ImplicitCopyCtorExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::ImplicitCopyCtorExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::ImplicitCopyCtorExpr * node ) {
         VISIT_START( node );
 
@@ -1357 +1357 @@
 //--------------------------------------------------------------------------
 // ConstructorExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::ConstructorExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::ConstructorExpr * node ) {
         VISIT_START( node );
 
@@ -1373 +1373 @@
 //--------------------------------------------------------------------------
 // CompoundLiteralExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::CompoundLiteralExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::CompoundLiteralExpr * node ) {
         VISIT_START( node );
 
@@ -1389 +1389 @@
 //--------------------------------------------------------------------------
 // RangeExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::RangeExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::RangeExpr * node ) {
         VISIT_START( node );
 
@@ -1406 +1406 @@
 //--------------------------------------------------------------------------
 // UntypedTupleExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::UntypedTupleExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedTupleExpr * node ) {
         VISIT_START( node );
 
@@ -1422 +1422 @@
 //--------------------------------------------------------------------------
 // TupleExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::TupleExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::TupleExpr * node ) {
         VISIT_START( node );
 
@@ -1438 +1438 @@
 //--------------------------------------------------------------------------
 // TupleIndexExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::TupleIndexExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::TupleIndexExpr * node ) {
         VISIT_START( node );
 
@@ -1454 +1454 @@
 //--------------------------------------------------------------------------
 // TupleAssignExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::TupleAssignExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::TupleAssignExpr * node ) {
         VISIT_START( node );
 
@@ -1470 +1470 @@
 //--------------------------------------------------------------------------
 // StmtExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::StmtExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::StmtExpr * node ) {
         VISIT_START( node );
 
         VISIT(// don't want statements from outer CompoundStmts to be added to this StmtExpr
                 // get the stmts that will need to be spliced in
-                auto stmts_before = __pass::stmtsToAddBefore( pass, 0);
-                auto stmts_after  = __pass::stmtsToAddAfter ( pass, 0);
+                auto stmts_before = __pass::stmtsToAddBefore( core, 0);
+                auto stmts_after  = __pass::stmtsToAddAfter ( core, 0);
 
                 // These may be modified by subnode but most be restored once we exit this statemnet.
-                ValueGuardPtr< const ast::TypeSubstitution * > __old_env( __pass::env( pass, 0) );
+                ValueGuardPtr< const ast::TypeSubstitution * > __old_env( __pass::env( core, 0) );
                 ValueGuardPtr< typename std::remove_pointer< decltype(stmts_before) >::type > __old_decls_before( stmts_before );
                 ValueGuardPtr< typename std::remove_pointer< decltype(stmts_after ) >::type > __old_decls_after ( stmts_after  );
@@ -1498 +1498 @@
 //--------------------------------------------------------------------------
 // UniqueExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::UniqueExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::UniqueExpr * node ) {
         VISIT_START( node );
 
@@ -1514 +1514 @@
 //--------------------------------------------------------------------------
 // UntypedInitExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::UntypedInitExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedInitExpr * node ) {
         VISIT_START( node );
 
@@ -1531 +1531 @@
 //--------------------------------------------------------------------------
 // InitExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::InitExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::InitExpr * node ) {
         VISIT_START( node );
 
@@ -1548 +1548 @@
 //--------------------------------------------------------------------------
 // DeletedExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::DeletedExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::DeletedExpr * node ) {
         VISIT_START( node );
 
@@ -1565 +1565 @@
 //--------------------------------------------------------------------------
 // DefaultArgExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::DefaultArgExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::DefaultArgExpr * node ) {
         VISIT_START( node );
 
@@ -1581 +1581 @@
 //--------------------------------------------------------------------------
 // GenericExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::GenericExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::GenericExpr * node ) {
         VISIT_START( node );
 
@@ -1621 +1621 @@
 //--------------------------------------------------------------------------
 // VoidType
-template< typename pass_t >
-const ast::Type * ast::Pass< pass_t >::visit( const ast::VoidType * node ) {
+template< typename core_t >
+const ast::Type * ast::Pass< core_t >::visit( const ast::VoidType * node ) {
         VISIT_START( node );
 
@@ -1630 +1630 @@
 //--------------------------------------------------------------------------
 // BasicType
-template< typename pass_t >
-const ast::Type * ast::Pass< pass_t >::visit( const ast::BasicType * node ) {
+template< typename core_t >
+const ast::Type * ast::Pass< core_t >::visit( const ast::BasicType * node ) {
         VISIT_START( node );
 
@@ -1639 +1639 @@
 //--------------------------------------------------------------------------
 // PointerType
-template< typename pass_t >
-const ast::Type * ast::Pass< pass_t >::visit( const ast::PointerType * node ) {
+template< typename core_t >
+const ast::Type * ast::Pass< core_t >::visit( const ast::PointerType * node ) {
         VISIT_START( node );
 
@@ -1653 +1653 @@
 //--------------------------------------------------------------------------
 // ArrayType
-template< typename pass_t >
-const ast::Type * ast::Pass< pass_t >::visit( const ast::ArrayType * node ) {
+template< typename core_t >
+const ast::Type * ast::Pass< core_t >::visit( const ast::ArrayType * node ) {
         VISIT_START( node );
 
@@ -1667 +1667 @@
 //--------------------------------------------------------------------------
 // ReferenceType
-template< typename pass_t >
-const ast::Type * ast::Pass< pass_t >::visit( const ast::ReferenceType * node ) {
+template< typename core_t >
+const ast::Type * ast::Pass< core_t >::visit( const ast::ReferenceType * node ) {
         VISIT_START( node );
 
@@ -1680 +1680 @@
 //--------------------------------------------------------------------------
 // QualifiedType
-template< typename pass_t >
-const ast::Type * ast::Pass< pass_t >::visit( const ast::QualifiedType * node ) {
+template< typename core_t >
+const ast::Type * ast::Pass< core_t >::visit( const ast::QualifiedType * node ) {
         VISIT_START( node );
 
@@ -1694 +1694 @@
 //--------------------------------------------------------------------------
 // FunctionType
-template< typename pass_t >
-const ast::Type * ast::Pass< pass_t >::visit( const ast::FunctionType * node ) {
+template< typename core_t >
+const ast::Type * ast::Pass< core_t >::visit( const ast::FunctionType * node ) {
         VISIT_START( node );
 
@@ -1710 +1710 @@
 //--------------------------------------------------------------------------
 // StructInstType
-template< typename pass_t >
-const ast::Type * ast::Pass< pass_t >::visit( const ast::StructInstType * node ) {
-        VISIT_START( node );
-
-        __pass::symtab::addStruct( pass, 0, node->name );
+template< typename core_t >
+const ast::Type * ast::Pass< core_t >::visit( const ast::StructInstType * node ) {
+        VISIT_START( node );
+
+        __pass::symtab::addStruct( core, 0, node->name );
 
         VISIT({
@@ -1728 +1728 @@
 //--------------------------------------------------------------------------
 // UnionInstType
-template< typename pass_t >
-const ast::Type * ast::Pass< pass_t >::visit( const ast::UnionInstType * node ) {
-        VISIT_START( node );
-
-        __pass::symtab::addUnion( pass, 0, node->name );
+template< typename core_t >
+const ast::Type * ast::Pass< core_t >::visit( const ast::UnionInstType * node ) {
+        VISIT_START( node );
+
+        __pass::symtab::addUnion( core, 0, node->name );
 
         VISIT({
@@ -1746 +1746 @@
 //--------------------------------------------------------------------------
 // EnumInstType
-template< typename pass_t >
-const ast::Type * ast::Pass< pass_t >::visit( const ast::EnumInstType * node ) {
+template< typename core_t >
+const ast::Type * ast::Pass< core_t >::visit( const ast::EnumInstType * node ) {
         VISIT_START( node );
 
@@ -1761 +1761 @@
 //--------------------------------------------------------------------------
 // TraitInstType
-template< typename pass_t >
-const ast::Type * ast::Pass< pass_t >::visit( const ast::TraitInstType * node ) {
+template< typename core_t >
+const ast::Type * ast::Pass< core_t >::visit( const ast::TraitInstType * node ) {
         VISIT_START( node );
 
@@ -1776 +1776 @@
 //--------------------------------------------------------------------------
 // TypeInstType
-template< typename pass_t >
-const ast::Type * ast::Pass< pass_t >::visit( const ast::TypeInstType * node ) {
+template< typename core_t >
+const ast::Type * ast::Pass< core_t >::visit( const ast::TypeInstType * node ) {
         VISIT_START( node );
 
@@ -1787 +1787 @@
                 }
                 // ensure that base re-bound if doing substitution
-                __pass::forall::replace( pass, 0, node );
+                __pass::forall::replace( core, 0, node );
         )
 
@@ -1795 +1795 @@
 //--------------------------------------------------------------------------
 // TupleType
-template< typename pass_t >
-const ast::Type * ast::Pass< pass_t >::visit( const ast::TupleType * node ) {
+template< typename core_t >
+const ast::Type * ast::Pass< core_t >::visit( const ast::TupleType * node ) {
         VISIT_START( node );
 
@@ -1809 +1809 @@
 //--------------------------------------------------------------------------
 // TypeofType
-template< typename pass_t >
-const ast::Type * ast::Pass< pass_t >::visit( const ast::TypeofType * node ) {
+template< typename core_t >
+const ast::Type * ast::Pass< core_t >::visit( const ast::TypeofType * node ) {
         VISIT_START( node );
 
@@ -1822 +1822 @@
 //--------------------------------------------------------------------------
 // VarArgsType
-template< typename pass_t >
-const ast::Type * ast::Pass< pass_t >::visit( const ast::VarArgsType * node ) {
+template< typename core_t >
+const ast::Type * ast::Pass< core_t >::visit( const ast::VarArgsType * node ) {
         VISIT_START( node );
 
@@ -1831 +1831 @@
 //--------------------------------------------------------------------------
 // ZeroType
-template< typename pass_t >
-const ast::Type * ast::Pass< pass_t >::visit( const ast::ZeroType * node ) {
+template< typename core_t >
+const ast::Type * ast::Pass< core_t >::visit( const ast::ZeroType * node ) {
         VISIT_START( node );
 
@@ -1840 +1840 @@
 //--------------------------------------------------------------------------
 // OneType
-template< typename pass_t >
-const ast::Type * ast::Pass< pass_t >::visit( const ast::OneType * node ) {
+template< typename core_t >
+const ast::Type * ast::Pass< core_t >::visit( const ast::OneType * node ) {
         VISIT_START( node );
 
@@ -1849 +1849 @@
 //--------------------------------------------------------------------------
 // GlobalScopeType
-template< typename pass_t >
-const ast::Type * ast::Pass< pass_t >::visit( const ast::GlobalScopeType * node ) {
+template< typename core_t >
+const ast::Type * ast::Pass< core_t >::visit( const ast::GlobalScopeType * node ) {
         VISIT_START( node );
 
@@ -1859 +1859 @@
 //--------------------------------------------------------------------------
 // Designation
-template< typename pass_t >
-const ast::Designation * ast::Pass< pass_t >::visit( const ast::Designation * node ) {
+template< typename core_t >
+const ast::Designation * ast::Pass< core_t >::visit( const ast::Designation * node ) {
         VISIT_START( node );
 
@@ -1870 +1870 @@
 //--------------------------------------------------------------------------
 // SingleInit
-template< typename pass_t >
-const ast::Init * ast::Pass< pass_t >::visit( const ast::SingleInit * node ) {
+template< typename core_t >
+const ast::Init * ast::Pass< core_t >::visit( const ast::SingleInit * node ) {
         VISIT_START( node );
 
@@ -1883 +1883 @@
 //--------------------------------------------------------------------------
 // ListInit
-template< typename pass_t >
-const ast::Init * ast::Pass< pass_t >::visit( const ast::ListInit * node ) {
+template< typename core_t >
+const ast::Init * ast::Pass< core_t >::visit( const ast::ListInit * node ) {
         VISIT_START( node );
 
@@ -1897 +1897 @@
 //--------------------------------------------------------------------------
 // ConstructorInit
-template< typename pass_t >
-const ast::Init * ast::Pass< pass_t >::visit( const ast::ConstructorInit * node ) {
+template< typename core_t >
+const ast::Init * ast::Pass< core_t >::visit( const ast::ConstructorInit * node ) {
         VISIT_START( node );
 
@@ -1912 +1912 @@
 //--------------------------------------------------------------------------
 // Attribute
-template< typename pass_t >
-const ast::Attribute * ast::Pass< pass_t >::visit( const ast::Attribute * node  )  {
+template< typename core_t >
+const ast::Attribute * ast::Pass< core_t >::visit( const ast::Attribute * node  )  {
         VISIT_START( node );
 
@@ -1925 +1925 @@
 //--------------------------------------------------------------------------
 // TypeSubstitution
-template< typename pass_t >
-const ast::TypeSubstitution * ast::Pass< pass_t >::visit( const ast::TypeSubstitution * node ) {
+template< typename core_t >
+const ast::TypeSubstitution * ast::Pass< core_t >::visit( const ast::TypeSubstitution * node ) {
         VISIT_START( node );
 

src/AST/Pass.proto.hpp

@@ -20 +20 @@
 
 namespace ast {
-template<typename pass_type>
+template<typename core_t>
 class Pass;
 
@@ -113 +113 @@
         /// "Short hand" to check if this is a valid previsit function
         /// Mostly used to make the static_assert look (and print) prettier
-        template<typename pass_t, typename node_t>
+        template<typename core_t, typename node_t>
         struct is_valid_previsit {
-                using ret_t = decltype( ((pass_t*)nullptr)->previsit( (const node_t *)nullptr ) );
+                using ret_t = decltype( ((core_t*)nullptr)->previsit( (const node_t *)nullptr ) );
 
                 static constexpr bool value = std::is_void< ret_t >::value ||
@@ -129 +129 @@
         template<>
         struct __assign<true> {
-                template<typename pass_t, typename node_t>
-                static inline void result( pass_t & pass, const node_t * & node ) {
-                        pass.previsit( node );
+                template<typename core_t, typename node_t>
+                static inline void result( core_t & core, const node_t * & node ) {
+                        core.previsit( node );
                 }
         };
@@ -137 +137 @@
         template<>
         struct __assign<false> {
-                template<typename pass_t, typename node_t>
-                static inline void result( pass_t & pass, const node_t * & node ) {
-                        node = pass.previsit( node );
+                template<typename core_t, typename node_t>
+                static inline void result( core_t & core, const node_t * & node ) {
+                        node = core.previsit( node );
                         assertf(node, "Previsit must not return NULL");
                 }
@@ -152 +152 @@
         template<>
         struct __return<true> {
-                template<typename pass_t, typename node_t>
-                static inline const node_t * result( pass_t & pass, const node_t * & node ) {
-                        pass.postvisit( node );
+                template<typename core_t, typename node_t>
+                static inline const node_t * result( core_t & core, const node_t * & node ) {
+                        core.postvisit( node );
                         return node;
                 }
@@ -161 +161 @@
         template<>
         struct __return<false> {
-                template<typename pass_t, typename node_t>
-                static inline auto result( pass_t & pass, const node_t * & node ) {
-                        return pass.postvisit( node );
+                template<typename core_t, typename node_t>
+                static inline auto result( core_t & core, const node_t * & node ) {
+                        return core.postvisit( node );
                 }
         };
@@ -182 +182 @@
         //-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
         // PreVisit : may mutate the pointer passed in if the node is mutated in the previsit call
-        template<typename pass_t, typename node_t>
-        static inline auto previsit( pass_t & pass, const node_t * & node, int ) -> decltype( pass.previsit( node ), void() ) {
+        template<typename core_t, typename node_t>
+        static inline auto previsit( core_t & core, const node_t * & node, int ) -> decltype( core.previsit( node ), void() ) {
                 static_assert(
-                        is_valid_previsit<pass_t, node_t>::value,
+                        is_valid_previsit<core_t, node_t>::value,
                         "Previsit may not change the type of the node. It must return its paremeter or void."
                 );
@@ -191 +191 @@
                 __assign<
                         std::is_void<
-                                decltype( pass.previsit( node ) )
+                                decltype( core.previsit( node ) )
                         >::value
-                >::result( pass, node );
+                >::result( core, node );
         }
 
-        template<typename pass_t, typename node_t>
-        static inline auto previsit( pass_t &, const node_t *, long ) {}
+        template<typename core_t, typename node_t>
+        static inline auto previsit( core_t &, const node_t *, long ) {}
 
         // PostVisit : never mutates the passed pointer but may return a different node
-        template<typename pass_t, typename node_t>
-        static inline auto postvisit( pass_t & pass, const node_t * node, int ) ->
-                decltype( pass.postvisit( node ), node->accept( *(Visitor*)nullptr ) )
+        template<typename core_t, typename node_t>
+        static inline auto postvisit( core_t & core, const node_t * node, int ) ->
+                decltype( core.postvisit( node ), node->accept( *(Visitor*)nullptr ) )
         {
                 return __return<
                         std::is_void<
-                                decltype( pass.postvisit( node ) )
+                                decltype( core.postvisit( node ) )
                         >::value
-                >::result( pass, node );
+                >::result( core, node );
         }
 
-        template<typename pass_t, typename node_t>
-        static inline const node_t * postvisit( pass_t &, const node_t * node, long ) { return node; }
+        template<typename core_t, typename node_t>
+        static inline const node_t * postvisit( core_t &, const node_t * node, long ) { return node; }
 
         //-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
@@ -227 +227 @@
         // The type is not strictly enforced but does match the accessory
         #define FIELD_PTR( name, default_type ) \
-        template< typename pass_t > \
-        static inline auto name( pass_t & pass, int ) -> decltype( &pass.name ) { return &pass.name; } \
+        template< typename core_t > \
+        static inline auto name( core_t & core, int ) -> decltype( &core.name ) { return &core.name; } \
         \
-        template< typename pass_t > \
-        static inline default_type * name( pass_t &, long ) { return nullptr; }
+        template< typename core_t > \
+        static inline default_type * name( core_t &, long ) { return nullptr; }
 
         // List of fields and their expected types
@@ -241 +241 @@
         FIELD_PTR( visit_children, __pass::bool_ref )
         FIELD_PTR( at_cleanup, __pass::at_cleanup_t )
-        FIELD_PTR( visitor, ast::Pass<pass_t> * const )
+        FIELD_PTR( visitor, ast::Pass<core_t> * const )
 
         // Remove the macro to make sure we don't clash
         #undef FIELD_PTR
 
-        template< typename pass_t >
-        static inline auto beginTrace(pass_t &, int) -> decltype( pass_t::traceId, void() ) {
-                // Stats::Heap::stacktrace_push(pass_t::traceId);
+        template< typename core_t >
+        static inline auto beginTrace(core_t &, int) -> decltype( core_t::traceId, void() ) {
+                // Stats::Heap::stacktrace_push(core_t::traceId);
         }
 
-        template< typename pass_t >
-        static inline auto endTrace(pass_t &, int) -> decltype( pass_t::traceId, void() ) {
+        template< typename core_t >
+        static inline auto endTrace(core_t &, int) -> decltype( core_t::traceId, void() ) {
                 // Stats::Heap::stacktrace_pop();
         }
 
-        template< typename pass_t >
-        static void beginTrace(pass_t &, long) {}
-
-        template< typename pass_t >
-        static void endTrace(pass_t &, long) {}
+        template< typename core_t >
+        static void beginTrace(core_t &, long) {}
+
+        template< typename core_t >
+        static void endTrace(core_t &, long) {}
 
         // Another feature of the templated visitor is that it calls beginScope()/endScope() for compound statement.
@@ -266 +266 @@
         // detect it using the same strategy
         namespace scope {
-                template<typename pass_t>
-                static inline auto enter( pass_t & pass, int ) -> decltype( pass.beginScope(), void() ) {
-                        pass.beginScope();
-                }
-
-                template<typename pass_t>
-                static inline void enter( pass_t &, long ) {}
-
-                template<typename pass_t>
-                static inline auto leave( pass_t & pass, int ) -> decltype( pass.endScope(), void() ) {
-                        pass.endScope();
-                }
-
-                template<typename pass_t>
-                static inline void leave( pass_t &, long ) {}
+                template<typename core_t>
+                static inline auto enter( core_t & core, int ) -> decltype( core.beginScope(), void() ) {
+                        core.beginScope();
+                }
+
+                template<typename core_t>
+                static inline void enter( core_t &, long ) {}
+
+                template<typename core_t>
+                static inline auto leave( core_t & core, int ) -> decltype( core.endScope(), void() ) {
+                        core.endScope();
+                }
+
+                template<typename core_t>
+                static inline void leave( core_t &, long ) {}
         } // namespace scope
 
@@ -287 +287 @@
         namespace symtab {
                 // Some simple scoping rules
-                template<typename pass_t>
-                static inline auto enter( pass_t & pass, int ) -> decltype( pass.symtab, void() ) {
-                        pass.symtab.enterScope();
-                }
-
-                template<typename pass_t>
-                static inline auto enter( pass_t &, long ) {}
-
-                template<typename pass_t>
-                static inline auto leave( pass_t & pass, int ) -> decltype( pass.symtab, void() ) {
-                        pass.symtab.leaveScope();
-                }
-
-                template<typename pass_t>
-                static inline auto leave( pass_t &, long ) {}
+                template<typename core_t>
+                static inline auto enter( core_t & core, int ) -> decltype( core.symtab, void() ) {
+                        core.symtab.enterScope();
+                }
+
+                template<typename core_t>
+                static inline auto enter( core_t &, long ) {}
+
+                template<typename core_t>
+                static inline auto leave( core_t & core, int ) -> decltype( core.symtab, void() ) {
+                        core.symtab.leaveScope();
+                }
+
+                template<typename core_t>
+                static inline auto leave( core_t &, long ) {}
 
                 // The symbol table has 2 kind of functions mostly, 1 argument and 2 arguments
                 // Create macro to condense these common patterns
                 #define SYMTAB_FUNC1( func, type ) \
-                template<typename pass_t> \
-                static inline auto func( pass_t & pass, int, type arg ) -> decltype( pass.symtab.func( arg ), void() ) {\
-                        pass.symtab.func( arg ); \
+                template<typename core_t> \
+                static inline auto func( core_t & core, int, type arg ) -> decltype( core.symtab.func( arg ), void() ) {\
+                        core.symtab.func( arg ); \
                 } \
                 \
-                template<typename pass_t> \
-                static inline void func( pass_t &, long, type ) {}
+                template<typename core_t> \
+                static inline void func( core_t &, long, type ) {}
 
                 #define SYMTAB_FUNC2( func, type1, type2 ) \
-                template<typename pass_t> \
-                static inline auto func( pass_t & pass, int, type1 arg1, type2 arg2 ) -> decltype( pass.symtab.func( arg1, arg2 ), void () ) {\
-                        pass.symtab.func( arg1, arg2 ); \
+                template<typename core_t> \
+                static inline auto func( core_t & core, int, type1 arg1, type2 arg2 ) -> decltype( core.symtab.func( arg1, arg2 ), void () ) {\
+                        core.symtab.func( arg1, arg2 ); \
                 } \
                         \
-                template<typename pass_t> \
-                static inline void func( pass_t &, long, type1, type2 ) {}
+                template<typename core_t> \
+                static inline void func( core_t &, long, type1, type2 ) {}
 
                 SYMTAB_FUNC1( addId     , const DeclWithType *  );
@@ -332 +332 @@
 
                 // A few extra functions have more complicated behaviour, they are hand written
-                template<typename pass_t>
-                static inline auto addStructFwd( pass_t & pass, int, const ast::StructDecl * decl ) -> decltype( pass.symtab.addStruct( decl ), void() ) {
+                template<typename core_t>
+                static inline auto addStructFwd( core_t & core, int, const ast::StructDecl * decl ) -> decltype( core.symtab.addStruct( decl ), void() ) {
                         ast::StructDecl * fwd = new ast::StructDecl( decl->location, decl->name );
                         fwd->params = decl->params;
-                        pass.symtab.addStruct( fwd );
-                }
-
-                template<typename pass_t>
-                static inline void addStructFwd( pass_t &, long, const ast::StructDecl * ) {}
-
-                template<typename pass_t>
-                static inline auto addUnionFwd( pass_t & pass, int, const ast::UnionDecl * decl ) -> decltype( pass.symtab.addUnion( decl ), void() ) {
+                        core.symtab.addStruct( fwd );
+                }
+
+                template<typename core_t>
+                static inline void addStructFwd( core_t &, long, const ast::StructDecl * ) {}
+
+                template<typename core_t>
+                static inline auto addUnionFwd( core_t & core, int, const ast::UnionDecl * decl ) -> decltype( core.symtab.addUnion( decl ), void() ) {
                         UnionDecl * fwd = new UnionDecl( decl->location, decl->name );
                         fwd->params = decl->params;
-                        pass.symtab.addUnion( fwd );
-                }
-
-                template<typename pass_t>
-                static inline void addUnionFwd( pass_t &, long, const ast::UnionDecl * ) {}
-
-                template<typename pass_t>
-                static inline auto addStruct( pass_t & pass, int, const std::string & str ) -> decltype( pass.symtab.addStruct( str ), void() ) {
-                        if ( ! pass.symtab.lookupStruct( str ) ) {
-                                pass.symtab.addStruct( str );
+                        core.symtab.addUnion( fwd );
+                }
+
+                template<typename core_t>
+                static inline void addUnionFwd( core_t &, long, const ast::UnionDecl * ) {}
+
+                template<typename core_t>
+                static inline auto addStruct( core_t & core, int, const std::string & str ) -> decltype( core.symtab.addStruct( str ), void() ) {
+                        if ( ! core.symtab.lookupStruct( str ) ) {
+                                core.symtab.addStruct( str );
                         }
                 }
 
-                template<typename pass_t>
-                static inline void addStruct( pass_t &, long, const std::string & ) {}
-
-                template<typename pass_t>
-                static inline auto addUnion( pass_t & pass, int, const std::string & str ) -> decltype( pass.symtab.addUnion( str ), void() ) {
-                        if ( ! pass.symtab.lookupUnion( str ) ) {
-                                pass.symtab.addUnion( str );
+                template<typename core_t>
+                static inline void addStruct( core_t &, long, const std::string & ) {}
+
+                template<typename core_t>
+                static inline auto addUnion( core_t & core, int, const std::string & str ) -> decltype( core.symtab.addUnion( str ), void() ) {
+                        if ( ! core.symtab.lookupUnion( str ) ) {
+                                core.symtab.addUnion( str );
                         }
                 }
 
-                template<typename pass_t>
-                static inline void addUnion( pass_t &, long, const std::string & ) {}
+                template<typename core_t>
+                static inline void addUnion( core_t &, long, const std::string & ) {}
 
                 #undef SYMTAB_FUNC1
@@ -380 +380 @@
         namespace forall {
                 // Some simple scoping rules
-                template<typename pass_t>
-                static inline auto enter( pass_t & pass, int, const ast::ParameterizedType * type )
-                -> decltype( pass.subs, void() ) {
-                        if ( ! type->forall.empty() ) pass.subs.beginScope();
-                }
-
-                template<typename pass_t>
-                static inline auto enter( pass_t &, long, const ast::ParameterizedType * ) {}
-
-                template<typename pass_t>
-                static inline auto leave( pass_t & pass, int, const ast::ParameterizedType * type )
-                -> decltype( pass.subs, void() ) {
-                        if ( ! type->forall.empty() ) { pass.subs.endScope(); }
-                }
-
-                template<typename pass_t>
-                static inline auto leave( pass_t &, long, const ast::ParameterizedType * ) {}
+                template<typename core_t>
+                static inline auto enter( core_t & core, int, const ast::ParameterizedType * type )
+                -> decltype( core.subs, void() ) {
+                        if ( ! type->forall.empty() ) core.subs.beginScope();
+                }
+
+                template<typename core_t>
+                static inline auto enter( core_t &, long, const ast::ParameterizedType * ) {}
+
+                template<typename core_t>
+                static inline auto leave( core_t & core, int, const ast::ParameterizedType * type )
+                -> decltype( core.subs, void() ) {
+                        if ( ! type->forall.empty() ) { core.subs.endScope(); }
+                }
+
+                template<typename core_t>
+                static inline auto leave( core_t &, long, const ast::ParameterizedType * ) {}
 
                 // Get the substitution table, if present
-                template<typename pass_t>
-                static inline auto subs( pass_t & pass, int ) -> decltype( &pass.subs ) {
-                        return &pass.subs;
-                }
-
-                template<typename pass_t>
-                static inline ast::ForallSubstitutionTable * subs( pass_t &, long ) { return nullptr; }
+                template<typename core_t>
+                static inline auto subs( core_t & core, int ) -> decltype( &core.subs ) {
+                        return &core.subs;
+                }
+
+                template<typename core_t>
+                static inline ast::ForallSubstitutionTable * subs( core_t &, long ) { return nullptr; }
 
                 // Replaces a TypeInstType's base TypeDecl according to the table
-                template<typename pass_t>
-                static inline auto replace( pass_t & pass, int, const ast::TypeInstType *& inst )
-                -> decltype( pass.subs, void() ) {
+                template<typename core_t>
+                static inline auto replace( core_t & core, int, const ast::TypeInstType *& inst )
+                -> decltype( core.subs, void() ) {
                         inst = ast::mutate_field(
-                                inst, &ast::TypeInstType::base, pass.subs.replace( inst->base ) );
-                }
-
-                template<typename pass_t>
-                static inline auto replace( pass_t &, long, const ast::TypeInstType *& ) {}
+                                inst, &ast::TypeInstType::base, core.subs.replace( inst->base ) );
+                }
+
+                template<typename core_t>
+                static inline auto replace( core_t &, long, const ast::TypeInstType *& ) {}
 
         } // namespace forall

src/AST/Type.cpp

@@ -94 +94 @@
 // --- ParameterizedType
 
-void ParameterizedType::initWithSub( 
-        const ParameterizedType & o, Pass< ForallSubstitutor > & sub 
+void ParameterizedType::initWithSub(
+        const ParameterizedType & o, Pass< ForallSubstitutor > & sub
 ) {
-        forall = sub.pass( o.forall );
+        forall = sub.core( o.forall );
 }
 
@@ -103 +103 @@
 
 FunctionType::FunctionType( const FunctionType & o )
-: ParameterizedType( o.qualifiers, copy( o.attributes ) ), returns(), params(), 
+: ParameterizedType( o.qualifiers, copy( o.attributes ) ), returns(), params(),
   isVarArgs( o.isVarArgs ) {
         Pass< ForallSubstitutor > sub;
         initWithSub( o, sub );           // initialize substitution map
-        returns = sub.pass( o.returns ); // apply to return and parameter types
-        params = sub.pass( o.params );
+        returns = sub.core( o.returns ); // apply to return and parameter types
+        params = sub.core( o.params );
 }
 
@@ -128 +128 @@
 void ReferenceToType::initWithSub( const ReferenceToType & o, Pass< ForallSubstitutor > & sub ) {
         ParameterizedType::initWithSub( o, sub ); // initialize substitution
-        params = sub.pass( o.params );            // apply to parameters
+        params = sub.core( o.params );            // apply to parameters
 }
 
@@ -166 +166 @@
 // --- TraitInstType
 
-TraitInstType::TraitInstType( 
+TraitInstType::TraitInstType(
         const TraitDecl * b, CV::Qualifiers q, std::vector<ptr<Attribute>>&& as )
 : ReferenceToType( b->name, q, move(as) ), base( b ) {}
@@ -172 +172 @@
 // --- TypeInstType
 
-TypeInstType::TypeInstType( const TypeInstType & o ) 
+TypeInstType::TypeInstType( const TypeInstType & o )
 : ReferenceToType( o.name, o.qualifiers, copy( o.attributes ) ), base(), kind( o.kind ) {
         Pass< ForallSubstitutor > sub;
         initWithSub( o, sub );      // initialize substitution
-        base = sub.pass( o.base );  // apply to base type
+        base = sub.core( o.base );  // apply to base type
 }
 

src/AST/TypeEnvironment.cpp

@@ -59 +59 @@
         std::copy( clz.vars.begin(), clz.vars.end(), std::ostream_iterator< std::string >( out, " " ) );
         out << ")";
-        
+
         if ( clz.bound ) {
                 out << " -> ";
@@ -92 +92 @@
                                 }
                         }
-                        
+
                         i = next;  // go to next node even if this removed
                 }
@@ -161 +161 @@
                 Pass<Occurs> occur{ var, env };
                 maybe_accept( ty, occur );
-                return occur.pass.result;
-        }
-}
-
-bool TypeEnvironment::combine( 
+                return occur.core.result;
+        }
+}
+
+bool TypeEnvironment::combine(
                 const TypeEnvironment & o, OpenVarSet & open, const SymbolTable & symtab ) {
         // short-circuit easy cases
@@ -199 +199 @@
                                 auto st = internal_lookup( *vt );
                                 if ( st == env.end() ) {
-                                        // unbound, safe to add if occurs 
+                                        // unbound, safe to add if occurs
                                         if ( r.bound && occurs( r.bound, *vt, *this ) ) return false;
                                         r.vars.emplace( *vt );
@@ -266 +266 @@
 }
 
-bool TypeEnvironment::bindVar( 
-                const TypeInstType * typeInst, const Type * bindTo, const TypeDecl::Data & data, 
-                AssertionSet & need, AssertionSet & have, const OpenVarSet & open, WidenMode widen, 
-                const SymbolTable & symtab 
+bool TypeEnvironment::bindVar(
+                const TypeInstType * typeInst, const Type * bindTo, const TypeDecl::Data & data,
+                AssertionSet & need, AssertionSet & have, const OpenVarSet & open, WidenMode widen,
+                const SymbolTable & symtab
 ) {
         // remove references from bound type, so that type variables can only bind to value types
@@ -286 +286 @@
                         ptr<Type> newType = it->bound;
                         reset_qualifiers( newType, typeInst->qualifiers );
-                        if ( unifyInexact( 
-                                        newType, target, *this, need, have, open, 
+                        if ( unifyInexact(
+                                        newType, target, *this, need, have, open,
                                         widen & WidenMode{ it->allowWidening, true }, symtab, common ) ) {
                                 if ( common ) {
@@ -300 +300 @@
                 }
         } else {
-                env.emplace_back( 
+                env.emplace_back(
                         typeInst->name, target, widen.first && widen.second, data );
         }
@@ -306 +306 @@
 }
 
-bool TypeEnvironment::bindVarToVar( 
-                const TypeInstType * var1, const TypeInstType * var2, TypeDecl::Data && data, 
-                AssertionSet & need, AssertionSet & have, const OpenVarSet & open, 
-                WidenMode widen, const SymbolTable & symtab 
+bool TypeEnvironment::bindVarToVar(
+                const TypeInstType * var1, const TypeInstType * var2, TypeDecl::Data && data,
+                AssertionSet & need, AssertionSet & have, const OpenVarSet & open,
+                WidenMode widen, const SymbolTable & symtab
 ) {
         auto c1 = internal_lookup( var1->name );
         auto c2 = internal_lookup( var2->name );
-        
+
         // exit early if variables already bound together
         if ( c1 != env.end() && c1 == c2 ) {
@@ -396 +396 @@
 }
 
-bool TypeEnvironment::mergeBound( 
+bool TypeEnvironment::mergeBound(
                 EqvClass & to, const EqvClass & from, OpenVarSet & open, const SymbolTable & symtab ) {
         if ( from.bound ) {
@@ -406 +406 @@
                         AssertionSet need, have;
 
-                        if ( unifyInexact( 
+                        if ( unifyInexact(
                                         toType, fromType, *this, need, have, open, widen, symtab, common ) ) {
                                 // unifies, set common type if necessary
@@ -424 +424 @@
 }
 
-bool TypeEnvironment::mergeClasses( 
+bool TypeEnvironment::mergeClasses(
         ClassList::iterator to, ClassList::iterator from, OpenVarSet & open, const SymbolTable & symtab
 ) {

src/AST/TypeSubstitution.cpp

@@ -121 +121 @@
         Pass<Substituter> sub( *this, true );
         do {
-                sub.pass.subCount = 0;
-                sub.pass.freeOnly = true;
+                sub.core.subCount = 0;
+                sub.core.freeOnly = true;
                 for ( TypeEnvType::iterator i = typeEnv.begin(); i != typeEnv.end(); ++i ) {
                         i->second = i->second->accept( sub );
                 }
-        } while ( sub.pass.subCount );
+        } while ( sub.core.subCount );
 }
 

src/AST/TypeSubstitution.hpp

@@ -99 +99 @@
         void initialize( const TypeSubstitution &src, TypeSubstitution &dest );
 
-        template<typename pass_type>
+        template<typename core_t>
         friend class Pass;
 
@@ -188 +188 @@
         Pass<Substituter> sub( *this, false );
         input = strict_dynamic_cast< const SynTreeClass * >( deepCopy(input)->accept( sub ) );
-        return { input, sub.pass.subCount };
+        return { input, sub.core.subCount };
 }
 
@@ -196 +196 @@
         Pass<Substituter> sub( *this, true );
         input = strict_dynamic_cast< const SynTreeClass * >( input->accept( sub ) );
-        return { input, sub.pass.subCount };
+        return { input, sub.core.subCount };
 }
 

src/Common/Eval.cc

@@ -168 +168 @@
         if (expr) {
                 expr->accept(ev);
-                return std::make_pair(ev.pass.value, ev.pass.valid);
+                return std::make_pair(ev.core.value, ev.core.valid);
         } else {
                 return std::make_pair(0, false);

src/InitTweak/InitTweak.cc

@@ -127 +127 @@
         ast::Pass< InitFlattener_new > flattener;
         maybe_accept( init, flattener );
-        return std::move( flattener.pass.argList );
+        return std::move( flattener.core.argList );
 }
 
@@ -561 +561 @@
                 ast::Pass< CallFinder_new > finder{ std::vector< std::string >{ "?{}", "^?{}" } };
                 maybe_accept( stmt, finder );
-                return std::move( finder.pass.matches );
+                return std::move( finder.core.matches );
         }
 

src/ResolvExpr/CandidateFinder.cpp

@@ -1590 +1590 @@
 
         if ( mode.failFast && candidates.empty() ) {
-                switch(finder.pass.reason.code) {
+                switch(finder.core.reason.code) {
                 case Finder::NotFound:
                         { SemanticError( expr, "No alternatives for expression " ); break; }

src/ResolvExpr/CastCost.cc

@@ -242 +242 @@
                         dst, srcIsLvalue, symtab, env, localCastCost );
                 src->accept( converter );
-                return converter.pass.cost;
+                return converter.core.cost;
         }
 }

src/ResolvExpr/CommonType.cc

@@ -968 +968 @@
                 ast::Pass<CommonType_new> visitor{ type2, widen, symtab, env, open };
                 type1->accept( visitor );
-                ast::ptr< ast::Type > result = visitor.pass.result;
+                ast::ptr< ast::Type > result = visitor.core.result;
 
                 // handling for opaque type declarations (?)

src/ResolvExpr/ConversionCost.cc

@@ -522 +522 @@
                 ast::Pass<ConversionCost_new> converter( dst, srcIsLvalue, symtab, env, localConversionCost );
                 src->accept( converter );
-                return converter.pass.cost;
+                return converter.core.cost;
         }
 }
@@ -565 +565 @@
                         ast::Pass<ConversionCost_new> converter( dst, srcIsLvalue, symtab, env, localConversionCost );
                         src->accept( converter );
-                        return converter.pass.cost;
+                        return converter.core.cost;
                 }
         } else {

src/ResolvExpr/PolyCost.cc

@@ -87 +87 @@
         ast::Pass<PolyCost_new> costing( symtab, env );
         type->accept( costing );
-        return costing.pass.result;
+        return costing.core.result;
 }
 

src/ResolvExpr/PtrsAssignable.cc

@@ -155 +155 @@
                 ast::Pass<PtrsAssignable_new> visitor( dst, env );
                 src->accept( visitor );
-                return visitor.pass.result;
+                return visitor.core.result;
         }
 

src/ResolvExpr/PtrsCastable.cc

@@ -293 +293 @@
                 ast::Pass< PtrsCastable_new > ptrs{ dst, env, symtab };
                 src->accept( ptrs );
-                return ptrs.pass.result;
+                return ptrs.core.result;
         }
 }

src/ResolvExpr/Resolver.cc

@@ -982 +982 @@
                 ast::Pass<DeleteFinder_new> finder;
                 expr->accept( finder );
-                return finder.pass.delExpr;
+                return finder.core.delExpr;
         }
 

src/ResolvExpr/SpecCost.cc

@@ -217 +217 @@
         }
         ast::Pass<SpecCounter> counter;
-        type->accept( *counter.pass.visitor );
-        return counter.pass.get_count();
+        type->accept( counter );
+        return counter.core.get_count();
 }
 

src/ResolvExpr/Unify.cc

@@ -1185 +1185 @@
                         ast::Pass<Unify_new> comparator{ type2, env, need, have, open, widen, symtab };
                         type1->accept( comparator );
-                        return comparator.pass.result;
+                        return comparator.core.result;
                 }
         }

src/SymTab/FixFunction.cc

@@ -141 +141 @@
         ast::Pass< FixFunction_new > fixer;
         dwt = dwt->accept( fixer );
-        isVoid |= fixer.pass.isVoid;
+        isVoid |= fixer.core.isVoid;
         return dwt;
 }

src/SymTab/Mangler.cc

@@ -447 +447 @@
                 ast::Pass<Mangler_new> mangler( mode );
                 maybeAccept( decl, mangler );
-                return mangler.pass.get_mangleName();
+                return mangler.core.get_mangleName();
         }
 
@@ -691 +691 @@
                                                                 mangleOverridable, typeMode, mangleGenericParams, nextVarNum, varNums );
                                                         assert->accept( sub_mangler );
-                                                        assertionNames.push_back( sub_mangler.pass.get_mangleName() );
+                                                        assertionNames.push_back( sub_mangler.core.get_mangleName() );
                                                         acount++;
                                                 } // for

src/Tuples/Explode.cc

@@ -179 +179 @@
         ast::Pass<CastExploderCore> exploder;
         expr = expr->accept( exploder );
-        if ( ! exploder.pass.foundUniqueExpr ) {
+        if ( ! exploder.core.foundUniqueExpr ) {
                 expr = new ast::CastExpr{ expr, new ast::ReferenceType{ expr->result } };
         }

src/Tuples/Tuples.cc

@@ -53 +53 @@
                 ast::Pass<Detector> detector;
                 expr->accept( detector );
-                return detector.pass.maybeImpure;
+                return detector.core.maybeImpure;
         }
 } // namespace