Changes in src/Tuples/Explode.h [f831177:141b786]

File:

• src/Tuples/Explode.h (modified) (3 diffs)

src/Tuples/Explode.h

@@ -33 +33 @@
         /// helper function used by explode
         template< typename OutputIterator >
-        void explodeUnique( Expression * expr, const ResolvExpr::Alternative & alt, const SymTab::Indexer & indexer, OutputIterator out, bool isTupleAssign ) {
-                if ( isTupleAssign ) {
-                        // tuple assignment needs AddressExprs to be recursively exploded to easily get at all of the components
-                        if ( AddressExpr * addrExpr = dynamic_cast< AddressExpr * >( expr ) ) {
-                                ResolvExpr::AltList alts;
-                                explodeUnique( addrExpr->get_arg(), alt, indexer, back_inserter( alts ), isTupleAssign );
-                                for ( ResolvExpr::Alternative & alt : alts ) {
-                                        // distribute '&' over all components
-                                        alt.expr = distributeAddr( alt.expr );
-                                        *out++ = alt;
-                                }
-                                // in tuple assignment, still need to handle the other cases, but only if not already handled here (don't want to output too many alternatives)
-                                return;
+        void explodeUnique( Expression * expr, const ResolvExpr::Alternative & alt, const SymTab::Indexer & indexer, OutputIterator out ) {
+                Type * res = expr->get_result();
+                if ( AddressExpr * addrExpr = dynamic_cast< AddressExpr * >( expr ) ) {
+                        ResolvExpr::AltList alts;
+                        explodeUnique( addrExpr->get_arg(), alt, indexer, back_inserter( alts ) );
+                        for ( ResolvExpr::Alternative & alt : alts ) {
+                                // distribute '&' over all components
+                                alt.expr = distributeAddr( alt.expr );
+                                *out++ = alt;
                         }
-                }
-                Type * res = expr->get_result();
-                if ( TupleType * tupleType = dynamic_cast< TupleType * > ( res ) ) {
+                } else if ( TupleType * tupleType = dynamic_cast< TupleType * > ( res ) ) {
                         if ( TupleExpr * tupleExpr = dynamic_cast< TupleExpr * >( expr ) ) {
                                 // can open tuple expr and dump its exploded components
                                 for ( Expression * expr : tupleExpr->get_exprs() ) {
-                                        explodeUnique( expr, alt, indexer, out, isTupleAssign );
+                                        explodeUnique( expr, alt, indexer, out );
                                 }
                         } else {
@@ -64 +58 @@
                                 for ( unsigned int i = 0; i < tupleType->size(); i++ ) {
                                         TupleIndexExpr * idx = new TupleIndexExpr( arg->clone(), i );
-                                        explodeUnique( idx, alt, indexer, out, isTupleAssign );
+                                        explodeUnique( idx, alt, indexer, out );
                                         delete idx;
                                 }
@@ -77 +71 @@
         /// expands a tuple-valued alternative into multiple alternatives, each with a non-tuple-type
         template< typename OutputIterator >
-        void explode( const ResolvExpr::Alternative &alt, const SymTab::Indexer & indexer, OutputIterator out, bool isTupleAssign = false ) {
-                explodeUnique( alt.expr, alt, indexer, out, isTupleAssign );
+        void explode( const ResolvExpr::Alternative &alt, const SymTab::Indexer & indexer, OutputIterator out ) {
+                explodeUnique( alt.expr, alt, indexer, out );
         }
 
         // explode list of alternatives
         template< typename AltIterator, typename OutputIterator >
-        void explode( AltIterator altBegin, AltIterator altEnd, const SymTab::Indexer & indexer, OutputIterator out, bool isTupleAssign = false ) {
+        void explode( AltIterator altBegin, AltIterator altEnd, const SymTab::Indexer & indexer, OutputIterator out ) {
                 for ( ; altBegin != altEnd; ++altBegin ) {
-                        explode( *altBegin, indexer, out, isTupleAssign );
+                        explode( *altBegin, indexer, out );
                 }
         }
 
         template< typename OutputIterator >
-        void explode( const ResolvExpr::AltList & alts, const SymTab::Indexer & indexer, OutputIterator out, bool isTupleAssign = false ) {
-                explode( alts.begin(), alts.end(), indexer, out, isTupleAssign );
+        void explode( const ResolvExpr::AltList & alts, const SymTab::Indexer & indexer, OutputIterator out ) {
+                explode( alts.begin(), alts.end(), indexer, out );
         }
 } // namespace Tuples