[Sema] Don't perform aggregate initialization for types with explicit constructors

[EricWF]

Summary

The C++17 rules for aggregate initialization changed to disallow types with explicit constructors [dcl.init.aggr]p1. This patch implements that new rule.

[rsmith]

Please also add a test to test/CXX/drs/dr15xx.cpp for core issue 1518, which this paper was resolving.

lib/AST/DeclCXX.cpp

561

Do we correctly handle the "or inherited" part? I'd also like to find out whether core intended for this issue to be treated as a DR or not (if so, this should apply all the way back to C++11).

[EricWF]

• Disallow classes with inherited constructors
• Add tests under test/CXX/drs/dr15xx.cpp

I still only implemented this change in C++1z, please let me know if you want me to backport the DR.

[EricWF]

@rsmith ping. This is kind-of blocking making libc++'s tag types not constructible from {}.

[rsmith]

lib/AST/DeclCXX.cpp

561

According to the current issues list, this issue is in DRWP status, so this change should be applied retroactively to C++11 and C++14 as well.

[EricWF]

OK, I've applied the fix to C++11 and C++14. Although the inheriting-constructor part still only matters in C++1z since it requires having base classes.

I also fixed aggregate initialization for types with non-aggregate base classes. For example:

struct A { A(int); };
struct B : A {};
B b = {42}; // OK in C++1z

[EricWF]

Add tests that explicit default constructors are still allowed outside of copy-initialization.

lib/AST/DeclCXX.cpp

if (!FunTmpl) {
       if (Constructor->isCopyConstructor(Quals)) {
         SMKind |= SMF_CopyConstructor;
 
         if (Quals & Qualifiers::Const)
           data().HasDeclaredCopyConstructorWithConstParam = true;
       } else if (Constructor->isMoveConstructor())
         SMKind |= SMF_MoveConstructor;
     }
+
+    // C++ [dcl.init.aggr]p1:
+    //   An aggregate is an array or a class with no user-declared
+    //   constructors [...].
+    // C++11 [dcl.init.aggr]p1: DR1518
+    //  An aggregate is an array or a class with no user-provided, explicit, or
+    //  inherited constructors
+    if (getASTContext().getLangOpts().CPlusPlus11
+            ? (Constructor->isUserProvided() || Constructor->isExplicit())
+            : !Constructor->isImplicit())
+      data().Aggregate = false;
   }
 
   // Handle constructors, including those inherited from base classes.
   if (CXXConstructorDecl *Constructor =
           dyn_cast<CXXConstructorDecl>(DUnderlying)) {
     // Record if we see any constexpr constructors which are neither copy
     // nor move constructors.
     // C++1z [basic.types]p10:
     //   [...] has at least one constexpr constructor or constructor template
     //   (possibly inherited from a base class) that is not a copy or move
     //   constructor [...]
     if (Constructor->isConstexpr() && !Constructor->isCopyOrMoveConstructor())
       data().HasConstexprNonCopyMoveConstructor = true;
-
-    // C++ [dcl.init.aggr]p1:
-    //   An aggregate is an array or a class with no user-declared
-    //   constructors [...].
-    // C++11 [dcl.init.aggr]p1:
-    //   An aggregate is an array or a class with no user-provided
-    //   constructors [...].
-    // C++11 [dcl.init.aggr]p1:
-    //   An aggregate is an array or a class with no user-provided
-    //   constructors (including those inherited from a base class) [...].
-    if (getASTContext().getLangOpts().CPlusPlus11
-            ? Constructor->isUserProvided()
-            : !Constructor->isImplicit())
-      data().Aggregate = false;
   }
 
   // Handle destructors.
   if (CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(D)) {
     SMKind |= SMF_Destructor;
 
     if (DD->isUserProvided())
       data().HasIrrelevantDestructor = false;
     // If the destructor is explicitly defaulted and not trivial or not public
     // or if the destructor is deleted, we clear HasIrrelevantDestructor in
if (Shadow->getDeclName().getNameKind()
           == DeclarationName::CXXConversionFunctionName) {
       ASTContext &Ctx = getASTContext();
       data().Conversions.get(Ctx).addDecl(Ctx, Shadow, Shadow->getAccess());
     }
   }
 
   if (UsingDecl *Using = dyn_cast<UsingDecl>(D)) {
     if (Using->getDeclName().getNameKind() ==
-        DeclarationName::CXXConstructorName)
+        DeclarationName::CXXConstructorName) {
       data().HasInheritedConstructor = true;
+      // C++1z [dcl.init.aggr]p1:
+      //  An aggregate is [...] a class [...] with no inherited constructors
+      data().Aggregate = false;
+    }
 
     if (Using->getDeclName().getCXXOverloadedOperator() == OO_Equal)
       data().HasInheritedAssignment = true;
   }
 }
 
 void CXXRecordDecl::finishedDefaultedOrDeletedMember(CXXMethodDecl *D) {
   assert(!D->isImplicit() && !D->isUserProvided());

test/CXX/dcl.decl/dcl.init/dcl.init.aggr/p1.cpp

struct DefaultedAggr {
   DefaultedAggr() = default;
   DefaultedAggr(const DefaultedAggr &) = default;
   DefaultedAggr(DefaultedAggr &&) = default;
   DefaultedAggr &operator=(const DefaultedAggr &) = default;
   DefaultedAggr &operator=(DefaultedAggr &&) = default;
   ~DefaultedAggr() = default;
 };
 DefaultedAggr da = { 42 } ;
+
+struct ExplicitDefaultedAggr {
+  int n;
+  explicit ExplicitDefaultedAggr() = default; // expected-note {{candidate}}
+  ExplicitDefaultedAggr(const ExplicitDefaultedAggr &) = default; // expected-note {{candidate}}
+  ExplicitDefaultedAggr(ExplicitDefaultedAggr &&) = default; // expected-note {{candidate}}
+};
+ExplicitDefaultedAggr eda = { 42 }; // expected-error {{no matching constructor}}
+ExplicitDefaultedAggr eda2{};
+
+struct DefaultedBase {
+  int n;
+  DefaultedBase() = default; // expected-note 0+ {{candidate}}
+  DefaultedBase(DefaultedBase const&) = default; // expected-note 0+ {{candidate}}
+  DefaultedBase(DefaultedBase &&) = default; // expected-note 0+ {{candidate}}
+};
+
+struct InheritingConstructors : DefaultedBase { // expected-note 3 {{candidate}}
+  using DefaultedBase::DefaultedBase; // expected-note 2 {{inherited here}}
+};
+InheritingConstructors ic = { 42 }; // expected-error {{no matching constructor}}
+
+struct NonInheritingConstructors : DefaultedBase {}; // expected-note 0+ {{candidate}}
+NonInheritingConstructors nic = { 42 };
+#if __cplusplus <= 201402L
+// expected-error@-2 {{no matching constructor}}
+#endif
+
+struct NonAggrBase {
+  NonAggrBase(int) {}
+};
+struct HasNonAggrBase : NonAggrBase {}; // expected-note 0+ {{candidate}}
+HasNonAggrBase hnab = {42};
+#if __cplusplus <= 201402L
+// expected-error@-2 {{no matching constructor}}
+#endif

test/CXX/dcl.decl/dcl.init/p7.cpp

 // RUN: %clang_cc1 -std=c++11 -verify %s
 
 struct NotAggregateBase {};
 
 struct A : NotAggregateBase {
 private:
   A() = default; // expected-note {{here}}
 };
 A a = {}; // expected-error {{calling a private constructor}}
 
 struct B : NotAggregateBase {
   explicit B() = default; // expected-note {{here}}
 };
 B b = {}; // expected-error {{chosen constructor is explicit}}
+B b2{};
+B b3;

test/CXX/drs/dr15xx.cpp

#if __cplusplus >= 201103L
     void(Wrap<nullptr_t>() < Wrap<int*>());
     void(Wrap<nullptr_t>() > Wrap<int*>());
     void(Wrap<nullptr_t>() <= Wrap<int*>());
     void(Wrap<nullptr_t>() >= Wrap<int*>());
 #endif
   }
 }
 
