Changeset 141b786 for src

Timestamp:

Nov 9, 2016, 2:21:05 PM (7 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:

b726084

Parents:

23bb1b9

Message:

rework UniqueExpr?, handle UniqueExpr? in FixInit?, fix translation for UniqueExprs?, refactor explode functions and fix AddressExpr? distribution over exploded tuple exprs

Location:

src

Files:

• InitTweak/FixInit.cc (modified) (5 diffs)
• Makefile.in (modified) (8 diffs)
• ResolvExpr/AlternativeFinder.cc (modified) (3 diffs)
• SynTree/Expression.cc (modified) (1 diff)
• SynTree/Expression.h (modified) (2 diffs)
• Tuples/Explode.cc (added)
• Tuples/Explode.h (added)
• Tuples/TupleAssignment.cc (modified) (1 diff)
• Tuples/TupleExpansion.cc (modified) (5 diffs)
• Tuples/Tuples.h (modified) (3 diffs)
• Tuples/module.mk (modified) (1 diff)
• main.cc (modified) (2 diffs)

src/InitTweak/FixInit.cc

@@ -65 +65 @@
                         static void resolveImplicitCalls( std::list< Declaration * > & translationUnit );
 
+                        typedef SymTab::Indexer Parent;
+                        using Parent::visit;
+
                         virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr );
+                        virtual void visit( UniqueExpr * unqExpr );
 
                         /// create and resolve ctor/dtor expression: fname(var, [cpArg])
@@ -178 +182 @@
 
                         virtual Expression * mutate( ImplicitCopyCtorExpr * impCpCtorExpr );
+                        virtual Expression * mutate( UniqueExpr * unqExpr );
                 };
 
@@ -421 +426 @@
                 void ResolveCopyCtors::visit( ImplicitCopyCtorExpr *impCpCtorExpr ) {
                         CP_CTOR_PRINT( std::cerr << "ResolveCopyCtors: " << impCpCtorExpr << std::endl; )
-                        Visitor::visit( impCpCtorExpr );
+                        Parent::visit( impCpCtorExpr );
                         env = impCpCtorExpr->get_env(); // xxx - maybe we really should just have a PolyIndexer...
 
@@ -455 +460 @@
                 }
 
+                void ResolveCopyCtors::visit( UniqueExpr * unqExpr ) {
+                        static std::unordered_set< int > vars;
+                        if ( vars.count( unqExpr->get_id() ) ) {
+                                // xxx - hack to prevent double-handling of unique exprs, otherwise too many temporary variables and destructors are generated
+                                return;
+                        }
+
+                        Parent::visit( unqExpr );
+                        // it should never be necessary to wrap a void-returning expression in a UniqueExpr - if this assumption changes, this needs to be rethought
+                        assert( unqExpr->get_result() );
+                        if ( ImplicitCopyCtorExpr * impCpCtorExpr = dynamic_cast<ImplicitCopyCtorExpr*>( unqExpr->get_expr() ) ) {
+                                // note the variable used as the result from the call
+                                assert( impCpCtorExpr->get_result() && impCpCtorExpr->get_returnDecls().size() == 1 );
+                                unqExpr->set_var( new VariableExpr( impCpCtorExpr->get_returnDecls().front() ) );
+                        } else {
+                                // expr isn't a call expr, so create a new temporary variable to use to hold the value of the unique expression
+                                unqExpr->set_object( new ObjectDecl( toString("_unq_expr_", unqExpr->get_id()), DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, unqExpr->get_result()->clone(), nullptr ) );
+                                unqExpr->set_var( new VariableExpr( unqExpr->get_object() ) );
+                        }
+                        vars.insert( unqExpr->get_id() );
+                }
+
 
                 Expression * FixCopyCtors::mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) {
@@ -526 +553 @@
                                 return callExpr;
                         } // if
