Index: src/ResolvExpr/Resolver.cc
===================================================================
--- src/ResolvExpr/Resolver.cc	(revision e4d829bf54d5191b9e826c8c7fc40b7c7c7bc768)
+++ src/ResolvExpr/Resolver.cc	(revision 6242335009c5d2ebee1bb50d1d228f5aacb0e5bd)
@@ -375,103 +375,54 @@
 	}
 
-	template< typename Aggr >
-	void lookupDesignation( Aggr * aggr, const std::list< Expression > & designators ) {
-
-	}
-
 	void Resolver::visit( SingleInit *singleInit ) {
+		// 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 );
-		singleInit->set_value( new CastExpr( initExpr->get_expr()->clone(), initExpr->get_result()->clone() ) );
+
+		// 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;
+					}
+				}
+			}
+		}
+
+		// set initializer expr to resolved express
+		singleInit->set_value( newExpr );
+
+		// move cursor to next object in preparation for next initializer
 		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 ) {
+		// 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);
@@ -479,7 +430,9 @@
 			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();
