MitalAshok updated this revision to Diff 544078.
MitalAshok added a comment.
Target clang 18 instead; add entry to release notes
Repository:
rG LLVM Github Monorepo
CHANGES SINCE LAST ACTION
https://reviews.llvm.org/D156032/new/
https://reviews.llvm.org/D156032
Files:
clang/docs/ReleaseNotes.rst
clang/lib/Sema/SemaInit.cpp
clang/lib/Sema/SemaOverload.cpp
clang/test/CXX/drs/dr14xx.cpp
clang/test/CXX/drs/dr21xx.cpp
clang/test/CXX/drs/dr23xx.cpp
clang/www/cxx_dr_status.html
Index: clang/www/cxx_dr_status.html
===================================================================
--- clang/www/cxx_dr_status.html
+++ clang/www/cxx_dr_status.html
@@ -12629,7 +12629,7 @@
<td><a href="https://cplusplus.github.io/CWG/issues/2137.html";>2137</a></td>
<td>CD4</td>
<td>List-initialization from object of same type</td>
- <td class="none" align="center">Unknown</td>
+ <td class="unreleased" align="center">Clang 18</td>
</tr>
<tr id="2138">
<td><a href="https://cplusplus.github.io/CWG/issues/2138.html";>2138</a></td>
Index: clang/test/CXX/drs/dr23xx.cpp
===================================================================
--- clang/test/CXX/drs/dr23xx.cpp
+++ clang/test/CXX/drs/dr23xx.cpp
@@ -5,6 +5,16 @@
// RUN: %clang_cc1 -std=c++20 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors 2>&1 | FileCheck %s
// RUN: %clang_cc1 -std=c++23 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors 2>&1 | FileCheck %s
+namespace std {
+ __extension__ typedef __SIZE_TYPE__ size_t;
+
+ template<typename E> struct initializer_list {
+ const E *p; size_t n;
+ initializer_list(const E *p, size_t n);
+ initializer_list();
+ };
+}
+
#if __cplusplus >= 201103L
namespace dr2303 { // dr2303: 12
template <typename... T>
@@ -37,6 +47,38 @@
} //namespace dr2303
#endif
+namespace dr2311 {
+#if __cplusplus >= 201707L
+template<typename T>
+void test() {
+ // These should all be elided (no move)
+ T a = T{T(0)};
+ T b{T(0)};
+ auto c{T(0)};
+ T d = {T(0)};
+ auto e = {T(0)};
+#if __cplusplus >= 202302L
+ auto f = auto{T(0)};
+#endif
+}
+
+struct NonMovable {
+ NonMovable(int);
+ NonMovable(NonMovable&&) = delete;
+};
+
+template void test<NonMovable>();
+
+struct NonMovableNonApplicableIList {
+ NonMovableNonApplicableIList(int);
+ NonMovableNonApplicableIList(NonMovableNonApplicableIList&&) = delete;
+ NonMovableNonApplicableIList(std::initializer_list<int>);
+};
+
+template void test<NonMovableNonApplicableIList>();
+#endif
+}
+
// dr2331: na
#if __cplusplus >= 201103L
Index: clang/test/CXX/drs/dr21xx.cpp
===================================================================
--- clang/test/CXX/drs/dr21xx.cpp
+++ clang/test/CXX/drs/dr21xx.cpp
@@ -10,6 +10,16 @@
#define static_assert(...) __extension__ _Static_assert(__VA_ARGS__)
#endif
+namespace std {
+ __extension__ typedef __SIZE_TYPE__ size_t;
+
+ template<typename E> struct initializer_list {
+ const E *p; size_t n;
+ initializer_list(const E *p, size_t n);
+ initializer_list();
+ };
+}
+
namespace dr2100 { // dr2100: 12
template<const int *P, bool = true> struct X {};
template<typename T> struct A {
@@ -110,6 +120,36 @@
#endif
}
+namespace dr2137 { // dr2137: 18
+#if __cplusplus >= 201103L
+ struct Q {
+ Q();
+ Q(Q&&);
+ Q(std::initializer_list<Q>) = delete; // expected-note 2 {{has been explicitly marked deleted here}}
+ };
+
+ Q x = Q { Q() }; // expected-error {{call to deleted constructor}}
+
+ int f(Q); // expected-note {{passing argument to parameter here}}
+ int y = f({ Q() }); // expected-error {{call to deleted constructor}}
+
+ struct U {
+ U();
+ U(const U&);
+ };
+
+ struct Derived : U {
+ Derived();
+ Derived(const Derived&);
+ } d;
+
+ int g(Derived);
+ int g(U(&&)[1]) = delete;
+
+ int z = g({ d });
+#endif
+}
+
namespace dr2140 { // dr2140: 9
#if __cplusplus >= 201103L
union U { int a; decltype(nullptr) b; };
Index: clang/test/CXX/drs/dr14xx.cpp
===================================================================
--- clang/test/CXX/drs/dr14xx.cpp
+++ clang/test/CXX/drs/dr14xx.cpp
@@ -423,16 +423,6 @@
}
} // nonaggregate
- namespace SelfInitIsNotListInit {
- struct S {
- S();
- explicit S(S &);
- S(const S &);
- };
- S s1;
- S s2 = {s1}; // ok, not list-initialization so we pick the non-explicit constructor
- }
-
struct NestedInit { int a, b, c; };
NestedInit ni[1] = {{NestedInit{1, 2, 3}}};
Index: clang/lib/Sema/SemaOverload.cpp
===================================================================
--- clang/lib/Sema/SemaOverload.cpp
+++ clang/lib/Sema/SemaOverload.cpp
@@ -1465,19 +1465,36 @@
// called for those cases.
if (CXXConstructorDecl *Constructor
= dyn_cast<CXXConstructorDecl>(ICS.UserDefined.ConversionFunction)) {
- QualType FromCanon
- = S.Context.getCanonicalType(From->getType().getUnqualifiedType());
+ QualType FromType;
+ SourceLocation FromLoc;
+ // C++ [over.ics.list]p6, per DR2137:
+ // If C is not an initializer-list constructor and the initializer list
+ // has a single element of type cv U, where U is X or a class derived
+ // from X, the implicit conversion sequence has Exact Match rank if U is
+ // X, or Conversion rank if U is derived from X.
+ if (const auto *InitList = dyn_cast<InitListExpr>(From);
+ InitList && InitList->getNumInits() == 1 &&
+ !S.isInitListConstructor(Constructor)) {
+ const Expr *SingleInit = InitList->getInit(0);
+ FromType = SingleInit->getType();
+ FromLoc = SingleInit->getBeginLoc();
+ } else {
+ FromType = From->getType();
+ FromLoc = From->getBeginLoc();
+ }
+ QualType FromCanon =
+ S.Context.getCanonicalType(FromType.getUnqualifiedType());
QualType ToCanon
= S.Context.getCanonicalType(ToType).getUnqualifiedType();
if (Constructor->isCopyConstructor() &&
(FromCanon == ToCanon ||
- S.IsDerivedFrom(From->getBeginLoc(), FromCanon, ToCanon))) {
+ S.IsDerivedFrom(FromLoc, FromCanon, ToCanon))) {
// Turn this into a "standard" conversion sequence, so that it
// gets ranked with standard conversion sequences.
DeclAccessPair Found = ICS.UserDefined.FoundConversionFunction;
ICS.setStandard();
ICS.Standard.setAsIdentityConversion();
- ICS.Standard.setFromType(From->getType());
+ ICS.Standard.setFromType(FromType);
ICS.Standard.setAllToTypes(ToType);
ICS.Standard.CopyConstructor = Constructor;
ICS.Standard.FoundCopyConstructor = Found;
@@ -5168,18 +5185,18 @@
IsDesignatedInit)
return Result;
- // Per DR1467:
- // If the parameter type is a class X and the initializer list has a single
- // element of type cv U, where U is X or a class derived from X, the
- // implicit conversion sequence is the one required to convert the element
- // to the parameter type.
+ // Per DR1467 and DR2137:
+ // If the parameter type is an aggregate class X and the initializer list
+ // has a single element of type cv U, where U is X or a class derived from
+ // X, the implicit conversion sequence is the one required to convert the
+ // element to the parameter type.
//
// Otherwise, if the parameter type is a character array [... ]
// and the initializer list has a single element that is an
// appropriately-typed string literal (8.5.2 [dcl.init.string]), the
// implicit conversion sequence is the identity conversion.
if (From->getNumInits() == 1 && !IsDesignatedInit) {
- if (ToType->isRecordType()) {
+ if (ToType->isRecordType() && ToType->isAggregateType()) {
QualType InitType = From->getInit(0)->getType();
if (S.Context.hasSameUnqualifiedType(InitType, ToType) ||
S.IsDerivedFrom(From->getBeginLoc(), InitType, ToType))
Index: clang/lib/Sema/SemaInit.cpp
===================================================================
--- clang/lib/Sema/SemaInit.cpp
+++ clang/lib/Sema/SemaInit.cpp
@@ -4232,6 +4232,14 @@
return;
}
+ bool CopyElisionPossible = false;
+ auto ElideConstructor = [&] {
+ // Convert qualifications if necessary.
+ Sequence.AddQualificationConversionStep(DestType, VK_PRValue);
+ if (ILE)
+ Sequence.RewrapReferenceInitList(DestType, ILE);
+ };
+
// C++17 [dcl.init]p17:
// - If the initializer expression is a prvalue and the cv-unqualified
// version of the source type is the same class as the class of the
@@ -4248,11 +4256,15 @@
InitializedEntity::EK_LambdaToBlockConversionBlockElement &&
UnwrappedArgs.size() == 1 && UnwrappedArgs[0]->isPRValue() &&
S.Context.hasSameUnqualifiedType(UnwrappedArgs[0]->getType(), DestType)) {
- // Convert qualifications if necessary.
- Sequence.AddQualificationConversionStep(DestType, VK_PRValue);
- if (ILE)
- Sequence.RewrapReferenceInitList(DestType, ILE);
- return;
+ if (ILE && !DestType->isAggregateType()) {
+ // 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)
+ CopyElisionPossible = true;
+ } else {
+ ElideConstructor();
+ return;
+ }
}
const RecordType *DestRecordType = DestType->getAs<RecordType>();
@@ -4314,6 +4326,14 @@
IsListInit);
}
if (Result) {
+ // Ambiguity means an initializer list constructor would not be called
+ // Or a deleted non-initializer-list constructor was to be called
+ if (CopyElisionPossible &&
+ (Result != OR_Deleted || !S.isInitListConstructor(Best->Function))) {
+ ElideConstructor();
+ return;
+ }
+
Sequence.SetOverloadFailure(
IsListInit ? InitializationSequence::FK_ListConstructorOverloadFailed
: InitializationSequence::FK_ConstructorOverloadFailed,
@@ -4332,6 +4352,8 @@
QualType ConvType = CD->getConversionType();
assert(S.Context.hasSameUnqualifiedType(ConvType, DestType) &&
"should not have selected this conversion function");
+ assert(!CopyElisionPossible &&
+ "conversion function picked converting to the same type?");
Sequence.AddUserConversionStep(CD, Best->FoundDecl, ConvType,
HadMultipleCandidates);
if (!S.Context.hasSameType(ConvType, DestType))
@@ -4342,6 +4364,10 @@
}
CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
+ if (CopyElisionPossible && !S.isInitListConstructor(CtorDecl)) {
+ ElideConstructor();
+ return;
+ }
if (Result != OR_Deleted) {
// C++11 [dcl.init]p6:
// If a program calls for the default initialization of an object
@@ -4567,9 +4593,9 @@
return;
}
- // C++11 [dcl.init.list]p3, per DR1467:
- // - If T is a class type and the initializer list has a single element of
- // type cv U, where U is T or a class derived from T, the object is
+ // C++11 [dcl.init.list]p3, per DR1467 and DR2137:
+ // - If T is an aggregate class and the initializer list has a single element
+ // of type cv U, where U is T or a class derived from T, the object is
// initialized from that element (by copy-initialization for
// copy-list-initialization, or by direct-initialization for
// direct-list-initialization).
@@ -4580,7 +4606,7 @@
// - Otherwise, if T is an aggregate, [...] (continue below).
if (S.getLangOpts().CPlusPlus11 && InitList->getNumInits() == 1 &&
!IsDesignatedInit) {
- if (DestType->isRecordType()) {
+ if (DestType->isRecordType() && DestType->isAggregateType()) {
QualType InitType = InitList->getInit(0)->getType();
if (S.Context.hasSameUnqualifiedType(InitType, DestType) ||
S.IsDerivedFrom(InitList->getBeginLoc(), InitType, DestType)) {
Index: clang/docs/ReleaseNotes.rst
===================================================================
--- clang/docs/ReleaseNotes.rst
+++ clang/docs/ReleaseNotes.rst
@@ -68,6 +68,8 @@
Resolutions to C++ Defect Reports
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+- Implemented `DR2137 <https://wg21.link/CWG2137>`_ which allows
+ list-initialization from objects of the same type.
C Language Changes
------------------
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
