Changes in src/AST/Pass.impl.hpp [4ec9513:eb211bf]

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 ) swap(container[i], values[i]);
+                        if( values[i] != nullptr ) std::swap(container[i], values[i]);
                 }
 
@@ -399 +399 @@
 
         template< typename core_t >
-        template<typename node_t, typename super_t, typename field_t>
+        template<typename node_t, typename parent_t, typename child_t>
         void ast::Pass< core_t >::maybe_accept(
                 const node_t * & parent,
-                field_t super_t::*field
+                child_t parent_t::*child
         ) {
-                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_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_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, field);
+                        new_val.apply(new_parent, child);
                         parent = new_parent;
                 }
@@ -423 +423 @@
 
         template< typename core_t >
-        template<typename node_t, typename super_t, typename field_t>
+        template<typename node_t, typename parent_t, typename child_t>
         void ast::Pass< core_t >::maybe_accept_as_compound(
                 const node_t * & parent,
-                field_t super_t::*child
+                child_t parent_t::*child
         ) {
-                static_assert( std::is_base_of<super_t, node_t>::value, "Error deducing member object" );
+                static_assert( std::is_base_of<parent_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::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::params );
-                                maybe_accept( node, &FunctionDecl::returns );
-                                maybe_accept( node, &FunctionDecl::type );
                                 // First remember that we are now within a function.
                                 ValueGuard< bool > oldInFunction( inFunction );
@@ -892 +893 @@
         if ( __visit_children() ) {
                 maybe_accept( node, &SwitchStmt::cond  );
-                maybe_accept( node, &SwitchStmt::cases );
+                maybe_accept( node, &SwitchStmt::stmts );
         }
 
@@ -899 +900 @@
 
 //--------------------------------------------------------------------------
-// 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 );
+// 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 );
 }
 
@@ -963 +964 @@
 
 //--------------------------------------------------------------------------
-// CatchClause
-template< typename core_t >
-const ast::CatchClause * ast::Pass< core_t >::visit( const ast::CatchClause * node ) {
+// CatchStmt
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::CatchStmt * node ) {
         VISIT_START( node );
 
@@ -971 +972 @@
                 // catch statements introduce a level of scope (for the caught exception)
                 guard_symtab guard { *this };
-                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 );
+                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 );
 }
 
@@ -1053 +1054 @@
                         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) swap(n->clauses.at(i).target.func, new_clauses.at(i).target.func);
+                                if(new_clauses.at(i).target.func != nullptr) std::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) 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) std::swap(n->clauses.at(i).target.args.at(j), new_clauses.at(i).target.args.at(j));
                                 }
 
-                                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);
+                                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);
                         }
                         node = n;
@@ -1515 +1516 @@
                 }
                 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 );
         }
 
@@ -1872 +1859 @@
 
         if ( __visit_children() ) {
-                maybe_accept( node, &PointerType::dimension );
+                // xxx - should PointerType visit/mutate dimension?
                 maybe_accept( node, &PointerType::base );
         }
@@ -2164 +2151 @@
 
         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;
+                        }
                 }
         }