Changes in / [1abc5ab:a12d5aa]

Location:

src

Files:

• CodeGen/CodeGenerator.cc (modified) (3 diffs)
• CodeGen/CodeGenerator.h (modified) (2 diffs)
• Common/PassVisitor.h (modified) (1 diff)
• Common/PassVisitor.impl.h (modified) (2 diffs)
• Common/PassVisitor.proto.h (modified) (2 diffs)
• Common/utility.h (modified) (1 diff)
• InitTweak/FixInit.cc (modified) (8 diffs)
• InitTweak/InitTweak.cc (modified) (1 diff)
• MakeLibCfa.cc (modified) (1 diff)
• Makefile.in (modified) (6 diffs)
• Parser/InitializerNode.cc (modified) (1 diff)
• Parser/TypeData.cc (modified) (2 diffs)
• ResolvExpr/AlternativeFinder.cc (modified) (4 diffs)
• ResolvExpr/AlternativeFinder.h (modified) (1 diff)
• ResolvExpr/CurrentObject.cc (added)
• ResolvExpr/CurrentObject.h (added)
• ResolvExpr/Resolver.cc (modified) (8 diffs)
• ResolvExpr/Unify.cc (modified) (4 diffs)
• ResolvExpr/module.mk (modified) (2 diffs)
• SymTab/Autogen.h (modified) (3 diffs)
• SymTab/ImplementationType.cc (modified) (2 diffs)
• SynTree/Constant.cc (modified) (2 diffs)
• SynTree/Constant.h (modified) (2 diffs)
• SynTree/Expression.cc (modified) (3 diffs)
• SynTree/Expression.h (modified) (1 diff)
• SynTree/Initializer.cc (modified) (3 diffs)
• SynTree/Initializer.h (modified) (7 diffs)
• SynTree/Mutator.cc (modified) (4 diffs)
• SynTree/Mutator.h (modified) (2 diffs)
• SynTree/SynTree.h (modified) (2 diffs)
• SynTree/TupleType.cc (modified) (1 diff)
• SynTree/Type.h (modified) (3 diffs)
• SynTree/VarExprReplacer.cc (modified) (1 diff)
• SynTree/VarExprReplacer.h (modified) (1 diff)
• SynTree/Visitor.cc (modified) (4 diffs)
• SynTree/Visitor.h (modified) (2 diffs)
• Tuples/TupleExpansion.cc (modified) (2 diffs)
• tests/.expect/designations.txt (added)
• tests/designations.c (added)

src/CodeGen/CodeGenerator.cc

@@ -288 +288 @@
         }
 
