Add more tests

Author: MitalAshok

clang/lib/Sema/SemaInit.cpp

@@ -4285,6 +4285,22 @@ static void TryConstructorInitialization(Sema &S,
       // CWG2311: T{ prvalue_of_type_T } is not eligible for copy elision
       // Make this an elision if this won't call an initializer-list
       // constructor. (Always on an aggregate type or check constructors first.)
+
+      // This effectively makes our resolution as follows. The parts in angle
+      // brackets are additions.
+      // C++17 [over.match.list]p(1.2):
+      //   - If no viable initializer-list constructor is found <and the
+      //     initializer list does not consist of exactly a single element with
+      //     the same cv-unqualified class type as T>, [...]
+      // C++17 [dcl.init.list]p(3.6):
+      //   - Otherwise, if T is a class type, constructors are considered. The
+      //     applicable constructors are enumerated and the best one is chosen
+      //     through overload resolution. <If no constructor is found and the
+      //     initializer list consists of exactly a single element with the same
+      //     cv-unqualified class type as T, the object is initialized from that
+      //     element (by copy-initialization for copy-list-initialization, or by
+      //     direct-initialization for direct-list-initialization). Otherwise, >
+      //     if a narrowing conversion [...]
       assert(!IsInitListCopy &&
              "IsInitListCopy only possible with aggregate types");
       CopyElisionPossible = true;

clang/test/CXX/drs/cwg23xx.cpp

@@ -176,6 +176,20 @@ struct X {
 X<std::initializer_list<any>> x{ X<std::initializer_list<any>>() };
 // since-cxx17-error@-1 {{call to deleted constructor of 'X<std::initializer_list<any>>'}}
 //   since-cxx17-note@#cwg2311-X {{'X' has been explicitly marked deleted here}}
+
+// Per the currently implemented resolution, this does not apply to std::initializer_list.
+// An initializer list initialized from `{ e }` always has exactly one element constructed
+// from `e`, where previously that could have been a copy of an init list or `e.operator std::initializer_list()`
+struct InitListCtor {
+  InitListCtor(int);
+  InitListCtor(InitListCtor&&) = delete;
+  InitListCtor(std::initializer_list<InitListCtor>) = delete; // #cwg2311-InitListCtor
+};
+
+std::initializer_list<InitListCtor> i;
+auto j = std::initializer_list<InitListCtor>{ i };
+// since-cxx17-error@-1 {{conversion function from 'std::initializer_list<InitListCtor>' to 'const cwg2311::InitListCtor' invokes a deleted function}}
+//   since-cxx17-note@#cwg2311-InitListCtor {{'InitListCtor' has been explicitly marked deleted here}}
 #endif
 }
 

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

@@ -19,13 +19,16 @@ template<typename T> constexpr bool has_type(T&) { return true; }
 
 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 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));
 
+auto il5 = std::initializer_list{il1};
+// expected-error@-1 {{no viable conversion from 'std::initializer_list<int>' to 'const int'}}
+
 template<typename T> struct vector {
   template<typename Iter> vector(Iter, Iter);
   vector(std::initializer_list<T>);

clang/test/SemaCXX/single-element-init-list.cpp

@@ -0,0 +1,82 @@
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -verify %s
+
+// This is heavily affected by the speculative resolution applied to CWG2311
+// So behaviour shown here is subject to change.
+
+// expected-no-diagnostics
+
+namespace std {
+  typedef decltype(sizeof(int)) size_t;
+
+  // libc++'s implementation
+  template <class _E>
+  class initializer_list
+  {
+    const _E* __begin_;
+    size_t    __size_;
+
+    initializer_list(const _E* __b, size_t __s)
+      : __begin_(__b),
+        __size_(__s)
+    {}
+
+  public:
+    typedef _E        value_type;
+    typedef const _E& reference;
+    typedef const _E& const_reference;
+    typedef size_t    size_type;
+
+    typedef const _E* iterator;
+    typedef const _E* const_iterator;
+
+    constexpr initializer_list() : __begin_(nullptr), __size_(0) {}
+
+    constexpr size_t    size()  const {return __size_;}
+    const _E* begin() const {return __begin_;}
+    const _E* end()   const {return __begin_ + __size_;}
+  };
+
+  template<typename T>
+  struct vector {
+    size_t sz;
+    constexpr vector() : sz(0) {}
+    constexpr vector(initializer_list<T> ilist) : sz(ilist.size()) {}
+    constexpr vector(const vector& other) : sz(other.sz) {}
+    constexpr std::size_t size() const { return sz; }
+  };
+}
+
+// https://github.com/llvm/llvm-project/pull/77768#issuecomment-1908062472
+namespace Issue1 {
+  struct A {
+    constexpr A() {}
+  };
+
+  struct B {
+    int called_ctor;
+    constexpr explicit B(A) : called_ctor(0) {}
+    constexpr explicit B(std::vector<A>) : called_ctor(1) {}
+  };
+
+  struct C {
+    B b;
+    constexpr C() : b({A()}) {}
+  };
+
+  static_assert(C().b.called_ctor == 0);
+}
+
+// https://github.com/llvm/llvm-project/pull/77768#issuecomment-1957171805
+namespace Issue2 {
+  struct A {
+    constexpr A(int x_) {}
+    constexpr A(const std::vector<A>& a) {}
+  };
+
+  void f() {
+    constexpr std::vector<A> a{1,2};
+    constexpr std::vector<A> b{a};
+    // -> constexpr std::vector<A> b(std::initializer_list<A>{ A(a) });
+    static_assert(b.size() == 1);
+  }
+}