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

File:

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

src/AST/Pass.impl.hpp

@@ -167 +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;
@@ -332 +324 @@
 
                 auto new_val = call_accept( 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 >
-        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");
@@ -502 +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 );
@@ -675 +640 @@
         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);
+                // 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( inFunction );
@@ -738 +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 );
         })
 
@@ -756 +721 @@
                 maybe_accept( node, &WhileStmt::inits );
                 maybe_accept( node, &WhileStmt::cond  );
-                maybe_accept_as_compound( node, &WhileStmt::body  );
+                maybe_accept( node, &WhileStmt::body  );
         })
 
@@ -771 +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  );
         })
 
@@ -870 +834 @@
                 maybe_accept( node, &CatchStmt::decl );
                 maybe_accept( node, &CatchStmt::cond );
-                maybe_accept_as_compound( node, &CatchStmt::body );
+                maybe_accept( node, &CatchStmt::body );
         })