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

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;
@@ -324 +332 @@
 
                 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");
@@ -470 +502 @@
                                 // foralls are still in function type
                                 maybe_accept( node, &FunctionDecl::type );
-                                // function body needs to have the same scope as parameters - CompoundStmt will not enter
-                                // a new scope if inFunction is true
+                                // First remember that we are now within a function.
                                 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 );
@@ -640 +675 @@
         VISIT_START( node );
         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);
+                // 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);
                 });
                 ValueGuard< bool > guard2( inFunction );
@@ -703 +738 @@
                 maybe_accept( node, &IfStmt::inits    );
                 maybe_accept( node, &IfStmt::cond     );
-                maybe_accept( node, &IfStmt::thenPart );
-                maybe_accept( node, &IfStmt::elsePart );
+                maybe_accept_as_compound( node, &IfStmt::thenPart );
+                maybe_accept_as_compound( node, &IfStmt::elsePart );
         })
 
@@ -721 +756 @@
                 maybe_accept( node, &WhileStmt::inits );
                 maybe_accept( node, &WhileStmt::cond  );
-                maybe_accept( node, &WhileStmt::body  );
+                maybe_accept_as_compound( node, &WhileStmt::body  );
         })
 
@@ -736 +771 @@
                 // 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( node, &ForStmt::body  );
+                maybe_accept_as_compound( node, &ForStmt::body  );
         })
 
@@ -834 +870 @@
                 maybe_accept( node, &CatchStmt::decl );
                 maybe_accept( node, &CatchStmt::cond );
-                maybe_accept( node, &CatchStmt::body );
+                maybe_accept_as_compound( node, &CatchStmt::body );
         })