Changes in src/AST/Pass.hpp [3e5dd913:e67991f]

File:

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

src/AST/Pass.hpp

@@ -8 +8 @@
 //
 // Author           : Thierry Delisle
-// Created On       : Thu May 09 15:37:05 2019
+// Created On       : Thu May 09 15::37::05 2019
 // Last Modified By :
 // Last Modified On :
@@ -46 +46 @@
 //
 // Several additional features are available through inheritance
-// | PureVisitor           - makes the visitor pure, it never modifies nodes in place and always
-//                           clones nodes it needs to make changes to
-// | WithConstTypeSubstitution - provides polymorphic const TypeSubstitution * typeSubs for the
-//                           current expression
-// | WithStmtsToAdd        - provides the ability to insert statements before or after the current
-//                           statement by adding new statements into stmtsToAddBefore or
-//                           stmtsToAddAfter respectively.
-// | WithDeclsToAdd        - provides the ability to insert declarations before or after the
-//                           current declarations by adding new DeclStmt into declsToAddBefore or
-//                           declsToAddAfter respectively.
-// | WithShortCircuiting   - provides the ability to skip visiting child nodes; set visit_children
-//                           to false in pre{visit,visit} to skip visiting children
-// | WithGuards            - provides the ability to save/restore data like a LIFO stack; to save,
-//                           call GuardValue with the variable to save, the variable will
-//                           automatically be restored to its previous value after the
-//                           corresponding postvisit/postmutate teminates.
-// | WithVisitorRef        - provides an pointer to the templated visitor wrapper
-// | WithSymbolTable       - provides symbol table functionality
-//
-// Other Special Members:
-// | result                - Either a method that takes no parameters or a field. If a method (or
-//                           callable field) get_result calls it, otherwise the value is returned.
+// | WithTypeSubstitution - provides polymorphic const TypeSubstitution * env for the
+//                          current expression
+// | WithStmtsToAdd       - provides the ability to insert statements before or after the current
+//                          statement by adding new statements into stmtsToAddBefore or
+//                          stmtsToAddAfter respectively.
+// | WithDeclsToAdd       - provides the ability to insert declarations before or after the current
+//                          declarations by adding new DeclStmt into declsToAddBefore or
+//                          declsToAddAfter respectively.
+// | WithShortCircuiting  - provides the ability to skip visiting child nodes; set visit_children
+//                          to false in pre{visit,visit} to skip visiting children
+// | WithGuards           - provides the ability to save/restore data like a LIFO stack; to save,
+//                          call GuardValue with the variable to save, the variable will
+//                          automatically be restored to its previous value after the corresponding
+//                          postvisit/postmutate teminates.
+// | WithVisitorRef       - provides an pointer to the templated visitor wrapper
+// | WithSymbolTable      - provides symbol table functionality
 //-------------------------------------------------------------------------------------------------
-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 +82 @@
         virtual ~Pass() = default;
 
-        /// Storage for the actual pass.
-        core_t core;
-
-        /// If the core defines a result, call it if possible, otherwise return it.
-        inline auto get_result() -> decltype( __pass::get_result( core, '0' ) ) {
-                return __pass::get_result( core, '0' );
-        }
-
-        /// Construct and run a pass on a translation unit.
-        template< typename... Args >
-        static void run( TranslationUnit & decls, Args &&... args ) {
-                Pass<core_t> visitor( std::forward<Args>( args )... );
-                accept_all( decls, visitor );
-        }
-
-        /// Contruct and run a pass on a pointer to extract a value.
-        template< typename node_type, typename... Args >
-        static auto read( node_type const * node, Args&&... args ) {
-                Pass<core_t> visitor( std::forward<Args>( args )... );
-                node_type const * temp = node->accept( visitor );
-                assert( temp == node );
-                return visitor.get_result();
-        }
-
-        // Versions of the above for older compilers.
-        template< typename... Args >
-        static void run( TranslationUnit & decls ) {
-                Pass<core_t> visitor;
-                accept_all( decls, visitor );
-        }
-
-        template< typename node_type, typename... Args >
-        static auto read( node_type const * node ) {
-                Pass<core_t> visitor;
-                node_type const * temp = node->accept( visitor );
-                assert( temp == node );
-                return visitor.get_result();
-        }
+        /// Storage for the actual pass
+        pass_t pass;
 
         /// Visit function declarations
@@ -155 +111 @@
         const ast::Stmt *             visit( const ast::CatchStmt            * ) override final;
         const ast::Stmt *             visit( const ast::FinallyStmt          * ) override final;
-        const ast::Stmt *             visit( const ast::SuspendStmt          * ) override final;
         const ast::Stmt *             visit( const ast::WaitForStmt          * ) override final;
         const ast::Decl *             visit( const ast::WithStmt             * ) override final;
@@ -223 +178 @@
         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 );
-
-        bool isInFunction() const {
-                return inFunction;
-        }
-
+        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:
         const ast::Stmt * call_accept( const ast::Stmt * );
         const ast::Expr * call_accept( const ast::Expr * );
-
-        // requests WithStmtsToAdd directly add to this statement, as if it is a compound.
-
-        const ast::Stmt * call_accept_as_compound(const ast::Stmt *);
 
         template< typename node_t >
@@ -260 +206 @@
         void maybe_accept(const node_t * &, child_t parent_t::* child);
 
-        template<typename node_t, typename parent_t, typename child_t>
-        void maybe_accept_as_compound(const node_t * &, child_t parent_t::* child);
-
 private:
         /// 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, 0); }
+                ~guard_symtab()                                   { __pass::symtab::leave(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;
-        };
-
-        /// Internal RAII guard for forall substitutions
-        struct guard_forall_subs {
-                guard_forall_subs( Pass<core_t> & pass, const FunctionType * 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 FunctionType * type;
+                guard_scope( Pass<pass_t> & pass ): pass( pass ) { __pass::scope::enter(pass, 0); }
+                ~guard_scope()                                   { __pass::scope::leave(pass, 0); }
+                Pass<pass_t> & pass;
         };
 
 private:
         bool inFunction = false;
-        bool atFunctionTop = false;
 };
 
 /// 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 core_t>
-void accept_all( ast::TranslationUnit &, ast::Pass<core_t> & visitor );
+template<typename pass_t>
+void accept_all( std::list< ast::ptr<ast::Decl> > &, ast::Pass<pass_t> & visitor );
 
 //-------------------------------------------------------------------------------------------------
@@ -303 +233 @@
 //-------------------------------------------------------------------------------------------------
 
-/// If used the visitor will always clone nodes.
-struct PureVisitor {};
-
-/// Keep track of the polymorphic const TypeSubstitution * typeSubs for the current expression.
+/// Keep track of the polymorphic const TypeSubstitution * env for the current expression
 struct WithConstTypeSubstitution {
-        const TypeSubstitution * typeSubs = nullptr;
+        const TypeSubstitution * env = nullptr;
 };
 
@@ -340 +267 @@
         };
 
-        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:
 
@@ -377 +304 @@
 
 /// 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;
-
-        bool isInFunction() const {
-                return visitor->isInFunction();
-        }
+        Pass<pass_t> * const visitor = nullptr;
 };
 
@@ -390 +313 @@
         SymbolTable symtab;
 };
-
 }
 
@@ -398 +320 @@
 extern struct PassVisitorStats {
         size_t depth = 0;
-        Stats::Counters::MaxCounter<double> * max;
-        Stats::Counters::AverageCounter<double> * avg;
+        Stats::Counters::MaxCounter<double> * max = nullptr;
+        Stats::Counters::AverageCounter<double> * avg = nullptr;
 } pass_visitor_stats;
 }