-        void CodeGenerator::printDesignators( std::list< Expression * > & designators ) {
-                typedef std::list< Expression * > DesignatorList;
+        void CodeGenerator::visit( Designation * designation ) {
+                std::list< Expression * > designators = designation->get_designators();
                 if ( designators.size() == 0 ) return;
-                for ( DesignatorList::iterator iter = designators.begin(); iter != designators.end(); ++iter ) {
-                        if ( dynamic_cast< NameExpr * >( *iter ) ) {
-                                // if expression is a name, then initializing aggregate member
+                for ( Expression * des : designators ) {
+                        if ( dynamic_cast< NameExpr * >( des ) || dynamic_cast< VariableExpr * >( des ) ) {
+                                // if expression is a NameExpr or VariableExpr, then initializing aggregate member
                                 output << ".";
-                                (*iter)->accept( *this );
+                                des->accept( *this );
                         } else {
-                                // if not a simple name, it has to be a constant expression, i.e. an array designator
+                                // otherwise, it has to be a ConstantExpr or CastExpr, initializing array eleemnt
                                 output << "[";
-                                (*iter)->accept( *this );
+                                des->accept( *this );
                                 output << "]";
                         } // if
@@ -307 +307 @@
 
         void CodeGenerator::visit( SingleInit * init ) {
-                printDesignators( init->get_designators() );
                 init->get_value()->accept( *this );
         }
 
         void CodeGenerator::visit( ListInit * init ) {
-                printDesignators( init->get_designators() );
+                auto initBegin = init->begin();
+                auto initEnd = init->end();
+                auto desigBegin = init->get_designations().begin();
+                auto desigEnd = init->get_designations().end();
+
                 output << "{ ";
-                genCommaList( init->begin(), init->end() );
+                for ( ; initBegin != initEnd && desigBegin != desigEnd; ) {
+                        (*desigBegin)->accept( *this );
+                        (*initBegin)->accept( *this );
+                        ++initBegin, ++desigBegin;
+                        if ( initBegin != initEnd ) {
+                                output << ", ";
+                        }
+                }
                 output << " }";
+                assertf( initBegin == initEnd && desigBegin == desigEnd, "Initializers and designators not the same length. %s", toString( init ).c_str() );
         }
 
@@ -716 +727 @@
 
         void CodeGenerator::visit( TypeExpr * typeExpr ) {
-                assertf( ! genC, "TypeExpr should not reach code generation." );
-                output<< genType( typeExpr->get_type(), "", pretty, genC );
+                // if ( genC ) std::cerr << "typeexpr still exists: " << typeExpr << std::endl;
+                // assertf( ! genC, "TypeExpr should not reach code generation." );
+                if ( ! genC ) {
+                        output<< genType( typeExpr->get_type(), "", pretty, genC );
+                }
         }
 

src/CodeGen/CodeGenerator.h

@@ -47 +47 @@
 
                 //*** Initializer
+                virtual void visit( Designation * );
                 virtual void visit( SingleInit * );
                 virtual void visit( ListInit * );
@@ -137 +138 @@
                 bool lineMarks = false;
 
-                void printDesignators( std::list< Expression * > & );
                 void handleStorageClass( DeclarationWithType *decl );
                 void handleAggregate( AggregateDecl *aggDecl, const std::string & kind );

src/Common/PassVisitor.h

@@ -257 +257 @@
 
         void set_visit_children( bool& ref ) { bool_ref * ptr = visit_children_impl(pass, 0); if(ptr) ptr->set( ref ); }
-
-        guard_value_impl init_guard() {
-                guard_value_impl guard;
-                auto at_cleanup = at_cleanup_impl(pass, 0);
-                if( at_cleanup ) {
-                        *at_cleanup = [&guard]( cleanup_func_t && func, void* val ) {
-                                guard.push( std::move( func ), val );
-                        };
-                }
-                return guard;
-        }
 };
 

src/Common/PassVisitor.impl.h

@@ -3 +3 @@
 #define VISIT_START( node )                     \
         __attribute__((unused))                   \
-        const auto & guard = init_guard();        \
+        guard_value_impl guard( at_cleanup_impl(pass, 0) );       \
         bool visit_children = true;               \
         set_visit_children( visit_children );   \
@@ -15 +15 @@
 #define MUTATE_START( node )                    \
         __attribute__((unused))                   \
-        const auto & guard = init_guard();        \
+        guard_value_impl guard( at_cleanup_impl(pass, 0) );       \
         bool visit_children = true;               \
         set_visit_children( visit_children );   \

src/Common/PassVisitor.proto.h

@@ -5 +5 @@
 
 typedef std::function<void( void * )> cleanup_func_t;
+typedef std::function< void( cleanup_func_t, void * ) > at_cleanup_t;
 
 class guard_value_impl {
 public:
-        guard_value_impl() = default;
+        guard_value_impl( at_cleanup_t * at_cleanup ) {
+                if( at_cleanup ) {
+                        *at_cleanup = [this]( cleanup_func_t && func, void* val ) {
+                                push( std::move( func ), val );
+                        };
+                }
+        }
 
         ~guard_value_impl() {
@@ -33 +40 @@
 };
 
-typedef std::function< void( cleanup_func_t, void * ) > at_cleanup_t;
 
 class bool_ref {

src/Common/utility.h

@@ -305 +305 @@
 // for ( val : group_iterate( container1, container2, ... ) ) {}
 // syntax to have a for each that iterates multiple containers of the same length
-// TODO: update to use variadic arguments
+// TODO: update to use variadic arguments, perfect forwarding
 
 template< typename T1, typename T2 >

src/InitTweak/FixInit.cc

@@ -104 +104 @@
                         typedef AddStmtVisitor Parent;
                         using Parent::visit;
-                        typedef std::set< ObjectDecl * > ObjectSet;
+                        // use ordered data structure to maintain ordering for set_difference and for consistent error messages
+                        typedef std::list< ObjectDecl * > ObjectSet;
                         virtual void visit( CompoundStmt *compoundStmt ) override;
                         virtual void visit( DeclStmt *stmt ) override;
@@ -116 +117 @@
 
                 // debug
-                struct printSet {
-                        typedef ObjDeclCollector::ObjectSet ObjectSet;
-                        printSet( const ObjectSet & objs ) : objs( objs ) {}
+                template<typename ObjectSet>
+                struct PrintSet {
+                        PrintSet( const ObjectSet & objs ) : objs( objs ) {}
                         const ObjectSet & objs;
                 };
-                std::ostream & operator<<( std::ostream & out, const printSet & set) {
+                template<typename ObjectSet>
+                PrintSet<ObjectSet> printSet( const ObjectSet & objs ) { return PrintSet<ObjectSet>( objs ); }
+                template<typename ObjectSet>
+                std::ostream & operator<<( std::ostream & out, const PrintSet<ObjectSet> & set) {
                         out << "{ ";
                         for ( ObjectDecl * obj : set.objs ) {
@@ -724 +728 @@
                                                 // static bool __objName_uninitialized = true
                                                 BasicType * boolType = new BasicType( Type::Qualifiers(), BasicType::Bool );
-                                                SingleInit * boolInitExpr = new SingleInit( new ConstantExpr( Constant::from_int( 1 ) ), noDesignators );
+                                                SingleInit * boolInitExpr = new SingleInit( new ConstantExpr( Constant::from_int( 1 ) ) );
                                                 ObjectDecl * isUninitializedVar = new ObjectDecl( objDecl->get_mangleName() + "_uninitialized", Type::StorageClasses( Type::Static ), LinkageSpec::Cforall, 0, boolType, boolInitExpr );
                                                 isUninitializedVar->fixUniqueId();
@@ -745 +749 @@
 
                                                 Statement * dtor = ctorInit->get_dtor();
-                                                objDecl->set_init( NULL );
-                                                ctorInit->set_ctor( NULL );
+                                                objDecl->set_init( nullptr );
+                                                ctorInit->set_ctor( nullptr );
                                                 ctorInit->set_dtor( nullptr );
                                                 if ( dtor ) {
@@ -799 +803 @@
                                                 } else {
                                                         stmtsToAddAfter.push_back( ctor );
-                                                        objDecl->set_init( NULL );
-                                                        ctorInit->set_ctor( NULL );
+                                                        objDecl->set_init( nullptr );
+                                                        ctorInit->set_ctor( nullptr );
                                                 }
                                         } // if
                                 } else if ( Initializer * init = ctorInit->get_init() ) {
                                         objDecl->set_init( init );
-                                        ctorInit->set_init( NULL );
+                                        ctorInit->set_init( nullptr );
                                 } else {
                                         // no constructor and no initializer, which is okay
-                                        objDecl->set_init( NULL );
+                                        objDecl->set_init( nullptr );
                                 } // if
                                 delete ctorInit;
@@ -816 +820 @@
 
                 void ObjDeclCollector::visit( CompoundStmt * compoundStmt ) {
-                        std::set< ObjectDecl * > prevVars = curVars;
+                        ObjectSet prevVars = curVars;
                         Parent::visit( compoundStmt );
                         curVars = prevVars;
@@ -824 +828 @@
                         // keep track of all variables currently in scope
                         if ( ObjectDecl * objDecl = dynamic_cast< ObjectDecl * > ( stmt->get_decl() ) ) {
-                                curVars.insert( objDecl );
+                                curVars.push_back( objDecl );
                         } // if
                         Parent::visit( stmt );
@@ -939 +943 @@
                         )
                         if ( ! diff.empty() ) {
+                                // create an auxilliary set for fast lookup -- can't make diff a set, because diff ordering should be consistent for error messages.
+                                std::unordered_set<ObjectDecl *> needsDestructor( diff.begin(), diff.end() );
+
                                 // go through decl ordered list of objectdecl. for each element that occurs in diff, output destructor
                                 OrderedDecls ordered;
                                 for ( OrderedDecls & rdo : reverseDeclOrder ) {
                                         // add elements from reverseDeclOrder into ordered if they occur in diff - it is key that this happens in reverse declaration order.
-                                        copy_if( rdo.begin(), rdo.end(), back_inserter( ordered ), [&]( ObjectDecl * objDecl ) { return diff.count( objDecl ); } );
+                                        copy_if( rdo.begin(), rdo.end(), back_inserter( ordered ), [&]( ObjectDecl * objDecl ) { return needsDestructor.count( objDecl ); } );
                                 } // for
                                 insertDtors( ordered.begin(), ordered.end(), back_inserter( stmtsToAdd ) );

src/InitTweak/InitTweak.cc

@@ -14 +14 @@
                 public:
                         bool hasDesignations = false;
-                        template<typename Init>
-                        void handleInit( Init * init ) {
-                                if ( ! init->get_designators().empty() ) hasDesignations = true;
-                                else Visitor::visit( init );
-                        }
-                        virtual void visit( SingleInit * singleInit ) { handleInit( singleInit); }
-                        virtual void visit( ListInit * listInit ) { handleInit( listInit); }
+                        virtual void visit( Designation * des ) {
+                                if ( ! des->get_designators().empty() ) hasDesignations = true;
+                                else Visitor::visit( des );
+                        }
                 };
 

src/MakeLibCfa.cc

@@ -92 +92 @@
                 assert( ! objDecl->get_init() );
                 std::list< Expression* > noDesignators;
-                objDecl->set_init( new SingleInit( new NameExpr( objDecl->get_name() ), noDesignators, false ) ); // cannot be constructed
+                objDecl->set_init( new SingleInit( new NameExpr( objDecl->get_name() ), false ) ); // cannot be constructed
                 newDecls.push_back( objDecl );
         }

src/Makefile.in

@@ -162 +162 @@
         ResolvExpr/driver_cfa_cpp-Occurs.$(OBJEXT) \
         ResolvExpr/driver_cfa_cpp-TypeEnvironment.$(OBJEXT) \
+        ResolvExpr/driver_cfa_cpp-CurrentObject.$(OBJEXT) \
         SymTab/driver_cfa_cpp-Indexer.$(OBJEXT) \
         SymTab/driver_cfa_cpp-Mangler.$(OBJEXT) \
@@ -416 +417 @@
         ResolvExpr/RenameVars.cc ResolvExpr/FindOpenVars.cc \
         ResolvExpr/PolyCost.cc ResolvExpr/Occurs.cc \
-        ResolvExpr/TypeEnvironment.cc SymTab/Indexer.cc \
-        SymTab/Mangler.cc SymTab/Validate.cc SymTab/FixFunction.cc \
-        SymTab/ImplementationType.cc SymTab/TypeEquality.cc \
-        SymTab/Autogen.cc SynTree/Type.cc SynTree/VoidType.cc \
-        SynTree/BasicType.cc SynTree/PointerType.cc \
-        SynTree/ArrayType.cc SynTree/FunctionType.cc \
-        SynTree/ReferenceToType.cc SynTree/TupleType.cc \
-        SynTree/TypeofType.cc SynTree/AttrType.cc \
+        ResolvExpr/TypeEnvironment.cc ResolvExpr/CurrentObject.cc \
+        SymTab/Indexer.cc SymTab/Mangler.cc SymTab/Validate.cc \
+        SymTab/FixFunction.cc SymTab/ImplementationType.cc \
+        SymTab/TypeEquality.cc SymTab/Autogen.cc SynTree/Type.cc \
+        SynTree/VoidType.cc SynTree/BasicType.cc \
+        SynTree/PointerType.cc SynTree/ArrayType.cc \
+        SynTree/FunctionType.cc SynTree/ReferenceToType.cc \
+        SynTree/TupleType.cc SynTree/TypeofType.cc SynTree/AttrType.cc \
         SynTree/VarArgsType.cc SynTree/ZeroOneType.cc \
         SynTree/Constant.cc SynTree/Expression.cc SynTree/TupleExpr.cc \
@@ -726 +727 @@
         ResolvExpr/$(am__dirstamp) \
         ResolvExpr/$(DEPDIR)/$(am__dirstamp)
+ResolvExpr/driver_cfa_cpp-CurrentObject.$(OBJEXT):  \
+        ResolvExpr/$(am__dirstamp) \
+        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
 SymTab/$(am__dirstamp):
         @$(MKDIR_P) SymTab
@@ -896 +900 @@
         -rm -f ResolvExpr/driver_cfa_cpp-CommonType.$(OBJEXT)
         -rm -f ResolvExpr/driver_cfa_cpp-ConversionCost.$(OBJEXT)
+        -rm -f ResolvExpr/driver_cfa_cpp-CurrentObject.$(OBJEXT)
         -rm -f ResolvExpr/driver_cfa_cpp-FindOpenVars.$(OBJEXT)
         -rm -f ResolvExpr/driver_cfa_cpp-Occurs.$(OBJEXT)
@@ -1009 +1014 @@
 @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CommonType.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-ConversionCost.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-FindOpenVars.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-Occurs.Po@am__quote@
@@ -1964 +1970 @@
 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o ResolvExpr/driver_cfa_cpp-TypeEnvironment.obj `if test -f 'ResolvExpr/TypeEnvironment.cc'; then $(CYGPATH_W) 'ResolvExpr/TypeEnvironment.cc'; else $(CYGPATH_W) '$(srcdir)/ResolvExpr/TypeEnvironment.cc'; fi`
 
+ResolvExpr/driver_cfa_cpp-CurrentObject.o: ResolvExpr/CurrentObject.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT ResolvExpr/driver_cfa_cpp-CurrentObject.o -MD -MP -MF ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Tpo -c -o ResolvExpr/driver_cfa_cpp-CurrentObject.o `test -f 'ResolvExpr/CurrentObject.cc' || echo '$(srcdir)/'`ResolvExpr/CurrentObject.cc
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Tpo ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='ResolvExpr/CurrentObject.cc' object='ResolvExpr/driver_cfa_cpp-CurrentObject.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 ResolvExpr/driver_cfa_cpp-CurrentObject.o `test -f 'ResolvExpr/CurrentObject.cc' || echo '$(srcdir)/'`ResolvExpr/CurrentObject.cc
+
+ResolvExpr/driver_cfa_cpp-CurrentObject.obj: ResolvExpr/CurrentObject.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT ResolvExpr/driver_cfa_cpp-CurrentObject.obj -MD -MP -MF ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Tpo -c -o ResolvExpr/driver_cfa_cpp-CurrentObject.obj `if test -f 'ResolvExpr/CurrentObject.cc'; then $(CYGPATH_W) 'ResolvExpr/CurrentObject.cc'; else $(CYGPATH_W) '$(srcdir)/ResolvExpr/CurrentObject.cc'; fi`
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Tpo ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='ResolvExpr/CurrentObject.cc' object='ResolvExpr/driver_cfa_cpp-CurrentObject.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 ResolvExpr/driver_cfa_cpp-CurrentObject.obj `if test -f 'ResolvExpr/CurrentObject.cc'; then $(CYGPATH_W) 'ResolvExpr/CurrentObject.cc'; else $(CYGPATH_W) '$(srcdir)/ResolvExpr/CurrentObject.cc'; fi`
+
 SymTab/driver_cfa_cpp-Indexer.o: SymTab/Indexer.cc
 @am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SymTab/driver_cfa_cpp-Indexer.o -MD -MP -MF SymTab/$(DEPDIR)/driver_cfa_cpp-Indexer.Tpo -c -o SymTab/driver_cfa_cpp-Indexer.o `test -f 'SymTab/Indexer.cc' || echo '$(srcdir)/'`SymTab/Indexer.cc

src/Parser/InitializerNode.cc

@@ -74 +74 @@
 
         InitializerNode *moreInit;
-        if  ( get_next() != 0 && ((moreInit = dynamic_cast< InitializerNode * >( get_next() ) ) != 0) )
+        if ( (moreInit = dynamic_cast< InitializerNode * >( get_next() ) ) ) {
                 moreInit->printOneLine( os );
+        }
 }
 
 Initializer *InitializerNode::build() const {
         if ( aggregate ) {
+                // steal designators from children
+                std::list< Designation * > designlist;
+                InitializerNode * child = next_init();
+                for ( ; child != nullptr; child = dynamic_cast< InitializerNode * >( child->get_next() ) ) {
+                        std::list< Expression * > desList;
+                        buildList< Expression, ExpressionNode >( child->designator, desList );
+                        designlist.push_back( new Designation( desList ) );
+                } // for
                 std::list< Initializer * > initlist;
                 buildList< Initializer, InitializerNode >( next_init(), initlist );
-
-                std::list< Expression * > designlist;
-
-                if ( designator != 0 ) {
-                        buildList< Expression, ExpressionNode >( designator, designlist );
-                } // if
-
                 return new ListInit( initlist, designlist, maybeConstructed );
         } else {
-                std::list< Expression * > designators;
-
-                if ( designator != 0 )
-                        buildList< Expression, ExpressionNode >( designator, designators );
-
-                if ( get_expression() != 0)
-                        return new SingleInit( maybeBuild< Expression >( get_expression() ), designators, maybeConstructed );
+                if ( get_expression() != 0) {
+                        return new SingleInit( maybeBuild< Expression >( get_expression() ), maybeConstructed );
+                }
         } // if
-
         return 0;
 }

src/Parser/TypeData.cc

@@ -760 +760 @@
                 if ( cur->has_enumeratorValue() ) {
                         ObjectDecl * member = dynamic_cast< ObjectDecl * >(* members);
-                        member->set_init( new SingleInit( maybeMoveBuild< Expression >( cur->consume_enumeratorValue() ), list< Expression * >() ) );
+                        member->set_init( new SingleInit( maybeMoveBuild< Expression >( cur->consume_enumeratorValue() ) ) );
                 } // if
         } // for
@@ -777 +777 @@
 TupleType * buildTuple( const TypeData * td ) {
         assert( td->kind == TypeData::Tuple );
-        TupleType * ret = new TupleType( buildQualifiers( td ) );
-        buildTypeList( td->tuple, ret->get_types() );
+        std::list< Type * > types;
+        buildTypeList( td->tuple, types );
+        TupleType * ret = new TupleType( buildQualifiers( td ), types );
         buildForall( td->forall, ret->get_forall() );
         return ret;

src/ResolvExpr/AlternativeFinder.cc

@@ -604 +604 @@
 //          )
                 SymTab::Indexer decls( indexer );
-                PRINT(
-                        std::cerr << "============= original indexer" << std::endl;
-                        indexer.print( std::cerr );
-                        std::cerr << "============= new indexer" << std::endl;
-                        decls.print( std::cerr );
-                )
+                // PRINT(
+                //      std::cerr << "============= original indexer" << std::endl;
+                //      indexer.print( std::cerr );
+                //      std::cerr << "============= new indexer" << std::endl;
+                //      decls.print( std::cerr );
+                // )
                 addToIndexer( have, decls );
                 AssertionSet newNeed;
@@ -809 +809 @@
         }
 
+        Expression * restructureCast( Expression * argExpr, Type * toType ) {
+                if ( argExpr->get_result()->size() > 1 && ! toType->isVoid() ) {
+                        // Argument expression is a tuple and the target type is not void. Cast each member of the tuple
+                        // to its corresponding target type, producing the tuple of those cast expressions. If there are
+                        // more components of the tuple than components in the target type, then excess components do not
+                        // come out in the result expression (but UniqueExprs ensure that side effects will still be done).
+                        if ( Tuples::maybeImpure( argExpr ) && ! dynamic_cast< UniqueExpr * >( argExpr ) ) {
+                                // expressions which may contain side effects require a single unique instance of the expression.
+                                argExpr = new UniqueExpr( argExpr );
+                        }
+                        std::list< Expression * > componentExprs;
+                        for ( unsigned int i = 0; i < toType->size(); i++ ) {
+                                // cast each component
+                                TupleIndexExpr * idx = new TupleIndexExpr( argExpr->clone(), i );
+                                componentExprs.push_back( restructureCast( idx, toType->getComponent( i ) ) );
+                        }
+                        delete argExpr;
+                        assert( componentExprs.size() > 0 );
+                        // produce the tuple of casts
+                        return new TupleExpr( componentExprs );
+                } else {
+                        // handle normally
+                        return new CastExpr( argExpr, toType->clone() );
+                }
+        }
+
         void AlternativeFinder::visit( CastExpr *castExpr ) {
                 Type *& toType = castExpr->get_result();
@@ -840 +866 @@
                                 thisCost += Cost( 0, 0, discardedValues );
 
-                                Expression * argExpr = i->expr->clone();
-                                if ( argExpr->get_result()->size() > 1 && ! castExpr->get_result()->isVoid() ) {
-                                        // Argument expression is a tuple and the target type is not void. Cast each member of the tuple
-                                        // to its corresponding target type, producing the tuple of those cast expressions. If there are
-                                        // more components of the tuple than components in the target type, then excess components do not
-                                        // come out in the result expression (but UniqueExprs ensure that side effects will still be done).
-                                        if ( Tuples::maybeImpure( argExpr ) && ! dynamic_cast< UniqueExpr * >( argExpr ) ) {
-                                                // expressions which may contain side effects require a single unique instance of the expression.
-                                                argExpr = new UniqueExpr( argExpr );
-                                        }
-                                        std::list< Expression * > componentExprs;
-                                        for ( unsigned int i = 0; i < castExpr->get_result()->size(); i++ ) {
-                                                // cast each component
-                                                TupleIndexExpr * idx = new TupleIndexExpr( argExpr->clone(), i );
-                                                componentExprs.push_back( new CastExpr( idx, castExpr->get_result()->getComponent( i )->clone() ) );
-                                        }
-                                        delete argExpr;
-                                        assert( componentExprs.size() > 0 );
-                                        // produce the tuple of casts
-                                        candidates.push_back( Alternative( new TupleExpr( componentExprs ), i->env, i->cost, thisCost ) );
-                                } else {
-                                        // handle normally
-                                        candidates.push_back( Alternative( new CastExpr( argExpr->clone(), toType->clone() ), i->env, i->cost, thisCost ) );
-                                }
+                                candidates.push_back( Alternative( restructureCast( i->expr->clone(), toType ), i->env, i->cost, thisCost ) );
                         } // if
                 } // for
@@ -1182 +1185 @@
         }
 
+        void AlternativeFinder::visit( UntypedInitExpr *initExpr ) {
+                // handle each option like a cast
+                AltList candidates;
+                PRINT( std::cerr << "untyped init expr: " << initExpr << std::endl; )
+                // O(N^2) checks of d-types with e-types
+                for ( InitAlternative & initAlt : initExpr->get_initAlts() ) {
+                        Type * toType = resolveTypeof( initAlt.type, indexer );
+                        SymTab::validateType( toType, &indexer );
+                        adjustExprType( toType, env, indexer );
+                        // Ideally the call to findWithAdjustment could be moved out of the loop, but unfortunately it currently has to occur inside or else
+                        // polymorphic return types are not properly bound to the initialization type, since return type variables are only open for the duration of resolving
+                        // the UntypedExpr. This is only actually an issue in initialization contexts that allow more than one possible initialization type, but it is still suboptimal.
+                        AlternativeFinder finder( indexer, env );
+                        finder.targetType = toType;
+                        finder.findWithAdjustment( initExpr->get_expr() );
+                        for ( Alternative & alt : finder.get_alternatives() ) {
+                                TypeEnvironment newEnv( alt.env );
+                                AssertionSet needAssertions, haveAssertions;
+                                OpenVarSet openVars;  // find things in env that don't have a "representative type" and claim those are open vars?
+                                PRINT( std::cerr << "  @ " << toType << " " << initAlt.designation << std::endl; )
+                                // It's possible that a cast can throw away some values in a multiply-valued expression.  (An example is a
+                                // cast-to-void, which casts from one value to zero.)  Figure out the prefix of the subexpression results
+                                // that are cast directly.  The candidate is invalid if it has fewer results than there are types to cast
+                                // to.
+                                int discardedValues = alt.expr->get_result()->size() - toType->size();
+                                if ( discardedValues < 0 ) continue;
+                                // xxx - may need to go into tuple types and extract relevant types and use unifyList. Note that currently, this does not
+                                // allow casting a tuple to an atomic type (e.g. (int)([1, 2, 3]))
+                                // unification run for side-effects
+                                unify( toType, alt.expr->get_result(), newEnv, needAssertions, haveAssertions, openVars, indexer ); // xxx - do some inspecting on this line... why isn't result bound to initAlt.type??
+
+                                Cost thisCost = castCost( alt.expr->get_result(), toType, indexer, newEnv );
+                                if ( thisCost != Cost::infinity ) {
+                                        // count one safe conversion for each value that is thrown away
+                                        thisCost += Cost( 0, 0, discardedValues );
+                                        candidates.push_back( Alternative( new InitExpr( restructureCast( alt.expr->clone(), toType ), initAlt.designation->clone() ), newEnv, alt.cost, thisCost ) );
+                                }
+                        }
+                }
+
+                // findMinCost selects the alternatives with the lowest "cost" members, but has the side effect of copying the
+                // cvtCost member to the cost member (since the old cost is now irrelevant).  Thus, calling findMinCost twice
+                // selects first based on argument cost, then on conversion cost.
+                AltList minArgCost;
+                findMinCost( candidates.begin(), candidates.end(), std::back_inserter( minArgCost ) );
+                findMinCost( minArgCost.begin(), minArgCost.end(), std::back_inserter( alternatives ) );
+        }
 } // namespace ResolvExpr
 

src/ResolvExpr/AlternativeFinder.h

@@ -73 +73 @@
                 virtual void visit( UniqueExpr *unqExpr );
                 virtual void visit( StmtExpr *stmtExpr );
+                virtual void visit( UntypedInitExpr *initExpr );
                 /// Runs a new alternative finder on each element in [begin, end)
                 /// and writes each alternative finder to out.

src/ResolvExpr/Resolver.cc

@@ -14 +14 @@
 //
 
+#include <iostream>
+
+#include "Alternative.h"
+#include "AlternativeFinder.h"
+#include "CurrentObject.h"
+#include "RenameVars.h"
 #include "Resolver.h"
-#include "AlternativeFinder.h"
-#include "Alternative.h"
-#include "RenameVars.h"
 #include "ResolveTypeof.h"
 #include "typeops.h"
+
+#include "SynTree/Expression.h"
+#include "SynTree/Initializer.h"
 #include "SynTree/Statement.h"
 #include "SynTree/Type.h"
-#include "SynTree/Expression.h"
-#include "SynTree/Initializer.h"
+
+#include "SymTab/Autogen.h"
 #include "SymTab/Indexer.h"
-#include "SymTab/Autogen.h"
+
 #include "Common/utility.h"
+
 #include "InitTweak/InitTweak.h"
 
-#include <iostream>
 using namespace std;
 
@@ -39 +45 @@
                         if ( const Resolver * res = dynamic_cast< const Resolver * >( &other ) ) {
                                 functionReturn = res->functionReturn;
-                                initContext = res->initContext;
+                                currentObject = res->currentObject;
                                 inEnumDecl = res->inEnumDecl;
                         }
@@ -79 +85 @@
 
                 Type * functionReturn = nullptr;
-                Type *initContext = nullptr;
+                CurrentObject currentObject = nullptr;
                 bool inEnumDecl = false;
         };
@@ -186 +192 @@
                 // each value of initContext is retained, so the type on the first analysis is preserved and used for selecting
                 // the RHS.
-                Type *temp = initContext;
-                initContext = new_type;
-                if ( inEnumDecl && dynamic_cast< EnumInstType * >( initContext ) ) {
+                ValueGuard<CurrentObject> temp( currentObject );
+                currentObject = CurrentObject( objectDecl->get_type() );
+                if ( inEnumDecl && dynamic_cast< EnumInstType * >( objectDecl->get_type() ) ) {
                         // enumerator initializers should not use the enum type to initialize, since
                         // the enum type is still incomplete at this point. Use signed int instead.
-                        initContext = new BasicType( Type::Qualifiers(), BasicType::SignedInt );
+                        currentObject = CurrentObject( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
                 }
                 Parent::visit( objectDecl );
-                if ( inEnumDecl && dynamic_cast< EnumInstType * >( initContext ) ) {
+                if ( inEnumDecl && dynamic_cast< EnumInstType * >( objectDecl->get_type() ) ) {
                         // delete newly created signed int type
-                        delete initContext;
-                }
-                initContext = temp;
+                        // delete currentObject.getType();
+                }
         }
 
@@ -315 +320 @@
 
         void Resolver::visit( SwitchStmt *switchStmt ) {
-                ValueGuard< Type * > oldInitContext( initContext );
+                ValueGuard< CurrentObject > oldCurrentObject( currentObject );
                 Expression *newExpr;
                 newExpr = findIntegralExpression( switchStmt->get_condition(), *this );
@@ -321 +326 @@
                 switchStmt->set_condition( newExpr );
 
-                initContext = newExpr->get_result();
+                currentObject = CurrentObject( newExpr->get_result() );
                 Parent::visit( switchStmt );
         }
@@ -327 +332 @@
         void Resolver::visit( CaseStmt *caseStmt ) {
                 if ( caseStmt->get_condition() ) {
-                        assert( initContext );
-                        CastExpr * castExpr = new CastExpr( caseStmt->get_condition(), initContext->clone() );
+                        std::list< InitAlternative > initAlts = currentObject.getOptions();
+                        assertf( initAlts.size() == 1, "SwitchStmt did not correctly resolve an integral expression." );
+                        CastExpr * castExpr = new CastExpr( caseStmt->get_condition(), initAlts.front().type->clone() );
                         Expression * newExpr = findSingleExpression( castExpr, *this );
                         castExpr = safe_dynamic_cast< CastExpr * >( newExpr );
@@ -370 +376 @@
 
         void Resolver::visit( SingleInit *singleInit ) {
-                if ( singleInit->get_value() ) {
-                        // // find all the d's
-                        // std::list<Expression *> &designators = singleInit->get_designators();
-                        // std::list<Type *> types1{ initContext }, types2;
-                        // for ( Expression * expr: designators ) {
-                        //      cerr << expr << endl;
-                        //      if ( NameExpr * nexpr = dynamic_cast<NameExpr *>( expr ) ) {
-                        //              for ( Type * type: types1 ) {
-                        //                      cerr << type << endl;
-                        //                      ReferenceToType * fred = dynamic_cast<ReferenceToType *>(type);
-                        //                      std::list<Declaration *> members;
-                        //                      if ( fred ) {
-                        //                              fred->lookup( nexpr->get_name(), members ); // concatenate identical field name
-                        //                              for ( Declaration * mem: members ) {
-                        //                                      if ( DeclarationWithType * dwt = dynamic_cast<DeclarationWithType *>(mem) ) {
-                        //                                              types2.push_back( dwt->get_type() );
-                        //                                      } // if
-                        //                              } // for
-                        //                      } // if
-                        //              } // for
-                        //              types1 = types2;
-                        //              types2.clear();
-                        //      } // if
-                        // } // for
-                        // // for ( Type * type: types1 ) {
-                        // //   cerr << type << endl;
-                        // // } // for
-
-                        // // O(N^2) checks of d-types with f-types
-                        // // find the minimum cost
-                        CastExpr *castExpr = new CastExpr( singleInit->get_value(), initContext->clone() );
-                        Expression *newExpr = findSingleExpression( castExpr, *this );
-                        delete castExpr;
-                        singleInit->set_value( newExpr );
-
-                        // check if initializing type is char[]
-                        if ( ArrayType * at = dynamic_cast< ArrayType * >( initContext ) ) {
-                                if ( isCharType( at->get_base() ) ) {
-                                        // check if the resolved type is char *
-                                        if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_result() ) ) {
-                                                if ( isCharType( pt->get_base() ) ) {
-                                                        // strip cast if we're initializing a char[] with a char *, e.g.  char x[] = "hello";
-                                                        CastExpr *ce = dynamic_cast< CastExpr * >( newExpr );
-                                                        singleInit->set_value( ce->get_arg() );
-                                                        ce->set_arg( NULL );
-                                                        delete ce;
-                                                }
+                // resolve initialization using the possibilities as determined by the currentObject cursor
+                UntypedInitExpr * untyped = new UntypedInitExpr( singleInit->get_value(), currentObject.getOptions() );
+                Expression * newExpr = findSingleExpression( untyped, *this );
+                InitExpr * initExpr = safe_dynamic_cast< InitExpr * >( newExpr );
+
+                // move cursor to the object that is actually initialized
+                currentObject.setNext( initExpr->get_designation() );
+
+                // discard InitExpr wrapper and retain relevant pieces
+                newExpr = initExpr->get_expr();
+                singleInit->get_value()->set_env( initExpr->get_env() );
+                initExpr->set_expr( nullptr );
+                initExpr->set_env( nullptr );
+                delete initExpr;
+
+                // get the actual object's type (may not exactly match what comes back from the resolver due to conversions)
+                Type * initContext = currentObject.getCurrentType();
+
+                // check if actual object's type is char[]
+                if ( ArrayType * at = dynamic_cast< ArrayType * >( initContext ) ) {
+                        if ( isCharType( at->get_base() ) ) {
+                                // check if the resolved type is char *
+                                if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_result() ) ) {
+                                        if ( isCharType( pt->get_base() ) ) {
+                                                // strip cast if we're initializing a char[] with a char *, e.g.  char x[] = "hello";
+                                                CastExpr *ce = safe_dynamic_cast< CastExpr * >( newExpr );
+                                                newExpr = ce->get_arg();
+                                                ce->set_arg( nullptr );
+                                                delete ce;
                                         }
                                 }
                         }
-                } // if
-        }
-
-        template< typename AggrInst >
-        TypeSubstitution makeGenericSubstitutuion( AggrInst * inst ) {
-                assert( inst );
-                assert( inst->get_baseParameters() );
-                std::list< TypeDecl * > baseParams = *inst->get_baseParameters();
-                std::list< Expression * > typeSubs = inst->get_parameters();
-                TypeSubstitution subs( baseParams.begin(), baseParams.end(), typeSubs.begin() );
-                return subs;
-        }
-
-        ReferenceToType * isStructOrUnion( Type * type ) {
-                if ( StructInstType * sit = dynamic_cast< StructInstType * >( type ) ) {
-                        return sit;
-                } else if ( UnionInstType * uit = dynamic_cast< UnionInstType * >( type ) ) {
-                        return uit;
-                }
-                return nullptr;
-        }
-
-        void Resolver::resolveSingleAggrInit( Declaration * dcl, InitIterator & init, InitIterator & initEnd, TypeSubstitution sub ) {
-                DeclarationWithType * dt = dynamic_cast< DeclarationWithType * >( dcl );
-                assert( dt );
-                // need to substitute for generic types, so that casts are to concrete types
-                initContext = dt->get_type()->clone();
-                sub.apply( initContext );
-
-                try {
-                        if ( init == initEnd ) return; // stop when there are no more initializers
-                        (*init)->accept( *this );
-                        ++init; // made it past an initializer
-                } catch( SemanticError & ) {
-                        // need to delve deeper, if you can
-                        if ( ReferenceToType * type = isStructOrUnion( initContext ) ) {
-                                resolveAggrInit( type, init, initEnd );
-                        } else {
-                                // member is not an aggregate type, so can't go any deeper
-
-                                // might need to rethink what is being thrown
-                                throw;
-                        } // if
-                }
-        }
-
-        void Resolver::resolveAggrInit( ReferenceToType * inst, InitIterator & init, InitIterator & initEnd ) {
-                if ( StructInstType * sit = dynamic_cast< StructInstType * >( inst ) ) {
-                        TypeSubstitution sub = makeGenericSubstitutuion( sit );
-                        StructDecl * st = sit->get_baseStruct();
-                        if(st->get_members().empty()) return;
-                        // want to resolve each initializer to the members of the struct,
-                        // but if there are more initializers than members we should stop
-                        list< Declaration * >::iterator it = st->get_members().begin();
-                        for ( ; it != st->get_members().end(); ++it) {
-                                resolveSingleAggrInit( *it, init, initEnd, sub );
-                        }
-                } else if ( UnionInstType * uit = dynamic_cast< UnionInstType * >( inst ) ) {
-                        TypeSubstitution sub = makeGenericSubstitutuion( uit );
-                        UnionDecl * un = uit->get_baseUnion();
-                        if(un->get_members().empty()) return;
-                        // only resolve to the first member of a union
-                        resolveSingleAggrInit( *un->get_members().begin(), init, initEnd, sub );
-                } // if
+                }
+
+                // set initializer expr to resolved express
+                singleInit->set_value( newExpr );
+
+                // move cursor to next object in preparation for next initializer
+                currentObject.increment();
         }
 
         void Resolver::visit( ListInit * listInit ) {
-                InitIterator iter = listInit->begin();
-                InitIterator end = listInit->end();
-
-                if ( ArrayType * at = dynamic_cast< ArrayType * >( initContext ) ) {
-                        // resolve each member to the base type of the array
-                        for ( ; iter != end; ++iter ) {
-                                initContext = at->get_base();
-                                (*iter)->accept( *this );
-                        } // for
-                } else if ( TupleType * tt = dynamic_cast< TupleType * > ( initContext ) ) {
-                        for ( Type * t : *tt ) {
-                                if ( iter == end ) break;
-                                initContext = t;
-                                (*iter++)->accept( *this );
-                        }
-                } else if ( ReferenceToType * type = isStructOrUnion( initContext ) ) {
-                        resolveAggrInit( type, iter, end );
-                } else if ( TypeInstType * tt = dynamic_cast< TypeInstType * >( initContext ) ) {
-                        Type * base = tt->get_baseType()->get_base();
-                        if ( base ) {
-                                // know the implementation type, so try using that as the initContext
-                                initContext = base;
-                                visit( listInit );
-                        } else {
-                                // missing implementation type -- might be an unknown type variable, so try proceeding with the current init context
-                                Parent::visit( listInit );
-                        }
-                } else {
-                        assert( dynamic_cast< BasicType * >( initContext ) || dynamic_cast< PointerType * >( initContext )
-                                || dynamic_cast< ZeroType * >( initContext ) || dynamic_cast< OneType * >( initContext ) || dynamic_cast < EnumInstType * > ( initContext ) );
-                        // basic types are handled here
-                        Parent::visit( listInit );
-                }
-
-#if 0
-                if ( ArrayType *at = dynamic_cast<ArrayType*>(initContext) ) {
-                        std::list<Initializer *>::iterator iter( listInit->begin_initializers() );
-                        for ( ; iter != listInit->end_initializers(); ++iter ) {
-                                initContext = at->get_base();
-                                (*iter)->accept( *this );
-                        } // for
-                } else if ( StructInstType *st = dynamic_cast<StructInstType*>(initContext) ) {
-                        StructDecl *baseStruct = st->get_baseStruct();
-                        std::list<Declaration *>::iterator iter1( baseStruct->get_members().begin() );
-                        std::list<Initializer *>::iterator iter2( listInit->begin_initializers() );
-                        for ( ; iter1 != baseStruct->get_members().end() && iter2 != listInit->end_initializers(); ++iter2 ) {
-                                if ( (*iter2)->get_designators().empty() ) {
-                                        DeclarationWithType *dt = dynamic_cast<DeclarationWithType *>( *iter1 );
-                                        initContext = dt->get_type();
-                                        (*iter2)->accept( *this );
-                                        ++iter1;
-                                } else {
-                                        StructDecl *st = baseStruct;
-                                        iter1 = st->get_members().begin();
-                                        std::list<Expression *>::iterator iter3( (*iter2)->get_designators().begin() );
-                                        for ( ; iter3 != (*iter2)->get_designators().end(); ++iter3 ) {
-                                                NameExpr *key = dynamic_cast<NameExpr *>( *iter3 );
-                                                assert( key );
-                                                for ( ; iter1 != st->get_members().end(); ++iter1 ) {
-                                                        if ( key->get_name() == (*iter1)->get_name() ) {
-                                                                (*iter1)->print( cout );
-                                                                cout << key->get_name() << endl;
-                                                                ObjectDecl *fred = dynamic_cast<ObjectDecl *>( *iter1 );
-                                                                assert( fred );
-                                                                StructInstType *mary = dynamic_cast<StructInstType*>( fred->get_type() );
-                                                                assert( mary );
-                                                                st = mary->get_baseStruct();
-                                                                iter1 = st->get_members().begin();
-                                                                break;
-                                                        } // if
-                                                }  // for
-                                        } // for
-                                        ObjectDecl *fred = dynamic_cast<ObjectDecl *>( *iter1 );
-                                        assert( fred );
-                                        initContext = fred->get_type();
-                                        (*listInit->begin_initializers())->accept( *this );
-                                } // if
-                        } // for
-                } else if ( UnionInstType *st = dynamic_cast<UnionInstType*>(initContext) ) {
-                        DeclarationWithType *dt = dynamic_cast<DeclarationWithType *>( *st->get_baseUnion()->get_members().begin() );
-                        initContext = dt->get_type();
-                        (*listInit->begin_initializers())->accept( *this );
-                } // if
-#endif
+                // move cursor into brace-enclosed initializer-list
+                currentObject.enterListInit();
+                // xxx - fix this so that the list isn't copied, iterator should be used to change current element
+                std::list<Designation *> newDesignations;
+                for ( auto p : group_iterate(listInit->get_designations(), listInit->get_initializers()) ) {
+                        // iterate designations and initializers in pairs, moving the cursor to the current designated object and resolving
+                        // the initializer against that object.
+                        Designation * des = std::get<0>(p);
+                        Initializer * init = std::get<1>(p);
+                        newDesignations.push_back( currentObject.findNext( des ) );
+                        init->accept( *this );
+                }
+                // set the set of 'resolved' designations and leave the brace-enclosed initializer-list
+                listInit->get_designations() = newDesignations; // xxx - memory management
+                currentObject.exitListInit();
+
+                // xxx - this part has not be folded into CurrentObject yet
+                // } else if ( TypeInstType * tt = dynamic_cast< TypeInstType * >( initContext ) ) {
+                //      Type * base = tt->get_baseType()->get_base();
+                //      if ( base ) {
+                //              // know the implementation type, so try using that as the initContext
+                //              ObjectDecl tmpObj( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, base->clone(), nullptr );
+                //              currentObject = &tmpObj;
+                //              visit( listInit );
+                //      } else {
+                //              // missing implementation type -- might be an unknown type variable, so try proceeding with the current init context
+                //              Parent::visit( listInit );
+                //      }
+                // } else {
         }
 

src/ResolvExpr/Unify.cc

@@ -606 +606 @@
                         } else if ( tupleParam ) {
                                 // bundle other parameters into tuple to match
-                                TupleType* binder = new TupleType{ paramTy->get_qualifiers() };
+                                std::list< Type * > binderTypes;
 
                                 do {
-                                        binder->get_types().push_back( otherParam->get_type()->clone() );
+                                        binderTypes.push_back( otherParam->get_type()->clone() );
                                         ++jt;
 
@@ -618 +618 @@
                                 } while (true);
 
-                                otherParamTy = binder;
+                                otherParamTy = new TupleType{ paramTy->get_qualifiers(), binderTypes };
                                 ++it;  // skip ttype parameter for break
                         } else if ( otherTupleParam ) {
                                 // bundle parameters into tuple to match other
-                                TupleType* binder = new TupleType{ otherParamTy->get_qualifiers() };
+                                std::list< Type * > binderTypes;
 
                                 do {
-                                        binder->get_types().push_back( param->get_type()->clone() );
+                                        binderTypes.push_back( param->get_type()->clone() );
                                         ++it;
 
@@ -634 +634 @@
                                 } while (true);
 
-                                paramTy = binder;
+                                paramTy = new TupleType{ otherParamTy->get_qualifiers(), binderTypes };
                                 ++jt;  // skip ttype parameter for break
                         }
@@ -756 +756 @@
                         return function->get_returnVals().front()->get_type()->clone();
                 } else {
-                        TupleType * tupleType = new TupleType( Type::Qualifiers() );
+                        std::list< Type * > types;
                         for ( DeclarationWithType * decl : function->get_returnVals() ) {
-                                tupleType->get_types().push_back( decl->get_type()->clone() );
+                                types.push_back( decl->get_type()->clone() );
                         } // for
-                        return tupleType;
+                        return new TupleType( Type::Qualifiers(), types );
                 }
         }