+                }
+
+                Expression * FixCopyCtors::mutate( UniqueExpr * unqExpr ) {
+                        static std::unordered_map< int, UniqueExpr * > unqMap;
+                        static std::unordered_set< int > addDeref;
+                        // has to be done to clean up ImplicitCopyCtorExpr nodes, even when this node was skipped in previous passes
+                        unqExpr = safe_dynamic_cast< UniqueExpr * >( Parent::mutate( unqExpr ) );
+                        if ( unqMap.count( unqExpr->get_id() ) ) {
+                                // take data from other UniqueExpr to ensure consistency
+                                delete unqExpr->get_expr();
+                                unqExpr->set_expr( unqMap[unqExpr->get_id()]->get_expr()->clone() );
+                                delete unqExpr->get_result();
+                                unqExpr->set_result( maybeClone( unqExpr->get_expr()->get_result() ) );
+                                if ( addDeref.count( unqExpr->get_id() ) ) {
+                                        // other UniqueExpr was dereferenced because it was an lvalue return, so this one should be too
+                                        return UntypedExpr::createDeref( unqExpr );
+                                }
+                                return unqExpr;
+                        }
+                        unqMap[unqExpr->get_id()] = unqExpr;
+                        if ( UntypedExpr * deref = dynamic_cast< UntypedExpr * >( unqExpr->get_expr() ) ) {
+                                // unique expression is now a dereference, because the inner expression is an lvalue returning function call.
+                                // Normalize the expression by dereferencing the unique expression, rather than the inner expression
+                                // (i.e. move the dereference out a level)
+                                assert( getFunctionName( deref ) == "*?" );
+                                unqExpr->set_expr( getCallArg( deref, 0 ) );
+                                getCallArg( deref, 0 ) = unqExpr;
+                                addDeref.insert( unqExpr->get_id() );
+                                return deref;
+                        }
+                        return unqExpr;
                 }
 

src/Makefile.in

@@ -189 +189 @@
         SynTree/driver_cfa_cpp-TypeSubstitution.$(OBJEXT) \
         SynTree/driver_cfa_cpp-Attribute.$(OBJEXT) \
+        SynTree/driver_cfa_cpp-VarExprReplacer.$(OBJEXT) \
         Tuples/driver_cfa_cpp-TupleAssignment.$(OBJEXT) \
-        Tuples/driver_cfa_cpp-TupleExpansion.$(OBJEXT)
+        Tuples/driver_cfa_cpp-TupleExpansion.$(OBJEXT) \
+        Tuples/driver_cfa_cpp-Explode.$(OBJEXT)
 am_driver_cfa_cpp_OBJECTS = $(am__objects_1)
 driver_cfa_cpp_OBJECTS = $(am_driver_cfa_cpp_OBJECTS)
@@ -403 +405 @@
         SynTree/Initializer.cc SynTree/Visitor.cc SynTree/Mutator.cc \
         SynTree/AddStmtVisitor.cc SynTree/TypeSubstitution.cc \
-        SynTree/Attribute.cc Tuples/TupleAssignment.cc \
-        Tuples/TupleExpansion.cc
+        SynTree/Attribute.cc SynTree/VarExprReplacer.cc \
+        Tuples/TupleAssignment.cc Tuples/TupleExpansion.cc \
+        Tuples/Explode.cc
 MAINTAINERCLEANFILES = Parser/parser.output ${libdir}/${notdir \
         ${cfa_cpplib_PROGRAMS}}
@@ -764 +767 @@
 SynTree/driver_cfa_cpp-Attribute.$(OBJEXT): SynTree/$(am__dirstamp) \
         SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/driver_cfa_cpp-VarExprReplacer.$(OBJEXT):  \
+        SynTree/$(am__dirstamp) SynTree/$(DEPDIR)/$(am__dirstamp)
 Tuples/$(am__dirstamp):
         @$(MKDIR_P) Tuples
@@ -774 +779 @@
 Tuples/driver_cfa_cpp-TupleExpansion.$(OBJEXT):  \
         Tuples/$(am__dirstamp) Tuples/$(DEPDIR)/$(am__dirstamp)
+Tuples/driver_cfa_cpp-Explode.$(OBJEXT): Tuples/$(am__dirstamp) \
+        Tuples/$(DEPDIR)/$(am__dirstamp)
 driver/$(am__dirstamp):
         @$(MKDIR_P) driver
@@ -878 +885 @@
         -rm -f SynTree/driver_cfa_cpp-TypeofType.$(OBJEXT)
         -rm -f SynTree/driver_cfa_cpp-VarArgsType.$(OBJEXT)
