[clang][C++20] P0960R3: Improves the diagnostic message

[0x59616e]

Summary

This patch depends on D129531, which tries to improve the diagnostic message regarding P0960R3.

[0x59616e]

There're some test cases haven't be resolved. They're tested with multiple language option (C++98, C++17, C++20...) and due to the materialization of P0960R3, C++20 gives a different diagnostic message to the pre-C++20 ones. I don't know how to add predicate that can satisfy all of them at the same time, since I'm unfamiliar with the testing framework of clang.

Or maybe this is unacceptable ?

clang/include/clang/Sema/Initialization.h

enum FailureKind {
     FK_PlaceholderType,
 
     /// Trying to take the address of a function that doesn't support
     /// having its address taken.
     FK_AddressOfUnaddressableFunction,
 
     /// List-copy-initialization chose an explicit constructor.
     FK_ExplicitConstructor,
+
+    /// Parenthesized list initialization failed at some point.
+    FK_ParenthesizedListInitFailed,
   };
 
 private:
   /// The reason why initialization failed.
   FailureKind Failure;
 
   /// The failed result of overload resolution.
   OverloadingResult FailedOverloadResult;

clang/lib/Sema/SemaInit.cpp

bool InitializationSequence::isAmbiguous() const {
   case FK_Incomplete:
   case FK_ArrayTypeMismatch:
   case FK_NonConstantArrayInit:
   case FK_ListInitializationFailed:
   case FK_VariableLengthArrayHasInitializer:
   case FK_PlaceholderType:
   case FK_ExplicitConstructor:
   case FK_AddressOfUnaddressableFunction:
+  case FK_ParenthesizedListInitFailed:
     return false;
 
   case FK_ReferenceInitOverloadFailed:
   case FK_UserConversionOverloadFailed:
   case FK_ConstructorOverloadFailed:
   case FK_ListConstructorOverloadFailed:
     return FailedOverloadResult == OR_Ambiguous;
   }
for (InitializedEntity SubEntity : Range) {
         return true;
 
       Expr *E = Args[Index++];
       InitializationKind SubKind = InitializationKind::CreateForInit(
           E->getExprLoc(), /*isDirectInit*/ false, E);
       InitializationSequence Seq(S, SubEntity, SubKind, E);
 
       if (Seq.Failed()) {
-        // FIXME: We should have diagnosed which member intialization fails. But
-        // that would break some existing tests, and I'm not sure whether it's
-        // acceptable.
+        if (!VerifyOnly)
+          Seq.Diagnose(S, SubEntity, SubKind, E);
         return false;
       }
       if (!VerifyOnly) {
         ExprResult ER = Seq.Perform(S, SubEntity, SubKind, E);
         InitExprs.push_back(ER.get());
       }
     }
     return true;
if (!InitHelper(BaseRange))
       return false;
 
     if (!InitHelper(FieldRange))
       return false;
 
     ResultType = Entity.getType();
   }
 
-  if (Index != Args.size())
-    // FIXME: We should have also diagnosed that the initializers
-    // exceeds the limit. But, as I mentioned earlier, I don't
-    // want to break existing tests unless an agreement has
-    // been forged among the community.
+  if (Index != Args.size()) {
+    if (!VerifyOnly) {
+      QualType T = Entity.getType();
+      // FIXME: Union type unsupported.
+      int InitKind = T->isArrayType() ? 0 : 4;
+      S.Diag(Kind.getLocation(), diag::err_excess_initializers)
+          << InitKind << Args[Index]->getSourceRange();
+    }
     return false;
+  }
 
   if (!VerifyOnly && Result)
     *Result = CXXParenListInitExpr::Create(S.getASTContext(), InitExprs,
                                            ResultType, Kind.getLocation());
   return true;
 }
 
 /// Attempt initialization by constructor (C++ [dcl.init]), which
