Changeset 2e9b59b for src/AST/Pass.impl.hpp

Timestamp:

Apr 19, 2022, 3:00:04 PM (3 years ago)

Author:

m3zulfiq <m3zulfiq@…>

Branches:

ADT, ast-experimental, master, pthread-emulation, qualifiedEnum

Children:

5b84a321

Parents:

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

Message:

added benchmark and evaluations chapter to thesis

File:

• src/AST/Pass.impl.hpp (modified) (13 diffs)

src/AST/Pass.impl.hpp

@@ -354 +354 @@
                         // Take all the elements that are different in 'values'
                         // and swap them into 'container'
-                        if( values[i] != nullptr ) std::swap(container[i], values[i]);
+                        if( values[i] != nullptr ) swap(container[i], values[i]);
                 }
 
@@ -399 +399 @@
 
         template< typename core_t >
-        template<typename node_t, typename parent_t, typename child_t>
+        template<typename node_t, typename super_t, typename field_t>
         void ast::Pass< core_t >::maybe_accept(
                 const node_t * & parent,
-                child_t parent_t::*child
+                field_t super_t::*field
         ) {
-                static_assert( std::is_base_of<parent_t, node_t>::value, "Error deducing member object" );
-
-                if(__pass::skip(parent->*child)) return;
-                const auto & old_val = __pass::get(parent->*child, 0);
+                static_assert( std::is_base_of<super_t, node_t>::value, "Error deducing member object" );
+
+                if(__pass::skip(parent->*field)) return;
+                const auto & old_val = __pass::get(parent->*field, 0);
 
                 static_assert( !std::is_same<const ast::Node * &, decltype(old_val)>::value, "ERROR");
@@ -417 +417 @@
                 if( new_val.differs ) {
                         auto new_parent = __pass::mutate<core_t>(parent);
-                        new_val.apply(new_parent, child);
+                        new_val.apply(new_parent, field);
                         parent = new_parent;
                 }
@@ -423 +423 @@
 
         template< typename core_t >
-        template<typename node_t, typename parent_t, typename child_t>
+        template<typename node_t, typename super_t, typename field_t>
         void ast::Pass< core_t >::maybe_accept_as_compound(
                 const node_t * & parent,
-                child_t parent_t::*child
+                field_t super_t::*child
         ) {
-                static_assert( std::is_base_of<parent_t, node_t>::value, "Error deducing member object" );
+                static_assert( std::is_base_of<super_t, node_t>::value, "Error deducing member object" );
 
                 if(__pass::skip(parent->*child)) return;
@@ -575 +575 @@
                         __pass::symtab::addId( core, 0, func );
                         if ( __visit_children() ) {
-                                // parameter declarations
+                                maybe_accept( node, &FunctionDecl::type_params );
+                                maybe_accept( node, &FunctionDecl::assertions );
                                 maybe_accept( node, &FunctionDecl::params );
                                 maybe_accept( node, &FunctionDecl::returns );
-                                // type params and assertions
-                                maybe_accept( node, &FunctionDecl::type_params );
-                                maybe_accept( node, &FunctionDecl::assertions );
+                                maybe_accept( node, &FunctionDecl::type );
                                 // First remember that we are now within a function.
                                 ValueGuard< bool > oldInFunction( inFunction );
@@ -893 +892 @@
         if ( __visit_children() ) {
                 maybe_accept( node, &SwitchStmt::cond  );
-                maybe_accept( node, &SwitchStmt::stmts );
+                maybe_accept( node, &SwitchStmt::cases );
         }
 
@@ -900 +899 @@
 
 //--------------------------------------------------------------------------
-// CaseStmt
-template< typename core_t >
-const ast::Stmt * ast::Pass< core_t >::visit( const ast::CaseStmt * node ) {
-        VISIT_START( node );
-
-        if ( __visit_children() ) {
-                maybe_accept( node, &CaseStmt::cond  );
-                maybe_accept( node, &CaseStmt::stmts );
-        }
-
-        VISIT_END( Stmt, node );
+// CaseClause
+template< typename core_t >
+const ast::CaseClause * ast::Pass< core_t >::visit( const ast::CaseClause * node ) {
+        VISIT_START( node );
+
+        if ( __visit_children() ) {
+                maybe_accept( node, &CaseClause::cond  );
+                maybe_accept( node, &CaseClause::stmts );
+        }
+
+        VISIT_END( CaseClause, node );
 }
 
@@ -964 +963 @@
 
 //--------------------------------------------------------------------------
-// CatchStmt
-template< typename core_t >
-const ast::Stmt * ast::Pass< core_t >::visit( const ast::CatchStmt * node ) {
+// CatchClause
+template< typename core_t >
+const ast::CatchClause * ast::Pass< core_t >::visit( const ast::CatchClause * node ) {
         VISIT_START( node );
 
@@ -972 +971 @@
                 // catch statements introduce a level of scope (for the caught exception)
                 guard_symtab guard { *this };
-                maybe_accept( node, &CatchStmt::decl );
-                maybe_accept( node, &CatchStmt::cond );
-                maybe_accept_as_compound( node, &CatchStmt::body );
-        }
-
-        VISIT_END( Stmt, node );
-}
-
-//--------------------------------------------------------------------------
-// FinallyStmt
-template< typename core_t >
-const ast::Stmt * ast::Pass< core_t >::visit( const ast::FinallyStmt * node ) {
-        VISIT_START( node );
-
-        if ( __visit_children() ) {
-                maybe_accept( node, &FinallyStmt::body );
-        }
-
-        VISIT_END( Stmt, node );
+                maybe_accept( node, &CatchClause::decl );
+                maybe_accept( node, &CatchClause::cond );
+                maybe_accept_as_compound( node, &CatchClause::body );
+        }
+
+        VISIT_END( CatchClause, node );
+}
+
+//--------------------------------------------------------------------------
+// FinallyClause
+template< typename core_t >
+const ast::FinallyClause * ast::Pass< core_t >::visit( const ast::FinallyClause * node ) {
+        VISIT_START( node );
+
+        if ( __visit_children() ) {
+                maybe_accept( node, &FinallyClause::body );
+        }
+
+        VISIT_END( FinallyClause, node );
 }
 
@@ -1054 +1053 @@
                         auto n = __pass::mutate<core_t>(node);
                         for(size_t i = 0; i < new_clauses.size(); i++) {
-                                if(new_clauses.at(i).target.func != nullptr) std::swap(n->clauses.at(i).target.func, new_clauses.at(i).target.func);
+                                if(new_clauses.at(i).target.func != nullptr) swap(n->clauses.at(i).target.func, new_clauses.at(i).target.func);
 
                                 for(size_t j = 0; j < new_clauses.at(i).target.args.size(); j++) {
-                                        if(new_clauses.at(i).target.args.at(j) != nullptr) std::swap(n->clauses.at(i).target.args.at(j), new_clauses.at(i).target.args.at(j));
+                                        if(new_clauses.at(i).target.args.at(j) != nullptr) swap(n->clauses.at(i).target.args.at(j), new_clauses.at(i).target.args.at(j));
                                 }
 
-                                if(new_clauses.at(i).stmt != nullptr) std::swap(n->clauses.at(i).stmt, new_clauses.at(i).stmt);
-                                if(new_clauses.at(i).cond != nullptr) std::swap(n->clauses.at(i).cond, new_clauses.at(i).cond);
+                                if(new_clauses.at(i).stmt != nullptr) swap(n->clauses.at(i).stmt, new_clauses.at(i).stmt);
+                                if(new_clauses.at(i).cond != nullptr) swap(n->clauses.at(i).cond, new_clauses.at(i).cond);
                         }
                         node = n;
@@ -1516 +1515 @@
                 }
                 maybe_accept( node, &TypeExpr::type );
+        }
+
+        VISIT_END( Expr, node );
+}
+
+//--------------------------------------------------------------------------
+// DimensionExpr
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::DimensionExpr * node ) {
+        VISIT_START( node );
+
+        if ( __visit_children() ) {
+                guard_symtab guard { *this };
+                maybe_accept( node, &DimensionExpr::result );
         }
 
@@ -1859 +1872 @@
 
         if ( __visit_children() ) {
-                // xxx - should PointerType visit/mutate dimension?
+                maybe_accept( node, &PointerType::dimension );
                 maybe_accept( node, &PointerType::base );
         }
@@ -2151 +2164 @@
 
         if ( __visit_children() ) {
-                {
-                        bool mutated = false;
-                        std::unordered_map< ast::TypeInstType::TypeEnvKey, ast::ptr< ast::Type > > new_map;
-                        for ( const auto & p : node->typeEnv ) {
-                                guard_symtab guard { *this };
-                                auto new_node = p.second->accept( *this );
-                                if (new_node != p.second) mutated = true;
-                                new_map.insert({ p.first, new_node });
-                        }
-                        if (mutated) {
-                                auto new_node = __pass::mutate<core_t>( node );
-                                new_node->typeEnv.swap( new_map );
-                                node = new_node;
-                        }
+                bool mutated = false;
+                std::unordered_map< ast::TypeInstType::TypeEnvKey, ast::ptr< ast::Type > > new_map;
+                for ( const auto & p : node->typeEnv ) {
+                        guard_symtab guard { *this };
+                        auto new_node = p.second->accept( *this );
+                        if (new_node != p.second) mutated = true;
+                        new_map.insert({ p.first, new_node });
+                }
+                if (mutated) {
+                        auto new_node = __pass::mutate<core_t>( node );
+                        new_node->typeEnv.swap( new_map );
+                        node = new_node;
                 }
         }