+        -rm -f SynTree/driver_cfa_cpp-VarExprReplacer.$(OBJEXT)
         -rm -f SynTree/driver_cfa_cpp-Visitor.$(OBJEXT)
         -rm -f SynTree/driver_cfa_cpp-VoidType.$(OBJEXT)
         -rm -f SynTree/driver_cfa_cpp-ZeroOneType.$(OBJEXT)
+        -rm -f Tuples/driver_cfa_cpp-Explode.$(OBJEXT)
         -rm -f Tuples/driver_cfa_cpp-TupleAssignment.$(OBJEXT)
         -rm -f Tuples/driver_cfa_cpp-TupleExpansion.$(OBJEXT)
@@ -984 +993 @@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-TypeofType.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-VarArgsType.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-VarExprReplacer.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-Visitor.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-VoidType.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-ZeroOneType.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@Tuples/$(DEPDIR)/driver_cfa_cpp-Explode.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Tuples/$(DEPDIR)/driver_cfa_cpp-TupleAssignment.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Tuples/$(DEPDIR)/driver_cfa_cpp-TupleExpansion.Po@am__quote@
@@ -2406 +2417 @@
 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-Attribute.obj `if test -f 'SynTree/Attribute.cc'; then $(CYGPATH_W) 'SynTree/Attribute.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/Attribute.cc'; fi`
 
+SynTree/driver_cfa_cpp-VarExprReplacer.o: SynTree/VarExprReplacer.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-VarExprReplacer.o -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-VarExprReplacer.Tpo -c -o SynTree/driver_cfa_cpp-VarExprReplacer.o `test -f 'SynTree/VarExprReplacer.cc' || echo '$(srcdir)/'`SynTree/VarExprReplacer.cc
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-VarExprReplacer.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-VarExprReplacer.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/VarExprReplacer.cc' object='SynTree/driver_cfa_cpp-VarExprReplacer.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-VarExprReplacer.o `test -f 'SynTree/VarExprReplacer.cc' || echo '$(srcdir)/'`SynTree/VarExprReplacer.cc
+
+SynTree/driver_cfa_cpp-VarExprReplacer.obj: SynTree/VarExprReplacer.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-VarExprReplacer.obj -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-VarExprReplacer.Tpo -c -o SynTree/driver_cfa_cpp-VarExprReplacer.obj `if test -f 'SynTree/VarExprReplacer.cc'; then $(CYGPATH_W) 'SynTree/VarExprReplacer.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/VarExprReplacer.cc'; fi`
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-VarExprReplacer.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-VarExprReplacer.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/VarExprReplacer.cc' object='SynTree/driver_cfa_cpp-VarExprReplacer.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-VarExprReplacer.obj `if test -f 'SynTree/VarExprReplacer.cc'; then $(CYGPATH_W) 'SynTree/VarExprReplacer.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/VarExprReplacer.cc'; fi`
+
 Tuples/driver_cfa_cpp-TupleAssignment.o: Tuples/TupleAssignment.cc
 @am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Tuples/driver_cfa_cpp-TupleAssignment.o -MD -MP -MF Tuples/$(DEPDIR)/driver_cfa_cpp-TupleAssignment.Tpo -c -o Tuples/driver_cfa_cpp-TupleAssignment.o `test -f 'Tuples/TupleAssignment.cc' || echo '$(srcdir)/'`Tuples/TupleAssignment.cc
@@ -2433 +2458 @@
 @AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o Tuples/driver_cfa_cpp-TupleExpansion.obj `if test -f 'Tuples/TupleExpansion.cc'; then $(CYGPATH_W) 'Tuples/TupleExpansion.cc'; else $(CYGPATH_W) '$(srcdir)/Tuples/TupleExpansion.cc'; fi`
