Changeset 04124c4 for src/AST/Pass.hpp

Timestamp:

May 10, 2019, 2:47:32 PM (5 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

37e3af4

Parents:

7f3f63c

Message:

More comments and naming conventions fix

File:

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

src/AST/Pass.hpp

@@ +1 @@
+//
+// Cforall Version 1.0.0 Copyright (C) 2019 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// Pass.hpp --
+//
+// Author           : Thierry Delisle
+// Created On       : Thu May 09 15::37::05 2019
+// Last Modified By :
+// Last Modified On :
+// Update Count     :
+//
+
 #pragma once
-// IWYU pragma: private, include "Common/PassVisitor.h"
+// IWYU pragma: private, include "AST/Pass.hpp"
 
 #include <functional>
@@ -6 +21 @@
 #include <stack>
 
-#include "Fwd.hpp"
-#include "Node.hpp"
+#include "AST/Fwd.hpp"
+#include "AST/Node.hpp"
+#include "AST/Decl.hpp"
+#include "AST/Visitor.hpp"
+
+#include "SymTab/Indexer.h"
 
 // Private prelude header, needed for some of the magic tricks this class pulls off
-#include "Pass.proto.hpp"
+#include "AST/Pass.proto.hpp"
 
 namespace ast {
@@ -20 +39 @@
 //
 // Several additional features are available through inheritance
-// | WithTypeSubstitution - provides polymorphic TypeSubstitution * env for the current expression
+// | 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
@@ -30 +53 @@
 //                          automatically be restored to its previous value after the corresponding
 //                          postvisit/postmutate teminates.
+// | WithVisitorRef       - provides an pointer to the templated visitor wrapper
+// | WithIndexer          - provides indexer functionality (i.e. up-to-date symbol table)
 //-------------------------------------------------------------------------------------------------
 template< typename pass_t >
 class Pass final : public ast::Visitor {
 public:
+        /// Forward any arguments to the pass constructor
+        /// Propagate 'this' if necessary
         template< typename... Args >
         Pass( Args &&... args)
-                : m_pass( 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
                 typedef Pass<pass_t> this_t;
-                this_t * const * visitor = __pass::visitor(m_pass, 0);
+                this_t * const * visitor = __pass::visitor(pass, 0);
                 if(visitor) {
                         *const_cast<this_t **>( visitor ) = this;
@@ -48 +75 @@
         virtual ~Pass() = default;
 
-        pass_t m_pass;
-
+        /// Storage for the actual pass
+        pass_t pass;
+
+        /// Visit function declarations
         virtual DeclWithType *     visit( const ObjectDecl           * ) override final;
         virtual DeclWithType *     visit( const FunctionDecl         * ) override final;
@@ -145 +174 @@
         virtual TypeSubstitution * visit( const TypeSubstitution     * ) override final;
 
+        friend void acceptAll( std::list< ptr<Decl> > & decls, Pass<pass_t>& visitor );
 private:
 
-        bool __visit_children() { __pass::bool_ref * ptr = __pass::visit_children(m_pass, 0); return ptr ? *ptr : true; }
+        bool __visit_children() { __pass::bool_ref * ptr = __pass::visit_children(pass, 0); return ptr ? *ptr : true; }
 
 private:
+        /// Logic to call the accept and mutate the parent if needed, delegates call to accept
         template<typename parent_t, typename child_t>
         void maybe_accept(parent_t * & , typename parent_t::child_t *);
 
-        ast::Statement  * call_accept( const ast::Statement  * );
-        ast::Expression * call_accept( const ast::Expression * );
+        Stmt * call_accept( const Stmt * );
+        Expr * call_accept( const Expr * );
 
         template< template <class> class container_t >
-        container_t< ast::ptr<ast::Statement> > call_accept( const container_t< ast::ptr<ast::Statement> > & );
+        container_t< ptr<Stmt> > call_accept( const container_t< ptr<Stmt> > & );
 
         template< template <class> class container_t, typename node_t >
-        container_t< ast::ptr<node_t> > call_accept( const container_t< ast::ptr<node_t> > & container );
+        container_t< ptr<node_t> > call_accept( const container_t< ptr<node_t> > & container );
 
 private:
-        struct indexer_guard {
+        /// Internal RAII guard for indexer features
+        struct guard_indexer {
+                guard_indexer( Pass<pass_t> & pass ): pass( pass ) { __pass::indexer::enter(pass, 0); }
+                ~guard_indexer()                                   { __pass::indexer::leave(pass, 0); }
                 Pass<pass_t> & pass;
-
-                indexer_guard( Pass<pass_t> & pass ) : pass( pass ) { __pass::indexer::enter(pass, 0); }
-                ~indexer_guard()                                    { __pass::indexer::leave(pass, 0); }
         };
 
-        indexer_guard make_indexer_guard() { return { *this }; }
-
-private:
-        struct scope_guard {
+        /// Internal RAII guard for scope features
+        struct guard_scope {
+                guard_scope( Pass<pass_t> & pass ): pass( pass ) { __pass::scope::enter(pass, 0); }
+                ~guard_scope()                                   { __pass::scope::leave(pass, 0); }
                 Pass<pass_t> & pass;
-
-                scope_guard( Pass<pass_t> & pass ) : pass( pass ) { __pass::scope::enter(pass, 0); }
-                ~scope_guard()                                    { __pass::scope::leave(pass, 0); }
         };
-
-        scope_guard make_scope_guard() { return { *this }; }
-};
-
-//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-// Guard value : RAII type to restore a value when the Pass finishes visiting this node
-template<typename pass_t, typename T>
-void GuardValue( pass_t * pass, T& val ) {
-        pass->at_cleanup( [ val ]( void * newVal ) {
-                * static_cast< T * >( newVal ) = val;
-        }, static_cast< void * >( & val ) );
-}
-
-//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+};
+
+template<typename pass_t>
+void acceptAll( std::list< ptr<Decl> >, Pass<pass_t>& visitor );
+
+//-------------------------------------------------------------------------------------------------
 // PASS ACCESSORIES
-//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-
-// Keep track of the type substitution
-struct WithConstTypeSubstitution {
-        const ast::TypeSubstitution * env = nullptr;
-};
+//-------------------------------------------------------------------------------------------------
 
 template<typename T>
 using std_list = std::list<T>;
 
-// Used if visitor requires added statements before or after the current node.
-// The Pass template handles what *before* and *after* means automatically
+/// Keep track of the polymorphic const TypeSubstitution * env for the current expression
+struct WithConstTypeSubstitution {
+        const TypeSubstitution * env = nullptr;
+};
+
+/// Used if visitor requires added statements before or after the current node.
+/// The Pass template handles what *before* and *after* means automatically
 template< template<class> class container_t = std_list >
 struct WithStmtsToAdd {
-        container_t< ast::ptr< ast::Statement > > stmtsToAddBefore;
-        container_t< ast::ptr< ast::Statement > > stmtsToAddAfter;
-};
-
-// Used if visitor requires added declarations before or after the current node.
-// The Pass template handles what *before* and *after* means automatically
+        container_t< ptr<Stmt> > stmtsToAddBefore;
+        container_t< ptr<Stmt> > stmtsToAddAfter;
+};
+
+/// Used if visitor requires added declarations before or after the current node.
+/// The Pass template handles what *before* and *after* means automatically
 template< template<class> class container_t = std_list >
 struct WithDeclsToAdd {
-        ~WithDeclsToAdd() {
-                assert( declsToAddBefore.empty() );
-        }
-
-        container_t< ast::ptr< ast::Declaration > > declsToAddBefore;
-        container_t< ast::ptr< ast::Declaration > > declsToAddAfter;
-};
-
-// Use if visitation should stop at certain levels
-// set visit_children false of all child nodes should be ignored
+        container_t< ptr<Decl> > declsToAddBefore;
+        container_t< ptr<Decl> > declsToAddAfter;
+};
+
+/// Use if visitation should stop at certain levels
+/// set visit_children false of all child nodes should be ignored
 struct WithShortCircuiting {
         __pass::bool_ref visit_children;
 };
 
-// class WithGuards {
-// protected:
-//      WithGuards() = default;
-//      ~WithGuards() = default;
-
-// public:
-//      at_cleanup_t at_cleanup;
-
-//      template< typename T >
-//      void GuardValue( T& val ) {
-//              at_cleanup( [ val ]( void * newVal ) {
-//                      * static_cast< T * >( newVal ) = val;
-//              }, static_cast< void * >( & val ) );
-//      }
-
-//      template< typename T >
-//      void GuardScope( T& val ) {
-//              val.beginScope();
-//              at_cleanup( []( void * val ) {
-//                      static_cast< T * >( val )->endScope();
-//              }, static_cast< void * >( & val ) );
-//      }
-
-//      template< typename Func >
-//      void GuardAction( Func func ) {
-//              at_cleanup( [func](__attribute__((unused)) void *) { func(); }, nullptr );
-//      }
-// };
-
-// template<typename pass_type>
-// class WithVisitorRef {
-// protected:
-//      WithVisitorRef() {}
-//      ~WithVisitorRef() {}
-
-// public:
-//      PassVisitor<pass_type> * const visitor = nullptr;
-// };
-
+/// Used to restore values/functions/etc. when the Pass finishes visiting this node
+class WithGuards {
+        __pass::at_cleanup_t at_cleanup;
+
+public:
+        /// When this node is finished being visited, restore the value of a variable
+        template< typename T >
+        void GuardValue( T& val ) {
+                at_cleanup( [ val ]( void * newVal ) {
+                        * static_cast< T * >( newVal ) = val;
+                }, static_cast< void * >( & val ) );
+        }
+
+        /// On the object, all beginScope now and endScope when the current node is finished being visited
+        template< typename T >
+        void GuardScope( T& val ) {
+                val.beginScope();
+                at_cleanup( []( void * val ) {
+                        static_cast< T * >( val )->endScope();
+                }, static_cast< void * >( & val ) );
+        }
+
+        /// When this node is finished being visited, call a function
+        template< typename Func >
+        void GuardAction( Func func ) {
+                at_cleanup( [func](void *) { func(); }, nullptr );
+        }
+};
+
+/// Used to get a pointer to the pass with its wrapped type
+template<typename pass_t>
+struct WithVisitorRef {
+        Pass<pass_t> * const visitor = nullptr;
+};
+
+/// Use when the templated visitor should update the indexer
 struct WithIndexer {
         SymTab::Indexer indexer;