Switch file-scope assignment initialization over to InitializationSequence.

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

diff --git a/lib/Sema/SemaDecl.cpp b/lib/Sema/SemaDecl.cpp
index a1792651302aeb921ed1e62cdbdfedf1bb235f29..f62d0aa6f9bda3ac743384bc091bcea29bff2195 100644 (file)
--- a/lib/Sema/SemaDecl.cpp
+++ b/lib/Sema/SemaDecl.cpp
@@ -3557,22 +3557,16 @@ void Sema::AddInitializerToDecl(DeclPtrTy dcl, ExprArg init, bool DirectInit) {
       VDecl->setInvalidDecl();
     } else if (!VDecl->isInvalidDecl()) {
       InitializationSequence InitSeq(*this, Entity, Kind, &Init, 1);
-      if (InitSeq) {
-        OwningExprResult Result = InitSeq.Perform(*this, Entity, Kind,
+      OwningExprResult Result = InitSeq.Perform(*this, Entity, Kind,
                                           MultiExprArg(*this, (void**)&Init, 1),
-                                                  &DclT);
-        if (Result.isInvalid()) {
-          VDecl->setInvalidDecl();
-          return;
-        }
-
-        Init = Result.takeAs<Expr>();
-      } else {
-        InitSeq.Diagnose(*this, Entity, Kind, &Init, 1);
+                                                &DclT);
+      if (Result.isInvalid()) {
         VDecl->setInvalidDecl();
         return;
       }
 
+      Init = Result.takeAs<Expr>();
+
       // C++ 3.6.2p2, allow dynamic initialization of static initializers.
       // Don't check invalid declarations to avoid emitting useless diagnostics.
       if (!getLangOptions().CPlusPlus && !VDecl->isInvalidDecl()) {
@@ -3630,9 +3624,18 @@ void Sema::AddInitializerToDecl(DeclPtrTy dcl, ExprArg init, bool DirectInit) {
   } else if (VDecl->isFileVarDecl()) {
     if (VDecl->getStorageClass() == VarDecl::Extern)
       Diag(VDecl->getLocation(), diag::warn_extern_init);
-    if (!VDecl->isInvalidDecl())
-      if (CheckInitializerTypes(Init, DclT, Entity, Kind))
+    if (!VDecl->isInvalidDecl()) {
+      InitializationSequence InitSeq(*this, Entity, Kind, &Init, 1);
+      OwningExprResult Result = InitSeq.Perform(*this, Entity, Kind,
+                                          MultiExprArg(*this, (void**)&Init, 1),
+                                                &DclT);
+      if (Result.isInvalid()) {
         VDecl->setInvalidDecl();
+        return;
+      }
+
+      Init = Result.takeAs<Expr>();
+    }
 
     // C++ 3.6.2p2, allow dynamic initialization of static initializers.
     // Don't check invalid declarations to avoid emitting useless diagnostics.

diff --git a/lib/Sema/SemaInit.cpp b/lib/Sema/SemaInit.cpp
index 3ff2588356589460dc217df19568cd1b1e21d4d0..c7a2769c448655ea9352fbd93ac31ff88078c1d0 100644 (file)
--- a/lib/Sema/SemaInit.cpp
+++ b/lib/Sema/SemaInit.cpp
@@ -3201,8 +3201,12 @@ InitializationSequence::Perform(Sema &S,
     return S.Owned((Expr *)0);
   
   QualType DestType = Entity.getType().getType().getNonReferenceType();
+  // FIXME: Ugly hack around the fact that Entity.getType().getType() is not
+  // the same as Entity.getDecl()->getType() in cases involving type merging,
+  //  and we want latter when it makes sense.
   if (ResultType)
-    *ResultType = Entity.getType().getType();
+    *ResultType = Entity.getDecl() ? Entity.getDecl()->getType() :
+                                     Entity.getType().getType();
 
   Sema::OwningExprResult CurInit = S.Owned((Expr *)0);
   

diff --git a/test/CXX/temp/temp.spec/temp.explicit/p1.cpp b/test/CXX/temp/temp.spec/temp.explicit/p1.cpp
index 7c7ca6cf329db36b05386e141073cfa6a9fe9fcc..626bdf18150389c3ea5fe3766ee575c9b99e226f 100644 (file)
--- a/test/CXX/temp/temp.spec/temp.explicit/p1.cpp
+++ b/test/CXX/temp/temp.spec/temp.explicit/p1.cpp
@@ -68,7 +68,7 @@ struct X2 {
 };
 
 template<typename T, typename U>
-T X2<T, U>::static_member1 = 17; // expected-error{{incompatible type}}
+T X2<T, U>::static_member1 = 17; // expected-error{{cannot initialize}}
 
 template<typename T, typename U>
 U X2<T, U>::static_member2; // expected-error{{no matching}}

diff --git a/test/CXX/temp/temp.spec/temp.explicit/p10.cpp b/test/CXX/temp/temp.spec/temp.explicit/p10.cpp
index 9021fc2b468c0f8f960707aabdaf1a29b0a5e02e..290a874296e1b28383309e71cd674da220035658 100644 (file)
--- a/test/CXX/temp/temp.spec/temp.explicit/p10.cpp
+++ b/test/CXX/temp/temp.spec/temp.explicit/p10.cpp
@@ -20,7 +20,7 @@ struct X0<T>::Inner {
 };
 
 template<typename T>
-T X0<T>::static_var = 1; // expected-error{{incompatible type}}
+T X0<T>::static_var = 1; // expected-error{{cannot initialize}}
 
 extern template struct X0<void*>;
 template struct X0<void*>; // expected-note 2{{instantiation}}

diff --git a/test/SemaCXX/addr-of-overloaded-function.cpp b/test/SemaCXX/addr-of-overloaded-function.cpp
index 45a65f8199d379827f2487128ff593b37889ddf0..3b06119393d00bfa0b2c8ac35349c0c84e9d2781 100644 (file)
--- a/test/SemaCXX/addr-of-overloaded-function.cpp
+++ b/test/SemaCXX/addr-of-overloaded-function.cpp
@@ -9,7 +9,7 @@ int (*pfi)(int) = &f;    // selects f(int)
 // FIXME: This error message is not very good. We need to keep better
 // track of what went wrong when the implicit conversion failed to
 // give a better error message here.
-int (*pfe)(...) = &f;    // expected-error{{incompatible type initializing '<overloaded function type>', expected 'int (*)(...)'}}
+int (*pfe)(...) = &f;    // expected-error{{cannot initialize a variable of type 'int (*)(...)' with an rvalue of type '<overloaded function type>'}}
 int (&rfi)(int) = f;     // selects f(int)
 int (&rfd)(double) = f;  // selects f(double)
 

diff --git a/test/SemaCXX/aggregate-initialization.cpp b/test/SemaCXX/aggregate-initialization.cpp
index cd801d78c2dc33c0c636bf27bce90d9c978dd448..255b3529823ee2c381720a9ca49a99c60850840a 100644 (file)
--- a/test/SemaCXX/aggregate-initialization.cpp
+++ b/test/SemaCXX/aggregate-initialization.cpp
@@ -22,7 +22,7 @@ struct NonAggr4 {
   virtual void f();
 };
 
-NonAggr1 na1 = { 17 }; // expected-error{{initialization of non-aggregate type 'struct NonAggr1' with an initializer list}}
-NonAggr2 na2 = { 17 }; // expected-error{{initialization of non-aggregate type 'struct NonAggr2' with an initializer list}}
-NonAggr3 na3 = { 17 }; // expected-error{{initialization of non-aggregate type 'class NonAggr3' with an initializer list}}
-NonAggr4 na4 = { 17 }; // expected-error{{initialization of non-aggregate type 'struct NonAggr4' with an initializer list}}
+NonAggr1 na1 = { 17 }; // expected-error{{non-aggregate type 'struct NonAggr1' cannot be initialized with an initializer list}}
+NonAggr2 na2 = { 17 }; // expected-error{{non-aggregate type 'struct NonAggr2' cannot be initialized with an initializer list}}
+NonAggr3 na3 = { 17 }; // expected-error{{non-aggregate type 'class NonAggr3' cannot be initialized with an initializer list}}
+NonAggr4 na4 = { 17 }; // expected-error{{non-aggregate type 'struct NonAggr4' cannot be initialized with an initializer list}}

diff --git a/test/SemaCXX/dcl_init_aggr.cpp b/test/SemaCXX/dcl_init_aggr.cpp
index 98aa7218f5631db5ea1d306e204e6b7804845f79..87b51e32e5cf3c44a8605563df81333f60be357d 100644 (file)
--- a/test/SemaCXX/dcl_init_aggr.cpp
+++ b/test/SemaCXX/dcl_init_aggr.cpp
@@ -13,7 +13,7 @@ struct NonAggregate {
 
   int a, b;
 };
-NonAggregate non_aggregate_test = { 1, 2 }; // expected-error{{initialization of non-aggregate type 'struct NonAggregate' with an initializer list}}
+NonAggregate non_aggregate_test = { 1, 2 }; // expected-error{{non-aggregate type 'struct NonAggregate' cannot be initialized with an initializer list}}
 
 NonAggregate non_aggregate_test2[2] = { { 1, 2 }, { 3, 4 } }; // expected-error 2 {{initialization of non-aggregate type 'struct NonAggregate' with an initializer list}}
 

diff --git a/test/SemaTemplate/typename-specifier-2.cpp b/test/SemaTemplate/typename-specifier-2.cpp
index 2a21f727df75212979d620083a088737f2930f75..551cac3168b299eb11632b99befd2a4d6606b6ee 100644 (file)
--- a/test/SemaTemplate/typename-specifier-2.cpp
+++ b/test/SemaTemplate/typename-specifier-2.cpp
@@ -18,7 +18,7 @@ int i;
 // 'aka' telling us that we're dealing with an int**. Should we fix
 // getDesugaredType to dig through pointers and such?
 bind_metafun<add_pointer, int>::type::type ip = &i;
-bind_metafun<add_pointer, float>::type::type fp = &i; // expected-error{{incompatible type initializing 'int *', expected 'bind_metafun<add_pointer, float>::type::type' (aka 'float *')}}
+bind_metafun<add_pointer, float>::type::type fp = &i; // expected-error{{cannot initialize a variable of type 'bind_metafun<add_pointer, float>::type::type' (aka 'float *') with an rvalue of type 'int *'}}
 
 
 template<typename T>