diff --git a/libcfa/prelude/builtins.c b/libcfa/prelude/builtins.c
index 240358527..666e53e6e 100644
--- a/libcfa/prelude/builtins.c
+++ b/libcfa/prelude/builtins.c
@@ -27,9 +27,10 @@ struct __Destructor {
 // Defined destructor in the case that non-generated code wants to use __Destructor.
 forall( T & )
 inline void ^?{}( __Destructor(T) & x ) {
-	if ( x.object && x.dtor ) {
-		x.dtor( x.object );
-	}
+	// MAKE SURE TO CHANGE THIS BACK!!!
+//	if ( x.object && x.dtor ) {
+//		x.dtor( x.object );
+//	}
 }
 
 // Easy interface into __Destructor's destructor for easy codegen purposes.
diff --git a/src/AST/Expr.cpp b/src/AST/Expr.cpp
index 4f9d7d17a..4f46ebd25 100644
--- a/src/AST/Expr.cpp
+++ b/src/AST/Expr.cpp
@@ -342,11 +342,17 @@ ConstructorExpr::ConstructorExpr( const CodeLocation & loc, const Expr * call )
 // --- CompoundLiteralExpr
 
 CompoundLiteralExpr::CompoundLiteralExpr( const CodeLocation & loc, const Type * t, const Init * i )
-: Expr( loc ), init( i ) {
+: Expr( loc ), init( i ), decl( nullptr ) {
 	assert( t && i );
 	result = t;
 }
 
+CompoundLiteralExpr::CompoundLiteralExpr( const CodeLocation & loc, const ObjectDecl * d )
+: Expr( loc ), init( nullptr ), decl( d ) {
+	assert( d );
+	result = deepCopy( d->type );
+}
+
 bool CompoundLiteralExpr::get_lvalue() const {
 	return true;
 }
diff --git a/src/AST/Expr.hpp b/src/AST/Expr.hpp
index 41be27950..30a5fbb37 100644
--- a/src/AST/Expr.hpp
+++ b/src/AST/Expr.hpp
@@ -688,8 +688,12 @@ private:
 class CompoundLiteralExpr final : public Expr {
 public:
 	ptr<Init> init;
+	// TODO: Reduce the CompoundLiteralExpr to an ObjectDecl but don't
+	// hoist it yet. (Temp fix for testing.)
+	ptr<ObjectDecl> decl;
 
 	CompoundLiteralExpr( const CodeLocation & loc, const Type * t, const Init * i );
+	CompoundLiteralExpr( const CodeLocation & loc, const ObjectDecl * d );
 
 	bool get_lvalue() const final;
 
diff --git a/src/AST/Pass.impl.hpp b/src/AST/Pass.impl.hpp
index b027ebb51..8c0b1c528 100644
--- a/src/AST/Pass.impl.hpp
+++ b/src/AST/Pass.impl.hpp
@@ -1583,6 +1583,7 @@ const ast::Expr * ast::Pass< core_t >::visit( const ast::CompoundLiteralExpr * n
 			maybe_accept( node, &CompoundLiteralExpr::result );
 		}
 		maybe_accept( node, &CompoundLiteralExpr::init );
+		maybe_accept( node, &CompoundLiteralExpr::decl );
 	}
 
 	VISIT_END( Expr, node );
@@ -2120,7 +2121,6 @@ const ast::Init * ast::Pass< core_t >::visit( const ast::ConstructorInit * node
 	if ( __visit_children() ) {
 		maybe_accept( node, &ConstructorInit::ctor );
 		maybe_accept( node, &ConstructorInit::dtor );
-		maybe_accept( node, &ConstructorInit::init );
 	}
 
 	VISIT_END( Init, node );
diff --git a/src/AST/Print.cpp b/src/AST/Print.cpp
index 3f30b5459..7570e9d64 100644
--- a/src/AST/Print.cpp
+++ b/src/AST/Print.cpp
@@ -1342,6 +1342,8 @@ public:
 		safe_print( node->result );
 		os << indent;
 		safe_print( node->init );
+		os << indent;
+		safe_print( node->decl );
 		--indent;
 		postprint( node );
 
diff --git a/src/CodeGen/CodeGenerator.cpp b/src/CodeGen/CodeGenerator.cpp
index 33d26febc..df98164fa 100644
--- a/src/CodeGen/CodeGenerator.cpp
+++ b/src/CodeGen/CodeGenerator.cpp
@@ -904,10 +904,16 @@ void CodeGenerator::postvisit( ast::AsmExpr const * expr ) {
 }
 
 void CodeGenerator::postvisit( ast::CompoundLiteralExpr const * expr ) {
-	//assert( expr->result && dynamic_cast<ast::ListInit const *>( expr->init ) );
-	assert( expr->result && expr->init.as<ast::ListInit>() );
+	assert( expr->result );
 	output << "(" << genType( expr->result, "", options ) << ")";
-	expr->init->accept( *visitor );
+	if ( expr->init ) {
+		//assert( expr->init.as<ast::ListInit>() );
+		expr->init->accept( *visitor );
+	} else {
+		assert( expr->decl );
+		//assert( expr->decl->init.as<ast::ListInit>() );
+		expr->decl->init->accept( *visitor );
+	}
 }
 
 void CodeGenerator::postvisit( ast::UniqueExpr const * expr ) {
diff --git a/src/ResolvExpr/CandidateFinder.cpp b/src/ResolvExpr/CandidateFinder.cpp
index 10bc39809..4ebf4251f 100644
--- a/src/ResolvExpr/CandidateFinder.cpp
+++ b/src/ResolvExpr/CandidateFinder.cpp
@@ -44,9 +44,11 @@
 #include "AST/Print.hpp"
 #include "AST/SymbolTable.hpp"
 #include "AST/Type.hpp"
+#include "Common/UniqueName.hpp"
 #include "Common/Utility.hpp"       // for move, copy
 #include "SymTab/Mangler.hpp"
 #include "Tuples/Tuples.hpp"        // for handleTupleAssignment
+#include "InitTweak/GenInit.hpp"    // for genCtorInit
 #include "InitTweak/InitTweak.hpp"  // for getPointerBase
 
 #include "Common/Stats/Counter.hpp"
@@ -688,6 +690,7 @@ namespace {
 		void postvisit( const ast::CommaExpr * commaExpr );
 		void postvisit( const ast::ImplicitCopyCtorExpr * ctorExpr );
 		void postvisit( const ast::ConstructorExpr * ctorExpr );
+		void postvisit( const ast::CompoundLiteralExpr * compoundExpr );
 		void postvisit( const ast::RangeExpr * rangeExpr );
 		void postvisit( const ast::UntypedTupleExpr * tupleExpr );
 		void postvisit( const ast::TupleExpr * tupleExpr );
@@ -1049,7 +1052,6 @@ namespace {
 		// Find function matches
 		CandidateList found;
 		SemanticErrorException errors;
-		
 		for ( CandidateRef & func : funcFinder ) {
 			try {
 				PRINT(
@@ -1669,6 +1671,50 @@ namespace {
 		}
 	}
 
+	void Finder::postvisit( const ast::CompoundLiteralExpr * expr ) {
+		// We are getting recursive cases. I don't know if this is a not
+		// supposed to happen (as a no-op) or not.
+		if ( !expr->init ) {
+			assert( expr->decl );
+			addCandidate( ast::deepCopy( expr ), tenv );
+			return;
+		}
+
+		// These names should never make it to code generation, but it does
+		// so for now they must be uniquely named.
+		static UniqueName compLit("_compLitExpr");
+		const CodeLocation& location = expr->location;
+		//const ast::Type * type = expr->result;
+
+		ast::ptr<ast::ObjectDecl> decl0 = new ast::ObjectDecl( location,
+			compLit.newName(),
+			expr->result,
+			ast::deepCopy( expr->init )
+		);
+
+		ast::ptr<ast::Decl> newDecl = ResolvExpr::resolveSingleDecl(
+			decl0.get(), context
+		);
+
+		ast::ObjectDecl const * objectDecl = newDecl.strict_as<ast::ObjectDecl>();
+
+		addCandidate(
+			new ast::CompoundLiteralExpr( location, objectDecl ),
+			tenv );
+
+		// Should has been resolved.
+		// This has all three fields set, ctor or init should be cleared.
+	//	ast::ptr<ast::ConstructorInit> init =
+	//	InitTweak::genCtorInit( location, decl );
+
+		// genCtorInit produces unresolved code.
+	//	ast::ptr<ast::Init> init2 = resolveCtorInit( init, context );
+
+	//	addCandidate(
+	//		new ast::CompoundLiteralExpr( location, objectDecl ),
+	//		tenv );
+	}
+
 	void Finder::postvisit( const ast::RangeExpr * rangeExpr ) {
 		// resolve low and high, accept candidates where low and high types unify
 		CandidateFinder finder1( context, tenv );
diff --git a/src/ResolvExpr/Resolver.cpp b/src/ResolvExpr/Resolver.cpp
index 1054d25ff..10d5a6005 100644
--- a/src/ResolvExpr/Resolver.cpp
+++ b/src/ResolvExpr/Resolver.cpp
@@ -439,6 +439,21 @@ void resolve( ast::TranslationUnit& translationUnit ) {
 	ast::Pass< Resolver >::run( translationUnit, translationUnit.global );
 }
 
+// Does this need to return a ptr?
+ast::ptr< ast::Decl > resolveSingleDecl(
+	    const ast::Decl * decl, const ResolveContext & context ) {
+	assert( decl );
+	ast::Pass< Resolver > resolver( context );
+	return decl->accept( resolver );
+}
+
+ast::ptr< ast::Init > resolveInit(
+		const ast::Init * init, const ResolveContext & context ) {
+	assert( init );
+	ast::Pass< Resolver > resolver( context );
+	return init->accept( resolver );
+}
+
 ast::ptr< ast::Init > resolveCtorInit(
 	const ast::ConstructorInit * ctorInit, const ResolveContext & context
 ) {
diff --git a/src/ResolvExpr/Resolver.hpp b/src/ResolvExpr/Resolver.hpp
index 85e790d74..e2732f90d 100644
--- a/src/ResolvExpr/Resolver.hpp
+++ b/src/ResolvExpr/Resolver.hpp
@@ -43,6 +43,9 @@ struct ResolveContext {
 void resolve( ast::TranslationUnit& translationUnit );
 /// Searches expr and returns the first DeletedExpr found, otherwise nullptr
 const ast::DeletedExpr * findDeletedExpr( const ast::Expr * expr );
+/// Resolve the declaration (and all its declarations) in the given context.
+ast::ptr< ast::Decl > resolveSingleDecl(
+	const ast::Decl * decl, const ResolveContext & );
 /// Find the expression candidate that is the unique
 /// best match for `untyped` in a `void` context.
 ast::ptr< ast::Expr > resolveInVoidContext(
@@ -54,6 +57,8 @@ ast::ptr< ast::Expr > findSingleExpression(
 ast::ptr< ast::Expr > findVoidExpression(
 	const ast::Expr * untyped, const ResolveContext & );
 /// Resolves a constructor init expression
+ast::ptr< ast::Init > resolveInit(
+	const ast::Init * init, const ResolveContext & context );
 ast::ptr< ast::Init > resolveCtorInit(
 	const ast::ConstructorInit * ctorInit, const ResolveContext & context );
 /// Resolves a statement expression
diff --git a/src/Validate/CompoundLiteral.cpp b/src/Validate/CompoundLiteral.cpp
index 72e253915..0dd90ca6b 100644
--- a/src/Validate/CompoundLiteral.cpp
+++ b/src/Validate/CompoundLiteral.cpp
@@ -30,6 +30,7 @@ struct CompoundLiteral final :
 	ast::Storage::Classes storageClasses;
 
 	void previsit( const ast::ObjectDecl * decl );
+	const ast::CompoundLiteralExpr * previsit( const ast::CompoundLiteralExpr * );
 	const ast::Expr * postvisit( const ast::CompoundLiteralExpr * expr );
 };
 
@@ -37,6 +38,15 @@ void CompoundLiteral::previsit( const ast::ObjectDecl * decl ) {
 	storageClasses = decl->storage;
 }
 
+const ast::CompoundLiteralExpr * CompoundLiteral::previsit( const ast::CompoundLiteralExpr * expr ) {
+	if ( expr->decl ) {
+		auto mut = ast::mutate( expr );
+		mut->decl.get_and_mutate()->storage = storageClasses;
+		return mut;
+	}
+	return expr;
+}
+
 const ast::Expr * CompoundLiteral::postvisit(
 		const ast::CompoundLiteralExpr * expr ) {
 	static UniqueName litName( "_compLit" );
@@ -44,13 +54,23 @@ const ast::Expr * CompoundLiteral::postvisit(
 	// Transform: [storageClasses] ... (struct S){...} ...
 	// Into:      [storageClasses] struct S _compLit = {...};
 	//                             ... _compLit ...
-	ast::ObjectDecl * temp = new ast::ObjectDecl(
-		expr->location,
-		litName.newName(),
-		expr->result,
-		expr->init,
-		storageClasses
+	ast::ObjectDecl * temp;
+	if ( expr->decl ) {
+		temp = ast::mutate( expr->decl.get() );
+		// I tried doing renaming, but that might require remangling.
+		temp->name = litName.newName();
+		temp->mangleName = "";
+	} else if ( expr->init ) {
+		temp = new ast::ObjectDecl(
+			expr->location,
+			litName.newName(),
+			expr->result,
+			expr->init,
+			storageClasses
 		);
+	} else {
+		assert( false );
+	}
 	// FIXME: A resolution of #280 could make the unused attribute unnecessary here
 	//     (let test nowarn/unused decide)
 	temp->attributes.push_back( new ast::Attribute( "unused" ) );
diff --git a/src/main.cpp b/src/main.cpp
index da1c9e93a..2d8efb127 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -233,7 +233,6 @@ int main( int argc, char * argv[] ) {
 		PASS( "Implement Virtual Destructors", Virtual::implementVirtDtors, transUnit );
 		PASS( "Implement Mutex", Concurrency::implementMutex, transUnit );
 		PASS( "Implement Thread Start", Concurrency::implementThreadStarter, transUnit );
-		PASS( "Compound Literal", Validate::handleCompoundLiterals, transUnit );
 		PASS( "Set Length From Initializer", Validate::setLengthFromInitializer, transUnit );
 		PASS( "Find Global Decls", Validate::findGlobalDecls, transUnit );
 
@@ -273,6 +272,7 @@ int main( int argc, char * argv[] ) {
 
 		PASS( "Resolve", ResolvExpr::resolve, transUnit );
 		DUMP( exprp, transUnit );
+		PASS( "Compound Literal", Validate::handleCompoundLiterals, transUnit );
 		PASS( "Fix Init", InitTweak::fix, transUnit, buildingLibrary() ); // Here
 		PASS( "Erase With", ResolvExpr::eraseWith, transUnit );
 
