Use new initialization code when dealing with [dcl.init.aggr]p12. This fixes the bug where array elements and member initializers weren't copied correctly.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@94340 91177308-0d34-0410-b5e6-96231b3b80d8

3 files changed, 62 insertions, 20 deletions

diff --git a/include/clang/Basic/DiagnosticSemaKinds.td b/include/clang/Basic/DiagnosticSemaKinds.td
index c93369ace4..7276ee902e 100644
--- a/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/include/clang/Basic/DiagnosticSemaKinds.td
@@ -597,13 +597,16 @@ def warn_field_is_uninit : Warning<"field is uninitialized when used here">,
 
 def err_temp_copy_no_viable : Error<
   "no viable copy constructor %select{copying variable|copying parameter|"
-  "returning object|throwing object}0 of type %1">;
+  "returning object|throwing object|copying member subobject|copying array "
+  "element}0 of type %1">;
 def err_temp_copy_ambiguous : Error<
   "ambiguous copy constructor call when %select{copying variable|copying "
-  "parameter|returning object|throwing object}0 of type %1">;
+  "parameter|returning object|throwing object|copying member subobject|copying "
+  "array element}0 of type %1">;
 def err_temp_copy_deleted : Error<
   "%select{copying variable|copying parameter|returning object|throwing "
-  "object}0 of type %1 invokes deleted copy constructor">;
+  "object|copying member subobject|copying array element}0 of type %1 invokes "
+  "deleted copy constructor">;
   
 // C++0x decltype
 def err_cannot_determine_declared_type_of_overloaded_function : Error<
