Changes in src/AST/Pass.hpp [7ff3e522:a86b2ca6]

File:

• src/AST/Pass.hpp (modified) (7 diffs)

src/AST/Pass.hpp

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