Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/AST/Pass.impl.hpp

    r9e23b446 r1df492a  
    155155                __pedantic_pass_assert( expr );
    156156
     157                const ast::TypeSubstitution ** typeSubs_ptr = __pass::typeSubs( core, 0 );
     158                if ( typeSubs_ptr && expr->env ) {
     159                        *typeSubs_ptr = expr->env;
     160                }
     161
    157162                auto nval = expr->accept( *this );
    158163                return { nval != expr, nval };
    … …  
    169174
    170175        template< typename core_t >
    171         __pass::template result1<ast::Expr> ast::Pass< core_t >::call_accept_top( const ast::Expr * expr ) {
    172                 __pedantic_pass_assert( __visit_children() );
    173                 __pedantic_pass_assert( expr );
    174 
    175                 const ast::TypeSubstitution ** typeSubs_ptr = __pass::typeSubs( core, 0 );
    176                 if ( typeSubs_ptr && expr->env ) {
    177                         *typeSubs_ptr = expr->env;
    178                 }
    179 
    180                 auto nval = expr->accept( *this );
    181                 return { nval != expr, nval };
    182         }
    183 
    184         template< typename core_t >
    185176        __pass::template result1<ast::Stmt> ast::Pass< core_t >::call_accept_as_compound( const ast::Stmt * stmt ) {
    186177                __pedantic_pass_assert( __visit_children() );
    … …  
    191182
    192183                // get the stmts/decls that will need to be spliced in
    193                 auto stmts_before = __pass::stmtsToAddBefore( core, 0 );
    194                 auto stmts_after  = __pass::stmtsToAddAfter ( core, 0 );
    195                 auto decls_before = __pass::declsToAddBefore( core, 0 );
    196                 auto decls_after  = __pass::declsToAddAfter ( core, 0 );
     184                auto stmts_before = __pass::stmtsToAddBefore( core, 0);
     185                auto stmts_after  = __pass::stmtsToAddAfter ( core, 0);
     186                auto decls_before = __pass::declsToAddBefore( core, 0);
     187                auto decls_after  = __pass::declsToAddAfter ( core, 0);
    197188
    198189                // These may be modified by subnode but most be restored once we exit this statemnet.
    … …  
    296287
    297288                // get the stmts/decls that will need to be spliced in
    298                 auto stmts_before = __pass::stmtsToAddBefore( core, 0 );
    299                 auto stmts_after  = __pass::stmtsToAddAfter ( core, 0 );
    300                 auto decls_before = __pass::declsToAddBefore( core, 0 );
    301                 auto decls_after  = __pass::declsToAddAfter ( core, 0 );
     289                auto stmts_before = __pass::stmtsToAddBefore( core, 0);
     290                auto stmts_after  = __pass::stmtsToAddAfter ( core, 0);
     291                auto decls_before = __pass::declsToAddBefore( core, 0);
     292                auto decls_after  = __pass::declsToAddAfter ( core, 0);
    302293
    303294                // These may be modified by subnode but most be restored once we exit this statemnet.
    … …  
    326317                                assert(( empty( stmts_before ) && empty( stmts_after ))
    327318                                    || ( empty( decls_before ) && empty( decls_after )) );
     319
     320
    328321
    329322                                // Take all the statements which should have gone after, N/A for first iteration
    … …  
    419412
    420413                auto new_val = call_accept( old_val );
    421 
    422                 static_assert( !std::is_same<const ast::Node *, decltype(new_val)>::value /* || std::is_same<int, decltype(old_val)>::value */, "ERROR");
    423 
    424                 if( new_val.differs ) {
    425                         auto new_parent = __pass::mutate<core_t>(parent);
    426                         new_val.apply(new_parent, field);
    427                         parent = new_parent;
    428                 }
    429         }
    430 
    431         template< typename core_t >
    432         template<typename node_t, typename super_t, typename field_t>
    433         void ast::Pass< core_t >::maybe_accept_top(
    434                 const node_t * & parent,
    435                 field_t super_t::*field
    436         ) {
    437                 static_assert( std::is_base_of<super_t, node_t>::value, "Error deducing member object" );
    438 
    439                 if(__pass::skip(parent->*field)) return;
    440                 const auto & old_val = __pass::get(parent->*field, 0);
    441 
    442                 static_assert( !std::is_same<const ast::Node * &, decltype(old_val)>::value, "ERROR");
    443 
    444                 auto new_val = call_accept_top( old_val );
    445414
    446415                static_assert( !std::is_same<const ast::Node *, decltype(new_val)>::value /* || std::is_same<int, decltype(old_val)>::value */, "ERROR");
    … …  
    681650        if ( __visit_children() ) {
    682651                // unlike structs, traits, and unions, enums inject their members into the global scope
     652                maybe_accept( node, &EnumDecl::base );
    683653                maybe_accept( node, &EnumDecl::params     );
    684654                maybe_accept( node, &EnumDecl::members    );
    … …  
    788758
    789759        if ( __visit_children() ) {
    790                 maybe_accept_top( node, &StaticAssertDecl::cond );
     760                maybe_accept( node, &StaticAssertDecl::cond );
    791761                maybe_accept( node, &StaticAssertDecl::msg  );
    792762        }
    … …  
    830800
    831801        if ( __visit_children() ) {
    832                 maybe_accept_top( node, &ExprStmt::expr );
     802                maybe_accept( node, &ExprStmt::expr );
    833803        }
    834804
    … …  
    871841                guard_symtab guard { *this };
    872842                maybe_accept( node, &IfStmt::inits    );
    873                 maybe_accept_top( node, &IfStmt::cond     );
     843                maybe_accept( node, &IfStmt::cond     );
    874844                maybe_accept_as_compound( node, &IfStmt::then );
    875845                maybe_accept_as_compound( node, &IfStmt::else_ );
    … …  
    889859                guard_symtab guard { *this };
    890860                maybe_accept( node, &WhileDoStmt::inits );
    891                 maybe_accept_top( node, &WhileDoStmt::cond  );
     861                maybe_accept( node, &WhileDoStmt::cond  );
    892862                maybe_accept_as_compound( node, &WhileDoStmt::body  );
    893863        }
    … …  
    907877                // xxx - old ast does not create WithStmtsToAdd scope for loop inits. should revisit this later.
    908878                maybe_accept( node, &ForStmt::inits );
    909                 maybe_accept_top( node, &ForStmt::cond  );
    910                 maybe_accept_top( node, &ForStmt::inc   );
     879                maybe_accept( node, &ForStmt::cond  );
     880                maybe_accept( node, &ForStmt::inc   );
    911881                maybe_accept_as_compound( node, &ForStmt::body  );
    912882        }
    … …  
    922892
    923893        if ( __visit_children() ) {
    924                 maybe_accept_top( node, &SwitchStmt::cond  );
     894                maybe_accept( node, &SwitchStmt::cond  );
    925895                maybe_accept( node, &SwitchStmt::cases );
    926896        }
    … …  
    936906
    937907        if ( __visit_children() ) {
    938                 maybe_accept_top( node, &CaseClause::cond  );
     908                maybe_accept( node, &CaseClause::cond  );
    939909                maybe_accept( node, &CaseClause::stmts );
    940910        }
    … …  
    958928
    959929        if ( __visit_children() ) {
    960                 maybe_accept_top( node, &ReturnStmt::expr );
     930                maybe_accept( node, &ReturnStmt::expr );
    961931        }
    962932
    … …  
    1003973                guard_symtab guard { *this };
    1004974                maybe_accept( node, &CatchClause::decl );
    1005                 maybe_accept_top( node, &CatchClause::cond );
     975                maybe_accept( node, &CatchClause::cond );
    1006976                maybe_accept_as_compound( node, &CatchClause::body );
    1007977        }
    … …  
    20902060
    20912061        if ( __visit_children() ) {
    2092                 maybe_accept_top( node, &SingleInit::value );
     2062                maybe_accept( node, &SingleInit::value );
    20932063        }
    20942064
    … …  
    21462116        if ( __visit_children() ) {
    21472117                bool mutated = false;
    2148                 ast::TypeSubstitution::TypeMap new_map;
    2149                 for ( const auto & p : node->typeMap ) {
     2118                std::unordered_map< ast::TypeInstType::TypeEnvKey, ast::ptr< ast::Type > > new_map;
     2119                for ( const auto & p : node->typeEnv ) {
    21502120                        guard_symtab guard { *this };
    21512121                        auto new_node = p.second->accept( *this );
    … …  
    21552125                if (mutated) {
    21562126                        auto new_node = __pass::mutate<core_t>( node );
    2157                         new_node->typeMap.swap( new_map );
     2127                        new_node->typeEnv.swap( new_map );
    21582128                        node = new_node;
    21592129                }
Note: See TracChangeset for help on using the changeset viewer.