Index: src/InitTweak/InitTweak.cc
===================================================================
--- src/InitTweak/InitTweak.cc	(revision b8524ca1420ff28d69347f46888a20baa805f797)
+++ src/InitTweak/InitTweak.cc	(revision f2f22e34cda38ea572dae4fcf8ee19c16aa4160d)
@@ -22,5 +22,7 @@
 
 #include "AST/Expr.hpp"
+#include "AST/Init.hpp"
 #include "AST/Node.hpp"
+#include "AST/Pass.hpp"
 #include "AST/Stmt.hpp"
 #include "AST/Type.hpp"
@@ -85,5 +87,5 @@
 		};
 
-		struct InitFlattener : public WithShortCircuiting {
+		struct InitFlattener_old : public WithShortCircuiting {
 			void previsit( SingleInit * singleInit ) {
 				visit_children = false;
@@ -93,8 +95,17 @@
 		};
 
-	}
+		struct InitFlattener_new : public ast::WithShortCircuiting {
+			std::vector< ast::ptr< ast::Expr > > argList;
+
+			void previsit( const ast::SingleInit * singleInit ) {
+				visit_children = false;
+				argList.emplace_back( singleInit->value );
+			}
+		};
+
+	} // anonymous namespace
 
 	std::list< Expression * > makeInitList( Initializer * init ) {
-		PassVisitor<InitFlattener> flattener;
+		PassVisitor<InitFlattener_old> flattener;
 		maybeAccept( init, flattener );
 		return flattener.pass.argList;
@@ -114,8 +125,7 @@
 
 std::vector< ast::ptr< ast::Expr > > makeInitList( const ast::Init * init ) {
-	#warning unimplmented
-	(void)init;
-	assert(false);
-	return {};
+	ast::Pass< InitFlattener_new > flattener;
+	maybe_accept( init, flattener );
+	return std::move( flattener.pass.argList );
 }
 
@@ -309,8 +319,75 @@
 	virtual std::vector< ast::ptr< ast::Expr > > next( IndexList & indices ) = 0;
 	virtual ast::ptr< ast::Stmt > buildListInit( 
-		const ast::UntypedExpr * callExpr, IndexList & indices ) = 0;
+		ast::UntypedExpr * callExpr, IndexList & indices ) = 0;
 };
 
 namespace {
+	template< typename Out >
+	void buildCallExpr( 
+		ast::UntypedExpr * callExpr, const ast::Expr * index, const ast::Expr * dimension, 
+		const ast::Init * init, Out & out
+	) {
+		const CodeLocation & loc = init->location;
+
+		auto cond = new ast::UntypedExpr{ 
+			loc, new ast::NameExpr{ loc, "?<?" }, { index, dimension } };
+		
+		std::vector< ast::ptr< ast::Expr > > args = makeInitList( init );
+		splice( callExpr->args, args );
+
+		out.emplace_back( new ast::IfStmt{ loc, cond, new ast::ExprStmt{ loc, callExpr } } );
+
+		out.emplace_back( new ast::ExprStmt{ 
+			loc, new ast::UntypedExpr{ loc, new ast::NameExpr{ loc, "++?" }, { index } } } );
+	}
+
+	template< typename Out >
+	void build(
+		ast::UntypedExpr * callExpr, const InitExpander_new::IndexList & indices, 
+		const ast::Init * init, Out & out
+	) {
+		if ( indices.empty() ) return;
+
+		unsigned idx = 0;
+
+		const ast::Expr * index = indices[idx++];
+		assert( idx != indices.size() );
+		const ast::Expr * dimension = indices[idx++];
+
+		if ( idx == indices.size() ) {
+			if ( auto listInit = dynamic_cast< const ast::ListInit * >( init ) ) {
+				for ( const ast::Init * init : *listInit ) {
+					buildCallExpr( callExpr, index, dimension, init, out );
+				}
+			} else {
+				buildCallExpr( callExpr, index, dimension, init, out );
+			}
+		} else {
+			const CodeLocation & loc = init->location;
+
+			unsigned long cond = 0;
+			auto listInit = dynamic_cast< const ast::ListInit * >( init );
+			if ( ! listInit ) { SemanticError( loc, "unbalanced list initializers" ); }
+
+			static UniqueName targetLabel( "L__autogen__" );
+			ast::Label switchLabel{ 
+				loc, targetLabel.newName(), { new ast::Attribute{ "unused" } } };
+			
+			std::vector< ast::ptr< ast::Stmt > > branches;
+			for ( const ast::Init * init : *listInit ) {
+				auto condition = ast::ConstantExpr::from_ulong( loc, cond );
+				++cond;
+
+				std::vector< ast::ptr< ast::Stmt > > stmts;
+				build( callExpr, indices, init, stmts );
+				stmts.emplace_back( 
+					new ast::BranchStmt{ loc, ast::BranchStmt::Break, switchLabel } );
+				branches.emplace_back( new ast::CaseStmt{ loc, condition, std::move( stmts ) } );
+			}
+			out.emplace_back( new ast::SwitchStmt{ loc, index, std::move( branches ) } );
+			out.emplace_back( new ast::NullStmt{ loc, { switchLabel } } );
+		}
+	}
+
 	class InitImpl_new final : public InitExpander_new::ExpanderImpl {
 		ast::ptr< ast::Init > init;
@@ -323,10 +400,23 @@
 		
 		ast::ptr< ast::Stmt > buildListInit( 
-			const ast::UntypedExpr * callExpr, InitExpander_new::IndexList & indices 
+			ast::UntypedExpr * callExpr, InitExpander_new::IndexList & indices 
 		) override {
-			#warning unimplemented
-			(void)callExpr; (void)indices;
-			assert(false);
-			return {};
+			// If array came with an initializer list, initialize each element. We may have more 
+			// initializers than elements of the array; need to check at each index that we have 
+			// not exceeded size. We may have fewer initializers than elements in the array; need 
+			// to default-construct remaining elements. To accomplish this, generate switch 
+			// statement consuming all of expander's elements
+
+			if ( ! init ) return {};
+
+			std::list< ast::ptr< ast::Stmt > > stmts;
+			build( callExpr, indices, init, stmts );
+			if ( stmts.empty() ) {
+				return {};
+			} else {
+				auto block = new ast::CompoundStmt{ init->location, std::move( stmts ) };
+				init = nullptr;  // consumed in creating the list init
+				return block;
+			}
 		}
 	};
@@ -340,12 +430,19 @@
 			InitExpander_new::IndexList & indices 
 		) override {
-			#warning unimplemented
-			(void)indices;
-			assert(false);
-			return {};
+			if ( ! arg ) return {};
+
+			const CodeLocation & loc = arg->location;
+			const ast::Expr * expr = arg;
+			for ( auto it = indices.rbegin(); it != indices.rend(); ++it ) {
+				// go through indices and layer on subscript exprs ?[?]
+				++it;
+				expr = new ast::UntypedExpr{ 
+					loc, new ast::NameExpr{ loc, "?[?]" }, { expr, *it } };
+			}
+			return { expr };
 		}
 		
 		ast::ptr< ast::Stmt > buildListInit( 
-			const ast::UntypedExpr *, InitExpander_new::IndexList & 
+			ast::UntypedExpr *, InitExpander_new::IndexList & 
 		) override { 
 			return {};
@@ -369,5 +466,5 @@
 /// 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
-ast::ptr< ast::Stmt > InitExpander_new::buildListInit( const ast::UntypedExpr * callExpr ) {
+ast::ptr< ast::Stmt > InitExpander_new::buildListInit( ast::UntypedExpr * callExpr ) {
 	return expander->buildListInit( callExpr, indices );
 }
Index: src/InitTweak/InitTweak.h
===================================================================
--- src/InitTweak/InitTweak.h	(revision b8524ca1420ff28d69347f46888a20baa805f797)
+++ src/InitTweak/InitTweak.h	(revision f2f22e34cda38ea572dae4fcf8ee19c16aa4160d)
@@ -154,6 +154,7 @@
 
 		/// 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
-		ast::ptr< ast::Stmt > buildListInit( const ast::UntypedExpr * callExpr );
+		/// initializers) using callExpr as the base expression to perform initialization. 
+		/// Mutates callExpr
+		ast::ptr< ast::Stmt > buildListInit( ast::UntypedExpr * callExpr );
 
 		void addArrayIndex( const ast::Expr * index, const ast::Expr * dimension );