Changeset 77971f6 for src/Tuples/Tuples.h

Timestamp:

Oct 27, 2016, 3:24:02 PM (8 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, with_gc

Children:

3f0c6a5

Parents:

a1e67dd

git-author:

Rob Schluntz <rschlunt@…> (10/27/16 15:11:00)

git-committer:

Rob Schluntz <rschlunt@…> (10/27/16 15:24:02)

Message:

resolve ctor/dtors for UniqueExprs?

File:

• src/Tuples/Tuples.h (modified) (5 diffs)

src/Tuples/Tuples.h

@@ -20 +20 @@
 #include <vector>
 #include "ResolvExpr/AlternativeFinder.h"
+#include "ResolvExpr/Resolver.h"
 
 #include "SynTree/Expression.h"
@@ -48 +49 @@
         /// helper function used by explode
         template< typename OutputIterator >
-        void explodeUnique( Expression * expr, const ResolvExpr::Alternative & alt, OutputIterator out ) {
+        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, back_inserter( alts ) );
+                        explodeUnique( addrExpr->get_arg(), alt, indexer, back_inserter( alts ) );
                         for ( ResolvExpr::Alternative & alt : alts ) {
                                 // distribute '&' over all components
@@ -62 +63 @@
                                 // can open tuple expr and dump its exploded components
                                 for ( Expression * expr : tupleExpr->get_exprs() ) {
-                                        explodeUnique( expr, alt, out );
+                                        explodeUnique( expr, alt, indexer, out );
                                 }
                         } else {
@@ -68 +69 @@
                                 Expression * arg = expr->clone();
                                 if ( Tuples::maybeImpure( arg ) ) {
-                                        // expressions which may contain side effects require a single unique instance of the expression
+                                        // expressions which may contain side effects require a single unique instance of the expression.
+                                        // resolve the UniqueExpr (which should be relatively cheap, since the argument is already resolved)
+                                        // so that its accompanying object is properly constructed and destructed.
                                         arg = new UniqueExpr( arg );
+                                        arg = ResolvExpr::resolveInVoidContext( arg, indexer );
                                 }
                                 for ( unsigned int i = 0; i < tupleType->size(); i++ ) {
                                         TupleIndexExpr * idx = new TupleIndexExpr( arg->clone(), i );
-                                        explodeUnique( idx, alt, out );
+                                        explodeUnique( idx, alt, indexer, out );
                                         delete idx;
                                 }
@@ -86 +90 @@
         /// expands a tuple-valued alternative into multiple alternatives, each with a non-tuple-type
         template< typename OutputIterator >
-        void explode( const ResolvExpr::Alternative &alt, OutputIterator out ) {
-                explodeUnique( alt.expr, alt, out );
+        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, OutputIterator out ) {
+        void explode( AltIterator altBegin, AltIterator altEnd, const SymTab::Indexer & indexer, OutputIterator out ) {
                 for ( ; altBegin != altEnd; ++altBegin ) {
-                        explode( *altBegin, out );
+                        explode( *altBegin, indexer, out );
                 }
         }
 
         template< typename OutputIterator >
-        void explode( const ResolvExpr::AltList & alts, OutputIterator out ) {
-                explode( alts.begin(), alts.end(), out );
+        void explode( const ResolvExpr::AltList & alts, const SymTab::Indexer & indexer, OutputIterator out ) {
+                explode( alts.begin(), alts.end(), indexer, out );
         }
 } // namespace Tuples