Changeset e4d829b

Timestamp:

Jun 20, 2017, 1:19:53 PM (6 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

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

Children:

579263a

Parents:

c6d2e93

git-author:

Rob Schluntz <rschlunt@…> (06/20/17 13:16:13)

git-committer:

Rob Schluntz <rschlunt@…> (06/20/17 13:19:53)

Message:

major effort on designations, works in many cases

Location:

src

Files:

• CodeGen/CodeGenerator.cc (modified) (3 diffs)
• CodeGen/CodeGenerator.h (modified) (2 diffs)
• Common/utility.h (modified) (1 diff)
• InitTweak/FixInit.cc (modified) (1 diff)
• 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) (1 diff)
• ResolvExpr/AlternativeFinder.cc (modified) (2 diffs)
• ResolvExpr/AlternativeFinder.h (modified) (1 diff)
• ResolvExpr/CurrentObject.cc (added)
• ResolvExpr/CurrentObject.h (added)
• ResolvExpr/Resolver.cc (modified) (8 diffs)
• ResolvExpr/module.mk (modified) (2 diffs)
• SymTab/Autogen.h (modified) (1 diff)
• SynTree/Expression.cc (modified) (2 diffs)
• SynTree/Expression.h (modified) (1 diff)
• SynTree/Initializer.cc (modified) (3 diffs)
• SynTree/Initializer.h (modified) (7 diffs)
• SynTree/Mutator.cc (modified) (3 diffs)
• SynTree/Mutator.h (modified) (2 diffs)
• SynTree/SynTree.h (modified) (2 diffs)
• SynTree/Visitor.cc (modified) (3 diffs)
• SynTree/Visitor.h (modified) (3 diffs)
• Tuples/TupleExpansion.cc (modified) (1 diff)

src/CodeGen/CodeGenerator.cc

@@ -298 +298 @@
         }
 
-        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< ConstantExpr * >( des ) ) {
+                                // if expression is a ConstantExpr, then initializing array element
+                                output << "[";
+                                des->accept( *this );
+                                output << "]";
+                        } else {
+                                // if not a ConstantExpr, it has to be a NameExpr or VariableExpr, initializing aggregate member
                                 output << ".";
-                                (*iter)->accept( *this );
-                        } else {
-                                // if not a simple name, it has to be a constant expression, i.e. an array designator
-                                output << "[";
-                                (*iter)->accept( *this );
-                                output << "]";
+                                des->accept( *this );
                         } // if
                 } // for
@@ -317 +317 @@
 
         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() );
         }
 
@@ -726 +737 @@
 
         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 * );
@@ -136 +137 @@
                 bool lineMarks = false;
 
-                void printDesignators( std::list< Expression * > & );
                 void handleStorageClass( DeclarationWithType *decl );
                 void handleAggregate( AggregateDecl *aggDecl, const std::string & kind );

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

@@ -726 +726 @@
                                                 // static bool __objName_uninitialized = true
                                                 BasicType * boolType = new BasicType( Type::Qualifiers(), BasicType::Bool );
-                                                SingleInit * boolInitExpr = new SingleInit( new ConstantExpr( Constant( boolType->clone(), "1" ) ), noDesignators );
+                                                SingleInit * boolInitExpr = new SingleInit( new ConstantExpr( Constant( boolType->clone(), "1" ) ) );
                                                 ObjectDecl * isUninitializedVar = new ObjectDecl( objDecl->get_mangleName() + "_uninitialized", Type::StorageClasses( Type::Static ), LinkageSpec::Cforall, 0, boolType, boolInitExpr );
                                                 isUninitializedVar->fixUniqueId();

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

@@ -161 +161 @@
         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) \
@@ -414 +415 @@
         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 \
@@ -721 +722 @@
         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
@@ -890 +894 @@
         -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)
@@ -1002 +1007 @@
 @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@
@@ -1943 +1949 @@
 @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

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;
@@ -1182 +1182 @@
         }
 