static void TryConstructorInitialization(Sema &S,
   //      Note: By contrast with direct-list-initialization, narrowing
   //      conversions (9.4.4) are permitted, designators are not permitted, a
   //      temporary object bound to a reference does not have its lifetime
   //      extended (6.7.7), and there is no brace elision.
   if (Result == OR_No_Viable_Function && S.getLangOpts().CPlusPlus20 &&
       DestRecordDecl->isAggregate()) {
     bool IsValid = VerifyOrPerformParenthesizedListInit(S, Entity, Kind, Args,
                                                         /*VerifyOnly=*/true);
-    if (IsValid) {
+    if (IsValid)
       Sequence.AddParenthesizedListInitStep(DestType);
-      return;
-    }
-  }
+    else
+      Sequence.SetFailed(
+          InitializationSequence::FK_ParenthesizedListInitFailed);
+
 
   if (Result) {
     Sequence.SetOverloadFailure(
         IsListInit ? InitializationSequence::FK_ListConstructorOverloadFailed
                    : InitializationSequence::FK_ConstructorOverloadFailed,
         Result);
 
     if (Result != OR_Deleted)
if (const ArrayType *DestAT = Context.getAsArrayType(DestType)) {
     // Note: as a GNU C++ extension, we allow list-initialization of a
     // class member of array type from a parenthesized initializer list.
     else if (S.getLangOpts().CPlusPlus &&
              Entity.getKind() == InitializedEntity::EK_Member &&
              Initializer && isa<InitListExpr>(Initializer)) {
       TryListInitialization(S, Entity, Kind, cast<InitListExpr>(Initializer),
                             *this, TreatUnavailableAsInvalid);
       AddParenthesizedArrayInitStep(DestType);
-    } else if (S.getLangOpts().CPlusPlus20 && !TopLevelOfInitList &&
-               VerifyOrPerformParenthesizedListInit(S, Entity, Kind, Args,
-                                                    /*VerifyOnly=*/true))
+    } else if (S.getLangOpts().CPlusPlus20 && !TopLevelOfInitList)
+      if (VerifyOrPerformParenthesizedListInit(S, Entity, Kind, Args,
         AddParenthesizedListInitStep(DestType);
+      else
+        SetFailed(FK_ParenthesizedListInitFailed);
     else if (DestAT->getElementType()->isCharType())
       SetFailed(FK_ArrayNeedsInitListOrStringLiteral);
     else if (IsWideCharCompatible(DestAT->getElementType(), Context))
       SetFailed(FK_ArrayNeedsInitListOrWideStringLiteral);
     else
       SetFailed(FK_ArrayNeedsInitList);
 
     return;
OverloadingResult Ovl
       = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best);
     (void)Ovl;
     assert(Ovl == OR_Success && "Inconsistent overload resolution");
     CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
     S.Diag(CtorDecl->getLocation(),
            diag::note_explicit_ctor_deduction_guide_here) << false;
     break;
   }
+
+  case FK_ParenthesizedListInitFailed: {
+    VerifyOrPerformParenthesizedListInit(S, Entity, Kind, Args,
+                                         /*VerifyOnly=*/false);
+  }
   }
 
   PrintInitLocationNote(S, Entity);
   return true;
 }
 
 void InitializationSequence::dump(raw_ostream &OS) const {
   switch (SequenceKind) {
case FailedSequence: {
 
     case FK_ListConstructorOverloadFailed:
       OS << "list constructor overloading failed";
       break;
 
     case FK_ExplicitConstructor:
       OS << "list copy initialization chose explicit constructor";
       break;
+
+    case FK_ParenthesizedListInitFailed:
+      OS << "parenthesized list initialization for aggregate failed";
+      break;
     }
     OS << '\n';
     return;
   }
 
   case DependentSequence:
     OS << "Dependent sequence\n";
     return;

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

 // RUN: %clang_cc1 -std=c++2a -verify %s -fcxx-exceptions
 
 namespace std {
-  struct strong_ordering { // expected-note 6{{candidate}}
+  struct strong_ordering {
     int n;
     constexpr operator int() const { return n; }
     static const strong_ordering less, equal, greater;
   };
   constexpr strong_ordering strong_ordering::less{-1},
       strong_ordering::equal{0}, strong_ordering::greater{1};
 
   struct weak_ordering {
use(
       Cmp<D2>() <=> Cmp<D2>(), // expected-error {{deleted}}
       Cmp<E>() <=> Cmp<E>(), // expected-error {{deleted}}
       Cmp<F>() <=> Cmp<F>(), // expected-error {{deleted}}
       // FIXME: The following three errors are not very good.
       // expected-error@#cmp {{value of type 'void' is not contextually convertible to 'bool'}}
       Cmp<G1>() <=> Cmp<G1>(), // expected-note-re {{in defaulted three-way comparison operator for '{{.*}}Cmp<{{.*}}G1>' first required here}}j
       // 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'}}
+      // expected-error@#cmp {{static_cast from 'void' to 'std::strong_ordering' is not allowed}}
       Cmp<H>() <=> Cmp<H>(), // expected-note-re {{in defaulted three-way comparison operator for '{{.*}}Cmp<{{.*}}H>' first required here}}j
       0
     );
   }
 
   // expected-note@#arr {{deleted comparison function for member 'arr'}}
   // expected-note@#arr {{no viable three-way comparison function for member 'arr'}}
   // expected-note@#arr {{three-way comparison cannot be synthesized because there is no viable function for '<' comparison}}
use(
       CmpArray<D2>() <=> CmpArray<D2>(), // expected-error {{deleted}}
       CmpArray<E>() <=> CmpArray<E>(), // expected-error {{deleted}}
       CmpArray<F>() <=> CmpArray<F>(), // expected-error {{deleted}}
       // FIXME: The following three errors are not very good.
       // expected-error@#cmparray {{value of type 'void' is not contextually convertible to 'bool'}}
       CmpArray<G1>() <=> CmpArray<G1>(), // expected-note-re {{in defaulted three-way comparison operator for '{{.*}}CmpArray<{{.*}}G1>' first required here}}j
       // 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'}}
+      // expected-error@#cmparray {{static_cast from 'void' to 'std::strong_ordering' is not allowed}}
       CmpArray<H>() <=> CmpArray<H>(), // expected-note-re {{in defaulted three-way comparison operator for '{{.*}}CmpArray<{{.*}}H>' first required here}}j
       0
     );
   }
 }
 
 namespace Access {
   class A {

clang/test/CXX/drs/dr2xx.cpp

namespace dr218 { // dr218: yes
 
   struct C {
     int f;
     void test1(A::S as) { f(as); } // expected-error {{called object type 'int'}}
     void test2(A::S as) { void f(); f(as); } // expected-error {{too many arguments}} expected-note {{}}
     void test3(A::S as) { using A::f; f(as); } // ok
     void test4(A::S as) { using B::f; f(as); } // ok
     void test5(A::S as) { int f; f(as); } // expected-error {{called object type 'int'}}
+    // FIXME: The error message given by C++20 is different to pre-C++20.
+    // How to resolve this ?
     void test6(A::S as) { struct f {}; (void) f(as); } // expected-error {{no matching conversion}} expected-note +{{}}
   };
 
   namespace D {
     struct S {};
     struct X { void operator()(S); } f;
   }
   void testD(D::S ds) { f(ds); } // expected-error {{undeclared identifier}}

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

 // RUN:  %clang_cc1 -std=c++2a -verify %s
 
 struct S2 {};
-// expected-note@-1 {{candidate constructor (the implicit copy constructor) not viable: no known conversion from 'S1<int>' to 'const S2' for 1st argument}}
-// expected-note@-2 {{candidate constructor (the implicit move constructor) not viable: no known conversion from 'S1<int>' to 'S2' for 1st argument}}
-// expected-note@-3 {{candidate constructor (the implicit default constructor) not viable: requires 0 arguments, but 1 was provided}}
 
 template<typename T>
 struct S1 {
   void foo() const requires true {}
   void foo() const requires false {}
   void bar() const requires false {}
   // expected-note@-1 {{because 'false' evaluated to false}}
   operator bool() const requires true { return true; }
   explicit operator bool() const requires false;
   explicit operator S2() const requires false;
-  // expected-note@-1 {{candidate function not viable: constraints not satisfied}}
-  // expected-note@-2 {{because 'false' evaluated to false}}
 };
 
 void foo() {
   S1<int>().foo();
   S1<int>().bar();
   // expected-error@-1 {{invalid reference to function 'bar': constraints not satisfied}}
   (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'}}
+  // expected-error@-1 {{static_cast from 'S1<int>' to 'S2' is not allowed}}
 }
 
 // Test that constraints are checked before implicit conversions are formed.
 
 template<typename T>
 struct invalid_template { using X = typename T::non_existant; };
 struct A {
   template<typename T, bool=invalid_template<T>::aadasas>

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

 template<typename ...Mixins>
 HasMixins<Mixins...>::HasMixins(): Mixins()... { }
 
 template<typename ...Mixins>
 HasMixins<Mixins...>::HasMixins(const HasMixins &other): Mixins(other)... { }
 
 template<typename ...Mixins>
 HasMixins<Mixins...>::HasMixins(int i): Mixins(i)... { }
+// FIXME: The error message given by C++20 is different to pre-C++20.
+// How to resolve this ?
 // expected-error@-1 {{no matching constructor for initialization of 'A'}}
 // expected-error@-2 {{no matching constructor for initialization of 'B'}}
 
 void test_has_mixins() {
   HasMixins<A, B> ab;
   HasMixins<A, B> ab2 = ab;
   HasMixins<A, B> ab3(17); // expected-note{{in instantiation of member function 'HasMixins<A, B>::HasMixins' requested here}}
 }

clang/test/SemaCXX/P0960R3.cpp

 // RUN: %clang_cc1 -verify -std=c++20 %s -fsyntax-only
 
-struct A { // expected-note 3{{candidate constructor}}
+struct A { // expected-note 4{{candidate constructor}}
   char i;
   double j;
 };
 
-struct B { // expected-note 3{{candidate constructor}}
+struct B {
   A a;
   int b[20];
   int &&c; // expected-note {{reference member declared here}}
 };
 
-struct C { // expected-note 6{{candidate constructor}}
+struct C { // expected-note 2{{candidate constructor}}
   A a;
   int b[20];
 };
 
-struct D : public C, public A { // expected-note 6{{candidate constructor}}
+struct D : public C, public A {
   int a;
 };
 
 void foo() {
   A a1(2.0, 2, 11);
-  // expected-error@-1 {{no matching constructor for initialization}}
+  // expected-error@-1 {{excess elements in struct initializer}}
   A a2(2.1);
   // expected-warning@-1 {{implicit conversion from 'double' to 'char'}}
   A a3(-1.2, 9.8);
   // expected-warning@-1 {{implicit conversion from 'double' to 'char'}}
   A a4 = static_cast<A>(1.1);
   // expected-warning@-1 {{implicit conversion from 'double' to 'char'}}
   A a5 = (A)3.1;
   // expected-warning@-1 {{implicit conversion from 'double' to 'char'}}
   A a6 = A(8.7);
   // expected-warning@-1 {{implicit conversion from 'double' to 'char'}}
 
   B b1(1, {2, 3});
-  // expected-error@-1 {{no matching constructor for initialization}}
+  // expected-error@-1 {{no viable conversion from 'int' to 'A'}}
   B b2(A(1), {}, 1);
   // expected-error@-1 {{reference member 'c' binds to a temporary object whose lifetime would be shorter than the lifetime of the constructed object}}
 
   C c1(A(1), 1, 2, 3, 4);
-  // expected-error@-1 {{no matching constructor for initialization}}
+  // expected-error@-1 {{excess elements in struct initializer}}
   D d1(1);
-  // expected-error@-1 {{no matching constructor for initialization}}
+  // expected-error@-1 {{no viable conversion from 'int' to 'C'}}
   D d2(C(1));
-  // expected-error@-1 {{no matching conversion for functional-style cast from 'int' to 'C'}}
+  // expected-error@-1 {{functional-style cast from 'int' to 'C' is not allowed}}
   D d3(C(A(1)), 1);
-  // expected-error@-1 {{no matching constructor for initialization}}
+  // expected-error@-1 {{no viable conversion from 'int' to 'A'}}
 
   int arr1[](0, 1, 2, A(1));
-  // expected-error@-1 {{array initializer must be an initializer list}}
+  // expected-error@-1 {{no viable conversion from 'A' to 'int'}}
   int arr2[2](0, 1, 2);
-  // expected-error@-1 {{array initializer must be an initializer list}}
+  // expected-error@-1 {{excess elements in array initializer}}
 }

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

 // expected-note@-1+ {{candidate constructor}}
   explicit(1 << a)
 // expected-note@-1 {{negative shift count -1}}
 // expected-error@-2 {{explicit specifier argument is not a constant expression}}
   A(int);
 };
 
 A<-1> a(0);
+// FIXME: The error message given by C++20 is different to pre-C++20.
+// How to resolve this ?
 // expected-error@-1 {{no matching constructor}}
 // expected-note@-2 {{in instantiation of template class}}
 
 template<int a>
 struct B {
   explicit(b)
   // expected-error@-1 {{use of undeclared identifier}}
   B(int);