[Sema] Don't crash when initializing an incomplete list-initialized variable

[majnemer]

Summary

A list-initialized variable may have an initializer of incomplete type.
We didn't ensure the sub-element type was complete before we
interrogated certain properties of the type.

[majnemer]

Ping.

[rsmith]

lib/Sema/SemaExprCXX.cpp

5113–5115

I think this is the wrong place for this: the code creating the rvalue should be checking that its type is complete.

lib/Sema/SemaExprCXX.cpp

ExprResult Sema::MaybeBindToTemporary(Expr *E) {
 
   // That should be enough to guarantee that this type is complete, if we're
   // not processing a decltype expression.
   CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
   if (RD->isInvalidDecl() || RD->isDependentContext())
     return E;
 
   bool IsDecltype = ExprEvalContexts.back().IsDecltype;
+
+  if (!IsDecltype &&
+      RequireCompleteType(E->getExprLoc(), QualType(RT, 0),
+                          diag::err_typecheck_decl_incomplete_type,
+                          SourceRange(E->getLocStart(), E->getLocEnd())))
+      return ExprError();
+
   CXXDestructorDecl *Destructor = IsDecltype ? nullptr : LookupDestructor(RD);
 
   if (Destructor) {
     MarkFunctionReferenced(E->getExprLoc(), Destructor);
     CheckDestructorAccess(E->getExprLoc(), Destructor,
                           PDiag(diag::err_access_dtor_temp)
                             << E->getType());
     if (DiagnoseUseOfDecl(Destructor, E->getExprLoc()))

lib/Sema/SemaInit.cpp

if (SemaRef.CheckSingleAssignmentConstraints(
                                   ExprRes.getAs<Expr>());
       ++Index;
       return;
     }
     ExprRes.get();
     // Fall through for subaggregate initialization
   }
 
+  if (SemaRef.RequireCompleteType(expr->getExprLoc(), ElemType, 0)) {
+    if (!VerifyOnly)
+      SemaRef.Diag(expr->getLocStart(),
+                   diag::err_typecheck_decl_incomplete_type)
+        << ElemType << expr->getSourceRange();
+    hadError = true;
+    ++Index;
+    ++StructuredIndex;
+    return;
+  }
+
   // C++ [dcl.init.aggr]p12:
   //
   //   [...] Otherwise, if the member is itself a non-empty
   //   subaggregate, brace elision is assumed and the initializer is
   //   considered for the initialization of the first member of
   //   the subaggregate.
   if (!SemaRef.getLangOpts().OpenCL && 
       (ElemType->isAggregateType() || ElemType->isVectorType())) {

test/CXX/dcl.decl/dcl.init/dcl.init.list/p3-0x.cpp

void test(MoveOnly mo) {
     auto &&list1 = {mo}; // expected-error {{call to implicitly-deleted copy constructor}} expected-note {{in initialization of temporary of type 'std::initializer_list}}
     MoveOnly (&&list2)[1] = {mo}; // expected-error {{call to implicitly-deleted copy constructor}} expected-note {{in initialization of temporary of type 'rdar13395022::MoveOnly [1]'}}
     std::initializer_list<MoveOnly> &&list3 = {};
     MoveOnly (&&list4)[1] = {}; // expected-error {{no matching constructor}}
     // expected-note@-1 {{in implicit initialization of array element 0 with omitted initializer}}
     // expected-note@-2 {{in initialization of temporary of type 'rdar13395022::MoveOnly [1]' created to list-initialize this reference}}
   }
 }
+
+namespace incomplete {
+union U; // expected-note{{forward declaration}}
+U(&&a)[]{};    // expected-error {{variable has incomplete type}}
+U(&&b)[]{123}; // expected-error {{variable has incomplete type}} expected-note {{in initialization of temporary}}
+}

test/Modules/submodules-merge-defs.cpp

 // RUN: rm -rf %t
 // RUN: %clang_cc1 -x c++ -std=c++11 -fmodules-cache-path=%t -fmodules -I %S/Inputs/submodules-merge-defs %s -verify -fno-modules-error-recovery -DTEXTUAL
 // RUN: %clang_cc1 -x c++ -std=c++11 -fmodules-cache-path=%t -fmodules -I %S/Inputs/submodules-merge-defs %s -verify -fno-modules-error-recovery
 
 // Trigger import of definitions, but don't make them visible.
 #include "empty.h"
 
 A pre_a; // expected-error {{must be imported}} expected-error {{must use 'struct'}}
 // expected-note@defs.h:1 +{{here}}
 // FIXME: We should warn that use_a is being used without being imported.
-int pre_use_a = use_a(pre_a); // expected-error {{'A' must be imported}}
+int pre_use_a = use_a(pre_a); // expected-error +{{'A' must be imported}}
 
 B::Inner2 pre_bi; // expected-error +{{must be imported}}
 // expected-note@defs.h:4 +{{here}}
 // expected-note@defs.h:11 +{{here}}
 
 C_Base<1> pre_cb1; // expected-error +{{must be imported}}
 // expected-note@defs.h:15 +{{here}}
 C1 pre_c1; // expected-error +{{must be imported}} expected-error {{must use 'struct'}}