Changes in src/AST/Pass.impl.hpp [293dc1c:954c954]

File:

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

src/AST/Pass.impl.hpp

@@ -20 +20 @@
 #include <unordered_map>
 
-#include "AST/TranslationUnit.hpp"
 #include "AST/TypeSubstitution.hpp"
 
@@ -168 +167 @@
                 __pedantic_pass_assert( stmt );
 
-                return stmt->accept( *this );
-        }
-
-        template< typename core_t >
-        const ast::Stmt * ast::Pass< core_t >::call_accept_as_compound( const ast::Stmt * stmt ) {
-                __pedantic_pass_assert( __visit_children() );
-                __pedantic_pass_assert( stmt );
-
                 // add a few useful symbols to the scope
                 using __pass::empty;
@@ -343 +334 @@
         }
 
-        template< typename core_t >
-        template<typename node_t, typename parent_t, typename child_t>
-        void ast::Pass< core_t >::maybe_accept_as_compound(
-                const node_t * & parent,
-                child_t parent_t::*child
-        ) {
-                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");
-
-                auto new_val = call_accept_as_compound( old_val );
-
-                static_assert( !std::is_same<const ast::Node *, decltype(new_val)>::value || std::is_same<int, decltype(old_val)>::value, "ERROR");
-
-                if( __pass::differs(old_val, new_val) ) {
-                        auto new_parent = __pass::mutate<core_t>(parent);
-                        new_parent->*child = new_val;
-                        parent = new_parent;
-                }
-        }
-
 
         template< typename core_t >
@@ -431 +398 @@
         pass_visitor_stats.depth--;
         if ( !errors.isEmpty() ) { throw errors; }
-}
-
-template< typename core_t >
-inline void ast::accept_all( ast::TranslationUnit & unit, ast::Pass< core_t > & visitor ) {
-        return ast::accept_all( unit.decls, visitor );
 }
 
@@ -508 +470 @@
                                 // foralls are still in function type
                                 maybe_accept( node, &FunctionDecl::type );
-                                // First remember that we are now within a function.
+                                // function body needs to have the same scope as parameters - CompoundStmt will not enter
+                                // a new scope if inFunction is true
                                 ValueGuard< bool > oldInFunction( inFunction );
                                 inFunction = true;
-                                // The function body needs to have the same scope as parameters.
-                                // A CompoundStmt will not enter a new scope if atFunctionTop is true.
-                                ValueGuard< bool > oldAtFunctionTop( atFunctionTop );
-                                atFunctionTop = true;
                                 maybe_accept( node, &FunctionDecl::stmts );
                                 maybe_accept( node, &FunctionDecl::attributes );
@@ -680 +639 @@
 const ast::CompoundStmt * ast::Pass< core_t >::visit( const ast::CompoundStmt * node ) {
         VISIT_START( node );
-        VISIT(
-                // Do not enter (or leave) a new scope if atFunctionTop. Remember to save the result.
-                auto guard1 = makeFuncGuard( [this, enterScope = !this->atFunctionTop]() {
-                        if ( enterScope ) __pass::symtab::enter(core, 0);
-                }, [this, leaveScope = !this->atFunctionTop]() {
-                        if ( leaveScope ) __pass::symtab::leave(core, 0);
+        VISIT({
+                // do not enter a new scope if inFunction is true - needs to check old state before the assignment
+                auto guard1 = makeFuncGuard( [this, inFunctionCpy = this->inFunction]() {
+                        if ( ! inFunctionCpy ) __pass::symtab::enter(core, 0);
+                }, [this, inFunctionCpy = this->inFunction]() {
+                        if ( ! inFunctionCpy ) __pass::symtab::leave(core, 0);
                 });
-                ValueGuard< bool > guard2( atFunctionTop );
-                atFunctionTop = false;
+                ValueGuard< bool > guard2( inFunction );
                 guard_scope guard3 { *this };
+                inFunction = false;
                 maybe_accept( node, &CompoundStmt::kids );
-        )
+        })
         VISIT_END( CompoundStmt, node );
 }
@@ -744 +703 @@
                 maybe_accept( node, &IfStmt::inits    );
                 maybe_accept( node, &IfStmt::cond     );
-                maybe_accept_as_compound( node, &IfStmt::thenPart );
-                maybe_accept_as_compound( node, &IfStmt::elsePart );
+                maybe_accept( node, &IfStmt::thenPart );
+                maybe_accept( node, &IfStmt::elsePart );
         })
 
@@ -762 +721 @@
                 maybe_accept( node, &WhileStmt::inits );
                 maybe_accept( node, &WhileStmt::cond  );
-                maybe_accept_as_compound( node, &WhileStmt::body  );
+                maybe_accept( node, &WhileStmt::body  );
         })
 
@@ -777 +736 @@
                 // for statements introduce a level of scope (for the initialization)
                 guard_symtab guard { *this };
-                // xxx - old ast does not create WithStmtsToAdd scope for loop inits. should revisit this later.
                 maybe_accept( node, &ForStmt::inits );
                 maybe_accept( node, &ForStmt::cond  );
                 maybe_accept( node, &ForStmt::inc   );
-                maybe_accept_as_compound( node, &ForStmt::body  );
+                maybe_accept( node, &ForStmt::body  );
         })
 
@@ -876 +834 @@
                 maybe_accept( node, &CatchStmt::decl );
                 maybe_accept( node, &CatchStmt::cond );
-                maybe_accept_as_compound( node, &CatchStmt::body );
+                maybe_accept( node, &CatchStmt::body );
         })