Changeset 907eccb


Ignore:
Timestamp:
Dec 22, 2016, 3:23:49 PM (8 years ago)
Author:
Rob Schluntz <rschlunt@…>
Branches:
ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc
Children:
4c8621ac
Parents:
0c286cf
Message:

added UntypedTupleExpr? to better differentiate typed and untyped contexts, simplifying some code

Location:
src
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • src/CodeGen/CodeGenerator.cc

    r0c286cf r907eccb  
    656656        }
    657657
    658         void CodeGenerator::visit( TupleExpr * tupleExpr ) { assert( false ); }
     658        void CodeGenerator::visit( UntypedTupleExpr * tupleExpr ) { assertf( false, "UntypedTupleExpr should not make it to Code Gen" ); }
     659
     660        void CodeGenerator::visit( TupleExpr * tupleExpr ) { assertf( false, "TupleExpr should not make it to Code Gen" ); }
    659661
    660662        void CodeGenerator::visit( TypeExpr * typeExpr ) {}

  • src/CodeGen/CodeGenerator.h

    r0c286cf r907eccb  
    7272                virtual void visit( CommaExpr *commaExpr );
    7373                virtual void visit( CompoundLiteralExpr *compLitExpr );
     74                virtual void visit( UntypedTupleExpr *tupleExpr );
    7475                virtual void visit( TupleExpr *tupleExpr );
    7576                virtual void visit( TypeExpr *typeExpr );

  • src/InitTweak/InitTweak.cc

    r0c286cf r907eccb  
    487487                virtual void visit( UntypedValofExpr *valofExpr ) { isConstExpr = false; }
    488488                virtual void visit( CompoundLiteralExpr *compLitExpr ) { isConstExpr = false; }
     489                virtual void visit( UntypedTupleExpr *tupleExpr ) { isConstExpr = false; }
    489490                virtual void visit( TupleExpr *tupleExpr ) { isConstExpr = false; }
    490491                virtual void visit( TupleAssignExpr *tupleExpr ) { isConstExpr = false; }

  • src/Parser/ExpressionNode.cc

    r0c286cf r907eccb  
    323323
    324324Expression *build_tuple( ExpressionNode * expr_node ) {
    325         TupleExpr *ret = new TupleExpr();
    326         buildMoveList( expr_node, ret->get_exprs() );
    327         return ret;
     325        std::list< Expression * > exprs;
     326        buildMoveList( expr_node, exprs );
     327        return new UntypedTupleExpr( exprs );;
    328328}
    329329

  • src/ResolvExpr/AlternativeFinder.cc

    r0c286cf r907eccb  
    351351                if ( TupleType * tupleType = dynamic_cast< TupleType * >( formalType ) ) {
    352352                        // formalType is a TupleType - group actuals into a TupleExpr whose type unifies with the TupleType
    353                         TupleExpr * tupleExpr = new TupleExpr();
     353                        std::list< Expression * > exprs;
    354354                        for ( Type * type : *tupleType ) {
    355                                 if ( ! instantiateArgument( type, defaultValue, actualIt, actualEnd, openVars, resultEnv, resultNeed, resultHave, indexer, cost, back_inserter( tupleExpr->get_exprs() ) ) ) {
    356                                         delete tupleExpr;
     355                                if ( ! instantiateArgument( type, defaultValue, actualIt, actualEnd, openVars, resultEnv, resultNeed, resultHave, indexer, cost, back_inserter( exprs ) ) ) {
     356                                        deleteAll( exprs );
    357357                                        return false;
    358358                                }
    359359                        }
    360                         tupleExpr->set_result( Tuples::makeTupleType( tupleExpr->get_exprs() ) );
    361                         *out++ = tupleExpr;
     360                        *out++ = new TupleExpr( exprs );
    362361                } else if ( actualIt != actualEnd ) {
    363362                        if ( TypeInstType * ttype = Tuples::isTtype( formalType ) ) {
    … …  
    10581057        }
    10591058
    1060         void AlternativeFinder::visit( TupleExpr *tupleExpr ) {
     1059        void AlternativeFinder::visit( UntypedTupleExpr *tupleExpr ) {
    10611060                std::list< AlternativeFinder > subExprAlternatives;
    10621061                findSubExprs( tupleExpr->get_exprs().begin(), tupleExpr->get_exprs().end(), back_inserter( subExprAlternatives ) );
    … …  
    10641063                combos( subExprAlternatives.begin(), subExprAlternatives.end(), back_inserter( possibilities ) );
    10651064                for ( std::list< AltList >::const_iterator i = possibilities.begin(); i != possibilities.end(); ++i ) {
    1066                         TupleExpr *newExpr = new TupleExpr;
    1067                         makeExprList( *i, newExpr->get_exprs() );
    1068                         newExpr->set_result( Tuples::makeTupleType( newExpr->get_exprs() ) );
     1065                        std::list< Expression * > exprs;
     1066                        makeExprList( *i, exprs );
    10691067
    10701068                        TypeEnvironment compositeEnv;
    10711069                        simpleCombineEnvironments( i->begin(), i->end(), compositeEnv );
    1072                         alternatives.push_back( Alternative( newExpr, compositeEnv, sumCost( *i ) ) );
     1070                        alternatives.push_back( Alternative( new TupleExpr( exprs ) , compositeEnv, sumCost( *i ) ) );
    10731071                } // for
     1072        }
     1073
     1074        void AlternativeFinder::visit( TupleExpr *tupleExpr ) {
     1075                alternatives.push_back( Alternative( tupleExpr->clone(), env, Cost::zero ) );
    10741076        }
    10751077

  • src/ResolvExpr/AlternativeFinder.h

    r0c286cf r907eccb  
    6464                virtual void visit( ConditionalExpr *conditionalExpr );
    6565                virtual void visit( CommaExpr *commaExpr );
    66                 virtual void visit( TupleExpr *tupleExpr );
    6766                virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr );
    6867                virtual void visit( ConstructorExpr * ctorExpr );
     68                virtual void visit( UntypedTupleExpr *tupleExpr );
     69                virtual void visit( TupleExpr *tupleExpr );
    6970                virtual void visit( TupleIndexExpr *tupleExpr );
    7071                virtual void visit( TupleAssignExpr *tupleExpr );

  • src/SymTab/Indexer.cc

    r0c286cf r907eccb  
    453453        }
    454454
    455         void Indexer::visit( TupleExpr *tupleExpr ) {
    456                 acceptNewScope( tupleExpr->get_result(), *this );
    457                 acceptAll( tupleExpr->get_exprs(), *this );
    458         }
    459 
    460         void Indexer::visit( TupleAssignExpr *tupleExpr ) {
    461                 acceptNewScope( tupleExpr->get_result(), *this );
    462                 maybeAccept( tupleExpr->get_stmtExpr(), *this );
    463         }
    464 
    465455        void Indexer::visit( TypeExpr *typeExpr ) {
    466456                acceptNewScope( typeExpr->get_result(), *this );
    … …  
    474464        }
    475465
     466        void Indexer::visit( ImplicitCopyCtorExpr *impCpCtorExpr ) {
     467                acceptNewScope( impCpCtorExpr->get_result(), *this );
     468                maybeAccept( impCpCtorExpr->get_callExpr(), *this );
     469                acceptAll( impCpCtorExpr->get_tempDecls(), *this );
     470                acceptAll( impCpCtorExpr->get_returnDecls(), *this );
     471                acceptAll( impCpCtorExpr->get_dtors(), *this );
     472        }
     473
     474        void Indexer::visit( ConstructorExpr * ctorExpr ) {
     475                acceptNewScope( ctorExpr->get_result(), *this );
     476                maybeAccept( ctorExpr->get_callExpr(), *this );
     477        }
     478
     479        void Indexer::visit( CompoundLiteralExpr *compLitExpr ) {
     480                acceptNewScope( compLitExpr->get_result(), *this );
     481                maybeAccept( compLitExpr->get_type(), *this );
     482                maybeAccept( compLitExpr->get_initializer(), *this );
     483        }
     484
    476485        void Indexer::visit( UntypedValofExpr *valofExpr ) {
    477486                acceptNewScope( valofExpr->get_result(), *this );
    478487                maybeAccept( valofExpr->get_body(), *this );
     488        }
     489
     490        void Indexer::visit( RangeExpr *rangeExpr ) {
     491                maybeAccept( rangeExpr->get_low(), *this );
     492                maybeAccept( rangeExpr->get_high(), *this );
     493        }
     494
     495        void Indexer::visit( UntypedTupleExpr *tupleExpr ) {
     496                acceptNewScope( tupleExpr->get_result(), *this );
     497                acceptAll( tupleExpr->get_exprs(), *this );
     498        }
     499
     500        void Indexer::visit( TupleExpr *tupleExpr ) {
     501                acceptNewScope( tupleExpr->get_result(), *this );
     502                acceptAll( tupleExpr->get_exprs(), *this );
     503        }
     504
     505        void Indexer::visit( TupleIndexExpr *tupleExpr ) {
     506                acceptNewScope( tupleExpr->get_result(), *this );
     507                maybeAccept( tupleExpr->get_tuple(), *this );
     508        }
     509
     510        void Indexer::visit( MemberTupleExpr *tupleExpr ) {
     511                acceptNewScope( tupleExpr->get_result(), *this );
     512                maybeAccept( tupleExpr->get_member(), *this );
     513                maybeAccept( tupleExpr->get_aggregate(), *this );
     514        }
     515
     516        void Indexer::visit( TupleAssignExpr *tupleExpr ) {
     517                acceptNewScope( tupleExpr->get_result(), *this );
     518                maybeAccept( tupleExpr->get_stmtExpr(), *this );
     519        }
     520
     521        void Indexer::visit( StmtExpr *stmtExpr ) {
     522                acceptNewScope( stmtExpr->get_result(), *this );
     523                maybeAccept( stmtExpr->get_statements(), *this );
     524                acceptAll( stmtExpr->get_returnDecls(), *this );
     525                acceptAll( stmtExpr->get_dtors(), *this );
     526        }
     527
     528        void Indexer::visit( UniqueExpr *uniqueExpr ) {
     529                acceptNewScope( uniqueExpr->get_result(), *this );
     530                maybeAccept( uniqueExpr->get_expr(), *this );
    479531        }
    480532

  • src/SymTab/Indexer.h

    r0c286cf r907eccb  
    6666                virtual void visit( TypeExpr *typeExpr );
    6767                virtual void visit( AsmExpr *asmExpr );
     68                virtual void visit( ImplicitCopyCtorExpr *impCpCtorExpr );
     69                virtual void visit( ConstructorExpr * ctorExpr );
     70                virtual void visit( CompoundLiteralExpr *compLitExpr );
    6871                virtual void visit( UntypedValofExpr *valofExpr );
     72                virtual void visit( RangeExpr *rangeExpr );
     73                virtual void visit( UntypedTupleExpr *tupleExpr );
    6974                virtual void visit( TupleExpr *tupleExpr );
     75                virtual void visit( TupleIndexExpr *tupleExpr );
     76                virtual void visit( MemberTupleExpr *tupleExpr );
    7077                virtual void visit( TupleAssignExpr *tupleExpr );
     78                virtual void visit( StmtExpr * stmtExpr );
     79                virtual void visit( UniqueExpr * uniqueExpr );
    7180
    7281                virtual void visit( TraitInstType *contextInst );

  • src/SynTree/Expression.h

    r0c286cf r907eccb  
    634634};
    635635
     636/// UntypedTupleExpr represents a tuple expression ( [a, b, c] ) before resolution
     637class UntypedTupleExpr : public Expression {
     638  public:
     639        UntypedTupleExpr( const std::list< Expression * > & exprs, Expression *_aname = nullptr );
     640        UntypedTupleExpr( const UntypedTupleExpr &other );
     641        virtual ~UntypedTupleExpr();
     642
     643        std::list<Expression*>& get_exprs() { return exprs; }
     644
     645        virtual UntypedTupleExpr *clone() const { return new UntypedTupleExpr( *this ); }
     646        virtual void accept( Visitor &v ) { v.visit( this ); }
     647        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     648        virtual void print( std::ostream &os, int indent = 0 ) const;
     649  private:
     650        std::list<Expression*> exprs;
     651};
     652
    636653/// TupleExpr represents a tuple expression ( [a, b, c] )
    637654class TupleExpr : public Expression {
    638655  public:
    639         TupleExpr( const std::list< Expression * > & exprs = std::list< Expression * >(), Expression *_aname = nullptr );
     656        TupleExpr( const std::list< Expression * > & exprs, Expression *_aname = nullptr );
    640657        TupleExpr( const TupleExpr &other );
    641658        virtual ~TupleExpr();
    642659
    643         void set_exprs( std::list<Expression*> newValue ) { exprs = newValue; }
    644660        std::list<Expression*>& get_exprs() { return exprs; }
    645661

  • src/SynTree/Mutator.cc

    r0c286cf r907eccb  
    345345Expression* Mutator::mutate( ImplicitCopyCtorExpr *impCpCtorExpr ) {
    346346        impCpCtorExpr->set_env( maybeMutate( impCpCtorExpr->get_env(), *this ) );
     347        impCpCtorExpr->set_result( maybeMutate( impCpCtorExpr->get_result(), *this ) );
    347348        impCpCtorExpr->set_callExpr( maybeMutate( impCpCtorExpr->get_callExpr(), *this ) );
    348349        mutateAll( impCpCtorExpr->get_tempDecls(), *this );
    … …  
    378379        rangeExpr->set_high( maybeMutate( rangeExpr->get_high(), *this ) );
    379380        return rangeExpr;
     381}
     382
     383Expression *Mutator::mutate( UntypedTupleExpr *tupleExpr ) {
     384        tupleExpr->set_env( maybeMutate( tupleExpr->get_env(), *this ) );
     385        tupleExpr->set_result( maybeMutate( tupleExpr->get_result(), *this ) );
     386        mutateAll( tupleExpr->get_exprs(), *this );
     387        return tupleExpr;
    380388}
    381389

  • src/SynTree/Mutator.h

    r0c286cf r907eccb  
    7878        virtual Expression* mutate( UntypedValofExpr *valofExpr );
    7979        virtual Expression* mutate( RangeExpr *rangeExpr );
     80        virtual Expression* mutate( UntypedTupleExpr *tupleExpr );
    8081        virtual Expression* mutate( TupleExpr *tupleExpr );
    8182        virtual Expression* mutate( TupleIndexExpr *tupleExpr );

  • src/SynTree/SynTree.h

    r0c286cf r907eccb  
    8383class UntypedValofExpr;
    8484class RangeExpr;
     85class UntypedTupleExpr;
    8586class TupleExpr;
    8687class TupleIndexExpr;

  • src/SynTree/TupleExpr.cc

    r0c286cf r907eccb  
    2121#include "VarExprReplacer.h"
    2222
     23UntypedTupleExpr::UntypedTupleExpr( const std::list< Expression * > & exprs, Expression *_aname ) : Expression( _aname ), exprs( exprs ) {
     24}
     25
     26UntypedTupleExpr::UntypedTupleExpr( const UntypedTupleExpr &other ) : Expression( other ) {
     27        cloneAll( other.exprs, exprs );
     28}
     29
     30UntypedTupleExpr::~UntypedTupleExpr() {
     31        deleteAll( exprs );
     32}
     33
     34void UntypedTupleExpr::print( std::ostream &os, int indent ) const {
     35        os << "Untyped Tuple:" << std::endl;
     36        printAll( exprs, os, indent+2 );
     37        Expression::print( os, indent );
     38}
     39
    2340TupleExpr::TupleExpr( const std::list< Expression * > & exprs, Expression *_aname ) : Expression( _aname ), exprs( exprs ) {
    24         if ( ! exprs.empty() ) {
    25                 if ( std::all_of( exprs.begin(), exprs.end(), [](Expression * expr) { return expr->get_result(); } ) ) {
    26                         set_result( Tuples::makeTupleType( exprs ) );
    27                 }
    28         }
     41        set_result( Tuples::makeTupleType( exprs ) );
    2942}
    3043
    … …  
    4558TupleIndexExpr::TupleIndexExpr( Expression * tuple, unsigned int index ) : tuple( tuple ), index( index )  {
    4659        TupleType * type = safe_dynamic_cast< TupleType * >( tuple->get_result() );
    47         assert( type->size() > index );
     60        assertf( type->size() > index, "TupleIndexExpr index out of bounds: tuple size %d, requested index %d", type->size(), index );
    4861        set_result( (*std::next( type->get_types().begin(), index ))->clone() );
    4962        get_result()->set_isLvalue( type->get_isLvalue() );

  • src/SynTree/Visitor.cc

    r0c286cf r907eccb  
    273273
    274274void Visitor::visit( ImplicitCopyCtorExpr *impCpCtorExpr ) {
     275        maybeAccept( impCpCtorExpr->get_result(), *this );
    275276        maybeAccept( impCpCtorExpr->get_callExpr(), *this );
    276277        acceptAll( impCpCtorExpr->get_tempDecls(), *this );
    … …  
    298299        maybeAccept( rangeExpr->get_low(), *this );
    299300        maybeAccept( rangeExpr->get_high(), *this );
     301}
     302
     303void Visitor::visit( UntypedTupleExpr *tupleExpr ) {
     304        maybeAccept( tupleExpr->get_result(), *this );
     305        acceptAll( tupleExpr->get_exprs(), *this );
    300306}
    301307

  • src/SynTree/Visitor.h

    r0c286cf r907eccb  
    7878        virtual void visit( UntypedValofExpr *valofExpr );
    7979        virtual void visit( RangeExpr *rangeExpr );
     80        virtual void visit( UntypedTupleExpr *tupleExpr );
    8081        virtual void visit( TupleExpr *tupleExpr );
    8182        virtual void visit( TupleIndexExpr *tupleExpr );

  • src/Tuples/TupleExpansion.cc

    r0c286cf r907eccb  
    144144
    145145        Expression * MemberTupleExpander::mutate( UntypedMemberExpr * memberExpr ) {
    146                 if ( TupleExpr * tupleExpr = dynamic_cast< TupleExpr * > ( memberExpr->get_member() ) ) {
     146                if ( UntypedTupleExpr * tupleExpr = dynamic_cast< UntypedTupleExpr * > ( memberExpr->get_member() ) ) {
    147147                        Expression * aggr = memberExpr->get_aggregate()->clone()->acceptMutator( *this );
    148148                        // aggregate expressions which might be impure must be wrapped in unique expressions
    … …  
    315315                        qualifiers &= type->get_qualifiers();
    316316                } // for
     317                if ( exprs.empty() ) qualifiers = Type::Qualifiers();
    317318                return tupleType;
    318319        }
Note: See TracChangeset for help on using the changeset viewer.