[SemaCXX] Recognise initializer_list injected-class-name types as initializer_lists

[MitalAshok]

Summary

This allows the implicitly-generated deduction guide for the copy constructor to be recognised as an initializer-list constructor, allowing CTAD for std::initializer_list

[MitalAshok]

The implicitly-generated guide for template<class E> struct initializer_list;'s copy constructor's first argument is an injected-class-name. When it was not recognised as an initializer_list, it was erroneously excluded when the initializer was a braced-init-list.

Also falls foul of -Wctad-maybe-unsupported. Looks like this is being worked on in https://reviews.llvm.org/D133425 but should std::initializer_list{ a, b, c } be a built-in exception to this diagnostic? If not, I would recommend using _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(initializer_list) in libc++ from https://reviews.llvm.org/D133535. For comparison, GCC does not warn with -Wctad-maybe-unsupported.

[MitalAshok]

Remove now unneeded FIXME

[shafik]

This makes sense I see that isStdInitializerList(...) is used in a lot of places, this makes me wonder if we need additional test coverage.

I also added some folks for more review visibility.

[MitalAshok]

Rebase changelog to clang 18, add more tests

[cor3ntin]

LGTM, thanks!

[cor3ntin]

clang/docs/ReleaseNotes.rst

111

[MitalAshok]

wording of changelog

[cor3ntin]

@MitalAshok Do you need me to land that for you> If so, what email should i use?

clang/docs/ReleaseNotes.rst

 Bug Fixes to Compiler Builtins
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Bug Fixes to Attribute Support
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Bug Fixes to C++ Support
 ^^^^^^^^^^^^^^^^^^^^^^^^
+- Fix CTAD for ``std::initializer_list``. This allows
+  ``std::initializer_list{1, 2, 3}`` to be a ``std::initializer_list<int>``
+  as intended.
 
 Bug Fixes to AST Handling
 ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Miscellaneous Bug Fixes
 ^^^^^^^^^^^^^^^^^^^^^^^
 
 Miscellaneous Clang Crashes Fixed

clang/lib/Sema/SemaDeclCXX.cpp

if (const RecordType *RT = Ty->getAs<RecordType>()) {
 
     ClassTemplateSpecializationDecl *Specialization =
         dyn_cast<ClassTemplateSpecializationDecl>(RT->getDecl());
     if (!Specialization)
       return false;
 
     Template = Specialization->getSpecializedTemplate();
     Arguments = Specialization->getTemplateArgs().data();
-  } else if (const TemplateSpecializationType *TST =
-                 Ty->getAs<TemplateSpecializationType>()) {
+  } else {
+    const TemplateSpecializationType *TST = nullptr;
+    if (auto *ICN = Ty->getAs<InjectedClassNameType>())
+      TST = ICN->getInjectedTST();
+    else
+      TST = Ty->getAs<TemplateSpecializationType>();
+    if (TST) {
       Template = dyn_cast_or_null<ClassTemplateDecl>(
           TST->getTemplateName().getAsTemplateDecl());
       Arguments = TST->template_arguments().begin();
     }
+  }
   if (!Template)
     return false;
 
   if (!StdInitializerList) {
     // Haven't recognized std::initializer_list yet, maybe this is it.
     CXXRecordDecl *TemplateClass = Template->getTemplatedDecl();
     if (TemplateClass->getIdentifier() !=
             &PP.getIdentifierTable().get("initializer_list") ||

clang/lib/Sema/SemaInit.cpp

Diag(TSInfo->getTypeLoc().getBeginLoc(),
          diag::warn_cxx14_compat_class_template_argument_deduction)
         << TSInfo->getTypeLoc().getSourceRange() << 0;
     return SubstAutoTypeDependent(TSInfo->getType());
   }
 
   // FIXME: Perform "exact type" matching first, per CWG discussion?
   //        Or implement this via an implied 'T(T) -> T' deduction guide?
 
-  // FIXME: Do we need/want a std::initializer_list<T> special case?
-
   // Look up deduction guides, including those synthesized from constructors.
   //
   // C++1z [over.match.class.deduct]p1:
   //   A set of functions and function templates is formed comprising:
   //   - For each constructor of the class template designated by the
   //     template-name, a function template [...]
   //  - For each deduction-guide, a function or function template [...]
   DeclarationNameInfo NameInfo(

clang/test/SemaCXX/cxx1z-class-template-argument-deduction.cpp

 // RUN: %clang_cc1 -std=c++1z -verify %s -DERRORS -Wundefined-func-template
 // RUN: %clang_cc1 -std=c++1z -verify %s -UERRORS -Wundefined-func-template
 
 // This test is split into two because we only produce "undefined internal"
 // warnings if we didn't produce any errors.
 #if ERRORS
 
 namespace std {
   using size_t = decltype(sizeof(0));
   template<typename T> struct initializer_list {
     const T *p;
     size_t n;
     initializer_list();
   };
-  // FIXME: This should probably not be necessary.
-  template<typename T> initializer_list(initializer_list<T>) -> initializer_list<T>;
 }
 
 template<typename T> constexpr bool has_type(...) { return false; }
 template<typename T> constexpr bool has_type(T&) { return true; }
 
-std::initializer_list il = {1, 2, 3, 4, 5};
+std::initializer_list il1 = {1, 2, 3, 4, 5};
+auto il2 = std::initializer_list{1, 2, 3, 4};
+auto il3 = std::initializer_list{il1};
+auto il4 = std::initializer_list{il1, il1, il1};
+static_assert(has_type<std::initializer_list<int>>(il1));
+static_assert(has_type<std::initializer_list<int>>(il2));
+static_assert(has_type<std::initializer_list<int>>(il3));
+static_assert(has_type<std::initializer_list<std::initializer_list<int>>>(il4));
 
 template<typename T> struct vector {
   template<typename Iter> vector(Iter, Iter);
   vector(std::initializer_list<T>);
 };
 
 template<typename T> vector(std::initializer_list<T>) -> vector<T>;
 template<typename Iter> explicit vector(Iter, Iter) -> vector<typename Iter::value_type>;