+
+Tuples/driver_cfa_cpp-Explode.o: Tuples/Explode.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Tuples/driver_cfa_cpp-Explode.o -MD -MP -MF Tuples/$(DEPDIR)/driver_cfa_cpp-Explode.Tpo -c -o Tuples/driver_cfa_cpp-Explode.o `test -f 'Tuples/Explode.cc' || echo '$(srcdir)/'`Tuples/Explode.cc
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) Tuples/$(DEPDIR)/driver_cfa_cpp-Explode.Tpo Tuples/$(DEPDIR)/driver_cfa_cpp-Explode.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='Tuples/Explode.cc' object='Tuples/driver_cfa_cpp-Explode.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o Tuples/driver_cfa_cpp-Explode.o `test -f 'Tuples/Explode.cc' || echo '$(srcdir)/'`Tuples/Explode.cc
+
+Tuples/driver_cfa_cpp-Explode.obj: Tuples/Explode.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Tuples/driver_cfa_cpp-Explode.obj -MD -MP -MF Tuples/$(DEPDIR)/driver_cfa_cpp-Explode.Tpo -c -o Tuples/driver_cfa_cpp-Explode.obj `if test -f 'Tuples/Explode.cc'; then $(CYGPATH_W) 'Tuples/Explode.cc'; else $(CYGPATH_W) '$(srcdir)/Tuples/Explode.cc'; fi`
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) Tuples/$(DEPDIR)/driver_cfa_cpp-Explode.Tpo Tuples/$(DEPDIR)/driver_cfa_cpp-Explode.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='Tuples/Explode.cc' object='Tuples/driver_cfa_cpp-Explode.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o Tuples/driver_cfa_cpp-Explode.obj `if test -f 'Tuples/Explode.cc'; then $(CYGPATH_W) 'Tuples/Explode.cc'; else $(CYGPATH_W) '$(srcdir)/Tuples/Explode.cc'; fi`
 
 .ll.cc:

src/ResolvExpr/AlternativeFinder.cc

@@ -39 +39 @@
 #include "SymTab/Validate.h"
 #include "Tuples/Tuples.h"
+#include "Tuples/Explode.h"
 #include "Common/utility.h"
 #include "InitTweak/InitTweak.h"
@@ -240 +241 @@
                                 } // if
                         } // if
+                } else if ( NameExpr * nameExpr = dynamic_cast< NameExpr * >( member ) ) {
+                        // xxx - temporary hack until 0/1 are int constants
+                        if ( nameExpr->get_name() == "0" || nameExpr->get_name() == "1" ) {
+                                std::stringstream ss( nameExpr->get_name() );
+                                int val;
+                                ss >> val;
+                                alternatives.push_back( Alternative( new TupleIndexExpr( expr->clone(), val ), env, newCost ) );
+                        }
                 } // if
         }
@@ -1057 +1066 @@
 
         void AlternativeFinder::visit( UniqueExpr *unqExpr ) {
-                // this won't work because the unqExprs wont share an expression anymore...
                 AlternativeFinder finder( indexer, env );
                 finder.findWithAdjustment( unqExpr->get_expr() );
                 for ( Alternative & alt : finder.alternatives ) {
-                        // xxx - attach a resolved ConstructorInit node?
-                        // xxx - is it possible to make the objDecl's type const?
-                        static UniqueName tempNamer( "_unq_expr_" );
-                        ObjectDecl * objDecl = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, alt.expr->get_result()->clone(), nullptr );
-                        // must be done on two lines because genCtorInit accesses objDecl's fields
-                        objDecl->set_init( InitTweak::genCtorInit( objDecl ) );
-
+                        // ensure that the id is passed on to the UniqueExpr alternative so that the expressions are "linked"
                         UniqueExpr * newUnqExpr = new UniqueExpr( alt.expr->clone(), unqExpr->get_id() );
-                        newUnqExpr->set_object( objDecl );
-
-                        resolveObject( indexer, objDecl );
-
-                        alternatives.push_back( Alternative( newUnqExpr, env, Cost::zero ) );
+                        alternatives.push_back( Alternative( newUnqExpr, alt.env, alt.cost ) );
                 }
         }

src/SynTree/Expression.cc

@@ -609 +609 @@
 
 long long UniqueExpr::count = 0;
