Changes in src/Tuples/TupleExpansion.cc [aee472e:68f9c43]

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;
@@ -46 +45 @@
 
                         std::map< int, Expression * > decls; // not vector, because order added may not be increasing order
-
-                        ~UniqueExprExpander() {
-                                for ( std::pair<const int, Expression *> & p : decls ) {
-                                        delete p.second;
-                                }
-                        }
                 };
 
@@ -112 +105 @@
                                 UntypedMemberExpr * newMemberExpr = new UntypedMemberExpr( memberExpr->member, inner );
                                 inner->location = newMemberExpr->location = loc;
-                                memberExpr->member = nullptr;
-                                memberExpr->aggregate = nullptr;
-                                delete memberExpr;
                                 return newMemberExpr->acceptMutator( expander );
                         } else {
@@ -129 +119 @@
                         Expression * aggr = memberExpr->aggregate->clone()->acceptMutator( *visitor );
                         // aggregate expressions which might be impure must be wrapped in unique expressions
-                        if ( Tuples::maybeImpureIgnoreUnique( memberExpr->aggregate ) ) aggr = new UniqueExpr( aggr );
+                        // 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->exprs ) {
                                 expr = reconstructMemberExpr( expr, aggr, memberExpr->location );
                                 expr->location = memberExpr->location;
                         }
-                        delete aggr;
                         tupleExpr->location = memberExpr->location;
                         return tupleExpr;
@@ -180 +171 @@
                         decls[id] = condExpr;
                 }
-                delete unqExpr;
                 return decls[id]->clone();
         }
@@ -190 +180 @@
                 ret->set_env( assnExpr->get_env() );
                 assnExpr->set_env( nullptr );
-                delete assnExpr;
                 return ret;
         }
@@ -221 +210 @@
                         newType->get_parameters().push_back( new TypeExpr( t->clone() ) );
                 }
-                delete tupleType;
                 return newType;
         }
 
         Expression * TupleIndexExpander::postmutate( TupleIndexExpr * tupleExpr ) {
-                Expression * tuple = tupleExpr->tuple;
+                Expression * tuple = tupleExpr->get_tuple();
                 assert( tuple );
-                tupleExpr->tuple = nullptr;
-                unsigned int idx = tupleExpr->index;
-                TypeSubstitution * env = tupleExpr->env;
-                tupleExpr->env = nullptr;
-                delete tupleExpr;
-
-                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);
+                tupleExpr->set_tuple( nullptr );
+                unsigned int idx = tupleExpr->get_index();
+                TypeSubstitution * env = tupleExpr->get_env();
+                tupleExpr->set_env( nullptr );
+
+                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);
                 MemberExpr * memExpr = new MemberExpr( strict_dynamic_cast< DeclarationWithType * >( member ), tuple );
-                memExpr->env = env;
+                memExpr->set_env( env );
                 return memExpr;
         }
@@ -287 +261 @@
                 TypeSubstitution * env = tupleExpr->get_env();
 
-                // remove data from shell and delete it
-                tupleExpr->set_result( nullptr );
-                tupleExpr->get_exprs().clear();
+                // remove data from shell
                 tupleExpr->set_env( nullptr );
-                delete tupleExpr;
 
                 return replaceTupleExpr( result, exprs, env );