Index: src/InitTweak/GenInit.cc
===================================================================
--- src/InitTweak/GenInit.cc	(revision aedfd91633ca1585181a0ce220879ca2041ede7c)
+++ src/InitTweak/GenInit.cc	(revision 39f84a4e271ab1b20b0bd4bae4f1ca69460c1dc7)
@@ -225,6 +225,7 @@
 					std::list< Statement * > dtor;
 
-					SymTab::genImplicitCall( NULL, new VariableExpr( objDecl ), "?{}", back_inserter( ctor ), objDecl );
-					SymTab::genImplicitCall( NULL, new VariableExpr( objDecl ), "^?{}", front_inserter( dtor ), objDecl, false );
+					InitExpander srcParam( (Expression *)NULL );
+					SymTab::genImplicitCall( srcParam, new VariableExpr( objDecl ), "?{}", back_inserter( ctor ), objDecl );
+					SymTab::genImplicitCall( srcParam, new VariableExpr( objDecl ), "^?{}", front_inserter( dtor ), objDecl, false );
 
 					// Currently genImplicitCall produces a single Statement - a CompoundStmt
Index: src/InitTweak/InitTweak.cc
===================================================================
--- src/InitTweak/InitTweak.cc	(revision aedfd91633ca1585181a0ce220879ca2041ede7c)
+++ src/InitTweak/InitTweak.cc	(revision 39f84a4e271ab1b20b0bd4bae4f1ca69460c1dc7)
@@ -20,7 +20,6 @@
 		};
 
