Changeset f240484

Timestamp:

Jan 8, 2018, 4:20:38 PM (7 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:

07c178f0

Parents:

b3fc977

Message:

Convert MemberTupleExpander? to PassVisitor?

File:

• src/Tuples/TupleExpansion.cc (modified) (5 diffs)

src/Tuples/TupleExpansion.cc

@@ -36 +36 @@
 namespace Tuples {
         namespace {
-                struct MemberTupleExpander final : public Mutator {
-                        typedef Mutator Parent;
-                        using Parent::mutate;
-
-                        virtual Expression * mutate( UntypedMemberExpr * memberExpr ) override;
+                struct MemberTupleExpander final : public WithShortCircuiting, public WithVisitorRef<MemberTupleExpander> {
+                        void premutate( UntypedMemberExpr * ) { visit_children = false; }
+                        Expression * postmutate( UntypedMemberExpr * memberExpr );
                 };
 
@@ -79 +77 @@
 
         void expandMemberTuples( std::list< Declaration * > & translationUnit ) {
-                MemberTupleExpander expander;
+                PassVisitor<MemberTupleExpander> expander;
                 mutateAll( translationUnit, expander );
         }
@@ -109 +107 @@
                                 // construct a new UntypedMemberExpr with the correct structure , and recursively
                                 // expand that member expression.
-                                MemberTupleExpander expander;
-                                UntypedMemberExpr * inner = new UntypedMemberExpr( memberExpr->get_aggregate(), aggr->clone() );
-                                UntypedMemberExpr * newMemberExpr = new UntypedMemberExpr( memberExpr->get_member(), inner );
+                                PassVisitor<MemberTupleExpander> expander;
+                                UntypedMemberExpr * inner = new UntypedMemberExpr( memberExpr->aggregate, aggr->clone() );
+                                UntypedMemberExpr * newMemberExpr = new UntypedMemberExpr( memberExpr->member, inner );
                                 inner->location = newMemberExpr->location = loc;
-                                memberExpr->set_member(nullptr);
-                                memberExpr->set_aggregate(nullptr);
+                                memberExpr->member = nullptr;
+                                memberExpr->aggregate = nullptr;
                                 delete memberExpr;
                                 return newMemberExpr->acceptMutator( expander );
@@ -126 +124 @@
         }
 
-        Expression * MemberTupleExpander::mutate( UntypedMemberExpr * memberExpr ) {
-                if ( UntypedTupleExpr * tupleExpr = dynamic_cast< UntypedTupleExpr * > ( memberExpr->get_member() ) ) {
-                        Expression * aggr = memberExpr->get_aggregate()->clone()->acceptMutator( *this );
+        Expression * MemberTupleExpander::postmutate( UntypedMemberExpr * memberExpr ) {
+                if ( UntypedTupleExpr * tupleExpr = dynamic_cast< UntypedTupleExpr * > ( memberExpr->member ) ) {
+                        Expression * aggr = memberExpr->aggregate->clone()->acceptMutator( *visitor );
                         // aggregate expressions which might be impure must be wrapped in unique expressions
                         // xxx - if there's a member-tuple expression nested in the aggregate, this currently generates the wrong code if a UniqueExpr is not used, and it's purely an optimization to remove the UniqueExpr
                         // if ( Tuples::maybeImpureIgnoreUnique( memberExpr->get_aggregate() ) ) aggr = new UniqueExpr( aggr );
                         aggr = new UniqueExpr( aggr );
-                        for ( Expression *& expr : tupleExpr->get_exprs() ) {
+                        for ( Expression *& expr : tupleExpr->exprs ) {
                                 expr = reconstructMemberExpr( expr, aggr, memberExpr->location );
                                 expr->location = memberExpr->location;
@@ -143 +141 @@
                         // there may be a tuple expr buried in the aggregate
                         // xxx - this is a memory leak
-                        UntypedMemberExpr * newMemberExpr = new UntypedMemberExpr( memberExpr->get_member()->clone(), memberExpr->get_aggregate()->acceptMutator( *this ) );
+                        UntypedMemberExpr * newMemberExpr = new UntypedMemberExpr( memberExpr->member->clone(), memberExpr->aggregate->acceptMutator( *visitor ) );
                         newMemberExpr->location = memberExpr->location;
                         return newMemberExpr;