Changes in src/Tuples/Explode.h [6b0b624:6d267ca]

File:

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

src/Tuples/Explode.h

@@ -9 +9 @@
 // Author           : Rob Schluntz
 // Created On       : Wed Nov 9 13:12:24 2016
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:55:16 2017
-// Update Count     : 3
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Nov 9 13:20:24 2016
+// Update Count     : 2
 //
 
-#pragma once
+#ifndef _EXPLODE_H_
+#define _EXPLODE_H_
 
 #include "ResolvExpr/AlternativeFinder.h"
@@ -26 +27 @@
 
 namespace Tuples {
-        /// helper function used by explode to properly distribute
-        /// '&' across a tuple expression
-        Expression * distributeAddr( Expression * expr );
-
         /// 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;
-                        }
-                }
-                Type * res = expr->get_result();
+                Type * res = expr->get_result()->stripReferences();
                 if ( TupleType * tupleType = dynamic_cast< TupleType * > ( res ) ) {
                         if ( TupleExpr * tupleExpr = dynamic_cast< TupleExpr * >( expr ) ) {
@@ -55 +38 @@
                                 }
                         } else {
-                                // tuple type, but not tuple expr - recursively index into its components
+                                // tuple type, but not tuple expr - recursively index into its components.
+                                // if expr type is reference, convert to value type
                                 Expression * arg = expr->clone();
+
+                                if ( dynamic_cast<ReferenceType *>( arg->get_result() ) ) {
+                                        // TODO: does this go here (inside uniqueexpr) or outside uniqueexpr? I'm guessing probably should go after...
+                                        arg = new CastExpr( arg, tupleType->clone() );
+                                }
                                 if ( Tuples::maybeImpure( arg ) && ! dynamic_cast< UniqueExpr * >( arg ) ) {
                                         // expressions which may contain side effects require a single unique instance of the expression.
@@ -94 +83 @@
 } // namespace Tuples
 
+#endif // _TUPLE_ASSIGNMENT_H_
+
 // Local Variables: //
 // tab-width: 4 //