Changeset d3aa64f


Ignore:
Timestamp:
Aug 31, 2020, 6:55:22 PM (14 months ago)
Author:
Fangren Yu <f37yu@…>
Branches:
arm-eh, jacob/cs343-translation, master, new-ast-unique-expr
Children:
25a1cb0, 68f0c4e
Parents:
49a980b
Message:

pure visitor interface for new ast

Location:
src
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • src/AST/Copy.hpp

    r49a980b rd3aa64f  
    2121#include "Stmt.hpp"
    2222#include "Type.hpp"
     23#include <unordered_set>
     24#include <unordered_map>
    2325
    2426namespace ast {
  • src/AST/Pass.hpp

    r49a980b rd3aa64f  
    266266
    267267/// Keep track of the polymorphic const TypeSubstitution * env for the current expression
     268
     269/// marker to force shallow copies in pass visit
     270struct PureVisitor {};
     271
    268272struct WithConstTypeSubstitution {
    269273        const TypeSubstitution * env = nullptr;
  • src/AST/Pass.impl.hpp

    r49a980b rd3aa64f  
    2121
    2222#include "AST/TypeSubstitution.hpp"
     23// #include "AST/Copy.hpp"
    2324
    2425#define VISIT_START( node ) \
     
    5758
    5859namespace ast {
     60        template<typename node_t>
     61        node_t * shallowCopy( const node_t * node );
     62
    5963        namespace __pass {
    6064                // Check if this is either a null pointer or a pointer to an empty container
     
    6266                static inline bool empty( T * ptr ) {
    6367                        return !ptr || ptr->empty();
     68                }
     69
     70                template< typename core_t, typename node_t >
     71                static inline node_t* mutate(const node_t *node) {
     72                        return std::is_base_of<PureVisitor, core_t>::value ? ::ast::shallowCopy(node) : ::ast::mutate(node);
    6473                }
    6574
     
    320329
    321330                if( __pass::differs(old_val, new_val) ) {
    322                         auto new_parent = mutate(parent);
     331                        // auto new_parent = mutate(parent);
     332                        auto new_parent = __pass::mutate<core_t>(parent);
    323333                        new_parent->*child = new_val;
    324334                        parent = new_parent;
     
    334344                        if ( node->forall.empty() ) return;
    335345
    336                         node_t * mut = mutate( node );
     346                        node_t * mut = __pass::mutate<core_t>( node );
    337347                        mut->forall = subs->clone( node->forall, *this );
    338348                        node = mut;
     
    894904
    895905                if(mutated) {
    896                         auto n = mutate(node);
     906                        auto n = __pass::mutate<core_t>(node);
    897907                        n->clauses = std::move( new_clauses );
    898908                        node = n;
     
    904914                        auto nval = call_accept( node->field ); \
    905915                        if(nval != node->field ) { \
    906                                 auto nparent = mutate(node); \
     916                                auto nparent = __pass::mutate<core_t>(node); \
    907917                                nparent->field = nval; \
    908918                                node = nparent; \
     
    16101620
    16111621                if(mutated) {
    1612                         auto n = mutate(node);
     1622                        auto n = __pass::mutate<core_t>(node);
    16131623                        n->associations = std::move( new_kids );
    16141624                        node = n;
     
    19401950                        }
    19411951                        if (mutated) {
    1942                                 auto new_node = mutate( node );
     1952                                auto new_node = __pass::mutate<core_t>( node );
    19431953                                new_node->typeEnv.swap( new_map );
    19441954                                node = new_node;
     
    19561966                        }
    19571967                        if (mutated) {
    1958                                 auto new_node = mutate( node );
     1968                                auto new_node = __pass::mutate<core_t>( node );
    19591969                                new_node->varEnv.swap( new_map );
    19601970                                node = new_node;
  • src/AST/Pass.proto.hpp

    r49a980b rd3aa64f  
    2222template<typename core_t>
    2323class Pass;
     24
     25struct PureVisitor;
    2426
    2527namespace __pass {
  • src/AST/TypeSubstitution.hpp

    r49a980b rd3aa64f  
    159159
    160160// definitition must happen after PassVisitor is included so that WithGuards can be used
    161 struct TypeSubstitution::Substituter : public WithGuards, public WithVisitorRef<Substituter> {
     161struct TypeSubstitution::Substituter : public WithGuards, public WithVisitorRef<Substituter>, public PureVisitor {
    162162                static size_t traceId;
    163163
     
    187187        assert( input );
    188188        Pass<Substituter> sub( *this, false );
    189         input = strict_dynamic_cast< const SynTreeClass * >( deepCopy(input)->accept( sub ) );
     189//      input = strict_dynamic_cast< const SynTreeClass * >( deepCopy(input)->accept( sub ) );
     190        input = strict_dynamic_cast< const SynTreeClass * >( input->accept( sub ) );
    190191        return { input, sub.core.subCount };
    191192}
     
    195196        assert( input );
    196197        Pass<Substituter> sub( *this, true );
    197         input = strict_dynamic_cast< const SynTreeClass * >( deepCopy(input)->accept( sub ) );
     198//      input = strict_dynamic_cast< const SynTreeClass * >( deepCopy(input)->accept( sub ) );
     199        input = strict_dynamic_cast< const SynTreeClass * >( input->accept( sub ) );
    198200        return { input, sub.core.subCount };
    199201}
  • src/ResolvExpr/Unify.cc

    r49a980b rd3aa64f  
    767767                /// If this isn't done when satifying ttype assertions, then argument lists can have
    768768                /// different size and structure when they should be compatible.
    769                 struct TtypeExpander_new : public ast::WithShortCircuiting {
     769                struct TtypeExpander_new : public ast::WithShortCircuiting, public ast::PureVisitor {
    770770                        ast::TypeEnvironment & tenv;
    771771
     
    793793                                // TtypeExpander pass is impure (may mutate nodes in place)
    794794                                // need to make nodes shared to prevent accidental mutation
    795                                 ast::ptr<ast::DeclWithType> dc = d;
    796                                 dc = dc->accept( expander );
     795                                ast::ptr<ast::DeclWithType> dc = d->accept(expander);
    797796                                auto types = flatten( dc->get_type() );
    798797                                for ( ast::ptr< ast::Type > & t : types ) {
     
    11141113                        ast::Pass<TtypeExpander_new> expander{ tenv };
    11151114
    1116                         ast::ptr<ast::TupleType> tuplec = tuple;
    1117                         ast::ptr<ast::TupleType> tuple2c = tuple2;
    1118                         const ast::Type * flat = tuplec->accept( expander );
    1119                         const ast::Type * flat2 = tuple2c->accept( expander );
     1115                        // ast::ptr<ast::TupleType> tuplec = tuple;
     1116                        // ast::ptr<ast::TupleType> tuple2c = tuple2;
     1117                        const ast::Type * flat = tuple->accept( expander );
     1118                        const ast::Type * flat2 = tuple2->accept( expander );
    11201119
    11211120                        auto types = flatten( flat );
Note: See TracChangeset for help on using the changeset viewer.