+namespace dr1518 { // dr1518: 4.0
+#if __cplusplus >= 201103L
+struct Z0 { // expected-note 0+ {{candidate}}
+  explicit Z0() = default; // expected-note 0+ {{here}}
+};
+struct Z { // expected-note 0+ {{candidate}}
+  explicit Z(); // expected-note 0+ {{here}}
+  explicit Z(int);
+  explicit Z(int, int); // expected-note 0+ {{here}}
+};
+template <class T> int Eat(T); // expected-note 0+ {{candidate}}
+Z0 a;
+Z0 b{};
+Z0 c = {}; // expected-error {{explicit in copy-initialization}}
+int i = Eat<Z0>({}); // expected-error {{no matching function for call to 'Eat'}}
+
+Z c2 = {}; // expected-error {{explicit in copy-initialization}}
+int i2 = Eat<Z>({}); // expected-error {{no matching function for call to 'Eat'}}
+Z a1 = 1; // expected-error {{no viable conversion}}
+Z a3 = Z(1);
+Z a2(1);
+Z *p = new Z(1);
+Z a4 = (Z)1;
+Z a5 = static_cast<Z>(1);
+Z a6 = {4, 3}; // expected-error {{explicit in copy-initialization}}
+
+struct UserProvidedBaseCtor { // expected-note 0+ {{candidate}}
+  UserProvidedBaseCtor() {}
+};
+struct DoesntInheritCtor : UserProvidedBaseCtor { // expected-note 0+ {{candidate}}
+  int x;
+};
+DoesntInheritCtor I{{}, 42};
+#if __cplusplus <= 201402L
+// expected-error@-2 {{no matching constructor}}
+#endif
+
+struct BaseCtor { BaseCtor() = default; }; // expected-note 0+ {{candidate}}
+struct InheritsCtor : BaseCtor { // expected-note 1+ {{candidate}}
+  using BaseCtor::BaseCtor;      // expected-note 2 {{inherited here}}
+  int x;
+};
+InheritsCtor II = {{}, 42}; // expected-error {{no matching constructor}}
+
+#endif                      // __cplusplus >= 201103L
+}
+
 namespace dr1550 { // dr1550: yes
   int f(bool b, int n) {
     return (b ? (throw 0) : n) + (b ? n : (throw 0));
   }
 }
 
 namespace dr1560 { // dr1560: 3.5
   void f(bool b, int n) {