diff --git a/lib/Sema/SemaInit.cpp b/lib/Sema/SemaInit.cpp
index 8830b8ba60..4d7d48debd 100644
--- a/lib/Sema/SemaInit.cpp
+++ b/lib/Sema/SemaInit.cpp
@@ -79,7 +79,8 @@ CheckSingleInitializer(const InitializedEntity &Entity,
   if (S.getLangOptions().CPlusPlus) {
     // C++ [dcl.init.aggr]p2:
     //   Each member is copy-initialized from the corresponding
-    //   initializer-clause
+    //   initializer-clause.
+    // FIXME: Use a better EqualLoc here.
     Sema::OwningExprResult Result = 
       S.PerformCopyInitialization(Entity, InitExpr->getLocStart(),
                                   S.Owned(InitExpr));
@@ -684,17 +685,21 @@ void InitListChecker::CheckSubElementType(const InitializedEntity &Entity,
       //   initializing the aggregate member with an ini- tializer from
       //   an initializer-list. If the initializer can initialize a
       //   member, the member is initialized. [...]
-      ImplicitConversionSequence ICS
-        = SemaRef.TryCopyInitialization(expr, ElemType,
-                                        /*SuppressUserConversions=*/false,
-                                        /*ForceRValue=*/false,
-                                        /*InOverloadResolution=*/false);
-
-      if (!ICS.isBad()) {
-        if (SemaRef.PerformImplicitConversion(expr, ElemType, ICS,
-                                              Sema::AA_Initializing))
+
+      // FIXME: Better EqualLoc?
+      InitializationKind Kind = 
+        InitializationKind::CreateCopy(expr->getLocStart(), SourceLocation());
+      InitializationSequence Seq(SemaRef, Entity, Kind, &expr, 1);
+      
+      if (Seq) {
+        Sema::OwningExprResult Result = 
+          Seq.Perform(SemaRef, Entity, Kind,
+                      Sema::MultiExprArg(SemaRef, (void **)&expr, 1));
+        if (Result.isInvalid())
           hadError = true;
-        UpdateStructuredListElement(StructuredList, StructuredIndex, expr);
+        
+        UpdateStructuredListElement(StructuredList, StructuredIndex, 
+                                    Result.takeAs<Expr>());
         ++Index;
         return;
       }
@@ -3004,13 +3009,13 @@ static bool shouldBindAsTemporary(const InitializedEntity &Entity,
   switch (Entity.getKind()) {
   case InitializedEntity::EK_Result:
   case InitializedEntity::EK_Exception:
+  case InitializedEntity::EK_ArrayElement:
+  case InitializedEntity::EK_Member:
     return !IsCopy;
       
   case InitializedEntity::EK_New:
   case InitializedEntity::EK_Variable:
   case InitializedEntity::EK_Base:
-  case InitializedEntity::EK_Member:
-  case InitializedEntity::EK_ArrayElement:
   case InitializedEntity::EK_VectorElement:
     return false;
     
@@ -3029,6 +3034,8 @@ static Sema::OwningExprResult CopyIfRequiredForEntity(Sema &S,
                                             const InitializedEntity &Entity,
                                              const InitializationKind &Kind,
                                              Sema::OwningExprResult CurInit) {
+  Expr *CurInitExpr = (Expr *)CurInit.get();
+  
   SourceLocation Loc;
   
   switch (Entity.getKind()) {
@@ -3049,6 +3056,14 @@ static Sema::OwningExprResult CopyIfRequiredForEntity(Sema &S,
     Loc = Entity.getDecl()->getLocation();
     break;
 
+  case InitializedEntity::EK_ArrayElement:
+  case InitializedEntity::EK_Member:
+    if (Entity.getType()->isReferenceType() ||
+        Kind.getKind() != InitializationKind::IK_Copy)
+      return move(CurInit);
+    Loc = CurInitExpr->getLocStart();
+    break;
+
   case InitializedEntity::EK_Parameter:
     // FIXME: Do we need this initialization for a parameter?
     return move(CurInit);
@@ -3056,14 +3071,11 @@ static Sema::OwningExprResult CopyIfRequiredForEntity(Sema &S,
   case InitializedEntity::EK_New:
   case InitializedEntity::EK_Temporary:
   case InitializedEntity::EK_Base:
-  case InitializedEntity::EK_Member:
-  case InitializedEntity::EK_ArrayElement:
   case InitializedEntity::EK_VectorElement:
     // We don't need to copy for any of these initialized entities.
     return move(CurInit);
   }
   
-  Expr *CurInitExpr = (Expr *)CurInit.get();
   CXXRecordDecl *Class = 0; 
   if (const RecordType *Record = CurInitExpr->getType()->getAs<RecordType>())
     Class = cast<CXXRecordDecl>(Record->getDecl());
diff --git a/test/SemaCXX/aggregate-initialization.cpp b/test/SemaCXX/aggregate-initialization.cpp
index 3c9333b795..83f4179d91 100644
--- a/test/SemaCXX/aggregate-initialization.cpp
+++ b/test/SemaCXX/aggregate-initialization.cpp
@@ -1,4 +1,4 @@
-// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s 
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++0x %s 
 
 // Verify that we can't initialize non-aggregates with an initializer
 // list.
@@ -40,3 +40,30 @@ int a[] = { (void *)1 }; // expected-error {{cannot initialize an array element
 
 // Struct initialization.
 struct S { int a; } s = { (void *)1 }; // expected-error {{cannot initialize a member subobject of type 'int' with an rvalue of type 'void *'}}
+
+// Check that we're copy-initializing the structs.
+struct A {
+  A();
+  A(int);
+  ~A();
+  
+  A(const A&) = delete; // expected-note 2 {{function has been explicitly marked deleted here}}
+};
+
+struct B {
+  A a;
+};
+
+struct C {
+  const A& a;
+};
+
+void f() {
+  A as1[1] = { };
+  A as2[1] = { 1 }; // expected-error {{copying array element of type 'struct A' invokes deleted copy constructor}}
+
+  B b1 = { };
+  B b2 = { 1 }; // expected-error {{copying member subobject of type 'struct A' invokes deleted copy constructor}}
+  
+  C c1 = { 1 };
+}