Changes in src/Tuples/Explode.h [03321e4:0b5d871]

File:

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

src/Tuples/Explode.h

@@ -16 +16 @@
 #pragma once
 
-#include <iterator>                  // for back_inserter, back_insert_iterator
+#include "ResolvExpr/AlternativeFinder.h"
+#include "ResolvExpr/Resolver.h"
 
-#include "ResolvExpr/Alternative.h"  // for Alternative, AltList
-#include "SynTree/Expression.h"      // for Expression, UniqueExpr, AddressExpr
-#include "SynTree/Type.h"            // for TupleType, Type
-#include "Tuples.h"                  // for maybeImpure
+#include "SynTree/Expression.h"
+#include "SynTree/Declaration.h"
+#include "SynTree/Type.h"
 
-namespace SymTab {
-class Indexer;
-}  // namespace SymTab
+#include "Tuples.h"
 
 namespace Tuples {
-        /// helper function used by explode to properly distribute
-        /// '&' across a tuple expression
-        Expression * distributeAddr( Expression * expr );
+        Expression * distributeReference( Expression * );
 
         /// helper function used by explode
@@ -36 +32 @@
         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 ) ) {
+                        // tuple assignment needs CastExprs to be recursively exploded to easily get at all of the components
+                        if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
                                 ResolvExpr::AltList alts;
-                                explodeUnique( addrExpr->get_arg(), alt, indexer, back_inserter( alts ), isTupleAssign );
+                                explodeUnique( castExpr->get_arg(), alt, indexer, back_inserter( alts ), isTupleAssign );
                                 for ( ResolvExpr::Alternative & alt : alts ) {
-                                        // distribute '&' over all components
-                                        alt.expr = distributeAddr( alt.expr );
+                                        // distribute reference cast over all components
+                                        alt.expr = distributeReference( alt.expr );
                                         *out++ = alt;
                                 }
@@ -49 +45 @@
                         }
                 }
-                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 ) ) {
@@ -57 +53 @@
                                 }
                         } 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 ( Tuples::maybeImpure( arg ) && ! dynamic_cast< UniqueExpr * >( arg ) ) {
+                                if ( Tuples::maybeImpureIgnoreUnique( arg ) ) {
                                         // expressions which may contain side effects require a single unique instance of the expression.
                                         arg = new UniqueExpr( arg );
+                                }
+                                // cast reference to value type to facilitate further explosion
+                                if ( dynamic_cast<ReferenceType *>( arg->get_result() ) ) {
+                                        arg = new CastExpr( arg, tupleType->clone() );
                                 }
                                 for ( unsigned int i = 0; i < tupleType->size(); i++ ) {