src/ResolvExpr/module.mk

@@ -6 +6 @@
 ## file "LICENCE" distributed with Cforall.
 ##
-## module.mk -- 
+## module.mk --
 ##
 ## Author           : Richard C. Bilson
@@ -31 +31 @@
        ResolvExpr/PolyCost.cc \
        ResolvExpr/Occurs.cc \
-       ResolvExpr/TypeEnvironment.cc
+       ResolvExpr/TypeEnvironment.cc \
+       ResolvExpr/CurrentObject.cc

src/SymTab/Autogen.h

@@ -25 +25 @@
 
 namespace SymTab {
-    /// Generates assignment operators, constructors, and destructor for aggregate types as required
-    void autogenerateRoutines( std::list< Declaration * > &translationUnit );
+        /// Generates assignment operators, constructors, and destructor for aggregate types as required
+        void autogenerateRoutines( std::list< Declaration * > &translationUnit );
 
-    /// returns true if obj's name is the empty string and it has a bitfield width
-    bool isUnnamedBitfield( ObjectDecl * obj );
+        /// returns true if obj's name is the empty string and it has a bitfield width
+        bool isUnnamedBitfield( ObjectDecl * obj );
 
-    /// size_t type - set when size_t typedef is seen. Useful in a few places,
-    /// such as in determining array dimension type
-    extern Type * SizeType;
+        /// size_t type - set when size_t typedef is seen. Useful in a few places,
+        /// such as in determining array dimension type
+        extern Type * SizeType;
 
-    /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls.
-    template< typename OutputIterator >
+        /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls.
+        template< typename OutputIterator >
         Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast = false, bool forward = true );
 
