Changeset 9e23b446


Ignore:
Timestamp:
Jul 25, 2022, 2:23:00 PM (16 months ago)
Author:
Fangren Yu <f37yu@…>
Branches:
ADT, ast-experimental, master, pthread-emulation, qualifiedEnum
Children:
ffec1bf
Parents:
76a798d
Message:

add specialize pass

Location:
src
Files:
1 added
10 edited

Legend:

Unmodified
Added
Removed

  • src/AST/Pass.hpp

    r76a798d r9e23b446  
    264264        __pass::result1<ast::Stmt> call_accept_as_compound(const ast::Stmt *);
    265265
     266        // requests type environment to be updated (why is it implemented like this?)
     267        __pass::result1<ast::Expr> call_accept_top(const ast::Expr *);
     268
    266269        template< template <class...> class container_t >
    267270        __pass::resultNstmt<container_t> call_accept( const container_t< ptr<Stmt> > & );
    … …  
    277280        template<typename node_t, typename parent_t, typename field_t>
    278281        void maybe_accept_as_compound(const node_t * &, field_t parent_t::* field);
     282
     283        template<typename node_t, typename parent_t, typename field_t>
     284        void maybe_accept_top(const node_t * &, field_t parent_t::* field);
    279285
    280286private:

  • src/AST/Pass.impl.hpp

    r76a798d r9e23b446  
    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 
    162157                auto nval = expr->accept( *this );
    163158                return { nval != expr, nval };
    … …  
    171166                const ast::Stmt * nval = stmt->accept( *this );
    172167                return { nval != stmt, nval };
     168        }
     169
     170        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 };
    173182        }
    174183
    … …  
    410419
    411420                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 );
    412445
    413446                static_assert( !std::is_same<const ast::Node *, decltype(new_val)>::value /* || std::is_same<int, decltype(old_val)>::value */, "ERROR");
    … …  
    755788
    756789        if ( __visit_children() ) {
    757                 maybe_accept( node, &StaticAssertDecl::cond );
     790                maybe_accept_top( node, &StaticAssertDecl::cond );
    758791                maybe_accept( node, &StaticAssertDecl::msg  );
    759792        }
    … …  
    797830
    798831        if ( __visit_children() ) {
    799                 maybe_accept( node, &ExprStmt::expr );
     832                maybe_accept_top( node, &ExprStmt::expr );
    800833        }
    801834
    … …  
    838871                guard_symtab guard { *this };
    839872                maybe_accept( node, &IfStmt::inits    );
    840                 maybe_accept( node, &IfStmt::cond     );
     873                maybe_accept_top( node, &IfStmt::cond     );
    841874                maybe_accept_as_compound( node, &IfStmt::then );
    842875                maybe_accept_as_compound( node, &IfStmt::else_ );
    … …  
    856889                guard_symtab guard { *this };
    857890                maybe_accept( node, &WhileDoStmt::inits );
    858                 maybe_accept( node, &WhileDoStmt::cond  );
     891                maybe_accept_top( node, &WhileDoStmt::cond  );
    859892                maybe_accept_as_compound( node, &WhileDoStmt::body  );
    860893        }
    … …  
    874907                // xxx - old ast does not create WithStmtsToAdd scope for loop inits. should revisit this later.
    875908                maybe_accept( node, &ForStmt::inits );
    876                 maybe_accept( node, &ForStmt::cond  );
    877                 maybe_accept( node, &ForStmt::inc   );
     909                maybe_accept_top( node, &ForStmt::cond  );
     910                maybe_accept_top( node, &ForStmt::inc   );
    878911                maybe_accept_as_compound( node, &ForStmt::body  );
    879912        }
    … …  
    889922
    890923        if ( __visit_children() ) {
    891                 maybe_accept( node, &SwitchStmt::cond  );
     924                maybe_accept_top( node, &SwitchStmt::cond  );
    892925                maybe_accept( node, &SwitchStmt::cases );
    893926        }
    … …  
    903936
    904937        if ( __visit_children() ) {
    905                 maybe_accept( node, &CaseClause::cond  );
     938                maybe_accept_top( node, &CaseClause::cond  );
    906939                maybe_accept( node, &CaseClause::stmts );
    907940        }
    … …  
    925958
    926959        if ( __visit_children() ) {
    927                 maybe_accept( node, &ReturnStmt::expr );
     960                maybe_accept_top( node, &ReturnStmt::expr );
    928961        }
    929962
    … …  
    9701003                guard_symtab guard { *this };
    9711004                maybe_accept( node, &CatchClause::decl );
    972                 maybe_accept( node, &CatchClause::cond );
     1005                maybe_accept_top( node, &CatchClause::cond );
    9731006                maybe_accept_as_compound( node, &CatchClause::body );
    9741007        }
    … …  
    20572090
    20582091        if ( __visit_children() ) {
    2059                 maybe_accept( node, &SingleInit::value );
     2092                maybe_accept_top( node, &SingleInit::value );
    20602093        }
    20612094

  • src/AST/SymbolTable.cpp

    r76a798d r9e23b446  
    6565
    6666Expr * SymbolTable::IdData::combine( const CodeLocation & loc, ResolvExpr::Cost & cost ) const {
    67         Expr * ret = ( baseExpr ) ?
    68                 (Expr *)new MemberExpr{ loc, id, referenceToRvalueConversion( baseExpr, cost ) } :
    69                 (Expr *)new VariableExpr{ loc, id };
     67        Expr * ret;
     68        if ( baseExpr ) {
     69                if (baseExpr->env) {
     70                        Expr * base = shallowCopy(baseExpr);
     71                        const TypeSubstitution * subs = baseExpr->env;
     72                        base->env = nullptr;
     73                        ret = new MemberExpr{loc, id, referenceToRvalueConversion( base, cost )};
     74                        ret->env = subs;
     75                }
     76                else {
     77                        ret = new MemberExpr{ loc, id, referenceToRvalueConversion( baseExpr, cost ) };
     78                }
     79        }
     80        else {
     81                ret = new VariableExpr{ loc, id };
     82        }
    7083        if ( deleter ) { ret = new DeletedExpr{ loc, ret, deleter }; }
    7184        return ret;
    … …  
    772785                                                && ! dynamic_cast<const UnionInstType *>(rty) ) continue;
    773786                                        ResolvExpr::Cost cost = ResolvExpr::Cost::zero;
     787                                        ast::ptr<ast::TypeSubstitution> tmp = expr->env;
     788                                        expr = mutate_field(expr, &Expr::env, nullptr);
    774789                                        const Expr * base = ResolvExpr::referenceToRvalueConversion( expr, cost );
     790                                        base = mutate_field(base, &Expr::env, tmp);
     791
    775792                                        addMembers(
    776793                                                rty->aggr(), new MemberExpr{ base->location, dwt, base }, handleConflicts );

  • src/AST/TypeSubstitution.cpp

    r76a798d r9e23b446  
    9797                TypeSubstitution * newEnv;
    9898                EnvTrimmer( const TypeSubstitution * env, TypeSubstitution * newEnv ) : env( env ), newEnv( newEnv ){}
    99                 void previsit( FunctionType * ftype ) {
     99                void previsit( const FunctionType * ftype ) {
    100100                        // transfer known bindings for seen type variables
    101101                        for (auto & formal : ftype->forall) {

  • src/GenPoly/Specialize.h

    r76a798d r9e23b446  
    1717
    1818#include <list>  // for list
     19#include "AST/TranslationUnit.hpp"
    1920
    2021class Declaration;
    … …  
    2324        /// generates thunks where needed
    2425        void convertSpecializations( std::list< Declaration* >& translationUnit );
     26
     27        void convertSpecializations( ast::TranslationUnit & translationUnit );
    2528} // namespace GenPoly
    2629

  • src/GenPoly/module.mk

    r76a798d r9e23b446  
    3434        GenPoly/ScrubTyVars.h \
    3535        GenPoly/Specialize.cc \
     36        GenPoly/SpecializeNew.cpp \
    3637        GenPoly/Specialize.h
    3738

  • src/InitTweak/FixInitNew.cpp

    r76a798d r9e23b446  
    7373        /// wrap function application expressions as ImplicitCopyCtorExpr nodes so that it is easy to identify which
    7474        /// function calls need their parameters to be copy constructed
    75         struct InsertImplicitCalls : public ast::WithConstTypeSubstitution, public ast::WithShortCircuiting {
     75        struct InsertImplicitCalls : public ast::WithShortCircuiting {
    7676                const ast::Expr * postvisit( const ast::ApplicationExpr * appExpr );
    7777
    … …  
    457457                // is needed to obtain the type of temporary variables so that copy
    458458                // constructor calls can be resolved.
    459                 assert( typeSubs );
    460459                expr->env = tmp;
    461460                return expr;

  • src/ResolvExpr/CandidateFinder.cpp

    r76a798d r9e23b446  
    12651265                                        newExpr, copy( tenv ), ast::OpenVarSet{}, ast::AssertionSet{}, Cost::zero,
    12661266                                        cost );
     1267
     1268                                if (newCand->expr->env) {
     1269                                        newCand->env.add(*newCand->expr->env);
     1270                                        auto mutExpr = newCand->expr.get_and_mutate();
     1271                                        mutExpr->env  = nullptr;
     1272                                        newCand->expr = mutExpr;
     1273                                }
     1274
    12671275                                PRINT(
    12681276                                        std::cerr << "decl is ";

  • src/ResolvExpr/Resolver.cc

    r76a798d r9e23b446  
    15551555                if ( type->dimension ) {
    15561556                        ast::ptr< ast::Type > sizeType = context.global.sizeType;
     1557                        ast::ptr< ast::Expr > dimension = findSingleExpression( type->dimension, sizeType, context );
     1558                        assertf(dimension->env->empty(), "array dimension expr has nonempty env");
     1559                        dimension.get_and_mutate()->env = nullptr;
    15571560                        ast::mutate_field(
    15581561                                type, &PtrType::dimension,
    1559                                 findSingleExpression( type->dimension, sizeType, context ) );
     1562                                dimension);
    15601563                }
    15611564                return type;
    … …  
    20082011                                tmp->accept( *visitor );
    20092012                        }
     2013                        else if (expr->env && expr->env->empty()) {
     2014                                expr = ast::mutate_field(expr.get(), &ast::Expr::env, nullptr);
     2015                        }
    20102016                }
    20112017        }

  • src/main.cc

    r76a798d r9e23b446  
    449449                        PASS( "Translate Tries", ControlStruct::translateTries( transUnit ) );
    450450                        PASS( "Gen Waitfor", Concurrency::generateWaitFor( transUnit ) );
     451                        PASS( "Convert Specializations",  GenPoly::convertSpecializations( transUnit ) ); // needs to happen before tuple types are expanded
     452
    451453
    452454                        translationUnit = convert( move( transUnit ) );
    … …  
    520522                        PASS( "Translate Tries", ControlStruct::translateTries( translationUnit ) );
    521523                        PASS( "Gen Waitfor", Concurrency::generateWaitFor( translationUnit ) );
     524                        PASS( "Convert Specializations",  GenPoly::convertSpecializations( translationUnit ) ); // needs to happen before tuple types are expanded
     525
    522526                }
    523527
    524                 PASS( "Convert Specializations",  GenPoly::convertSpecializations( translationUnit ) ); // needs to happen before tuple types are expanded
     528
     529                // PASS( "Convert Specializations",  GenPoly::convertSpecializations( translationUnit ) ); // needs to happen before tuple types are expanded
    525530
    526531                PASS( "Expand Tuples", Tuples::expandTuples( translationUnit ) ); // xxx - is this the right place for this?
Note: See TracChangeset for help on using the changeset viewer.