Check for polymorphic types and bases

Author: MitalAshok

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -12210,7 +12210,7 @@ def err_std_source_location_impl_malformed : Error<
   "'std::source_location::__impl' must be standard-layout and have only two 'const char *' fields '_M_file_name' and '_M_function_name', and two integral fields '_M_line' and '_M_column'">;
 
 def err_std_initializer_list_malformed : Error<
-  "%0 layout not recognized. Must be a struct with two fields, a 'const E *' and either another 'const E *' or a 'std::size_t'">;
+  "%0 layout not recognized. Must be a non-polymorphic class type with no bases and two fields: a 'const E *' and either another 'const E *' or a 'std::size_t'">;
 
 // HLSL Diagnostics
 def err_hlsl_attr_unsupported_in_stage : Error<"attribute %0 is unsupported in '%1' shaders, requires %select{|one of the following: }2%3">;

clang/lib/Sema/SemaInit.cpp

@@ -9393,16 +9393,16 @@ ExprResult InitializationSequence::Perform(Sema &S,
       CurInit = new (S.Context) CXXStdInitializerListExpr(Step->Type, MTE);
 
       if (!Step->Type->isDependentType()) {
-        assert(S.isCompleteType(CurInit.get()->getExprLoc(), Step->Type,
-                                Sema::CompleteTypeKind::Normal) &&
-               "std::initializer_list<E> incomplete when used during "
-               "initialization");
         QualType ElementType;
         [[maybe_unused]] bool IsStdInitializerList =
             S.isStdInitializerList(Step->Type, &ElementType);
         assert(IsStdInitializerList &&
                "StdInitializerList step to non-std::initializer_list");
-        RecordDecl *Record = Step->Type->castAs<RecordType>()->getDecl();
+        const CXXRecordDecl *Record =
+            Step->Type->getAsCXXRecordDecl()->getDefinition();
+        assert(Record && Record->isCompleteDefinition() &&
+               "std::initializer_list should have already be "
+               "complete/instantiated by this point");
 
         auto InvalidType = [&] {
           S.Diag(Record->getLocation(),
@@ -9411,8 +9411,8 @@ ExprResult InitializationSequence::Perform(Sema &S,
           return ExprError();
         };
 
-        // FIXME: What if the initializer_list type has base classes, etc?
-        if (Record->isUnion())
+        if (Record->isUnion() || Record->getNumBases() != 0 ||
+            Record->isPolymorphic())
           return InvalidType();
 
         RecordDecl::field_iterator Field = Record->field_begin();
@@ -9429,12 +9429,12 @@ ExprResult InitializationSequence::Perform(Sema &S,
           return InvalidType();
 
         // Size or end pointer
-        if (Field->getType()->isPointerType()) {
-          if (!S.Context.hasSameType(Field->getType()->getPointeeType(),
+        if (const auto *PT = Field->getType()->getAs<PointerType>()) {
+          if (!S.Context.hasSameType(PT->getPointeeType(),
                                      ElementType.withConst()))
             return InvalidType();
         } else {
-          if (Field->isUnnamedBitField() ||
+          if (Field->isBitField() ||
               !S.Context.hasSameType(Field->getType(), S.Context.getSizeType()))
             return InvalidType();
         }

clang/test/SemaCXX/PR20334-std_initializer_list_diagnosis_assertion.cpp

@@ -1,14 +1,13 @@
 // RUN: %clang_cc1 -std=c++11 -verify=cxx11 -emit-llvm-only %s
-// RUN: %clang_cc1 -std=c++98 -fsyntax-only -verify=cxx98 %s -DCPP98
+// RUN: %clang_cc1 -std=c++98 -fsyntax-only -verify=cxx98 %s
 // RUN: %clang_cc1 -std=c++11 -verify=cxx11 -emit-llvm-only %s -fexperimental-new-constant-interpreter
-// RUN: %clang_cc1 -std=c++98 -fsyntax-only -verify=cxx98 %s -DCPP98 -fexperimental-new-constant-interpreter
+// RUN: %clang_cc1 -std=c++98 -fsyntax-only -verify=cxx98 %s -fexperimental-new-constant-interpreter
 
 
 namespace std {
   template <class _E>
-  class initializer_list
-  {};
-  // cxx11-error@-2 {{'std::initializer_list<int>' layout not recognized}}
+  class initializer_list {};
+  // cxx11-error@-1 {{'std::initializer_list<int>' layout not recognized. Must be a non-polymorphic class type with no bases and two fields: a 'const E *' and either another 'const E *' or a 'std::size_t'}}
 }
 
 template<class E> int f(std::initializer_list<E> il);

clang/test/SemaCXX/cxx0x-initializer-stdinitializerlist.cpp

@@ -390,19 +390,39 @@ template<> struct std::initializer_list<weird_initlist::weird<1>> { std::size_t
 template<> struct std::initializer_list<weird_initlist::weird<2>> { const weird_initlist::weird<2>* first; const weird_initlist::weird<2>* last; };
 template<> struct std::initializer_list<weird_initlist::weird<3>> { weird_initlist::weird<3>* p; std::size_t sz; };
 // expected-error@-1 {{'std::initializer_list<weird<3>>' layout not recognized}}
-template<> struct std::initializer_list<weird_initlist::weird<4>> { const weird_initlist::weird<3>& p; std::size_t sz; };
+template<> struct std::initializer_list<weird_initlist::weird<4>> { const weird_initlist::weird<4>& p; std::size_t sz; };
 // expected-error@-1 {{'std::initializer_list<weird<4>>' layout not recognized}}
-template<> struct std::initializer_list<weird_initlist::weird<5>> { const weird_initlist::weird<3>* p; std::size_t : sizeof(std::size_t) * __CHAR_BIT__; };
+template<> struct std::initializer_list<weird_initlist::weird<5>> { const weird_initlist::weird<5>* p; std::size_t : sizeof(std::size_t) * __CHAR_BIT__; };
 // expected-error@-1 {{'std::initializer_list<weird<5>>' layout not recognized}}
+template<> struct std::initializer_list<weird_initlist::weird<6>> { const weird_initlist::weird<6>* p; std::size_t sz : sizeof(std::size_t) * __CHAR_BIT__; };
+// expected-error@-1 {{'std::initializer_list<weird<6>>' layout not recognized}}
+struct empty_base {};
+template<> struct std::initializer_list<weird_initlist::weird<7>> : empty_base { const weird_initlist::weird<7>* p; std::size_t sz; };
+// expected-error@-1 {{'std::initializer_list<weird<7>>' layout not recognized}}
+template<> struct std::initializer_list<weird_initlist::weird<8>> { const weird_initlist::weird<8>* p; std::size_t sz; ~initializer_list(); };
+template<> struct std::initializer_list<weird_initlist::weird<9>> { const weird_initlist::weird<9>* p; std::size_t sz; virtual void f(); };
+// expected-error@-1 {{'std::initializer_list<weird<9>>' layout not recognized}}
+template<> struct std::initializer_list<weird_initlist::weird<10>> { const weird_initlist::weird<10>* p; alignas(64) std::size_t sz; };
+template<> struct std::initializer_list<weird_initlist::weird<11>>;
+// expected-note@-1 {{forward declaration of 'std::initializer_list<weird_initlist::weird<11>>'}}
 namespace weird_initlist {
   auto _0 = {weird<0>{}, weird<0>{}, weird<0>{}, weird<0>{}, weird<0>{}};
-  constexpr auto _00 = {weird<0>{}, weird<0>{}, weird<0>{}, weird<0>{}, weird<0>{}};
+  constexpr auto _0c = {weird<0>{}, weird<0>{}, weird<0>{}, weird<0>{}, weird<0>{}};
   auto _1 = {weird<1>{}, weird<1>{}};
-  constexpr auto _2 = {weird<2>{}, weird<2>{}, weird<2>{}}; // (Two pointer representation is supported)
-  static_assert(_2.first + 3 == _2.last, "");
+  auto _2 = {weird<2>{}, weird<2>{}, weird<2>{}};
+  constexpr auto _2c = {weird<2>{}, weird<2>{}, weird<2>{}}; // (Two pointer representation is supported)
+  static_assert(_2c.first + 3 == _2c.last, "");
   auto _3 = {weird<3>{}, weird<3>{}};
   auto _4 = {weird<4>{}, weird<4>{}};
   auto _5 = {weird<5>{}, weird<5>{}};
+  auto _6 = {weird<6>{}, weird<6>{}};
+  auto _7 = {weird<7>{}, weird<7>{}};
+  auto _8 = {weird<8>{}, weird<8>{}};
+  auto _9 = {weird<9>{}, weird<9>{}};
+  auto _10 = {weird<10>{}, weird<10>{}};
+  constexpr auto _10c = {weird<10>{}, weird<10>{}, weird<10>{}};
+  static_assert(_10c.sz == 3, "");
+  const auto& _11 = {weird<11>{}, weird<11>{}}; // expected-error {{initialization of incomplete type 'const std::initializer_list<weird<11>>'}}
 }
 
 auto v = std::initializer_list<int>{1,2,3}; // expected-warning {{array backing local initializer list 'v' will be destroyed at the end of the full-expression}}