diff --git a/lib/Sema/Sema.h b/lib/Sema/Sema.h
index 3014a8e..5b3ea40 100644
--- a/lib/Sema/Sema.h
+++ b/lib/Sema/Sema.h
@@ -2630,9 +2630,12 @@
                                    IdentifierInfo &Comp, SourceLocation CmpLoc);
   
   /// type checking declaration initializers (C99 6.7.8)
+  
+  /// FIXME: The VarDecl parameter should not have a default value,
+  /// and all call sites should be audited.
   bool CheckInitializerTypes(Expr *&simpleInit_or_initList, QualType &declType,
                              SourceLocation InitLoc,DeclarationName InitEntity,
-                             bool DirectInit);
+                             bool DirectInit, VarDecl *VD = 0);
   bool CheckInitList(InitListExpr *&InitList, QualType &DeclType);
   bool CheckForConstantInitializer(Expr *e, QualType t);
   
diff --git a/lib/Sema/SemaDecl.cpp b/lib/Sema/SemaDecl.cpp
index 4149fa4..5e09851 100644
--- a/lib/Sema/SemaDecl.cpp
+++ b/lib/Sema/SemaDecl.cpp
@@ -2562,7 +2562,7 @@
       VDecl->setInvalidDecl();
     } else if (!VDecl->isInvalidDecl()) {
       if (CheckInitializerTypes(Init, DclT, VDecl->getLocation(),
-                                VDecl->getDeclName(), DirectInit))
+                                VDecl->getDeclName(), DirectInit, VDecl))
         VDecl->setInvalidDecl();
       
       // C++ 3.6.2p2, allow dynamic initialization of static initializers.
diff --git a/lib/Sema/SemaInit.cpp b/lib/Sema/SemaInit.cpp
index d880c23..3fae86d 100644
--- a/lib/Sema/SemaInit.cpp
+++ b/lib/Sema/SemaInit.cpp
@@ -18,6 +18,7 @@
 #include "Sema.h"
 #include "clang/Parse/Designator.h"
 #include "clang/AST/ASTContext.h"
+#include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprObjC.h"
 #include <map>
 using namespace clang;
@@ -116,7 +117,7 @@
 bool Sema::CheckInitializerTypes(Expr *&Init, QualType &DeclType,
                                  SourceLocation InitLoc,
                                  DeclarationName InitEntity,
-                                 bool DirectInit) {
+                                 bool DirectInit, VarDecl *VD) {
   if (DeclType->isDependentType() || 
       Init->isTypeDependent() || Init->isValueDependent())
     return false;
@@ -160,7 +161,14 @@
                                              InitLoc, Init->getSourceRange(),
                                              InitEntity, 
                                              DirectInit? IK_Direct : IK_Copy);
-        return Constructor == 0;
+        if (!Constructor)
+          return true;
+        
+        // FIXME: What do do if VD is null here?
+        assert(VD && "Must have a var decl to construct into!");
+        Init = CXXConstructExpr::Create(Context, VD, DeclType, Constructor, 
+                                        false, &Init, 1);
+        return false;
       }
       
       //   -- Otherwise (i.e., for the remaining copy-initialization
