Changeset 90152a4 for src/Tuples/TupleExpansion.cc

Timestamp:

Aug 27, 2018, 4:40:34 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, arm-eh, ast-experimental, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

b7c89aa

Parents:

f9feab8 (diff), 305581d (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' into cleanup-dtors

File:

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

src/Tuples/TupleExpansion.cc

@@ -30 +30 @@
 #include "SynTree/Type.h"         // for Type, Type::Qualifiers, TupleType
 #include "SynTree/Visitor.h"      // for Visitor
+#include "Tuples.h"
 
 class CompoundStmt;
@@ -36 +37 @@
 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 +78 @@
 
         void expandMemberTuples( std::list< Declaration * > & translationUnit ) {
-                MemberTupleExpander expander;
+                PassVisitor<MemberTupleExpander> expander;
                 mutateAll( translationUnit, expander );
         }
@@ -109 +108 @@
                                 // 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 +125 @@
         }
 
-        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() ) {
+                        if ( Tuples::maybeImpureIgnoreUnique( memberExpr->aggregate ) ) aggr = new UniqueExpr( aggr );
+                        for ( Expression *& expr : tupleExpr->exprs ) {
                                 expr = reconstructMemberExpr( expr, aggr, memberExpr->location );
                                 expr->location = memberExpr->location;
@@ -143 +140 @@
                         // 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;
@@ -202 +199 @@
                         // generate struct type to replace tuple type based on the number of components in the tuple
                         StructDecl * decl = new StructDecl( toString( "_tuple", tupleSize, "_" ) );
+                        decl->location = tupleType->location;
                         decl->set_body( true );
                         for ( size_t i = 0; i < tupleSize; ++i ) {
@@ -228 +226 @@
 
         Expression * TupleIndexExpander::postmutate( TupleIndexExpr * tupleExpr ) {
-                Expression * tuple = tupleExpr->get_tuple();
+                Expression * tuple = tupleExpr->tuple;
                 assert( tuple );
-                tupleExpr->set_tuple( nullptr );
-                unsigned int idx = tupleExpr->get_index();
-                TypeSubstitution * env = tupleExpr->get_env();
-                tupleExpr->set_env( nullptr );
+                tupleExpr->tuple = nullptr;
+                unsigned int idx = tupleExpr->index;
+                TypeSubstitution * env = tupleExpr->env;
+                tupleExpr->env = nullptr;
                 delete tupleExpr;
 
-                StructInstType * type = strict_dynamic_cast< StructInstType * >( tuple->get_result() );
-                StructDecl * structDecl = type->get_baseStruct();
-                assert( structDecl->get_members().size() > idx );
-                Declaration * member = *std::next(structDecl->get_members().begin(), idx);
+                if ( TupleExpr * tupleExpr = dynamic_cast< TupleExpr * > ( tuple ) ) {
+                        if ( ! maybeImpureIgnoreUnique( tupleExpr ) ) {
+                                // optimization: definitely pure tuple expr => can reduce to the only relevant component.
+                                assert( tupleExpr->exprs.size() > idx );
+                                Expression *& expr = *std::next(tupleExpr->exprs.begin(), idx);
+                                Expression * ret = expr;
+                                ret->env = env;
+                                expr = nullptr; // remove from list so it can safely be deleted
+                                delete tupleExpr;
+                                return ret;
+                        }
+                }
+
+                StructInstType * type = strict_dynamic_cast< StructInstType * >( tuple->result );
+                StructDecl * structDecl = type->baseStruct;
+                assert( structDecl->members.size() > idx );
+                Declaration * member = *std::next(structDecl->members.begin(), idx);
                 MemberExpr * memExpr = new MemberExpr( strict_dynamic_cast< DeclarationWithType * >( member ), tuple );
-                memExpr->set_env( env );
+                memExpr->env = env;
                 return memExpr;
         }