-    /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Should only be called with non-array types.
-    /// optionally returns a statement which must be inserted prior to the containing loop, if there is one
-    template< typename OutputIterator >
+        /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Should only be called with non-array types.
+        /// optionally returns a statement which must be inserted prior to the containing loop, if there is one
+        template< typename OutputIterator >
         Statement * genScalarCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast = false ) {
         // want to be able to generate assignment, ctor, and dtor generically,
@@ -50 +50 @@
         dstParam = new AddressExpr( dstParam );
         if ( addCast ) {
-            // cast to T* with qualifiers removed, so that qualified objects can be constructed
-            // and destructed with the same functions as non-qualified objects.
-            // unfortunately, lvalue is considered a qualifier. For AddressExpr to resolve, its argument
-            // must have an lvalue qualified type, so remove all qualifiers except lvalue. If we ever
-            // remove lvalue as a qualifier, this can change to
-            //   type->get_qualifiers() = Type::Qualifiers();
-            assert( type );
-            Type * castType = type->clone();
-//                      castType->get_qualifiers() -= Type::Qualifiers(true, true, true, false, true, false);
-            castType->get_qualifiers() -= Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic );
-            castType->set_lvalue( true ); // xxx - might not need this
-            dstParam = new CastExpr( dstParam, new PointerType( Type::Qualifiers(), castType ) );
+                // cast to T* with qualifiers removed, so that qualified objects can be constructed
+                // and destructed with the same functions as non-qualified objects.
+                // unfortunately, lvalue is considered a qualifier. For AddressExpr to resolve, its argument
+                // must have an lvalue qualified type, so remove all qualifiers except lvalue. If we ever
+                // remove lvalue as a qualifier, this can change to
+                //   type->get_qualifiers() = Type::Qualifiers();
+                assert( type );
+                Type * castType = type->clone();
+                castType->get_qualifiers() -= Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic );
+                castType->set_lvalue( true ); // xxx - might not need this
+                dstParam = new CastExpr( dstParam, new PointerType( Type::Qualifiers(), castType ) );
         }
         fExpr->get_args().push_back( dstParam );
