[clang][C++20] p0960 Allow initializing aggregates from a parenthesized list of values

[ecatmur]

Summary

• p0960 Allow initializing aggregates from a parenthesized list of values
• p1975 Fixing the wording of parenthesized aggregate-initialization

Follows gcc for the most part, except for coroutines (cf. https://cpplang.slack.com/archives/CBTFTLR9R/p1657730176797929)

Fixes https://github.com/llvm/llvm-project/issues/53627

In competition with https://reviews.llvm.org/D129531, sorry - I got frustrated waiting.

[shafik]

Hello Ed, thank you for picking up this work.

I liked the approach in the first PR, did you consider reaching out to the author is asking if it was ok to commandeer the work to allow it to move forward?

[ecatmur]

In D134231#3803380, @shafik wrote:

Hello Ed, thank you for picking up this work.

I liked the approach in the first PR, did you consider reaching out to the author is asking if it was ok to commandeer the work to allow it to move forward?

Hi Shafik,

No, I didn't consider that - sorry! I felt that having done this work independently it was worth presenting separately. Sorry if I wasted anyone's time and happy to see that Alan has picked up the other PR. I'll close this as superseded if I can work out how.

[aaron.ballman]

In D134231#3910882, @ecatmur wrote:

In D134231#3803380, @shafik wrote:

Hello Ed, thank you for picking up this work.

I liked the approach in the first PR, did you consider reaching out to the author is asking if it was ok to commandeer the work to allow it to move forward?

Hi Shafik,

No, I didn't consider that - sorry! I felt that having done this work independently it was worth presenting separately. Sorry if I wasted anyone's time and happy to see that Alan has picked up the other PR.

No worries at all, I think it's great that we had a few independent approaches to this, so definitely not a waste of time IMO.

I'll close this as superseded if I can work out how.

If you go to the "Add Action" dropdown, there should be an "Abandon Revision" option (or something along those lines).

clang/include/clang/Basic/DiagnosticSemaKinds.td

     "function (the implicit copy assignment operator)|"
     "function (the implicit move assignment operator)|"
     "function (the implicit 'operator==' for this 'operator<=>)'|"
-    "inherited constructor}0%select{| template| %2}1">;
+    "inherited constructor|"
+    "aggregate parenthesis initializer}0%select{| template| %2}1">;
 
 def note_ovl_candidate : Note<
     "candidate %sub{select_ovl_candidate_kind}0,1,3"

clang/include/clang/Sema/Initialization.h

     SK_OCLSamplerInit,
 
     /// Initialize an opaque OpenCL type (event_t, queue_t, etc.) with zero
-    SK_OCLZeroOpaqueType
+    SK_OCLZeroOpaqueType,
+
+    /// Array initialization from a parenthesized list: int a[](1, 2, 3) (C++20)
+    SK_ArrayParenthesizedInit,
+
+    /// Initialize an aggregate from a parenthesized list (C++20)
+    SK_AggregateParenthesizedInit,
   };
 
   /// A single step in the initialization sequence.

 
     /// List-copy-initialization chose an explicit constructor.
     FK_ExplicitConstructor,
+
+    /// Array parenthesized initialization failed.
+    FK_ArrayParenthesizedInitFailed,
   };
 
 private:

                 const InitializationKind &Kind,
                 ArrayRef<Expr *> Args);
 
+  /// Add diagnostics for failure in aggregate parenthesis initialization,
+  /// shared between constructor overload and cast diagnostics.
+  void DiagnoseFailedAggregateParenthesizedInitialization(
+      Sema &S, const InitializedEntity &Entity, ArrayRef<Expr *> Args) const;
+
   /// Determine the kind of initialization sequence computed.
   enum SequenceKind getKind() const { return SequenceKind; }
 

   /// from a zero constant.
   void AddOCLZeroOpaqueTypeStep(QualType T);
 
+  /// Add an array parenthesized initialization step.
+  void AddArrayParenthesizedInitStep(QualType T);
+
+  /// Add an aggregate parenthesized initialization step.
+  void AddAggregateParenthesizedInitStep(QualType T);
+
   /// Add steps to unwrap a initializer list for a reference around a
   /// single element and rewrap it at the end.
   void RewrapReferenceInitList(QualType T, InitListExpr *Syntactic);

clang/lib/Frontend/InitPreprocessor.cpp

 
   // C++20 features.
   if (LangOpts.CPlusPlus20) {
-    // Builder.defineMacro("__cpp_aggregate_paren_init", "201902L");
+    Builder.defineMacro("__cpp_aggregate_paren_init", "201902L");
 
     // P0848 is implemented, but we're still waiting for other concepts
     // issues to be addressed before bumping __cpp_concepts up to 202002L.

clang/lib/Sema/SemaCast.cpp

                                        << src->getSourceRange()),
       S, howManyCandidates, src);
 
+  if (S.getLangOpts().CPlusPlus20 && destType->isAggregateType())
+    sequence.DiagnoseFailedAggregateParenthesizedInitialization(S, entity, src);
+
   return true;
 }
 

clang/lib/Sema/SemaCoroutine.cpp

     // assembling an argument list  q_1 ... q_n . If a viable constructor is
     // found ([over.match.viable]), then promise-constructor-arguments is ( q_1
     // , ...,  q_n ), otherwise promise-constructor-arguments is empty.
