Changeset 0b5d871 for src/Tuples/Explode.h

Timestamp:

Aug 22, 2017, 7:07:22 PM (9 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, stuck-waitfor-destruct, with_gc

Children:

5fb6830

Parents:

5ccb10d

Message:

Update explode for references

File:

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

src/Tuples/Explode.h

@@ -26 +26 @@
 
 namespace Tuples {
+        Expression * distributeReference( Expression * );
+
         /// 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 CastExprs to be recursively exploded to easily get at all of the components
+                        if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
+                                ResolvExpr::AltList alts;
+                                explodeUnique( castExpr->get_arg(), alt, indexer, back_inserter( alts ), isTupleAssign );
+                                for ( ResolvExpr::Alternative & alt : alts ) {
+                                        // distribute reference cast over all components
+                                        alt.expr = distributeReference( 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()->stripReferences();
                 if ( TupleType * tupleType = dynamic_cast< TupleType * > ( res ) ) {
@@ -40 +56 @@
                                 // 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 ) ) {
+                                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++ ) {