@@ -75 +74 @@
 
         return listInit;
-    }
-
-    /// Store in out a loop which calls fname on each element of the array with srcParam and dstParam as arguments.
-    /// If forward is true, loop goes from 0 to N-1, else N-1 to 0
-    template< typename OutputIterator >
-        void genArrayCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, bool addCast = false, bool forward = true ) {
-        static UniqueName indexName( "_index" );
-
-        // for a flexible array member nothing is done -- user must define own assignment
-        if ( ! array->get_dimension() ) return ;
-
-        Expression * begin, * end, * update, * cmp;
-        if ( forward ) {
-            // generate: for ( int i = 0; i < N; ++i )
-            begin = new ConstantExpr( Constant::from_int( 0 ) );
-            end = array->get_dimension()->clone();
-            cmp = new NameExpr( "?<?" );
-            update = new NameExpr( "++?" );
-        } else {
-            // generate: for ( int i = N-1; i >= 0; --i )
-            begin = new UntypedExpr( new NameExpr( "?-?" ) );
-            ((UntypedExpr*)begin)->get_args().push_back( array->get_dimension()->clone() );
-            ((UntypedExpr*)begin)->get_args().push_back( new ConstantExpr( Constant::from_int( 1 ) ) );
-            end = new ConstantExpr( Constant::from_int( 0 ) );
-            cmp = new NameExpr( "?>=?" );
-            update = new NameExpr( "--?" );
         }
 
-        ObjectDecl *index = new ObjectDecl( indexName.newName(), Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin, std::list<Expression*>() ) );
+        /// Store in out a loop which calls fname on each element of the array with srcParam and dstParam as arguments.
+        /// If forward is true, loop goes from 0 to N-1, else N-1 to 0
+        template< typename OutputIterator >
+        void genArrayCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, bool addCast = false, bool forward = true ) {
+                static UniqueName indexName( "_index" );
 
-        UntypedExpr *cond = new UntypedExpr( cmp );
-        cond->get_args().push_back( new VariableExpr( index ) );
-        cond->get_args().push_back( end );
+                // for a flexible array member nothing is done -- user must define own assignment
+                if ( ! array->get_dimension() ) return ;
 
-        UntypedExpr *inc = new UntypedExpr( update );
-        inc->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) );
+                Expression * begin, * end, * update, * cmp;
+                if ( forward ) {
+                        // generate: for ( int i = 0; i < N; ++i )
+                        begin = new ConstantExpr( Constant::from_int( 0 ) );
+                        end = array->get_dimension()->clone();
+                        cmp = new NameExpr( "?<?" );
+                        update = new NameExpr( "++?" );
+                } else {
+                        // generate: for ( int i = N-1; i >= 0; --i )
+                        begin = new UntypedExpr( new NameExpr( "?-?" ) );
+                        ((UntypedExpr*)begin)->get_args().push_back( array->get_dimension()->clone() );
+                        ((UntypedExpr*)begin)->get_args().push_back( new ConstantExpr( Constant::from_int( 1 ) ) );
+                        end = new ConstantExpr( Constant::from_int( 0 ) );
+                        cmp = new NameExpr( "?>=?" );
+                        update = new NameExpr( "--?" );
+                }
 
-        UntypedExpr *dstIndex = new UntypedExpr( new NameExpr( "?[?]" ) );
-        dstIndex->get_args().push_back( dstParam );
-        dstIndex->get_args().push_back( new VariableExpr( index ) );
-        dstParam = dstIndex;
+                ObjectDecl *index = new ObjectDecl( indexName.newName(), Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin ) );
 