-    if (InitSeq) {
+    if (InitSeq && InitSeq.isConstructorInitialization()) {
       ExprResult Result = InitSeq.Perform(*this, Entity, Kind, CtorArgExprs);
       if (Result.isInvalid()) {
         VD->setInvalidDecl();

clang/lib/Sema/SemaExprCXX.cpp

                      Initializer);
 }
 
-static bool isLegalArrayNewInitializer(CXXNewExpr::InitializationStyle Style,
+static bool isLegalArrayNewInitializer(Sema &S,
+                                       CXXNewExpr::InitializationStyle Style,
                                        Expr *Init) {
   if (!Init)
     return true;
   if (ParenListExpr *PLE = dyn_cast<ParenListExpr>(Init))
-    return PLE->getNumExprs() == 0;
+    return S.getLangOpts().CPlusPlus20 ||
+           llvm::all_of(PLE->exprs(),
+                        [](Expr *E) { return isa<PackExpansionExpr>(E); });
   if (isa<ImplicitValueInitExpr>(Init))
     return true;
   else if (CXXConstructExpr *CCE = dyn_cast<CXXConstructExpr>(Init))
     return !CCE->isListInitialization() &&
-           CCE->getConstructor()->isDefaultConstructor();
+           (S.getLangOpts().CPlusPlus20 ||
+            CCE->getConstructor()->isDefaultConstructor() ||
+            llvm::all_of(CCE->arguments(),
+                         [](Expr *E) { return isa<PackExpansionExpr>(E); }));
   else if (Style == CXXNewExpr::ListInit) {
     assert(isa<InitListExpr>(Init) &&
            "Shouldn't create list CXXConstructExprs for arrays.");

   // Array 'new' can't have any initializers except empty parentheses.
   // Initializer lists are also allowed, in C++11. Rely on the parser for the
   // dialect distinction.
-  if (ArraySize && !isLegalArrayNewInitializer(initStyle, Initializer)) {
+  if (ArraySize && !isLegalArrayNewInitializer(*this, initStyle, Initializer)) {
     SourceRange InitRange(Exprs.front()->getBeginLoc(),
                           Exprs.back()->getEndLoc());
     Diag(StartLoc, diag::err_new_array_init_args) << InitRange;

 
     // Make sure the first argument is not incomplete nor a function type.
     QualType T = Args[0]->getType();
-    if (T->isIncompleteType() || T->isFunctionType())
+    if ((T->isIncompleteType() || T->isFunctionType()) &&
+        !(S.getLangOpts().CPlusPlus20 && T->isIncompleteArrayType() &&
+          Args.size() > 1))
       return false;
 
     // Make sure the first argument is not an abstract type.

clang/lib/Sema/SemaInit.cpp

   case SK_StdInitializerListConstructorCall:
   case SK_OCLSamplerInit:
   case SK_OCLZeroOpaqueType:
+  case SK_ArrayParenthesizedInit:
+  case SK_AggregateParenthesizedInit:
     break;
 
   case SK_ConversionSequence:

   case FK_PlaceholderType:
   case FK_ExplicitConstructor:
   case FK_AddressOfUnaddressableFunction:
+  case FK_ArrayParenthesizedInitFailed:
     return false;
 
   case FK_ReferenceInitOverloadFailed:

   Steps.push_back(S);
 }
 
+void InitializationSequence::AddArrayParenthesizedInitStep(QualType T) {
+  Step S;
+  S.Kind = SK_ArrayParenthesizedInit;
+  S.Type = T;
+  Steps.push_back(S);
+}
+
+void InitializationSequence::AddAggregateParenthesizedInitStep(QualType T) {
+  Step S;
+  S.Kind = SK_AggregateParenthesizedInit;
+  S.Type = T;
+  Steps.push_back(S);
+}
+
 void InitializationSequence::RewrapReferenceInitList(QualType T,
                                                      InitListExpr *Syntactic) {
   assert(Syntactic->getNumInits() == 1 &&

   return true;
 }
 
+static void TryValueInitialization(Sema &S, const InitializedEntity &Entity,
+                                   const InitializationKind &Kind,
+                                   InitializationSequence &Sequence,
+                                   InitListExpr *InitList = nullptr);
+
+enum AggregateParenInitKind {
+  APIK_Verify,
+  APIK_Diagnose,
+  APIK_Perform,
+};
+
+static ExprResult TryArrayParenthesizedInitialization(
+    Sema &S, const InitializedEntity &Entity, llvm::ArrayRef<Expr *> Args,
+    QualType DestType, QualType *ResultType, AggregateParenInitKind APIK) {
+  InitListExpr *Result = nullptr;
+  bool Invalid = false;
+  if (APIK == APIK_Perform)
+    Result = new (S.Context) InitListExpr(
+        S.Context, Args.front()->getBeginLoc(), None, Args.back()->getEndLoc());
+  InitializedEntity IE =
+      InitializedEntity::InitializeElement(S.Context, 0, Entity);
+
+  llvm::Optional<unsigned> NumElements;
+  if (DestType->isIncompleteArrayType()) {
+    NumElements = Args.size();
+    DestType = S.Context.getConstantArrayType(
+        S.Context.getAsArrayType(DestType)->getElementType(),
+        llvm::APInt(32, *NumElements), nullptr, ArrayType::Normal, 0);
+    if (ResultType) {
+      if ((*ResultType)->isRValueReferenceType())
+        *ResultType = S.Context.getRValueReferenceType(DestType);
+      else if ((*ResultType)->isLValueReferenceType())
+        *ResultType = S.Context.getLValueReferenceType(
+            DestType,
+            (*ResultType)->castAs<LValueReferenceType>()->isSpelledAsLValue());
+      else
+        *ResultType = DestType;
+    }
+  } else if (auto CAT = S.Context.getAsConstantArrayType(DestType)) {
+    NumElements = CAT->getSize().getZExtValue();
+  }
+
+  if (NumElements && Args.size() > *NumElements) {
+    // Diagnose excess initializers: int a[3](1, 2, 3, /*^*/ 4);
+    if (APIK == APIK_Verify)
+      return ExprError();
+    S.Diag(Args[*NumElements]->getBeginLoc(), diag::err_excess_initializers)
+        << /* initKind = */ 0 /* array */
+        << Args[*NumElements]->getSourceRange();
+    Invalid = true;
+  } else if (!NumElements || Args.size() < *NumElements) {
+    // Ensure that we can value-initialize trailing elements.
+    SourceLocation Loc = Args.back()->getEndLoc().getLocWithOffset(1);
+    auto Kind = InitializationKind::CreateValue(Loc, Loc, Loc, true);
+    MultiExprArg SubInit;
+    IE.setElementIndex(Args.size());
+    InitializationSequence ValueSequence(S, IE, Kind, SubInit);
+    TryValueInitialization(S, IE, Kind, ValueSequence);
+    if (ValueSequence.Failed()) {
+      if (APIK == APIK_Verify)
+        return ExprError();
+      ValueSequence.Diagnose(S, IE, Kind, SubInit);
+      S.Diag(Loc, diag::note_in_omitted_aggregate_initializer)
+          << 0 << Args.size();
+      Invalid = true;
+    } else if (Result) {
+      auto ER = ValueSequence.Perform(S, IE, Kind, SubInit);
+      Result->setArrayFiller(ER.get());
+    }
+  }
+
+  if (Result) {
+    Result->setType(DestType);
+    Result->resizeInits(S.Context, Args.size());
+  }
+  for (unsigned Index = 0; Index != Args.size(); ++Index) {
+    IE.setElementIndex(Index);
+    Expr *Init = Args[Index];
+    if (APIK == APIK_Verify) {
+      if (!S.CanPerformCopyInitialization(IE, Init))
+        return ExprError();
+    } else {
+      auto InitResult =
+          S.PerformCopyInitialization(IE, Init->getBeginLoc(), Init);
+      if (InitResult.isInvalid())
+        Invalid = true;
+      else if (Result)
+        Result->setInit(Index, InitResult.getAs<Expr>());
+    }
+  }
+
+  return Invalid ? ExprError() : Result;
+}
+
+static ExprResult TryAggregateParenthesizedInitialization(
+    Sema &S, const InitializedEntity &Entity, llvm::ArrayRef<Expr *> Args,
+    QualType DestType, AggregateParenInitKind APIK) {
+  InitListExpr *Result = nullptr;
+  bool Invalid = false;
+  if (APIK == APIK_Perform) {
+    Result = new (S.Context) InitListExpr(
+        S.Context, Args.front()->getBeginLoc(), None, Args.back()->getEndLoc());
+    Result->setType(DestType);
+  }
+
+  // Otherwise, if no constructor is viable, the destination type is an
+  // aggregate class, and the initializer is a parenthesized expression-list,
+  // the object is initialized as follows.
+  RecordDecl *RD = DestType->castAs<RecordType>()->getDecl();
+  auto Bases =
+      CXXRecordDecl::base_class_range(CXXRecordDecl::base_class_iterator(),
+                                      CXXRecordDecl::base_class_iterator());
+  if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
+    Bases = CXXRD->bases();
+
+  unsigned Index = 0;
+  if (Result)
+    Result->resizeInits(S.Context, size(Bases));
+  for (auto &Base : Bases) {
+    Expr *Init = Index < Args.size() ? Args[Index] : nullptr;
+    InitializedEntity BaseEntity =
+        InitializedEntity::InitializeBase(S.Context, &Base, false, &Entity);
+    if (Init) {
+      // The element e_i is copy-initialized with x_i for 1 ≤ i ≤ k.
+      if (Result) {
+        auto InitResult =
+            S.PerformCopyInitialization(BaseEntity, Init->getBeginLoc(), Init);
+        if (InitResult.isInvalid())
+          Invalid = true;
+        else
+          Result->setInit(Index, InitResult.getAs<Expr>());
+      } else if (!S.CanPerformCopyInitialization(BaseEntity, Init)) {
+        if (APIK == APIK_Verify)
+          return ExprError();
+        S.Diag(Init->getBeginLoc(), diag::note_ovl_candidate_bad_conv)
+            << 11 << 0 << "" << Init->getType() << BaseEntity.getType() << 0
+            << Index + 1 << 0 << Init->getSourceRange();
+        S.Diag(Base.getBeginLoc(), diag::note_base_class_specified_here)
+            << BaseEntity.getType() << Base.getSourceRange();
+        Invalid = true;
+      }
+    } else {
+      // Bases don't have NSDMIs, so always value-init.
+      SourceLocation Loc = Args.back()->getEndLoc().getLocWithOffset(1);
+      auto Kind = InitializationKind::CreateValue(Loc, Loc, Loc, true);
+      MultiExprArg SubInit;
+      InitializationSequence ValueSequence(S, BaseEntity, Kind, SubInit);
+      TryValueInitialization(S, BaseEntity, Kind, ValueSequence);
+      if (ValueSequence.Failed()) {
+        if (APIK == APIK_Verify)
+          return ExprError();
+        S.Diag(Args.back()->getEndLoc(), diag::note_ovl_candidate_arity)
+            << 11 << 0 << "" << 0 << Index + 1 << Args.size();
+        S.Diag(Base.getBeginLoc(), diag::note_base_class_specified_here)
+            << BaseEntity.getType() << Base.getSourceRange();
+        Invalid = true;
+      } else if (Result) {
+        auto ER = ValueSequence.Perform(S, BaseEntity, Kind, SubInit);
+        Result->setInit(Index, ER.get());
+      }
+    }
+    ++Index;
+  }
+
+  for (auto *Field : RD->fields()) {
+    Expr *Init = Index < Args.size() ? Args[Index] : nullptr;
+    if (Result)
+      Result->resizeInits(S.Context, Index + 1);
+    InitializedEntity MemberEntity =
+        InitializedEntity::InitializeMember(Field, &Entity);
+    if (Init) {
+      // The element e_i is copy-initialized with x_i for 1 ≤ i ≤ k.
+      if (Result) {
+        auto InitResult = S.PerformCopyInitialization(
+            MemberEntity, Init->getBeginLoc(), Init);
+        if (InitResult.isInvalid())
+          Invalid = true;
+        else
+          Result->setInit(Index, InitResult.getAs<Expr>());
+      } else if (!S.CanPerformCopyInitialization(MemberEntity, Init)) {
+        if (APIK == APIK_Verify)
+          return ExprError();
+        S.Diag(Init->getBeginLoc(), diag::note_ovl_candidate_bad_conv)
+            << 11 << 0 << "" << Init->getType() << MemberEntity.getType() << 0
+            << Index + 1 << 0 << Init->getSourceRange();
+        S.Diag(Field->getBeginLoc(), diag::note_member_declared_here)
+            << Field->getName() << Field->getSourceRange();
+        Invalid = true;
+      }
+    } else if (Field->hasInClassInitializer()) {
+      // The remaining elements are initialized with their default member
+      // initializers, if any,
+      SourceLocation Loc = Args.back()->getEndLoc();
+      ExprResult DIE;
+      if (Result) {
+        DIE = S.BuildCXXDefaultInitExpr(Loc, Field);
+      } else {
+        bool WasInvalid = Field->isInvalidDecl();
+        Sema::TentativeAnalysisScope DisableDiag(S);
+        DIE = S.BuildCXXDefaultInitExpr(Loc, Field);
+        Field->setInvalidDecl(WasInvalid); // back out side effects
+      }
+      if (DIE.isInvalid()) {
+        if (APIK == APIK_Verify)
+          return ExprError();
+        S.Diag(Args.back()->getEndLoc(), diag::note_ovl_candidate_arity)
+            << 11 << 0 << "" << 0 << Index + 1 << Args.size();
+        S.Diag(Field->getBeginLoc(),
+               diag::note_init_with_default_member_initalizer)
+            << Field->getName() << Field->getSourceRange();
+        Invalid = true;
+      } else if (Result)
+        Result->setInit(Index, DIE.get());
+    } else {
+      // and otherwise are value-initialized.
+      SourceLocation Loc = Args.back()->getEndLoc().getLocWithOffset(1);
+      auto Kind = InitializationKind::CreateValue(Loc, Loc, Loc, true);
+      MultiExprArg SubInit;
+      InitializationSequence ValueSequence(S, MemberEntity, Kind, SubInit);
+      TryValueInitialization(S, MemberEntity, Kind, ValueSequence);
+      if (ValueSequence.Failed()) {
+        if (APIK == APIK_Verify)
+          return ExprError();
+        S.Diag(Args.back()->getEndLoc(), diag::note_ovl_candidate_arity)
+            << 11 << 0 << "" << 0 << Index + 1 << Args.size();
+        S.Diag(Field->getBeginLoc(),
+               diag::note_in_omitted_aggregate_initializer)
+            << 1 << Field << Field->getSourceRange();
+        Invalid = true;
+      } else if (Result) {
+        auto ER = ValueSequence.Perform(S, MemberEntity, Kind, SubInit);
+        Result->setInit(Index, ER.get());
+      }
+    }
+    ++Index;
+  }
+
+  if (Index < Args.size()) {
+    if (APIK == APIK_Verify)
+      return ExprError();
+    S.Diag(Args[Index]->getBeginLoc(), diag::note_ovl_candidate_arity)
+        << 11 << 0 << "" << 1 << Index << Args.size()
+        << Args[Index]->getSourceRange();
+    Invalid = true;
+  }
+
+  return Invalid ? ExprError() : Result;
+}
+
 /// Determine if the constructor has the signature of a copy or move
 /// constructor for the type T of the class in which it was found. That is,
 /// determine if its first parameter is of type T or reference to (possibly

                                         /*OnlyListConstructors=*/false,
                                         IsListInit);
   }
+
+  // C++20 [dcl.init.general]p16.6.2.2:
+  // Otherwise, if no constructor is viable, the destination type is an
+  // aggregate class, and the initializer is a parenthesized expression-list,
+  // the object is initialized as follows. [...]
+  if (S.getLangOpts().CPlusPlus20 && Result == OR_No_Viable_Function &&
+      DestType->isAggregateType() &&
+      Kind.getKind() == InitializationKind::IK_Direct &&
+      !TryAggregateParenthesizedInitialization(S, Entity, Args, DestType,
+                                               APIK_Verify)
+           .isInvalid()) {
+    Sequence.AddAggregateParenthesizedInitStep(DestType);
+    return;
+  }
+
   if (Result) {
     Sequence.SetOverloadFailure(
         IsListInit ? InitializationSequence::FK_ListConstructorOverloadFailed

                                            Qualifiers T2Quals,
                                            InitializationSequence &Sequence);
 
-static void TryValueInitialization(Sema &S,
-                                   const InitializedEntity &Entity,
-                                   const InitializationKind &Kind,
-                                   InitializationSequence &Sequence,
-                                   InitListExpr *InitList = nullptr);
-
 /// Attempt list initialization of a reference.
 static void TryReferenceListInitialization(Sema &S,
                                            const InitializedEntity &Entity,

   //       char16_t, an array of char32_t, or an array of wchar_t, and the
   //       initializer is a string literal, see 8.5.2.
   //     - Otherwise, if the destination type is an array, the program is
-  //       ill-formed.
+  //       ill-formed [until C++20].
   if (const ArrayType *DestAT = Context.getAsArrayType(DestType)) {
     if (Initializer && isa<VariableArrayType>(DestAT)) {
       SetFailed(FK_VariableLengthArrayHasInitializer);

       return;
     }
 
+    // C++20 permits array parenthesized initialization.
+    if (S.getLangOpts().CPlusPlus20 &&
+        Kind.getKind() == InitializationKind::IK_Direct) {
+      if (!TryArrayParenthesizedInitialization(S, Entity, Args, DestType,
+                                               nullptr, APIK_Verify)
+               .isInvalid()) {
+        AddArrayParenthesizedInitStep(DestType);
+        return;
+      } else if (Entity.getKind() == InitializedEntity::EK_Member &&
+                 Initializer && isa<InitListExpr>(Initializer)) {
+        ; // fall through to GNU C++ extension below
+      } else {
+        SetFailed(FK_ArrayParenthesizedInitFailed);
+        return;
+      }
+    }
+
     // Note: as an GNU C extension, we allow initialization of an
     // array from a compound literal that creates an array of the same
     // type, so long as the initializer has no side effects.

   case SK_ConstructorInitializationFromList:
   case SK_StdInitializerListConstructorCall:
   case SK_ZeroInitialization:
+  case SK_ArrayParenthesizedInit:
+  case SK_AggregateParenthesizedInit:
     break;
   }
 

                                     CurInit.get()->getValueKind());
       break;
     }
+    case SK_ArrayParenthesizedInit: {
+      CurInit = TryArrayParenthesizedInitialization(S, Entity, Args, Step->Type,
+                                                    ResultType, APIK_Perform);
+      break;
+    }
+    case SK_AggregateParenthesizedInit: {
+      CurInit = TryAggregateParenthesizedInitialization(
+          S, Entity, Args, Step->Type, APIK_Perform);
+      break;
+    }
     }
   }
 

                      diag::note_previous_decl)
                 << S.Context.getTagDeclType(Record->getDecl());
           }
