Changeset 6a036eb


Ignore:
Timestamp:
Oct 30, 2020, 5:15:47 PM (12 months ago)
Author:
Andrew Beach <ajbeach@…>
Branches:
arm-eh, jacob/cs343-translation, master, new-ast-unique-expr
Children:
ea3fa25
Parents:
0e707bd
Message:

Switched to ast::Pass::read FixInitNew?.cpp.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/InitTweak/FixInitNew.cpp

    r0e707bd r6a036eb  
    357357        // if two expressions are "the same" (used to determine if self assignment occurs)
    358358        struct StructuralChecker {
    359                 const ast::Expr * stripCasts( const ast::Expr * expr ) {
     359                // Strip all casts and then dynamic_cast.
     360                template<typename T>
     361                static const T * cast( const ast::Expr * expr ) {
    360362                        // this might be too permissive. It's possible that only particular casts are relevant.
    361363                        while ( auto cast = dynamic_cast< const ast::CastExpr * >( expr ) ) {
    362364                                expr = cast->arg;
    363365                        }
    364                         return expr;
     366                        return dynamic_cast< const T * >( expr );
    365367                }
    366368
    367369                void previsit( const ast::Expr * ) {
    368370                        // anything else does not qualify
    369                         isSimilar = false;
    370                 }
    371 
    372                 template<typename T>
    373                 T * cast( const ast::Expr * node ) {
    374                         // all expressions need to ignore casts, so this bit has been factored out
    375                         return dynamic_cast< T * >( stripCasts( node ) );
     371                        result = false;
    376372                }
    377373
     
    380376
    381377                void previsit( const ast::MemberExpr * memExpr ) {
    382                         if ( auto otherMember = cast< const ast::MemberExpr >( other ) ) {
     378                        if ( auto otherMember = cast< ast::MemberExpr >( other ) ) {
    383379                                if ( otherMember->member == memExpr->member ) {
    384380                                        other = otherMember->aggregate;
     
    386382                                }
    387383                        }
    388                         isSimilar = false;
     384                        result = false;
    389385                }
    390386
    391387                void previsit( const ast::VariableExpr * varExpr ) {
    392                         if ( auto otherVar = cast< const ast::VariableExpr >( other ) ) {
     388                        if ( auto otherVar = cast< ast::VariableExpr >( other ) ) {
    393389                                if ( otherVar->var == varExpr->var ) {
    394390                                        return;
    395391                                }
    396392                        }
    397                         isSimilar = false;
     393                        result = false;
    398394                }
    399395
    400396                void previsit( const ast::AddressExpr * ) {
    401                         if ( auto addrExpr = cast< const ast::AddressExpr >( other ) ) {
     397                        if ( auto addrExpr = cast< ast::AddressExpr >( other ) ) {
    402398                                other = addrExpr->arg;
    403399                                return;
    404400                        }
    405                         isSimilar = false;
    406                 }
    407 
    408                 const ast::Expr * other = nullptr;
    409                 bool isSimilar = true;
     401                        result = false;
     402                }
     403
     404                const ast::Expr * other;
     405                bool result = true;
     406                StructuralChecker( const ast::Expr * other ) : other(other) {}
    410407        };
    411408
    412409        bool structurallySimilar( const ast::Expr * e1, const ast::Expr * e2 ) {
    413                 ast::Pass<StructuralChecker> checker;
    414                 checker.core.other = e2;
    415                 e1->accept( checker );
    416                 return checker.core.isSimilar;
     410                return ast::Pass<StructuralChecker>::read( e1, e2 );
    417411        }
    418412
Note: See TracChangeset for help on using the changeset viewer.