-UniqueExpr::UniqueExpr( Expression *expr, long long idVal ) : expr( new Expression* ), object( new ObjectDecl* ), id( idVal ) {
+UniqueExpr::UniqueExpr( Expression *expr, long long idVal ) : expr( expr ), object( nullptr ), var( nullptr ), id( idVal ) {
+        assert( expr );
         assert( count != -1 );
         if ( id == -1 ) id = count++;
-        set_expr( expr );
-        assert( expr );
         if ( expr->get_result() ) {
                 set_result( expr->get_result()->clone() );
         }
-        set_object( nullptr );
-}
-UniqueExpr::UniqueExpr( const UniqueExpr &other ) : Expression( other ), expr( other.expr ), object( other.object ), id( other.id ) {
+}
+UniqueExpr::UniqueExpr( const UniqueExpr &other ) : Expression( other ), expr( maybeClone( other.expr ) ), object( maybeClone( other.object ) ), var( maybeClone( other.var ) ), id( other.id ) {
 }
 UniqueExpr::~UniqueExpr() {
-        if ( expr.unique() ) {
-                delete *expr;
-        }
-        if ( object.unique() ) {
-                delete *object;
-        }
+        delete expr;
+        delete object;
+        delete var;
 }
 void UniqueExpr::print( std::ostream &os, int indent ) const {

src/SynTree/Expression.h

@@ -742 +742 @@
         ~UniqueExpr();
 
-        Expression * get_expr() const { return *expr; }
-        UniqueExpr * set_expr( Expression * newValue ) { *expr = newValue; return this; }
-
-        ObjectDecl * get_object() const { return *object; }
-        UniqueExpr * set_object( ObjectDecl * newValue ) { *object = newValue; return this; }
+        Expression * get_expr() const { return expr; }
+        UniqueExpr * set_expr( Expression * newValue ) { expr = newValue; return this; }
+
+        ObjectDecl * get_object() const { return object; }
+        UniqueExpr * set_object( ObjectDecl * newValue ) { object = newValue; return this; }
+
+        VariableExpr * get_var() const { return var; }
+        UniqueExpr * set_var( VariableExpr * newValue ) { var = newValue; return this; }
 
         int get_id() const { return id; }
@@ -755 +758 @@
         virtual void print( std::ostream &os, int indent = 0 ) const;
 private:
-        std::shared_ptr< Expression * > expr;
-        std::shared_ptr< ObjectDecl * > object;
+        Expression * expr;
+        ObjectDecl * object;
+        VariableExpr * var;
         int id;
         static long long count;

src/Tuples/TupleAssignment.cc

@@ -20 +20 @@
 #include "SynTree/Initializer.h"
 #include "Tuples.h"
+#include "Explode.h"
 #include "Common/SemanticError.h"
 #include "InitTweak/InitTweak.h"

src/Tuples/TupleExpansion.cc

@@ -41 +41 @@
                 public:
                         typedef GenPoly::DeclMutator Parent;
+
                         virtual Expression * mutate( UniqueExpr * unqExpr );
-                        std::map< int, ObjectDecl * > decls; // not vector, because order added may not be increasing order
+
+                        std::map< int, Expression * > decls; // not vector, because order added may not be increasing order
+
+                        ~UniqueExprExpander() {
+                                for ( std::pair<const int, Expression *> & p : decls ) {
+                                        delete p.second;
+                                }
+                        }
                 };
 
@@ -107 +115 @@
                 /// given a expression representing the member and an expression representing the aggregate,
                 /// reconstructs a flattened UntypedMemberExpr with the right precedence
-                Expression * reconstructMemberExpr( Expression * member, UniqueExpr * aggr ) {
+                Expression * reconstructMemberExpr( Expression * member, Expression * aggr ) {
                         if ( UntypedMemberExpr * memberExpr = dynamic_cast< UntypedMemberExpr * >( member ) ) {
                                 // construct a new UntypedMemberExpr with the correct structure , and recursively
@@ -127 +135 @@
         Expression * MemberTupleExpander::mutate( UntypedMemberExpr * memberExpr ) {
                 if ( TupleExpr * tupleExpr = dynamic_cast< TupleExpr * > ( memberExpr->get_member() ) ) {
-                        UniqueExpr * unqExpr = new UniqueExpr( memberExpr->get_aggregate()->clone() );
+                        Expression * aggr = memberExpr->get_aggregate()->clone()->acceptMutator( *this );
+                        // aggregate expressions which might be impure must be wrapped in unique expressions
+                        // xxx - if there's a member-tuple expression nested in the aggregate, this currently generates the wrong code if a UniqueExpr is not used, and it's purely an optimization to remove the UniqueExpr
+                        // if ( Tuples::maybeImpure( memberExpr->get_aggregate() ) ) aggr = new UniqueExpr( aggr );
+                        aggr = new UniqueExpr( aggr );
                         for ( Expression *& expr : tupleExpr->get_exprs() ) {
-                                expr = reconstructMemberExpr( expr, unqExpr );
-                        }
-                        delete unqExpr;
+                                expr = reconstructMemberExpr( expr, aggr );
+                        }
+                        delete aggr;
                         return tupleExpr;
                 } else {
@@ -142 +154 @@
         Expression * UniqueExprExpander::mutate( UniqueExpr * unqExpr ) {
                 unqExpr = safe_dynamic_cast< UniqueExpr * > ( Parent::mutate( unqExpr ) );
-                if ( ! decls.count( unqExpr->get_id() ) ) {
-                        // xxx - it's possible (likely?) that expressions can appear in the wrong order because of this. Need to ensure they're placed in the correct location.
-
-                        // xxx - this doesn't work, because it would need to be placed after fixInit, but fixInit doesn't know (and shouldn't have to know) about the existance of UniqueExprs - i.e. it will visit them twice
-                        // need to construct/destruct unique exprs in general - maybe it's not worth it and fixInit should handle UniqueExpr explicitly?
-                        // currently, tmp is being destructed before unqExpr is used, which suggests there should be a separate lifetime for unqExpr from the tmp_ret
-
-                        // if ( CommaExpr * commaExpr = dynamic_cast< CommaExpr * >( unqExpr->get_expr() ) ) {
-                        //      if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( commaExpr->get_arg2() ) ) {
-                        //              // steal existing decl from expr
-                        //              if ( ObjectDecl * decl = dynamic_cast< ObjectDecl * >( varExpr->get_var() ) ) {
-                        //                      decls[unqExpr->get_id()] = decl;
-                        //                      return unqExpr->get_expr()->clone();
-                        //              }
-                        //      }
-                        // }
-
-                        ObjectDecl * objDecl = unqExpr->get_object();
-                        unqExpr->set_object( nullptr );
-                        decls[unqExpr->get_id()] = objDecl;
-                        addDeclaration( objDecl );
-                }
-                return new VariableExpr( decls[unqExpr->get_id()] );
+                const int id = unqExpr->get_id();
+
+                // on first time visiting a unique expr with a particular ID, generate the expression that replaces all UniqueExprs with that ID,
+                // and lookup on subsequent hits. This ensures that all unique exprs with the same ID reference the same variable.
+                if ( ! decls.count( id ) ) {
+                        Expression * assignUnq;
+                        Expression * var = unqExpr->get_var();
+                        if ( unqExpr->get_object() ) {
+                                // an object was generated to represent this unique expression -- it should be added to the list of declarations now
+                                addDeclaration( unqExpr->get_object() );
+                                unqExpr->set_object( nullptr );
+                                // steal the expr from the unqExpr
+                                assignUnq = UntypedExpr::createAssign( unqExpr->get_var()->clone(), unqExpr->get_expr() );
+                                unqExpr->set_expr( nullptr );
+                        } else {
+                                // steal the already generated assignment to var from the unqExpr - this has been generated by FixInit
+                                Expression * expr = unqExpr->get_expr();
+                                CommaExpr * commaExpr = safe_dynamic_cast< CommaExpr * >( expr );
+                                assignUnq = commaExpr->get_arg1();
+                                commaExpr->set_arg1( nullptr );
+                        }
+                        BasicType * boolType = new BasicType( Type::Qualifiers(), BasicType::Bool );
+                        ObjectDecl * finished = new ObjectDecl( toString( "_unq_expr_finished_", id ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::Bool ), new SingleInit( new ConstantExpr( Constant( boolType->clone(), "0" ) ), noDesignators ) );
+                        addDeclaration( finished );
+                        // (finished ? _unq_expr_N : (_unq_expr_N = <unqExpr->get_expr()>, finished = 1, _unq_expr_N))
+                        // This pattern ensures that each unique expression is evaluated once, regardless of evaluation order of the generated C code.
+                        Expression * assignFinished = UntypedExpr::createAssign( new VariableExpr(finished), new ConstantExpr( Constant( boolType->clone(), "1" ) ) );
+                        ConditionalExpr * condExpr = new ConditionalExpr( new VariableExpr( finished ), var->clone(),
+                                new CommaExpr( new CommaExpr( assignUnq, assignFinished ), var->clone() ) );
+                        condExpr->set_result( var->get_result()->clone() );
+                        decls[id] = condExpr;
+                }
+                delete unqExpr;
+                return decls[id]->clone();
         }
 
         Expression * TupleAssignExpander::mutate( TupleAssignExpr * assnExpr ) {
-                // xxx - Parent::mutate?
+                assnExpr = safe_dynamic_cast< TupleAssignExpr * >( Parent::mutate( assnExpr ) );
                 CompoundStmt * compoundStmt = new CompoundStmt( noLabels );
                 std::list< Statement * > & stmts = compoundStmt->get_kids();
@@ -192 +215 @@
                         int cnt = 0;
                         for ( Type * t : *newType ) {
-                                decl->get_members().push_back( new ObjectDecl( "field_"+std::to_string(++cnt), DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, t->clone(), nullptr ) );
+                                decl->get_members().push_back( new ObjectDecl( toString("field_", cnt++), DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, t->clone(), nullptr ) );
                         }
                         typeMap[mangleName] = decl;

src/Tuples/Tuples.h

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Mon May 18 15:04:02 2015
-// Update Count     : 2
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Nov 9 13:17:58 2016
+// Update Count     : 15
 //
 
@@ -18 +18 @@
 
 #include <string>
-#include <vector>
-#include "ResolvExpr/AlternativeFinder.h"
-#include "ResolvExpr/Resolver.h"
 
 #include "SynTree/Expression.h"
 #include "SynTree/Declaration.h"
 #include "SynTree/Type.h"
+
+#include "ResolvExpr/AlternativeFinder.h"
 
 namespace Tuples {
@@ -45 +44 @@
         /// returns true if the expression may contain side-effects.
         bool maybeImpure( Expression * expr );
-
-
-        /// helper function used by explode
-        template< typename OutputIterator >
-        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 = new AddressExpr( alt.expr );
-                                *out++ = alt;
-                        }
-                } 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 );
-                                }
-                        } else {
-                                // tuple type, but not tuple expr - recursively index into its components
-                                Expression * arg = expr->clone();
-                                if ( Tuples::maybeImpure( arg ) ) {
-                                        // 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, indexer, out );
-                                        delete idx;
-                                }
-                                delete arg;
-                        }
-                } else {
-                        // atomic (non-tuple) type - output a clone of the expression in a new alternative
-                        *out++ = ResolvExpr::Alternative( expr->clone(), alt.env, alt.cost, alt.cvtCost );
-                }
-        }
-
-        /// 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 ) {
-                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 ) {
-                for ( ; altBegin != altEnd; ++altBegin ) {
-                        explode( *altBegin, indexer, out );
-                }
-        }
-
-        template< typename OutputIterator >
-        void explode( const ResolvExpr::AltList & alts, const SymTab::Indexer & indexer, OutputIterator out ) {
-                explode( alts.begin(), alts.end(), indexer, out );
-        }
 } // namespace Tuples
 

src/Tuples/module.mk

@@ -16 +16 @@
 
 SRC +=  Tuples/TupleAssignment.cc \
-        Tuples/TupleExpansion.cc
+        Tuples/TupleExpansion.cc \
+        Tuples/Explode.cc

src/main.cc

@@ -251 +251 @@
                 } // if
 
-                OPTPRINT( "expandUniqueExpr" ); // xxx - is this the right place for this? want to expand ASAP so that subsequent passes don't need to worry about double-visiting a unique expr
-                Tuples::expandUniqueExpr( translationUnit );
-
                 // fix ObjectDecl - replaces ConstructorInit nodes
                 OPTPRINT( "fixInit" )
@@ -261 +258 @@
                         return 0;
                 } // if
+
+                OPTPRINT( "expandUniqueExpr" ); // xxx - is this the right place for this? want to expand ASAP so that subsequent passes don't need to worry about double-visiting a unique expr - needs to go after InitTweak::fix so that copy constructed return declarations are reused
+                Tuples::expandUniqueExpr( translationUnit );
 
                 OPTPRINT("instantiateGenerics")