+
           break;
         }
 

                 S.PDiag(diag::err_ovl_no_viable_function_in_init)
                     << DestType << ArgsRange),
             S, OCD_AllCandidates, Args);
+
+        if (S.getLangOpts().CPlusPlus20 && DestType->isAggregateType() &&
+            Kind.getKind() == InitializationKind::IK_Direct)
+          DiagnoseFailedAggregateParenthesizedInitialization(S, Entity, Args);
         break;
 
       case OR_Deleted: {

            diag::note_explicit_ctor_deduction_guide_here) << false;
     break;
   }
+
+  case FK_ArrayParenthesizedInitFailed: {
+    TryArrayParenthesizedInitialization(S, Entity, Args, DestType, nullptr,
+                                        APIK_Diagnose);
+    break;
+  }
   }
 
   PrintInitLocationNote(S, Entity);
   return true;
 }
 
+void InitializationSequence::DiagnoseFailedAggregateParenthesizedInitialization(
+    Sema &S, const InitializedEntity &Entity, ArrayRef<Expr *> Args) const {
+  TryAggregateParenthesizedInitialization(S, Entity, Args, Entity.getType(),
+                                          APIK_Diagnose);
+}
+
 void InitializationSequence::dump(raw_ostream &OS) const {
   switch (SequenceKind) {
   case FailedSequence: {

     case FK_ExplicitConstructor:
       OS << "list copy initialization chose explicit constructor";
       break;
+
+    case FK_ArrayParenthesizedInitFailed:
+      OS << "array parenthesized initialization failed";
+      break;
     }
     OS << '\n';
     return;

     case SK_OCLZeroOpaqueType:
       OS << "OpenCL opaque type from zero";
       break;
+
+    case SK_ArrayParenthesizedInit:
+      OS << "array initialization from parenthesized list";
+      break;
+
+    case SK_AggregateParenthesizedInit:
+      OS << "aggregate initialization from parenthesized list";
+      break;
     }
 
     OS << " [" << S->Type << ']';

clang/test/CXX/class/class.compare/class.spaceship/p1.cpp

 namespace std {
   struct strong_ordering { // expected-note 6{{candidate}}
     int n;
+#if __cpp_aggregate_paren_init >= 201902
+    // expected-note@-2 2{{member n declared here}}
+#endif
     constexpr operator int() const { return n; }
     static const strong_ordering less, equal, greater;
   };

       // expected-error@#cmp {{value of type 'void' is not contextually convertible to 'bool'}}
       Cmp<G2>() <=> Cmp<G2>(), // expected-note-re {{in defaulted three-way comparison operator for '{{.*}}Cmp<{{.*}}G2>' first required here}}j
       // expected-error@#cmp {{no matching conversion for static_cast from 'void' to 'std::strong_ordering'}}
+#if __cpp_aggregate_paren_init >= 201902
+      // expected-note@#cmp {{candidate aggregate parenthesis initializer not viable}}
+#endif
       Cmp<H>() <=> Cmp<H>(), // expected-note-re {{in defaulted three-way comparison operator for '{{.*}}Cmp<{{.*}}H>' first required here}}j
       0
     );

       // expected-error@#cmparray {{value of type 'void' is not contextually convertible to 'bool'}}
       CmpArray<G2>() <=> CmpArray<G2>(), // expected-note-re {{in defaulted three-way comparison operator for '{{.*}}CmpArray<{{.*}}G2>' first required here}}j
       // expected-error@#cmparray {{no matching conversion for static_cast from 'void' to 'std::strong_ordering'}}
+#if __cpp_aggregate_paren_init >= 201902
+      // expected-note@#cmparray {{candidate aggregate parenthesis initializer not viable}}
+#endif
       CmpArray<H>() <=> CmpArray<H>(), // expected-note-re {{in defaulted three-way comparison operator for '{{.*}}CmpArray<{{.*}}H>' first required here}}j
       0
     );