+        void AlternativeFinder::visit( UntypedInitExpr *initExpr ) {
+                AlternativeFinder finder( indexer, env );
+                finder.findWithAdjustment( initExpr->get_expr() );
+                // handle each option like a cast -- should probably push this info into AltFinder as a kind of expression, both to keep common code close and to have less 'reach-in', but more 'push-in'
+                AltList candidates;
+                std::cerr << "untyped init expr: " << initExpr << std::endl;
+                // O(N^2) checks of d-types with e-types
+                for ( Alternative & alt : finder.get_alternatives() ) {
+                        for ( InitAlternative & initAlt : initExpr->get_initAlts() ) {
+                                AssertionSet needAssertions, haveAssertions;
+                                OpenVarSet openVars;
+                                std::cerr << "  " << initAlt.type << " " << 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() - initAlt.type->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( initAlt.type, alt.expr->get_result(), alt.env, needAssertions, haveAssertions, openVars, indexer );
+
+                                Cost thisCost = castCost( alt.expr->get_result(), initAlt.type, indexer, alt.env );
+                                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( alt.expr->clone(), initAlt.type->clone(), initAlt.designation->clone() ), alt.env, 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 );
@@ -369 +375 @@
         }
 
+        template< typename Aggr >
+        void lookupDesignation( Aggr * aggr, const std::list< Expression > & designators ) {
+
+        }
+
         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;
-                                                }
-                                        }
-                                }
-                        }
-                } // 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
-        }
+                UntypedInitExpr * untyped = new UntypedInitExpr( singleInit->get_value(), currentObject.getOptions() );
+                Expression * newExpr = findSingleExpression( untyped, *this );
+                InitExpr * initExpr = safe_dynamic_cast< InitExpr * >( newExpr );
+                singleInit->set_value( new CastExpr( initExpr->get_expr()->clone(), initExpr->get_result()->clone() ) );
+                currentObject.setNext( initExpr->get_designation() );
+                currentObject.increment();
+                delete initExpr;
+
+                // // 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;
+                //                      }
+                //              }
+                //      }
+                // }
+        }
+
+        // template< typename AggrInst >
+        // TypeSubstitution makeGenericSubstitution( 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 ) {
+        //      ObjectDecl * obj = dynamic_cast< ObjectDecl * >( dcl );
+        //      assert( obj );
+        //      // need to substitute for generic types, so that casts are to concrete types
+        //      currentObject = obj->clone();  // xxx - delete this
+        //      sub.apply( currentObject );
+
+        //      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( currentObject->get_type() ) ) {
+        //                      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 = makeGenericSubstitution( 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 = makeGenericSubstitution( 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
+        // }
 
         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
+                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()) ) {
+                        Designation * des = std::get<0>(p);
+                        Initializer * init = std::get<1>(p);
+                        newDesignations.push_back( currentObject.findNext( des ) );
+                        init->accept( *this );
+                }
+                listInit->get_designations() = newDesignations; // xxx - memory management
+                currentObject.exitListInit();
+
+                // } 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/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

@@ -103 +103 @@
                 }
 
-                ObjectDecl *index = new ObjectDecl( indexName.newName(), Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin, std::list<Expression*>() ) );
+                ObjectDecl *index = new ObjectDecl( indexName.newName(), Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin ) );
 
                 UntypedExpr *cond = new UntypedExpr( cmp );

src/SynTree/Expression.cc

@@ -92 +92 @@
 
         Declaration *decl = get_var();
-        // if ( decl != 0) decl->print(os, indent + 2);
         if ( decl != 0) decl->printShort(os, indent + 2);
         os << std::endl;
@@ -670 +669 @@
 }
 
+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, Type * type, Designation * designation ) : expr( expr ), designation( designation ) {
+        set_result( type );
+}
+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

@@ -781 +781 @@
 };
 
+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, Type * type, 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( std::ostream &os, 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*> &initializers, const std::list<Designation *> &designations, bool maybeConstructed )
+        : Initializer( maybeConstructed ), initializers( initializers ), designations( designations ) {
 }
 
 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 +103 @@
 }
 
-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 +124 @@
 }
 
-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 );
+        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

@@ -439 +439 @@
 }
 
+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 ) {
@@ -541 +557 @@
 
 
+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 ) );
@@ -547 +568 @@
 
 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

@@ -86 +86 @@
         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 );
@@ -104 +106 @@
         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/Visitor.cc

@@ -344 +344 @@
 }
 
+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 ) {
@@ -428 +440 @@
 }
 
+void Visitor::visit( Designation * designation ) {
+        acceptAll( designation->get_designators(), *this );
+}
 
 void Visitor::visit( SingleInit *singleInit ) {
@@ -434 +449 @@
 
 void Visitor::visit( ListInit *listInit ) {
-        acceptAll( listInit->get_designators(), *this );
+        acceptAll( listInit->get_designations(), *this );
         acceptAll( listInit->get_initializers(), *this );
 }

src/SynTree/Visitor.h

@@ -89 +89 @@
         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 );
@@ -107 +109 @@
         virtual void visit( OneType *oneType );
 
+        virtual void visit( Designation *designation );
         virtual void visit( SingleInit *singleInit );
         virtual void visit( ListInit *listInit );
@@ -163 +166 @@
                         } // if
                 } catch( SemanticError &e ) {
-                        e.set_location( (*i)->location );                       
+                        e.set_location( (*i)->location );
                         errors.append( e );
                 } // try

src/Tuples/TupleExpansion.cc

@@ -192 +192 @@
                         }
                         BasicType * boolType = new BasicType( Type::Qualifiers(), BasicType::Bool );
-                        ObjectDecl * finished = new ObjectDecl( toString( "_unq", id, "_finished_" ), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::Bool ), new SingleInit( new ConstantExpr( Constant( boolType->clone(), "0" ) ), noDesignators ) );
+                        ObjectDecl * finished = new ObjectDecl( toString( "_unq", id, "_finished_" ), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::Bool ), new SingleInit( new ConstantExpr( Constant( boolType->clone(), "0" ) ) ) );
                         addDeclaration( finished );
                         // (finished ? _unq_expr_N : (_unq_expr_N = <unqExpr->get_expr()>, finished = 1, _unq_expr_N))