-        // srcParam must keep track of the array indices to build the
-        // source parameter and/or array list initializer
-        srcParam.addArrayIndex( new VariableExpr( index ), array->get_dimension()->clone() );
+                UntypedExpr *cond = new UntypedExpr( cmp );
+                cond->get_args().push_back( new VariableExpr( index ) );
+                cond->get_args().push_back( end );
 
-        // for stmt's body, eventually containing call
-        CompoundStmt * body = new CompoundStmt( noLabels );
-        Statement * listInit = genCall( srcParam, dstParam, fname, back_inserter( body->get_kids() ), array->get_base(), addCast, forward );
+                UntypedExpr *inc = new UntypedExpr( update );
+                inc->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) );
 
-        // block containing for stmt and index variable
-        std::list<Statement *> initList;
-        CompoundStmt * block = new CompoundStmt( noLabels );
-        block->get_kids().push_back( new DeclStmt( noLabels, index ) );
-        if ( listInit ) block->get_kids().push_back( listInit );
-        block->get_kids().push_back( new ForStmt( noLabels, initList, cond, inc, body ) );
+                UntypedExpr *dstIndex = new UntypedExpr( new NameExpr( "?[?]" ) );
+                dstIndex->get_args().push_back( dstParam );
+                dstIndex->get_args().push_back( new VariableExpr( index ) );
+                dstParam = dstIndex;
 
-        *out++ = block;
-    }
+                // srcParam must keep track of the array indices to build the
+                // source parameter and/or array list initializer
+                srcParam.addArrayIndex( new VariableExpr( index ), array->get_dimension()->clone() );
 
-    template< typename OutputIterator >
+                // for stmt's body, eventually containing call
+                CompoundStmt * body = new CompoundStmt( noLabels );
+                Statement * listInit = genCall( srcParam, dstParam, fname, back_inserter( body->get_kids() ), array->get_base(), addCast, forward );
+
+                // block containing for stmt and index variable
+                std::list<Statement *> initList;
+                CompoundStmt * block = new CompoundStmt( noLabels );
+                block->get_kids().push_back( new DeclStmt( noLabels, index ) );
+                if ( listInit ) block->get_kids().push_back( listInit );
+                block->get_kids().push_back( new ForStmt( noLabels, initList, cond, inc, body ) );
+
+                *out++ = block;
+        }
+
+        template< typename OutputIterator >
         Statement * genCall( InitTweak::InitExpander &  srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast, bool forward ) {
-        if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
-            genArrayCall( srcParam, dstParam, fname, out, at, addCast, forward );
-            return 0;
-        } else {
-            return genScalarCall( srcParam, dstParam, fname, out, type, addCast );
+                if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
+                        genArrayCall( srcParam, dstParam, fname, out, at, addCast, forward );
+                        return 0;
+                } else {
+                        return genScalarCall( srcParam, dstParam, fname, out, type, addCast );
+                }
         }
-    }
 
-    /// inserts into out a generated call expression to function fname with arguments dstParam
-    /// and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls. decl is the
-    /// object being constructed. The function wraps constructor and destructor calls in an
-    /// ImplicitCtorDtorStmt node.
-    template< typename OutputIterator >
+        /// inserts into out a generated call expression to function fname with arguments dstParam
+        /// and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls. decl is the
+        /// object being constructed. The function wraps constructor and destructor calls in an
+        /// ImplicitCtorDtorStmt node.
+        template< typename OutputIterator >
         void genImplicitCall( InitTweak::InitExpander &  srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, DeclarationWithType * decl, bool forward = true ) {
-        ObjectDecl *obj = dynamic_cast<ObjectDecl *>( decl );
-        assert( obj );
-        // unnamed bit fields are not copied as they cannot be accessed
-        if ( isUnnamedBitfield( obj ) ) return;
+                ObjectDecl *obj = dynamic_cast<ObjectDecl *>( decl );
+                assert( obj );
+                // unnamed bit fields are not copied as they cannot be accessed
+                if ( isUnnamedBitfield( obj ) ) return;
 
-        bool addCast = (fname == "?{}" || fname == "^?{}") && ( !obj || ( obj && obj->get_bitfieldWidth() == NULL ) );
-        std::list< Statement * > stmts;
-        genCall( srcParam, dstParam, fname, back_inserter( stmts ), obj->get_type(), addCast, forward );
+                bool addCast = (fname == "?{}" || fname == "^?{}") && ( !obj || ( obj && obj->get_bitfieldWidth() == NULL ) );
+                std::list< Statement * > stmts;
+                genCall( srcParam, dstParam, fname, back_inserter( stmts ), obj->get_type(), addCast, forward );
 
-        // currently genCall should produce at most one element, but if that changes then the next line needs to be updated to grab the statement which contains the call
-        assert( stmts.size() <= 1 );
-        if ( stmts.size() == 1 ) {
-            Statement * callStmt = stmts.front();
-            if ( addCast ) {
-                // implicitly generated ctor/dtor calls should be wrapped
-                // so that later passes are aware they were generated.
-                // xxx - don't mark as an implicit ctor/dtor if obj is a bitfield,
-                // because this causes the address to be taken at codegen, which is illegal in C.
-                callStmt = new ImplicitCtorDtorStmt( callStmt );
-            }
-            *out++ = callStmt;
+                // currently genCall should produce at most one element, but if that changes then the next line needs to be updated to grab the statement which contains the call
+                assert( stmts.size() <= 1 );
+                if ( stmts.size() == 1 ) {
+                        Statement * callStmt = stmts.front();
+                        if ( addCast ) {
+                                // implicitly generated ctor/dtor calls should be wrapped
+                                // so that later passes are aware they were generated.
+                                // xxx - don't mark as an implicit ctor/dtor if obj is a bitfield,
+                                // because this causes the address to be taken at codegen, which is illegal in C.
+                                callStmt = new ImplicitCtorDtorStmt( callStmt );
+                        }
+                        *out++ = callStmt;
+                }
         }
-    }
 } // namespace SymTab
 #endif // AUTOGEN_H

src/SymTab/ImplementationType.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// ImplementationType.cc -- 
+// ImplementationType.cc --
 //
 // Author           : Richard C. Bilson
@@ -92 +92 @@
 
         void ImplementationType::visit(TupleType *tupleType) {
-                TupleType *newType = new TupleType( Type::Qualifiers() );
+                std::list< Type * > types;
                 for ( std::list< Type* >::iterator i = tupleType->get_types().begin(); i != tupleType->get_types().end(); ++i ) {
                         Type *implType = implementationType( *i, indexer );
                         implType->get_qualifiers() |= tupleType->get_qualifiers();
-                        newType->get_types().push_back( implType );
+                        types.push_back( implType );
                 } // for
-                result = newType;
+                result = new TupleType( Type::Qualifiers(), types );
         }
 

src/SynTree/Constant.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Constant.cc -- 
+// Constant.cc --
 //
 // Author           : Richard C. Bilson
@@ -46 +46 @@
 }
 
+unsigned long long Constant::get_ival() const {
+        assertf( safe_dynamic_cast<BasicType*>(type)->isInteger(), "Attempt to retrieve ival from non-integer constant." );
+        return val.ival;
+}
+
+double Constant::get_dval() const {
+        assertf( ! safe_dynamic_cast<BasicType*>(type)->isInteger(), "Attempt to retrieve dval from integer constant." );
+        return val.dval;
+}
+
 void Constant::print( std::ostream &os ) const {
         os << "(" << rep << " " << val.ival;

src/SynTree/Constant.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Constant.h -- 
+// Constant.h --
 //
 // Author           : Richard C. Bilson
@@ -32 +32 @@
         std::string & get_value() { return rep; }
         void set_value( std::string newValue ) { rep = newValue; }
+        unsigned long long get_ival() const;
+        double get_dval() const;
 
         /// generates a boolean constant of the given bool

src/SynTree/Expression.cc

@@ -21 +21 @@
 #include <iterator>
 
+#include "Declaration.h"
+#include "Expression.h"
+#include "Initializer.h"
+#include "Statement.h"
 #include "Type.h"
-#include "Initializer.h"
-#include "Expression.h"
-#include "Declaration.h"
-#include "Statement.h"
 #include "TypeSubstitution.h"
+#include "VarExprReplacer.h"
+
 #include "Common/utility.h"
+#include "Common/PassVisitor.h"
+
 #include "InitTweak/InitTweak.h"
 
@@ -92 +96 @@
 
         Declaration *decl = get_var();
-        // if ( decl != 0) decl->print(os, indent + 2);
         if ( decl != 0) decl->printShort(os, indent + 2);
         os << std::endl;
@@ -657 +660 @@
 }
 