clang/test/CXX/over/over.match/over.match.viable/p3.cpp

   (void) static_cast<bool>(S1<int>());
   (void) static_cast<S2>(S1<int>());
   // expected-error@-1 {{no matching conversion for static_cast from 'S1<int>' to 'S2'}}
+#if __cpp_aggregate_paren_init >= 201902
+  // expected-note@-3 {{candidate aggregate parenthesis initializer not viable}}
+#endif
 }
 
 // Test that constraints are checked before implicit conversions are formed.

clang/test/CXX/temp/temp.decls/temp.variadic/p4.cpp

 HasMixins<Mixins...>::HasMixins(int i): Mixins(i)... { }
 // expected-error@-1 {{no matching constructor for initialization of 'A'}}
 // expected-error@-2 {{no matching constructor for initialization of 'B'}}
+#if __cpp_aggregate_paren_init >= 201902
+// expected-note@-4 2{{candidate aggregate parenthesis initializer not viable}}
+#endif
 
 void test_has_mixins() {
   HasMixins<A, B> ab;

clang/test/Lexer/cxx-features.cpp

 
 // --- C++20 features ---
 
-#if check(aggregate_paren_init, 0, 0, 0, 0, 0, 0)
-// FIXME: 201902 in C++20
+#if check(aggregate_paren_init, 0, 0, 0, 0, 201902, 201902)
 #error "wrong value for __cpp_aggregate_paren_init"
 #endif
 

clang/test/SemaCXX/cxx20-p0960-aggregate-paren-init.cpp

+// RUN: %clang_cc1 -std=c++20 -verify %s
+// RUN: %clang_cc1 -std=c++17 -verify %s
+
+// p0960 Allow initializing aggregates from a parenthesized list of values
+// p1975 Fixing the wording of parenthesized aggregate-initialization
+// class.temporary/6
+// dcl.init/17.5, 17.6
+
+#if __cplusplus >= 202002 && __cpp_aggregate_paren_init < 201902
+#   error "should set __cpp_aggregate_paren_init in C++20 mode"
+#endif
+
+// definitions for std::move
+namespace std { template <class T> T &&move(T &); }
+// definitions for std::is_constructible
+namespace std {
+template<class T, class... A>
+inline constexpr bool is_constructible_v = __is_constructible(T, A...);
+}
+
+int i1[](1, 2, 3);
+#if __cpp_aggregate_paren_init < 201902
+// expected-error@-2{{array initializer must be an initializer list}}
+#else
+static_assert(sizeof i1 == sizeof(int[3]));
+#endif
+
+int i2[2](1, 2, 3);
+#if __cpp_aggregate_paren_init < 201902
+// expected-error@-2{{array initializer must be an initializer list}}
+#else
+// expected-error@-4{{excess elements in array initializer}}
+#endif
+
+int i3[4](1, 2, 3);
+#if __cpp_aggregate_paren_init < 201902
+// expected-error@-2{{array initializer must be an initializer list}}
+#endif
+
+int i4[](1);
+#if __cpp_aggregate_paren_init < 201902
+// expected-error@-2{{array initializer must be an initializer list}}
+#else
+static_assert(sizeof i4 == sizeof(int[1]));
+#endif
+
+int *p1 = new int[](1, 2, 3);
+#if __cpp_aggregate_paren_init < 201902
+// expected-error@-2{{array 'new' cannot have initialization arguments}}
+#endif
+
+int *p2[2] = new int[2](1, 2, 3);
+#if __cpp_aggregate_paren_init < 201902
+// expected-error@-2{{array 'new' cannot have initialization arguments}}
+#else
+// expected-error@-4{{excess elements in array initializer}}
+#endif
+
+int *p3 = new int[4](1, 2, 3);
+#if __cpp_aggregate_paren_init < 201902
+// expected-error@-2{{array 'new' cannot have initialization arguments}}
+#endif
+
+struct E {
+#if __cpp_aggregate_paren_init >= 201902
+// expected-note@-2 +{{candidate constructor (the implicit copy constructor) not viable}}
+// expected-note@-3 +{{candidate constructor (the implicit move constructor) not viable}}
+#endif
+  E(int);
+#if __cpp_aggregate_paren_init >= 201902
+// expected-note@-2 +{{candidate constructor not viable: requires 1 argument, but 0 were provided}}
+#endif
+};
+
+E e1[3](1, 2, 3);
+#if __cpp_aggregate_paren_init < 201902
+// expected-error@-2{{array initializer must be an initializer list}}
+#endif
+
+E e2[4](1, 2, 3);
+#if __cpp_aggregate_paren_init < 201902
+// expected-error@-2{{array initializer must be an initializer list}}
+#else
+// expected-error@-4{{no matching constructor for initialization of 'E'}}
+// expected-note@-5{{in implicit initialization of array element 3 with omitted initializer}}
+#endif
+
+struct A {
+#if __cpp_aggregate_paren_init < 201902
+// expected-note@-2 +{{candidate constructor (the implicit copy constructor) not viable}}
+// expected-note@-3 +{{candidate constructor (the implicit move constructor) not viable}}
+// expected-note@-4 +{{candidate constructor (the implicit default constructor) not viable}}
+#endif
+  int a;
+  int&& r;
+};
+
+int f();
+int n = 10;
+
+A a1{1, f()};               // OK, lifetime is extended
+A a2(1, f());               // well-formed, but dangling reference
+#if __cpp_aggregate_paren_init < 201902
+// expected-error@-2{{no matching constructor for initialization of 'A'}}
+#endif
+A a3{1.0, 1};               // error: narrowing conversion
+// expected-error@-1{{type 'double' cannot be narrowed to 'int' in initializer list}}
+// expected-note@-2{{insert an explicit cast to silence this issue}}
+A a4(1.0, 1);               // well-formed, but dangling reference
+#if __cpp_aggregate_paren_init < 201902
+// expected-error@-2{{no matching constructor for initialization of 'A'}}
+#endif
+A a5(1.0, std::move(n));    // OK
+#if __cpp_aggregate_paren_init < 201902
+// expected-error@-2{{no matching constructor for initialization of 'A'}}
+#endif
+
+struct B {
+// expected-note@-1 +{{candidate constructor (the implicit copy constructor) not viable}}
+// expected-note@-2 +{{candidate constructor (the implicit move constructor) not viable}}
+// expected-note@-3 +{{candidate constructor (the implicit default constructor) not viable}}
+  int a;
+  int b;
+};
+
+B b1(n);
+#if __cpp_aggregate_paren_init < 201902
+// expected-error@-2{{no matching constructor for initialization of 'B'}}
+#endif
+B b2(1.0);
+#if __cpp_aggregate_paren_init < 201902
+// expected-error@-2{{no matching constructor for initialization of 'B'}}
+#endif
+B b3(1, 2, 3); // expected-error{{no matching constructor for initialization of 'B'}}
+#if __cpp_aggregate_paren_init >= 201902
+// expected-note@-2{{candidate aggregate parenthesis initializer not viable}}
+#endif
+
+struct C {
+// expected-note@-1 +{{candidate constructor (the implicit copy constructor) not viable}}
+// expected-note@-2 +{{candidate constructor (the implicit move constructor) not viable}}
+// expected-note@-3 +{{candidate constructor (the implicit default constructor) not viable}}
+  int i;
+  E e;
+#if __cpp_aggregate_paren_init >= 201902
+// expected-note@-2{{in implicit initialization of field 'e' with omitted initializer}}
+#endif
+  E f = 10;
+};
+C c1(1); // expected-error{{no matching constructor for initialization of 'C'}}
+#if __cpp_aggregate_paren_init >= 201902
+// expected-note@-2{{candidate aggregate parenthesis initializer not viable}}
+#endif
+C c2(1, 2);
+#if __cpp_aggregate_paren_init < 201902
+// expected-error@-2{{no matching constructor for initialization of 'C'}}
+#endif
+
+struct D : B, E {
+// expected-note@-1 +{{candidate constructor (the implicit copy constructor) not viable}}
+// expected-note@-2 +{{candidate constructor (the implicit move constructor) not viable}}
+// expected-note@-3 +{{candidate constructor (the implicit default constructor) not viable}}
+#if __cpp_aggregate_paren_init >= 201902
+// expected-note@-5{{base class 'E' specified here}}
+#endif
+  int i;
+};
+D d1(B(1)); // expected-error{{no matching constructor for initialization of 'D'}}
+#if __cpp_aggregate_paren_init < 201902
+// expected-error@-2{{no matching conversion for functional-style cast from 'int' to 'B'}}
+#else
+// expected-note@-4{{candidate aggregate parenthesis initializer not viable}}
+#endif
+D d2(B(), 10, 1);
+#if __cpp_aggregate_paren_init < 201902
+// expected-error@-2{{no matching constructor for initialization of 'D'}}
+#endif
+
+template<class T>
+struct F {
+// expected-note@-1 +{{candidate constructor (the implicit copy constructor) not viable}}
+// expected-note@-2 +{{candidate constructor (the implicit move constructor) not viable}}
+// expected-note@-3 +{{candidate constructor (the implicit default constructor) not viable}}
+// expected-note@-4 {{in instantiation of default member initializer 'F<int>::b' requested here}}
+  T a;
+  T b = "str";
+// expected-error@-1 {{cannot initialize a member subobject of type 'int' with an lvalue of type 'const char[4]'}}
+#if __cpp_aggregate_paren_init >= 201902
+// expected-note@-3 {{initializing field b with default member initializer}}
+#endif
+};
+F<char const*> f1;
+F<char const*> f2("ok");
+#if __cpp_aggregate_paren_init < 201902
+// expected-error@-2 {{no matching constructor for initialization of 'F<const char *>'}}
+#endif
+F<char const*> f3("ok", "ok");
+#if __cpp_aggregate_paren_init < 201902
+// expected-error@-2 {{no matching constructor for initialization of 'F<const char *>'}}
+#endif
+F<int> f4; // expected-note {{in evaluation of exception specification for 'F<int>::F' needed here}}
+F<int> f5(10); // expected-error {{no matching constructor for initialization of 'F<int>'}}
+#if __cpp_aggregate_paren_init >= 201902
+// expected-note@-2{{candidate aggregate parenthesis initializer not viable}}
+#endif
+F<int> f6(10, 10);
+#if __cpp_aggregate_paren_init < 201902
+// expected-error@-2 {{no matching constructor for initialization of 'F<int>'}}
+#endif
+
+#ifndef __cpp_aggregate_paren_init
+#   define __cpp_aggregate_paren_init 0
+#endif
+
+static_assert(std::is_constructible_v<B>);
+static_assert(std::is_constructible_v<B, int> == (__cpp_aggregate_paren_init >= 201902));
+static_assert(std::is_constructible_v<B, long> == (__cpp_aggregate_paren_init >= 201902));
+static_assert(std::is_constructible_v<B, float> == (__cpp_aggregate_paren_init >= 201902));
+static_assert(std::is_constructible_v<B, int, int> == (__cpp_aggregate_paren_init >= 201902));
+static_assert(not std::is_constructible_v<B, int, int, int>);
+static_assert(not std::is_constructible_v<B, char*>);
+static_assert(not std::is_constructible_v<B, int, char*>);
+static_assert(not std::is_constructible_v<C, int>);
+static_assert(std::is_constructible_v<C, int, int> == (__cpp_aggregate_paren_init >= 201902));
+static_assert(std::is_constructible_v<C, int, int, int> == (__cpp_aggregate_paren_init >= 201902));
+static_assert(not std::is_constructible_v<D, B>);
+static_assert(std::is_constructible_v<D, B, int, int> == (__cpp_aggregate_paren_init >= 201902));
+static_assert(std::is_constructible_v<F<char const*>, char const*> == (__cpp_aggregate_paren_init >= 201902));
+static_assert(not std::is_constructible_v<F<int>, int>);
+static_assert(std::is_constructible_v<F<int>, int, int> == (__cpp_aggregate_paren_init >= 201902));
+
+static_assert(std::is_constructible_v<int[2]>);
+static_assert(std::is_constructible_v<int[2], int> == (__cpp_aggregate_paren_init >= 201902));
+static_assert(std::is_constructible_v<int[2], int, int> == (__cpp_aggregate_paren_init >= 201902));
+static_assert(not std::is_constructible_v<int[2], int, int, int>);
+static_assert(not std::is_constructible_v<int[]>);
+static_assert(std::is_constructible_v<int[], int, int> == (__cpp_aggregate_paren_init >= 201902));
+static_assert(not std::is_constructible_v<E[2], int>);
+static_assert(std::is_constructible_v<int[2], int, int> == (__cpp_aggregate_paren_init >= 201902));

clang/test/SemaCXX/cxx2a-explicit-bool.cpp

 A<-1> a(0);
 // expected-error@-1 {{no matching constructor}}
 // expected-note@-2 {{in instantiation of template class}}
+#if __cpp_aggregate_paren_init >= 201902
+// expected-note@-4{{candidate aggregate parenthesis initializer not viable}}
+#endif
 
 template<int a>
 struct B {