-		class InitExpander : public Visitor {
+		class InitExpander_OLD : public Visitor {
 			public:
-			InitExpander() {}
 			virtual void visit( SingleInit * singleInit );
 			virtual void visit( ListInit * listInit );
@@ -28,9 +27,9 @@
 		};
 
-		void InitExpander::visit( SingleInit * singleInit ) {
+		void InitExpander_OLD::visit( SingleInit * singleInit ) {
 			argList.push_back( singleInit->get_value()->clone() );
 		}
 
-		void InitExpander::visit( ListInit * listInit ) {
+		void InitExpander_OLD::visit( ListInit * listInit ) {
 			// xxx - for now, assume no nested list inits
 			std::list<Initializer*>::iterator it = listInit->begin_initializers();
@@ -42,5 +41,5 @@
 
 	std::list< Expression * > makeInitList( Initializer * init ) {
-		InitExpander expander;
+		InitExpander_OLD expander;
 		maybeAccept( init, expander );
 		return expander.argList;
@@ -51,4 +50,108 @@
 		maybeAccept( init, finder );
 		return finder.hasDesignations;
+	}
+
+	class InitExpander::ExpanderImpl {
+	public:
+		virtual std::list< Expression * > next( std::list< Expression * > & indices ) = 0;
+	};
+
+	class InitImpl : public InitExpander::ExpanderImpl {
+	public:
+		InitImpl( Initializer * init ) {
+			if ( init ) inits.push_back( init );
+		}
+
+		virtual std::list< Expression * > next( std::list< Expression * > & indices ) {
+			// this is wrong, but just a placeholder for now
+			return ! inits.empty() ? makeInitList( inits.front() ) : std::list< Expression * >();
+		}
+	private:
+		std::list< Initializer * > inits;
+	};
+
+	class ExprImpl : public InitExpander::ExpanderImpl {
+	public:
+		ExprImpl( Expression * expr ) : arg( expr ) {}
+
+		virtual std::list< Expression * > next( std::list< Expression * > & indices ) {
+			std::list< Expression * > ret;
+			Expression * expr = maybeClone( arg );
+			if ( expr ) {
+				for ( std::list< Expression * >::reverse_iterator it = indices.rbegin(); it != indices.rend(); ++it ) {
+					// go through indices and layer on subscript exprs ?[?]
+					++it;
+					UntypedExpr * subscriptExpr = new UntypedExpr( new NameExpr( "?[?]") );
+					subscriptExpr->get_args().push_back( expr );
+					subscriptExpr->get_args().push_back( (*it)->clone() );
+					expr = subscriptExpr;
+				}
+				ret.push_back( expr );
+			}
+			return ret;
+		}
+	private:
+		Expression * arg;
+	};
+
+	InitExpander::InitExpander( Initializer * init ) : expander( new InitImpl( init ) ) {}
+
+	InitExpander::InitExpander( Expression * expr ) : expander( new ExprImpl( expr ) ) {}
+
+	std::list< Expression * > InitExpander::operator*() {
+		return cur;
+	}
+
+	InitExpander & InitExpander::operator++() {
+		cur = expander->next( indices );
+		return *this;
+	}
+
+	// use array indices list to build switch statement
+	void InitExpander::addArrayIndex( Expression * index, Expression * dimension ) {
+		indices.push_back( index );
+		indices.push_back( dimension );
+	}
+
+	template< typename OutIterator >
+	void build( UntypedExpr * callExpr, InitExpander::IndexList::iterator idx, InitExpander::IndexList::iterator end, OutIterator out ) {
+		if ( idx == end ) return;
+		Expression * index = *idx++;
+		assert( idx != end );
+		Expression * dimension = *idx++;
+
+		// if ( idx == end ) {
+		// 	// loop through list of expressions belonging to the current initializer
+		// 	UntypedExpr * cond = new UntypedExpr( new NameExpr( "?<?") );
+		// 	cond->get_args().push_back( index->clone() );
+		// 	cond->get_args().push_back( dimension->clone() );
+
+		// 	UntypedExpr * call = callExpr->clone();
+		// 	std::list< Expression * > args = *++expander; // xxx - need a way to indentify the end of an init list
+		// 	call->get_args().splice( args );
+
+		// 	*out++ = new IfStmt( noLabels, cond, new ExprStmt( call ), NULL );
+
+		// 	UntypedExpr * increment = new UntypedExpr( new NameExpr( "++?" ) );
+		// 	increment->get_args().push_back( index->clone() );
+		// 	*out++ = new ExprStmt( increment );
+		// } else {
+		// 	std::list< Statement * > branches;
+		// 	for (...) { // loop over conditions?
+		// 		std::list< Statement * > stmts;
+		// 		build( idx, end, back_inserter( stmts ) );
+		// 		CaseStmt * caseStmt = new CaseStmt( noLabels, condition, stmts );
+		// 		branches.push_back( caseStmt );
+		// 	}
+		// 	*out++ = new SwitchStmt( noLabels, index->clone(), branches );
+		// }
+	}
+
+	// generate switch statement, consuming all of expander's elements
+	Statement * InitExpander::buildListInit( UntypedExpr * dst ) {
+		std::list< Statement * > results;
+		build( dst, indices.begin(), indices.end(), back_inserter( results ) );
+		assert( results.size() <= 1 );
+		return ! results.empty() ? results.front() : NULL;
 	}
 
Index: src/InitTweak/InitTweak.h
===================================================================
--- src/InitTweak/InitTweak.h	(revision aedfd91633ca1585181a0ce220879ca2041ede7c)
+++ src/InitTweak/InitTweak.h	(revision 39f84a4e271ab1b20b0bd4bae4f1ca69460c1dc7)
@@ -61,4 +61,31 @@
 	bool isConstExpr( Expression * expr );
 	bool isConstExpr( Initializer * init );
+
+	class InitExpander {
+	public:
+		// expand by stepping through init to get each list of arguments
+		InitExpander( Initializer * init );
+
+		// always expand to expr
+		InitExpander( Expression * expr );
+
+		// iterator-like interface
+		std::list< Expression * > operator*();
+		InitExpander & operator++();
+
+		// builds statement which has the same semantics as a C-style list initializer
+		// (for array initializers) using callExpr as the base expression to perform initialization
+		Statement * buildListInit( UntypedExpr * callExpr );
+		void addArrayIndex( Expression * index, Expression * dimension );
+
+		class ExpanderImpl;
+	private:
+		std::shared_ptr< ExpanderImpl > expander;
+		std::list< Expression * > cur;
+
+		// invariant: list of size 2N (elements come in pairs [index, dimension])
+		typedef std::list< Expression * > IndexList;
+		IndexList indices;
+	};
 } // namespace