+InitAlternative::InitAlternative( Type * type, Designation * designation ) : type( type ), designation( designation ) {}
+InitAlternative::InitAlternative( const InitAlternative & other ) : type( maybeClone( other.type ) ), designation( maybeClone( other.designation ) ) {}
+InitAlternative::~InitAlternative() {
+        delete type;
+        delete designation;
+}
+
+UntypedInitExpr::UntypedInitExpr( Expression * expr, const std::list<InitAlternative> & initAlts ) : expr( expr ), initAlts( initAlts ) {}
+UntypedInitExpr::UntypedInitExpr( const UntypedInitExpr & other ) : Expression( other ), expr( maybeClone( other.expr ) ), initAlts( other.initAlts ) {}
+UntypedInitExpr::~UntypedInitExpr() {
+        delete expr;
+}
+
+void UntypedInitExpr::print( std::ostream & os, int indent ) const {
+        os << "Untyped Init Expression" << std::endl << std::string( indent+2, ' ' );
+        expr->print( os, indent+2 );
+        if ( ! initAlts.empty() ) {
+                for ( const InitAlternative & alt : initAlts ) {
+                        os << std::string( indent+2, ' ' ) <<  "InitAlternative: ";
+                        alt.type->print( os, indent+2 );
+                        alt.designation->print( os, indent+2 );
+                }
+        }
+}
+
+InitExpr::InitExpr( Expression * expr, Designation * designation ) : expr( expr ), designation( designation ) {
+        set_result( expr->get_result()->clone() );
+}
+InitExpr::InitExpr( const InitExpr & other ) : Expression( other ), expr( maybeClone( other.expr ) ), designation( maybeClone( other.designation) ) {}
+InitExpr::~InitExpr() {
+        delete expr;
+        delete designation;
+}
+
+void InitExpr::print( std::ostream & os, int indent ) const {
+        os << "Init Expression" << std::endl << std::string( indent+2, ' ' );
+        expr->print( os, indent+2 );
+        os << std::string( indent+2, ' ' ) << "with designation: ";
+        designation->print( os, indent+2 );
+}
+
+
 std::ostream & operator<<( std::ostream & out, const Expression * expr ) {
         if ( expr ) {

src/SynTree/Expression.h

@@ -744 +744 @@
 };
 
+struct InitAlternative {
+public:
+        Type * type = nullptr;
+        Designation * designation = nullptr;
+        InitAlternative( Type * type, Designation * designation );
+        InitAlternative( const InitAlternative & other );
+        InitAlternative & operator=( const Initializer & other ) = delete; // at the moment this isn't used, and I don't want to implement it
+        ~InitAlternative();
+};
+
+class UntypedInitExpr : public Expression {
+public:
+        UntypedInitExpr( Expression * expr, const std::list<InitAlternative> & initAlts );
+        UntypedInitExpr( const UntypedInitExpr & other );
+        ~UntypedInitExpr();
+
+        Expression * get_expr() const { return expr; }
+        UntypedInitExpr * set_expr( Expression * newValue ) { expr = newValue; return this; }
+
+        std::list<InitAlternative> & get_initAlts() { return initAlts; }
+
+        virtual UntypedInitExpr * clone() const { return new UntypedInitExpr( * this ); }
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const;
+private:
+        Expression * expr;
+        std::list<InitAlternative> initAlts;
+};
+
+class InitExpr : public Expression {
+public:
+        InitExpr( Expression * expr, Designation * designation );
+        InitExpr( const InitExpr & other );
+        ~InitExpr();
+
+        Expression * get_expr() const { return expr; }
+        InitExpr * set_expr( Expression * newValue ) { expr = newValue; return this; }
+
+        Designation * get_designation() const { return designation; }
+        InitExpr * set_designation( Designation * newValue ) { designation = newValue; return this; }
+
+        virtual InitExpr * clone() const { return new InitExpr( * this ); }
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const;
+private:
+        Expression * expr;
+        Designation * designation;
+};
+
+
 std::ostream & operator<<( std::ostream & out, const Expression * expr );
 

src/SynTree/Initializer.cc

@@ -19 +19 @@
 #include "Common/utility.h"
 
+Designation::Designation( const std::list< Expression * > & designators ) : designators( designators ) {}
+Designation::Designation( const Designation & other ) : BaseSyntaxNode( other ) {
+        // std::cerr << "cloning designation" << std::endl;
+        cloneAll( other.designators, designators );
+        // std::cerr << "finished cloning designation" << std::endl;
+}
+
+Designation::~Designation() {
+        // std::cerr << "destroying designation" << std::endl;
+        deleteAll( designators );
+        // std::cerr << "finished destroying designation" << std::endl;
+}
+
+void Designation::print( std::ostream &os, int indent ) const {
+        if ( ! designators.empty() ) {
+                os << std::string(indent + 2, ' ' ) << "designated by: " << std::endl;
+                for ( std::list < Expression * >::const_iterator i = designators.begin(); i != designators.end(); i++ ) {
+                        os << std::string(indent + 4, ' ' );
+                        ( *i )->print(os, indent + 4 );
+                }
+                os << std::endl;
+        } // if
+}
+
 Initializer::Initializer( bool maybeConstructed ) : maybeConstructed( maybeConstructed ) {}
 Initializer::Initializer( const Initializer & other ) : BaseSyntaxNode( other ), maybeConstructed( other.maybeConstructed ) {
 }
-
-
 Initializer::~Initializer() {}
 
-std::string Initializer::designator_name( Expression *des ) {
-        if ( NameExpr *n = dynamic_cast<NameExpr *>(des) )
-                return n->get_name();
-        else
-                throw 0;
-}
-
-// void Initializer::print( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent ) {}
-
-SingleInit::SingleInit( Expression *v, const std::list< Expression *> &_designators, bool maybeConstructed ) : Initializer( maybeConstructed ), value ( v ), designators( _designators ) {
+SingleInit::SingleInit( Expression *v, bool maybeConstructed ) : Initializer( maybeConstructed ), value ( v ) {
 }
 
 SingleInit::SingleInit( const SingleInit &other ) : Initializer(other), value ( maybeClone( other.value ) ) {
-        cloneAll(other.designators, designators );
 }
 
 SingleInit::~SingleInit() {
         delete value;
-        deleteAll(designators);
 }
 
-void SingleInit::print( std::ostream &os, int indent ) {
-        os << std::endl << std::string(indent, ' ' ) << "Simple Initializer: " << std::endl;
+void SingleInit::print( std::ostream &os, int indent ) const {
+        os << std::string(indent, ' ' ) << "Simple Initializer: " << std::endl;
         os << std::string(indent+4, ' ' );
         value->print( os, indent+4 );
-
-        if ( ! designators.empty() ) {
-                os << std::endl << std::string(indent + 2, ' ' ) << "designated by: " << std::endl;
-                for ( std::list < Expression * >::iterator i = designators.begin(); i != designators.end(); i++ ) {
-                        os << std::string(indent + 4, ' ' );
-                        ( *i )->print(os, indent + 4 );
-                }
-        } // if
 }
 
-ListInit::ListInit( const std::list<Initializer*> &_initializers, const std::list<Expression *> &_designators, bool maybeConstructed )
-        : Initializer( maybeConstructed ), initializers( _initializers ), designators( _designators ) {
+
+ListInit::ListInit( const std::list<Initializer*> &inits, const std::list<Designation *> &des, bool maybeConstructed )
+        : Initializer( maybeConstructed ), initializers( inits ), designations( des ) {
+                // handle the common case where a ListInit is created without designations by making a list of empty designations with the same length as the initializer
+                if ( designations.empty() ) {
+                        for ( auto & i : initializers ) {
+                                (void)i;
+                                designations.push_back( new Designation( {} ) );
+                        }
+                }
+                assertf( initializers.size() == designations.size(), "Created ListInit with mismatching initializers (%d) and designations (%d)", initializers.size(), designations.size() );
 }
 
 ListInit::ListInit( const ListInit & other ) : Initializer( other ) {
         cloneAll( other.initializers, initializers );
-        cloneAll( other.designators, designators );
+        cloneAll( other.designations, designations );
 }
-
 
 ListInit::~ListInit() {
         deleteAll( initializers );
-        deleteAll( designators );
+        deleteAll( designations );
 }
 
-void ListInit::print( std::ostream &os, int indent ) {
-        os << std::endl << std::string(indent, ' ') << "Compound initializer:  ";
-        if ( ! designators.empty() ) {
-                os << std::string(indent + 2, ' ' ) << "designated by: [";
-                for ( std::list < Expression * >::iterator i = designators.begin();
-                          i != designators.end(); i++ ) {
-                        ( *i )->print(os, indent + 4 );
-                } // for
+void ListInit::print( std::ostream &os, int indent ) const {
+        os << std::string(indent, ' ') << "Compound initializer:  " << std::endl;
+        for ( Designation * d : designations ) {
+                d->print( os, indent + 2 );
+        }
 
-                os << std::string(indent + 2, ' ' ) << "]";
-        } // if
-
-        for ( std::list<Initializer *>::iterator i = initializers.begin(); i != initializers.end(); i++ )
-                (*i)->print( os, indent + 2 );
+        for ( const Initializer * init : initializers ) {
+                init->print( os, indent + 2 );
+                os << std::endl;
+        }
 }
 
@@ -103 +110 @@
 }
 
-void ConstructorInit::print( std::ostream &os, int indent ) {
+void ConstructorInit::print( std::ostream &os, int indent ) const {
         os << std::endl << std::string(indent, ' ') << "Constructor initializer: " << std::endl;
         if ( ctor ) {
@@ -124 +131 @@
 }
 
-std::ostream & operator<<( std::ostream & out, Initializer * init ) {
-        init->print( out );
+std::ostream & operator<<( std::ostream & out, const Initializer * init ) {
+        if ( init ) {
+                init->print( out );
+        } else {
+                out << "nullptr";
+        }
+        return out;
+}
+
+std::ostream & operator<<( std::ostream & out, const Designation * des ) {
+        if ( des ) {
+                des->print( out );
+        } else {
+                out << "nullptr";
+        }
         return out;
 }

src/SynTree/Initializer.h

@@ -25 +25 @@
 #include "Visitor.h"
 
-const std::list<Expression*> noDesignators;
+// Designation: list of designator (NameExpr, VariableExpr, and ConstantExpr) expressions that specify an object being initialized.
+class Designation : public BaseSyntaxNode {
+public:
+        Designation( const std::list< Expression * > & designators );
+        Designation( const Designation & other );
+        virtual ~Designation();
+
+        std::list< Expression * > & get_designators() { return designators; }
+
+        virtual Designation * clone() const { return new Designation( *this ); };
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Designation * acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+private:
+        std::list< Expression * > designators;
+};
+
+const std::list<Designation *> noDesignators;
 
 // Initializer: base class for object initializers (provide default values)
 class Initializer : public BaseSyntaxNode {
   public:
-        //      Initializer( std::string _name = std::string(""), int _pos = 0 );
         Initializer( bool maybeConstructed );
         Initializer( const Initializer & other );
         virtual ~Initializer();
-
-        static std::string designator_name( Expression *designator );
-
-        //      void set_name( std::string newValue ) { name = newValue; }
-        //      std::string get_name() const { return name; }
-
-        //      void set_pos( int newValue ) { pos = newValue; }
-        //      int get_pos() const { return pos; }
-        virtual void set_designators( std::list<Expression *> & ) { assert(false); }
-        virtual std::list<Expression *> &get_designators() {
-                assert(false);
-                std::list<Expression *> *ret = 0; return *ret;  // never reached
-        }
 
         bool get_maybeConstructed() { return maybeConstructed; }
@@ -53 +56 @@
         virtual void accept( Visitor &v ) = 0;
         virtual Initializer *acceptMutator( Mutator &m ) = 0;
-        virtual void print( std::ostream &os, int indent = 0 ) = 0;
+        virtual void print( std::ostream &os, int indent = 0 ) const = 0;
   private:
-        //      std::string name;
-        //      int pos;
         bool maybeConstructed;
 };
@@ -63 +64 @@
 class SingleInit : public Initializer {
   public:
-        SingleInit( Expression *value, const std::list< Expression *> &designators = std::list< Expression * >(), bool maybeConstructed = false );
+        SingleInit( Expression *value, bool maybeConstructed = false );
         SingleInit( const SingleInit &other );
         virtual ~SingleInit();
@@ -70 +71 @@
         void set_value( Expression *newValue ) { value = newValue; }
 
-        std::list<Expression *> &get_designators() { return designators; }
-        void set_designators( std::list<Expression *> &newValue ) { designators = newValue; }
-
         virtual SingleInit *clone() const { return new SingleInit( *this); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 );
+        virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
         //Constant *value;
         Expression *value;      // has to be a compile-time constant
-        std::list< Expression * > designators;
 };
 
@@ -88 +85 @@
   public:
         ListInit( const std::list<Initializer*> &initializers,
-                          const std::list<Expression *> &designators = std::list< Expression * >(), bool maybeConstructed = false );
+                          const std::list<Designation *> &designators = {}, bool maybeConstructed = false );
         ListInit( const ListInit & other );
         virtual ~ListInit();
 
-        void set_designators( std::list<Expression *> &newValue ) { designators = newValue; }
-        std::list<Expression *> &get_designators() { return designators; }
-        void set_initializers( std::list<Initializer*> &newValue ) { initializers = newValue; }
-        std::list<Initializer*> &get_initializers() { return initializers; }
+        std::list<Designation *> & get_designations() { return designations; }
+        std::list<Initializer *> & get_initializers() { return initializers; }
 
         typedef std::list<Initializer*>::iterator iterator;
+        typedef std::list<Initializer*>::const_iterator const_iterator;
         iterator begin() { return initializers.begin(); }
         iterator end() { return initializers.end(); }
+        const_iterator begin() const { return initializers.begin(); }
+        const_iterator end() const { return initializers.end(); }
 
         virtual ListInit *clone() const { return new ListInit( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 );
+        virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
-        std::list<Initializer*> initializers;  // order *is* important
-        std::list<Expression *> designators;
+        std::list<Initializer *> initializers;  // order *is* important
+        std::list<Designation *> designations;  // order/length is consistent with initializers
 };
 
@@ -130 +128 @@
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 );
+        virtual void print( std::ostream &os, int indent = 0 ) const;
 
   private:
@@ -140 +138 @@
 };
 
-std::ostream & operator<<( std::ostream & out, Initializer * init );
+std::ostream & operator<<( std::ostream & out, const Initializer * init );
+std::ostream & operator<<( std::ostream & out, const Designation * des );
 
 #endif // INITIALIZER_H

src/SynTree/Mutator.cc

@@ -433 +433 @@
 }
 
+Expression *Mutator::mutate( UntypedInitExpr * initExpr ) {
+        initExpr->set_env( maybeMutate( initExpr->get_env(), *this ) );
+        initExpr->set_result( maybeMutate( initExpr->get_result(), *this ) );
+        initExpr->set_expr( maybeMutate( initExpr->get_expr(), *this ) );
+        // not currently mutating initAlts, but this doesn't matter since this node is only used in the resolver.
+        return initExpr;
+}
+
+Expression *Mutator::mutate( InitExpr * initExpr ) {
+        initExpr->set_env( maybeMutate( initExpr->get_env(), *this ) );
+        initExpr->set_result( maybeMutate( initExpr->get_result(), *this ) );
+        initExpr->set_expr( maybeMutate( initExpr->get_expr(), *this ) );
+        initExpr->set_designation( maybeMutate( initExpr->get_designation(), *this ) );
+        return initExpr;
+}
+
 
 Type *Mutator::mutate( VoidType *voidType ) {
@@ -499 +515 @@
         mutateAll( tupleType->get_forall(), *this );
         mutateAll( tupleType->get_types(), *this );
+        mutateAll( tupleType->get_members(), *this );
         return tupleType;
 }
@@ -535 +552 @@
 
 
+Designation *Mutator::mutate( Designation * designation ) {
+        mutateAll( designation->get_designators(), *this );
+        return designation;
+}
+
 Initializer *Mutator::mutate( SingleInit *singleInit ) {
         singleInit->set_value( singleInit->get_value()->acceptMutator( *this ) );
@@ -541 +563 @@
 
 Initializer *Mutator::mutate( ListInit *listInit ) {
-        mutateAll( listInit->get_designators(), *this );
+        mutateAll( listInit->get_designations(), *this );
         mutateAll( listInit->get_initializers(), *this );
         return listInit;

src/SynTree/Mutator.h

@@ -85 +85 @@
         virtual Expression* mutate( StmtExpr * stmtExpr );
         virtual Expression* mutate( UniqueExpr * uniqueExpr );
+        virtual Expression* mutate( UntypedInitExpr * initExpr );
+        virtual Expression* mutate( InitExpr * initExpr );
 
         virtual Type* mutate( VoidType *basicType );
@@ -103 +105 @@
         virtual Type* mutate( OneType *oneType );
 
+        virtual Designation* mutate( Designation *designation );
         virtual Initializer* mutate( SingleInit *singleInit );
         virtual Initializer* mutate( ListInit *listInit );

src/SynTree/SynTree.h

@@ -93 +93 @@
 class StmtExpr;
 class UniqueExpr;
+class UntypedInitExpr;
+class InitExpr;
 
 class Type;
@@ -113 +115 @@
 class OneType;
 
+class Designation;
 class Initializer;
 class SingleInit;

src/SynTree/TupleType.cc

@@ -14 +14 @@
 //
 
+#include "Declaration.h"
+#include "Initializer.h"
 #include "Type.h"
 #include "Common/utility.h"
+#include "Parser/LinkageSpec.h"
 
 TupleType::TupleType( const Type::Qualifiers &tq, const std::list< Type * > & types, const std::list< Attribute * > & attributes ) : Type( tq, attributes ), types( types ) {
+        for ( Type * t : *this ) {
+                // xxx - this is very awkward. TupleTypes should contain objects so that members can be named, but if they don't have an initializer node then
+                // they end up getting constructors, which end up being inserted causing problems. This happens because the object decls have to be visited so that
+                // their types are kept in sync with the types list here. Ultimately, the types list here should be eliminated and perhaps replaced with a list-view
+                // of the object types list, but I digress. The temporary solution here is to make a ListInit with maybeConstructed = false, that way even when the
+                // object is visited, it is never constructed. Ultimately, a better solution might be either:
+                // a) to separate TupleType from its declarations, into TupleDecl and Tuple{Inst?}Type, ala StructDecl and StructInstType
+                // b) separate initializer nodes better, e.g. add a MaybeConstructed node that is replaced by genInit, rather than what currently exists in a bool
+                members.push_back( new ObjectDecl( "" , Type::StorageClasses(), LinkageSpec::Cforall, nullptr, t->clone(), new ListInit( {}, {}, false ) ) );
+        }
 }
 
 TupleType::TupleType( const TupleType& other ) : Type( other ) {
         cloneAll( other.types, types );
+        cloneAll( other.members, members );
 }
 
 TupleType::~TupleType() {
         deleteAll( types );
+        deleteAll( members );
 }
 

src/SynTree/Type.h

@@ -481 +481 @@
 class TupleType : public Type {
   public:
-        TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types = std::list< Type * >(), const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
         TupleType( const TupleType& );
         virtual ~TupleType();
@@ -488 +488 @@
         typedef value_type::iterator iterator;
 
-        std::list<Type*>& get_types() { return types; }
+        std::list<Type *> & get_types() { return types; }
         virtual unsigned size() const { return types.size(); };
+
+        // For now, this is entirely synthetic -- tuple types always have unnamed members.
+        // Eventually, we may allow named tuples, in which case members should subsume types
+        std::list<Declaration *> & get_members() { return members; }
 
         iterator begin() { return types.begin(); }
@@ -506 +510 @@
         virtual void print( std::ostream & os, int indent = 0 ) const;
   private:
-        std::list<Type*> types;
+        std::list<Type *> types;
+        std::list<Declaration *> members;
 };
 

src/SynTree/VarExprReplacer.cc

@@ -14 +14 @@
 //
 
+#include "Declaration.h"
 #include "Expression.h"
 #include "VarExprReplacer.h"
 
-VarExprReplacer::VarExprReplacer( const DeclMap & declMap ) : declMap( declMap ) {}
+VarExprReplacer::VarExprReplacer( const DeclMap & declMap, bool debug ) : declMap( declMap ), debug( debug ) {}
 
 // replace variable with new node from decl map
 void VarExprReplacer::visit( VariableExpr * varExpr ) {
-  // xxx - assertions and parameters aren't accounted for in this... (i.e. they aren't inserted into the map when it's made, only DeclStmts are)
-  if ( declMap.count( varExpr->get_var() ) ) {
-    varExpr->set_var( declMap.at( varExpr->get_var() ) );
-  }
+        // xxx - assertions and parameters aren't accounted for in this... (i.e. they aren't inserted into the map when it's made, only DeclStmts are)
+        if ( declMap.count( varExpr->get_var() ) ) {
+                if ( debug ) {
+                        std::cerr << "replacing variable reference: " << (void*)varExpr->get_var() << " " << varExpr->get_var() << " with " << (void*)declMap.at( varExpr->get_var() ) << " " << declMap.at( varExpr->get_var() ) << std::endl;
+                }
+                varExpr->set_var( declMap.at( varExpr->get_var() ) );
+        }
 }

src/SynTree/VarExprReplacer.h

@@ -27 +27 @@
 private:
         const DeclMap & declMap;
+  bool debug;
 public:
-        VarExprReplacer( const DeclMap & declMap );
+        VarExprReplacer( const DeclMap & declMap, bool debug = false );
 
         // replace variable with new node from decl map

src/SynTree/Visitor.cc

@@ -340 +340 @@
 }
 
+void Visitor::visit( UntypedInitExpr * initExpr ) {
+        maybeAccept( initExpr->get_result(), *this );
+        maybeAccept( initExpr->get_expr(), *this );
+        // not currently visiting initAlts, but this doesn't matter since this node is only used in the resolver.
+}
+
+void Visitor::visit( InitExpr * initExpr ) {
+        maybeAccept( initExpr->get_result(), *this );
+        maybeAccept( initExpr->get_expr(), *this );
+        maybeAccept( initExpr->get_designation(), *this );
+}
+
 
 void Visitor::visit( VoidType *voidType ) {
@@ -395 +407 @@
         acceptAll( tupleType->get_forall(), *this );
         acceptAll( tupleType->get_types(), *this );
+        acceptAll( tupleType->get_members(), *this );
 }
 
@@ -424 +437 @@
 }
 
+void Visitor::visit( Designation * designation ) {
+        acceptAll( designation->get_designators(), *this );
+}
 
 void Visitor::visit( SingleInit *singleInit ) {
@@ -430 +446 @@
 
 void Visitor::visit( ListInit *listInit ) {
-        acceptAll( listInit->get_designators(), *this );
+        acceptAll( listInit->get_designations(), *this );
         acceptAll( listInit->get_initializers(), *this );
 }

src/SynTree/Visitor.h

@@ -88 +88 @@
         virtual void visit( StmtExpr * stmtExpr );
         virtual void visit( UniqueExpr * uniqueExpr );
+        virtual void visit( UntypedInitExpr * initExpr );
+        virtual void visit( InitExpr * initExpr );
 
         virtual void visit( VoidType *basicType );
@@ -106 +108 @@
         virtual void visit( OneType *oneType );
 
+        virtual void visit( Designation *designation );
         virtual void visit( SingleInit *singleInit );
         virtual void visit( ListInit *listInit );

src/Tuples/TupleExpansion.cc

@@ -192 +192 @@
                         }
                         ObjectDecl * finished = new ObjectDecl( toString( "_unq", id, "_finished_" ), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::Bool ),
-                                                                                                        new SingleInit( new ConstantExpr( Constant::from_int( 0 ) ), noDesignators ) );
+                                                                                                        new SingleInit( new ConstantExpr( Constant::from_int( 0 ) ) ) );
                         addDeclaration( finished );
                         // (finished ? _unq_expr_N : (_unq_expr_N = <unqExpr->get_expr()>, finished = 1, _unq_expr_N))
@@ -310 +310 @@
         Type * makeTupleType( const std::list< Expression * > & exprs ) {
                 // produce the TupleType which aggregates the types of the exprs
-                TupleType *tupleType = new TupleType( Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Lvalue | Type::Atomic | Type::Mutex ) );
-                Type::Qualifiers &qualifiers = tupleType->get_qualifiers();
+                std::list< Type * > types;
+                Type::Qualifiers qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Lvalue | Type::Atomic | Type::Mutex );
                 for ( Expression * expr : exprs ) {
                         assert( expr->get_result() );
                         if ( expr->get_result()->isVoid() ) {
                                 // if the type of any expr is void, the type of the entire tuple is void
-                                delete tupleType;
                                 return new VoidType( Type::Qualifiers() );
                         }
                         Type * type = expr->get_result()->clone();
-                        tupleType->get_types().push_back( type );
+                        types.push_back( type );
                         // the qualifiers on the tuple type are the qualifiers that exist on all component types
                         qualifiers &= type->get_qualifiers();
                 } // for
                 if ( exprs.empty() ) qualifiers = Type::Qualifiers();
-                return tupleType;
+                return new TupleType( qualifiers, types );
         }