[Sema] Add support for reporting multiple errors during initialization

[nullptr.cpp]

Summary

During the initialization process, more than one error may be encountered, but
Clang reports only one of them. This patch makes Clang report all errors.

Depends on D93962

[nullptr.cpp]

Update

[nullptr.cpp]

Separate out D93962

[• Quuxplusone]

clang/test/SemaCXX/diagnostic-initialization.cpp

7 ↗

(On Diff #314214)

Looking at other places like clang/test/CXX/dcl.decl/dcl.init/dcl.init.list/p3.cpp, I think you don't need quite so much code here. However, also, I'm amazed that people are cutting-and-pasting class initializer_list between test cases; shouldn't it just be in a support header somewhere? (My second sentence is likely out of scope for this PR, I know.)
Anyway, my next comment shows that you don't need initializer_list at all, so both parts of this comment are moot.

43 ↗

(On Diff #314214)

https://godbolt.org/z/aMa4e6 (showing the old behavior, and also showing that you don't need class initializer_list to trigger it)

IIUC, the changed behavior here is that old-Clang complained only that the chosen ctor was deleted; new-Clang complains that the chosen ctor is deleted and that the chosen ctor is explicit?
IMHO this is not actually an improvement, at least not in this particular case. However, it's not significantly worse, and also it brings Clang (back) into line with GCC and ICC in terms of outputting multiple complaints about the same problem, so I wouldn't say that this patch is wrong...
Still, could you find an example where this patch clearly improves Clang's behavior?

clang/include/clang/Sema/Initialization.h

enum FailureKind {
     FK_AddressOfUnaddressableFunction,
 
     /// List-copy-initialization chose an explicit constructor.
     FK_ExplicitConstructor,
   };
 
 private:
   /// The reason why initialization failed.
-  FailureKind Failure;
+  SmallVector<FailureKind> Failures;
 
   /// The failed result of overload resolution.
   OverloadingResult FailedOverloadResult;
 
   /// The candidate set created when initialization failed.
   OverloadCandidateSet FailedCandidateSet;
 
   /// The incomplete type that caused a failure.
public:
 
   /// 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);
 
   /// Note that this initialization sequence failed.
   void SetFailed(FailureKind Failure) {
     SequenceKind = FailedSequence;
-    this->Failure = Failure;
+    this->Failures.push_back(Failure);
     assert((Failure != FK_Incomplete || !FailedIncompleteType.isNull()) &&
            "Incomplete type failure requires a type!");
   }
 
   /// Note that this initialization sequence failed due to failed
   /// overload resolution.
   void SetOverloadFailure(FailureKind Failure, OverloadingResult Result);
 
public:
   /// Note that this initialization sequence failed due to an
   /// incomplete type.
   void setIncompleteTypeFailure(QualType IncompleteType) {
     FailedIncompleteType = IncompleteType;
     SetFailed(FK_Incomplete);
   }
 
   /// Determine why initialization failed.
-  FailureKind getFailureKind() const {
+  SmallVector<FailureKind> getFailureKind() const {
     assert(Failed() && "Not an initialization failure!");
-    return Failure;
+    return Failures;
   }
 
   /// Dump a representation of this initialization sequence to
   /// the given stream, for debugging purposes.
   void dump(raw_ostream &OS) const;
 
   /// Dump a representation of this initialization sequence to
   /// standard error, for debugging purposes.
   void dump() const;
 };
 
 } // namespace clang
 
 #endif // LLVM_CLANG_SEMA_INITIALIZATION_H

clang/lib/Sema/SemaCast.cpp

case CT_Functional:
     break;
   }
 
   QualType srcType = src->getType();
   if (!destType->isRecordType() && !srcType->isRecordType())
     return false;
 
   InitializedEntity entity = InitializedEntity::InitializeTemporary(destType);
-  InitializationKind initKind
-    = (CT == CT_CStyle)? InitializationKind::CreateCStyleCast(range.getBegin(),
-                                                      range, listInitialization)
-    : (CT == CT_Functional)? InitializationKind::CreateFunctionalCast(range,
-                                                             listInitialization)
+  InitializationKind initKind =
+      (CT == CT_CStyle) ? InitializationKind::CreateCStyleCast(
+                              range.getBegin(), range, listInitialization)
+      : (CT == CT_Functional)
+          ? InitializationKind::CreateFunctionalCast(range, listInitialization)
           : InitializationKind::CreateCast(/*type range?*/ range);
   InitializationSequence sequence(S, entity, initKind, src);
 
   assert(sequence.Failed() && "initialization succeeded on second try?");
-  switch (sequence.getFailureKind()) {
-  default: return false;
+  for (auto Failure : sequence.getFailureKind()) {
+    switch (Failure) {
+    default:
+      return false;
 
     case InitializationSequence::FK_ConstructorOverloadFailed:
     case InitializationSequence::FK_UserConversionOverloadFailed:
       break;
     }
+  }
 
   OverloadCandidateSet &candidates = sequence.getFailedCandidateSet();
 
   unsigned msg = 0;
   OverloadCandidateDisplayKind howManyCandidates = OCD_AllCandidates;
 
   switch (sequence.getFailedOverloadResult()) {
   case OR_Success: llvm_unreachable("successful failed overload");

clang/lib/Sema/SemaInit.cpp

ExprResult InitListChecker::PerformEmptyInit(SourceLocation Loc,
   }
 
   InitializationSequence InitSeq(SemaRef, Entity, Kind, SubInit);
   // libstdc++4.6 marks the vector default constructor as explicit in
   // _GLIBCXX_DEBUG mode, so recover using the C++03 logic in that case.
   // stlport does so too. Look for std::__debug for libstdc++, and for
   // std:: for stlport.  This is effectively a compiler-side implementation of
   // LWG2193.
-  if (!InitSeq && EmptyInitList && InitSeq.getFailureKind() ==
-          InitializationSequence::FK_ExplicitConstructor) {
+  if (!InitSeq && EmptyInitList) {
+    auto Failures = InitSeq.getFailureKind();
+    if (Failures.end() !=
+        std::find(Failures.begin(), Failures.end(),
+                  InitializationSequence::FK_ExplicitConstructor)) {
       OverloadCandidateSet::iterator Best;
-    OverloadingResult O =
-        InitSeq.getFailedCandidateSet()
-            .BestViableFunction(SemaRef, Kind.getLocation(), Best);
+      OverloadingResult O = InitSeq.getFailedCandidateSet().BestViableFunction(
+          SemaRef, Kind.getLocation(), Best);
       (void)O;
       assert(O == OR_Success && "Inconsistent overload resolution");
       CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
       CXXRecordDecl *R = CtorDecl->getParent();
 
-    if (CtorDecl->getMinRequiredArguments() == 0 &&
-        CtorDecl->isExplicit() && R->getDeclName() &&
+      if (CtorDecl->getMinRequiredArguments() == 0 && CtorDecl->isExplicit() &&
+          R->getDeclName() &&
           SemaRef.SourceMgr.isInSystemHeader(CtorDecl->getLocation())) {
         bool IsInStd = false;
         for (NamespaceDecl *ND = dyn_cast<NamespaceDecl>(R->getDeclContext());
              ND && !IsInStd; ND = dyn_cast<NamespaceDecl>(ND->getParent())) {
           if (SemaRef.getStdNamespace()->InEnclosingNamespaceSetOf(ND))
             IsInStd = true;
         }
 
-      if (IsInStd && llvm::StringSwitch<bool>(R->getName())
+        if (IsInStd &&
+            llvm::StringSwitch<bool>(R->getName())
                 .Cases("basic_string", "deque", "forward_list", true)
                 .Cases("list", "map", "multimap", "multiset", true)
                 .Cases("priority_queue", "queue", "set", "stack", true)
                 .Cases("unordered_map", "unordered_set", "vector", true)
                 .Default(false)) {
           InitSeq.InitializeFrom(
               SemaRef, Entity,
               InitializationKind::CreateValue(Loc, Loc, Loc, true),
               MultiExprArg(), /*TopLevelOfInitList=*/false,
               TreatUnavailableAsInvalid);
           // Emit a warning for this.  System header warnings aren't shown
           // by default, but people working on system headers should see it.
           if (!VerifyOnly) {
             SemaRef.Diag(CtorDecl->getLocation(),
                          diag::warn_invalid_initializer_from_system_header);
             if (Entity.getKind() == InitializedEntity::EK_Member)
               SemaRef.Diag(Entity.getDecl()->getLocation(),
                            diag::note_used_in_initialization_here);
             else if (Entity.getKind() == InitializedEntity::EK_ArrayElement)
               SemaRef.Diag(Loc, diag::note_used_in_initialization_here);
           }
         }
       }
     }
+  }
   if (!InitSeq) {
     if (!VerifyOnly) {
       InitSeq.Diagnose(SemaRef, Entity, Kind, SubInit);
       if (Entity.getKind() == InitializedEntity::EK_Member)
         SemaRef.Diag(Entity.getDecl()->getLocation(),
                      diag::note_in_omitted_aggregate_initializer)
           << /*field*/1 << Entity.getDecl();
       else if (Entity.getKind() == InitializedEntity::EK_ArrayElement) {
bool InitializationSequence::isDirectReferenceBinding() const {
   }
   return false;
 }
 
 bool InitializationSequence::isAmbiguous() const {
   if (!Failed())
     return false;
 
-  switch (getFailureKind()) {
+  for (auto Failure : getFailureKind()) {
+    switch (Failure) {
     case FK_TooManyInitsForReference:
     case FK_ParenthesizedListInitForReference:
     case FK_ArrayNeedsInitList:
     case FK_ArrayNeedsInitListOrStringLiteral:
     case FK_ArrayNeedsInitListOrWideStringLiteral:
     case FK_NarrowStringIntoWideCharArray:
     case FK_WideStringIntoCharArray:
     case FK_IncompatWideStringIntoWideChar:
     case FK_PlainStringIntoUTF8Char:
     case FK_UTF8StringIntoPlainChar:
     case FK_AddressOfOverloadFailed: // FIXME: Could do better
     case FK_NonConstLValueReferenceBindingToTemporary:
     case FK_NonConstLValueReferenceBindingToBitfield:
     case FK_NonConstLValueReferenceBindingToVectorElement:
     case FK_NonConstLValueReferenceBindingToMatrixElement:
     case FK_NonConstLValueReferenceBindingToUnrelated:
     case FK_RValueReferenceBindingToLValue:
     case FK_ReferenceAddrspaceMismatchTemporary:
     case FK_ReferenceInitDropsQualifiers:
     case FK_ReferenceInitFailed:
     case FK_ConversionFailed:
     case FK_ConversionFromPropertyFailed:
     case FK_TooManyInitsForScalar:
     case FK_ParenthesizedListInitForScalar:
     case FK_ReferenceBindingToInitList:
     case FK_InitListBadDestinationType:
     case FK_DefaultInitOfConst:
     case FK_Incomplete:
     case FK_ArrayTypeMismatch:
     case FK_NonConstantArrayInit:
     case FK_ListInitializationFailed:
     case FK_VariableLengthArrayHasInitializer:
     case FK_PlaceholderType:
     case FK_ExplicitConstructor:
     case FK_AddressOfUnaddressableFunction:
       return false;
 
     case FK_ReferenceInitOverloadFailed:
     case FK_UserConversionOverloadFailed:
     case FK_ConstructorOverloadFailed:
     case FK_ListConstructorOverloadFailed:
       return FailedOverloadResult == OR_Ambiguous;
     }
+  }
 
   llvm_unreachable("Invalid EntityKind!");
 }
 
 bool InitializationSequence::isConstructorInitialization() const {
   return !Steps.empty() && Steps.back().Kind == SK_ConstructorInitialization;
 }
 
void InitializationSequence::RewrapReferenceInitList(QualType T,
   S.Type = T;
   S.WrappingSyntacticList = Syntactic;
   Steps.push_back(S);
 }
 
 void InitializationSequence::SetOverloadFailure(FailureKind Failure,
                                                 OverloadingResult Result) {
   setSequenceKind(FailedSequence);
-  this->Failure = Failure;
+  this->Failures.push_back(Failure);
   this->FailedOverloadResult = Result;
 }
 
 //===----------------------------------------------------------------------===//
 // Attempt initialization
 //===----------------------------------------------------------------------===//
 
 /// Tries to add a zero initializer. Returns true if that worked.
if (auto *CD = dyn_cast<CXXConversionDecl>(Best->Function)) {
     if (!S.Context.hasSameType(ConvType, DestType))
       Sequence.AddQualificationConversionStep(DestType, VK_RValue);
     if (IsListInit)
       Sequence.RewrapReferenceInitList(Entity.getType(), ILE);
     return;
   }
 
   CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
-  if (Result != OR_Deleted) { // TODO: Support for more than one failure.
-    // C++11 [dcl.init]p6:
-    //   If a program calls for the default initialization of an object
-    //   of a const-qualified type T, T shall be a class type with a
-    //   user-provided default constructor.
-    // C++ core issue 253 proposal:
-    //   If the implicit default constructor initializes all subobjects, no
-    //   initializer should be required.
-    // The 253 proposal is for example needed to process libstdc++ headers
-    // in 5.x.
-    if (Kind.getKind() == InitializationKind::IK_Default &&
-        Entity.getType().isConstQualified()) {
-      if (!CtorDecl->getParent()->allowConstDefaultInit()) {
-        if (!maybeRecoverWithZeroInitialization(S, Sequence, Entity))
-          Sequence.SetFailed(InitializationSequence::FK_DefaultInitOfConst);
-        return;
-      }
-    }
 
-    // C++11 [over.match.list]p1:
-    //   In copy-list-initialization, if an explicit constructor is chosen, the
-    //   initializer is ill-formed.
-    if (IsListInit && !Kind.AllowExplicit() && CtorDecl->isExplicit()) {
-      Sequence.SetFailed(InitializationSequence::FK_ExplicitConstructor);
-      return;
-    }
   }
 
+  if (Result == OR_Success && Sequence.Failed())
+    return;
+
   // [class.copy.elision]p3:
   // In some copy-initialization contexts, a two-stage overload resolution
   // is performed.
   // If the first overload resolution selects a deleted function, we also
   // need the initialization sequence to decide whether to perform the second
   // overload resolution.
   // For deleted functions in other contexts, there is no need to get the
   // initialization sequence.
if (RefRelationship == Sema::Ref_Incompatible && T2->isRecordType() &&
         (isLValueRef || InitCategory.isRValue())) {
       if (S.getLangOpts().CPlusPlus) {
         // Try conversion functions only for C++.
         ConvOvlResult = TryRefInitWithConversionFunction(
             S, Entity, Kind, Initializer, /*AllowRValues*/ isRValueRef,
             /*IsLValueRef*/ isLValueRef, Sequence);
         if (ConvOvlResult == OR_Success)
           return;
-        if (ConvOvlResult != OR_No_Viable_Function)
-          Sequence.SetOverloadFailure(
-              InitializationSequence::FK_ReferenceInitOverloadFailed,
-              ConvOvlResult);
       } else {
         ConvOvlResult = OR_No_Viable_Function;
       }
     }
   }
 
   //     - Otherwise, the reference shall be an lvalue reference to a
   //       non-volatile const type (i.e., cv1 shall be const), or the reference
bool InitializationSequence::Diagnose(Sema &S,
   // we need to factor it out.
   Expr *OnlyArg;
   if (Args.size() == 1) {
     auto *List = dyn_cast<InitListExpr>(Args[0]);
     if (List && List->getNumInits() == 1)
       OnlyArg = List->getInit(0);
     else
       OnlyArg = Args[0];
-  }
-  else
+  } else
     OnlyArg = nullptr;
 
   QualType DestType = Entity.getType();
+  for (auto Failure : Failures) {
     switch (Failure) {
     case FK_TooManyInitsForReference:
       // FIXME: Customize for the initialized entity?
       if (Args.empty()) {
-      // Dig out the reference subobject which is uninitialized and diagnose it.
-      // If this is value-initialization, this could be nested some way within
-      // the target type.
+        // Dig out the reference subobject which is uninitialized and diagnose
+        // it. If this is value-initialization, this could be nested some way
+        // within the target type.
         assert(Kind.getKind() == InitializationKind::IK_Value ||
                DestType->isReferenceType());
         bool Diagnosed =
             DiagnoseUninitializedReference(S, Kind.getLocation(), DestType);
-      assert(Diagnosed && "couldn't find uninitialized reference to diagnose");
+        assert(Diagnosed &&
+               "couldn't find uninitialized reference to diagnose");
         (void)Diagnosed;
-    } else  // FIXME: diagnostic below could be better!
+      } else // FIXME: diagnostic below could be better!
         S.Diag(Kind.getLocation(), diag::err_reference_has_multiple_inits)
-          << SourceRange(Args.front()->getBeginLoc(), Args.back()->getEndLoc());
+            << SourceRange(Args.front()->getBeginLoc(),
+                           Args.back()->getEndLoc());
       break;
     case FK_ParenthesizedListInitForReference:
       S.Diag(Kind.getLocation(), diag::err_list_init_in_parens)
           << 1 << Entity.getType() << Args[0]->getSourceRange();
       break;
 
     case FK_ArrayNeedsInitList:
       S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 0;
       break;
     case FK_ArrayNeedsInitListOrStringLiteral:
       S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 1;
       break;
     case FK_ArrayNeedsInitListOrWideStringLiteral:
       S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 2;
       break;
     case FK_NarrowStringIntoWideCharArray:
       S.Diag(Kind.getLocation(), diag::err_array_init_narrow_string_into_wchar);
       break;
     case FK_WideStringIntoCharArray:
       S.Diag(Kind.getLocation(), diag::err_array_init_wide_string_into_char);
       break;
     case FK_IncompatWideStringIntoWideChar:
       S.Diag(Kind.getLocation(),
              diag::err_array_init_incompat_wide_string_into_wchar);
       break;
     case FK_PlainStringIntoUTF8Char:
       S.Diag(Kind.getLocation(),
              diag::err_array_init_plain_string_into_char8_t);
       S.Diag(Args.front()->getBeginLoc(),
              diag::note_array_init_plain_string_into_char8_t)
           << FixItHint::CreateInsertion(Args.front()->getBeginLoc(), "u8");
       break;
     case FK_UTF8StringIntoPlainChar:
-    S.Diag(Kind.getLocation(),
-           diag::err_array_init_utf8_string_into_char)
+      S.Diag(Kind.getLocation(), diag::err_array_init_utf8_string_into_char)
           << S.getLangOpts().CPlusPlus20;
       break;
     case FK_ArrayTypeMismatch:
     case FK_NonConstantArrayInit:
       S.Diag(Kind.getLocation(),
              (Failure == FK_ArrayTypeMismatch
                   ? diag::err_array_init_different_type
                   : diag::err_array_init_non_constant_array))
-      << DestType.getNonReferenceType()
-      << OnlyArg->getType()
+          << DestType.getNonReferenceType() << OnlyArg->getType()
           << Args[0]->getSourceRange();
       break;
 
     case FK_VariableLengthArrayHasInitializer:
       S.Diag(Kind.getLocation(), diag::err_variable_object_no_init)
           << Args[0]->getSourceRange();
       break;
 
     case FK_AddressOfOverloadFailed: {
       DeclAccessPair Found;
-    S.ResolveAddressOfOverloadedFunction(OnlyArg,
-                                         DestType.getNonReferenceType(),
-                                         true,
-                                         Found);
+      S.ResolveAddressOfOverloadedFunction(
+          OnlyArg, DestType.getNonReferenceType(), true, Found);
       break;
     }
 
     case FK_AddressOfUnaddressableFunction: {
       auto *FD = cast<FunctionDecl>(cast<DeclRefExpr>(OnlyArg)->getDecl());
       S.checkAddressOfFunctionIsAvailable(FD, /*Complain=*/true,
                                           OnlyArg->getBeginLoc());
       break;
     }
 
     case FK_ReferenceInitOverloadFailed:
     case FK_UserConversionOverloadFailed:
       switch (FailedOverloadResult) {
       case OR_Ambiguous:
 
         FailedCandidateSet.NoteCandidates(
             PartialDiagnosticAt(
                 Kind.getLocation(),
                 Failure == FK_UserConversionOverloadFailed
                     ? (S.PDiag(diag::err_typecheck_ambiguous_condition)
                        << OnlyArg->getType() << DestType
                        << Args[0]->getSourceRange())
                     : (S.PDiag(diag::err_ref_init_ambiguous)
                        << DestType << OnlyArg->getType()
                        << Args[0]->getSourceRange())),
             S, OCD_AmbiguousCandidates, Args);
         break;
 
       case OR_No_Viable_Function: {
-      auto Cands = FailedCandidateSet.CompleteCandidates(S, OCD_AllCandidates, Args);
-      if (!S.RequireCompleteType(Kind.getLocation(),
-                                 DestType.getNonReferenceType(),
-                          diag::err_typecheck_nonviable_condition_incomplete,
-                               OnlyArg->getType(), Args[0]->getSourceRange()))
+        auto Cands =
+            FailedCandidateSet.CompleteCandidates(S, OCD_AllCandidates, Args);
+        if (!S.RequireCompleteType(
+                Kind.getLocation(), DestType.getNonReferenceType(),
           S.Diag(Kind.getLocation(), diag::err_typecheck_nonviable_condition)
               << (Entity.getKind() == InitializedEntity::EK_Result)
               << OnlyArg->getType() << Args[0]->getSourceRange()
               << DestType.getNonReferenceType();
 
         FailedCandidateSet.NoteCandidates(S, Args, Cands);
         break;
       }
       case OR_Deleted: {
         S.Diag(Kind.getLocation(), diag::err_typecheck_deleted_function)
             << OnlyArg->getType() << DestType.getNonReferenceType()
             << Args[0]->getSourceRange();
         OverloadCandidateSet::iterator Best;
-      OverloadingResult Ovl
-        = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best);
+        OverloadingResult Ovl =
+            FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best);
         if (Ovl == OR_Deleted) {
           S.NoteDeletedFunction(Best->Function);
         } else {
           llvm_unreachable("Inconsistent overload resolution?");
         }
         break;
       }
 
       case OR_Success:
         llvm_unreachable("Conversion did not fail!");
       }
       break;
 
     case FK_NonConstLValueReferenceBindingToTemporary:
       if (isa<InitListExpr>(Args[0])) {
-      S.Diag(Kind.getLocation(),
-             diag::err_lvalue_reference_bind_to_initlist)
+        S.Diag(Kind.getLocation(), diag::err_lvalue_reference_bind_to_initlist)
             << DestType.getNonReferenceType().isVolatileQualified()
-      << DestType.getNonReferenceType()
-      << Args[0]->getSourceRange();
+            << DestType.getNonReferenceType() << Args[0]->getSourceRange();
         break;
       }
       LLVM_FALLTHROUGH;
 
     case FK_NonConstLValueReferenceBindingToUnrelated:
       S.Diag(Kind.getLocation(),
              Failure == FK_NonConstLValueReferenceBindingToTemporary
                  ? diag::err_lvalue_reference_bind_to_temporary
                  : diag::err_lvalue_reference_bind_to_unrelated)
           << DestType.getNonReferenceType().isVolatileQualified()
-      << DestType.getNonReferenceType()
-      << OnlyArg->getType()
+          << DestType.getNonReferenceType() << OnlyArg->getType()
           << Args[0]->getSourceRange();
       break;
 
     case FK_NonConstLValueReferenceBindingToBitfield: {
       // We don't necessarily have an unambiguous source bit-field.
       FieldDecl *BitField = Args[0]->getSourceBitField();
       S.Diag(Kind.getLocation(), diag::err_reference_bind_to_bitfield)
           << DestType.isVolatileQualified()
           << (BitField ? BitField->getDeclName() : DeclarationName())
-      << (BitField != nullptr)
-      << Args[0]->getSourceRange();
+          << (BitField != nullptr) << Args[0]->getSourceRange();
       if (BitField)
         S.Diag(BitField->getLocation(), diag::note_bitfield_decl);
       break;
     }
 
     case FK_NonConstLValueReferenceBindingToVectorElement:
       S.Diag(Kind.getLocation(), diag::err_reference_bind_to_vector_element)
-      << DestType.isVolatileQualified()
-      << Args[0]->getSourceRange();
+          << DestType.isVolatileQualified() << Args[0]->getSourceRange();
       break;
 
     case FK_NonConstLValueReferenceBindingToMatrixElement:
       S.Diag(Kind.getLocation(), diag::err_reference_bind_to_matrix_element)
           << DestType.isVolatileQualified() << Args[0]->getSourceRange();
       break;
 
     case FK_RValueReferenceBindingToLValue:
       S.Diag(Kind.getLocation(), diag::err_lvalue_to_rvalue_ref)
           << DestType.getNonReferenceType() << OnlyArg->getType()
           << Args[0]->getSourceRange();
       break;
 
     case FK_ReferenceAddrspaceMismatchTemporary:
       S.Diag(Kind.getLocation(), diag::err_reference_bind_temporary_addrspace)
           << DestType << Args[0]->getSourceRange();
       break;
 
     case FK_ReferenceInitDropsQualifiers: {
       QualType SourceType = OnlyArg->getType();
       QualType NonRefType = DestType.getNonReferenceType();
       Qualifiers DroppedQualifiers =
           SourceType.getQualifiers() - NonRefType.getQualifiers();
 
       if (!NonRefType.getQualifiers().isAddressSpaceSupersetOf(
               SourceType.getQualifiers()))
         S.Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals)
             << NonRefType << SourceType << 1 /*addr space*/
             << Args[0]->getSourceRange();
       else if (DroppedQualifiers.hasQualifiers())
         S.Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals)
             << NonRefType << SourceType << 0 /*cv quals*/
             << Qualifiers::fromCVRMask(DroppedQualifiers.getCVRQualifiers())
-          << DroppedQualifiers.getCVRQualifiers() << Args[0]->getSourceRange();
+            << DroppedQualifiers.getCVRQualifiers()
+            << Args[0]->getSourceRange();
       else
         // FIXME: Consider decomposing the type and explaining which qualifiers
         // were dropped where, or on which level a 'const' is missing, etc.
         S.Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals)
             << NonRefType << SourceType << 2 /*incompatible quals*/
             << Args[0]->getSourceRange();
       break;
     }
 
     case FK_ReferenceInitFailed:
       S.Diag(Kind.getLocation(), diag::err_reference_bind_failed)
           << DestType.getNonReferenceType()
           << DestType.getNonReferenceType()->isIncompleteType()
-      << OnlyArg->isLValue()
-      << OnlyArg->getType()
+          << OnlyArg->isLValue() << OnlyArg->getType()
           << Args[0]->getSourceRange();
       emitBadConversionNotes(S, Entity, Args[0]);
       break;
 
     case FK_ConversionFailed: {
       QualType FromType = OnlyArg->getType();
       PartialDiagnostic PDiag = S.PDiag(diag::err_init_conversion_failed)
-      << (int)Entity.getKind()
-      << DestType
-      << OnlyArg->isLValue()
-      << FromType
+                                << (int)Entity.getKind() << DestType
+                                << OnlyArg->isLValue() << FromType
                                 << Args[0]->getSourceRange();
       S.HandleFunctionTypeMismatch(PDiag, FromType, DestType);
       S.Diag(Kind.getLocation(), PDiag);
       emitBadConversionNotes(S, Entity, Args[0]);
       break;
     }
 
     case FK_ConversionFromPropertyFailed:
       // No-op. This error has already been reported.
       break;
 
     case FK_TooManyInitsForScalar: {
       SourceRange R;
 
       auto *InitList = dyn_cast<InitListExpr>(Args[0]);
       if (InitList && InitList->getNumInits() >= 1) {
-      R = SourceRange(InitList->getInit(0)->getEndLoc(), InitList->getEndLoc());
+        R = SourceRange(InitList->getInit(0)->getEndLoc(),
+                        InitList->getEndLoc());
       } else {
         assert(Args.size() > 1 && "Expected multiple initializers!");
         R = SourceRange(Args.front()->getEndLoc(), Args.back()->getEndLoc());
       }
 
       R.setBegin(S.getLocForEndOfToken(R.getBegin()));
       if (Kind.isCStyleOrFunctionalCast())
-      S.Diag(Kind.getLocation(), diag::err_builtin_func_cast_more_than_one_arg)
+        S.Diag(Kind.getLocation(),
+               diag::err_builtin_func_cast_more_than_one_arg)
             << R;
       else
         S.Diag(Kind.getLocation(), diag::err_excess_initializers)
             << /*scalar=*/2 << R;
       break;
     }
 
     case FK_ParenthesizedListInitForScalar:
       S.Diag(Kind.getLocation(), diag::err_list_init_in_parens)
           << 0 << Entity.getType() << Args[0]->getSourceRange();
       break;
 
     case FK_ReferenceBindingToInitList:
       S.Diag(Kind.getLocation(), diag::err_reference_bind_init_list)
           << DestType.getNonReferenceType() << Args[0]->getSourceRange();
       break;
 
     case FK_InitListBadDestinationType:
       S.Diag(Kind.getLocation(), diag::err_init_list_bad_dest_type)
-      << (DestType->isRecordType()) << DestType << Args[0]->getSourceRange();
+          << (DestType->isRecordType()) << DestType
+          << Args[0]->getSourceRange();
       break;
 
     case FK_ListConstructorOverloadFailed:
     case FK_ConstructorOverloadFailed: {
       SourceRange ArgsRange;
       if (Args.size())
         ArgsRange =
             SourceRange(Args.front()->getBeginLoc(), Args.back()->getEndLoc());
 
       if (Failure == FK_ListConstructorOverloadFailed) {
         assert(Args.size() == 1 &&
                "List construction from other than 1 argument.");
         InitListExpr *InitList = cast<InitListExpr>(Args[0]);
         Args = MultiExprArg(InitList->getInits(), InitList->getNumInits());
       }
 
       // FIXME: Using "DestType" for the entity we're printing is probably
       // bad.
       switch (FailedOverloadResult) {
       case OR_Ambiguous:
         FailedCandidateSet.NoteCandidates(
             PartialDiagnosticAt(Kind.getLocation(),
                                 S.PDiag(diag::err_ovl_ambiguous_init)
                                     << DestType << ArgsRange),
             S, OCD_AmbiguousCandidates, Args);
         break;
 
       case OR_No_Viable_Function:
         if (Kind.getKind() == InitializationKind::IK_Default &&
             (Entity.getKind() == InitializedEntity::EK_Base ||
              Entity.getKind() == InitializedEntity::EK_Member) &&
             isa<CXXConstructorDecl>(S.CurContext)) {
           // This is implicit default initialization of a member or
           // base within a constructor. If no viable function was
           // found, notify the user that they need to explicitly
           // initialize this base/member.
-          CXXConstructorDecl *Constructor
-            = cast<CXXConstructorDecl>(S.CurContext);
+          CXXConstructorDecl *Constructor =
+              cast<CXXConstructorDecl>(S.CurContext);
           const CXXRecordDecl *InheritedFrom = nullptr;
           if (auto Inherited = Constructor->getInheritedConstructor())
             InheritedFrom = Inherited.getShadowDecl()->getNominatedBaseClass();
           if (Entity.getKind() == InitializedEntity::EK_Base) {
             S.Diag(Kind.getLocation(), diag::err_missing_default_ctor)
-              << (InheritedFrom ? 2 : Constructor->isImplicit() ? 1 : 0)
+                << (InheritedFrom               ? 2
+                    : Constructor->isImplicit() ? 1
+                                                : 0)
                 << S.Context.getTypeDeclType(Constructor->getParent())
-              << /*base=*/0
-              << Entity.getType()
-              << InheritedFrom;
+                << /*base=*/0 << Entity.getType() << InheritedFrom;
 
-            RecordDecl *BaseDecl
-              = Entity.getBaseSpecifier()->getType()->castAs<RecordType>()
-                                                                  ->getDecl();
+            RecordDecl *BaseDecl = Entity.getBaseSpecifier()
+                                       ->getType()
+                                       ->castAs<RecordType>()
             S.Diag(BaseDecl->getLocation(), diag::note_previous_decl)
                 << S.Context.getTagDeclType(BaseDecl);
           } else {
             S.Diag(Kind.getLocation(), diag::err_missing_default_ctor)
-              << (InheritedFrom ? 2 : Constructor->isImplicit() ? 1 : 0)
+                << (InheritedFrom               ? 2
+                    : Constructor->isImplicit() ? 1
+                                                : 0)
                 << S.Context.getTypeDeclType(Constructor->getParent())
-              << /*member=*/1
-              << Entity.getName()
-              << InheritedFrom;
+                << /*member=*/1 << Entity.getName() << InheritedFrom;
             S.Diag(Entity.getDecl()->getLocation(),
                    diag::note_member_declared_at);
 
-            if (const RecordType *Record
-                                 = Entity.getType()->getAs<RecordType>())
-              S.Diag(Record->getDecl()->getLocation(),
-                     diag::note_previous_decl)
+            if (const RecordType *Record =
+                    Entity.getType()->getAs<RecordType>())
+              S.Diag(Record->getDecl()->getLocation(), diag::note_previous_decl)
                   << S.Context.getTagDeclType(Record->getDecl());
           }
           break;
         }
 
         FailedCandidateSet.NoteCandidates(
             PartialDiagnosticAt(
                 Kind.getLocation(),
                 S.PDiag(diag::err_ovl_no_viable_function_in_init)
                     << DestType << ArgsRange),
             S, OCD_AllCandidates, Args);
         break;
 
       case OR_Deleted: {
         OverloadCandidateSet::iterator Best;
-        OverloadingResult Ovl
-          = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best);
+        OverloadingResult Ovl =
+            FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best);
         if (Ovl != OR_Deleted) {
           S.Diag(Kind.getLocation(), diag::err_ovl_deleted_init)
               << DestType << ArgsRange;
           llvm_unreachable("Inconsistent overload resolution?");
           break;
         }
 
         // If this is a defaulted or implicitly-declared function, then
         // it was implicitly deleted. Make it clear that the deletion was
         // implicit.
         if (S.isImplicitlyDeleted(Best->Function))
           S.Diag(Kind.getLocation(), diag::err_ovl_deleted_special_init)
               << S.getSpecialMember(cast<CXXMethodDecl>(Best->Function))
               << DestType << ArgsRange;
         else
           S.Diag(Kind.getLocation(), diag::err_ovl_deleted_init)
               << DestType << ArgsRange;
 
         S.NoteDeletedFunction(Best->Function);
         break;
       }
 
       case OR_Success:
         llvm_unreachable("Conversion did not fail!");
       }
-  }
-  break;
+    } break;
 
     case FK_DefaultInitOfConst:
       if (Entity.getKind() == InitializedEntity::EK_Member &&
           isa<CXXConstructorDecl>(S.CurContext)) {
         // This is implicit default-initialization of a const member in
         // a constructor. Complain that it needs to be explicitly
         // initialized.
-      CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(S.CurContext);
+        CXXConstructorDecl *Constructor =
+            cast<CXXConstructorDecl>(S.CurContext);
         S.Diag(Kind.getLocation(), diag::err_uninitialized_member_in_ctor)
-        << (Constructor->getInheritedConstructor() ? 2 :
-            Constructor->isImplicit() ? 1 : 0)
+            << (Constructor->getInheritedConstructor() ? 2
+                : Constructor->isImplicit()            ? 1
+                                                       : 0)
             << S.Context.getTypeDeclType(Constructor->getParent())
-        << /*const=*/1
-        << Entity.getName();
+            << /*const=*/1 << Entity.getName();
         S.Diag(Entity.getDecl()->getLocation(), diag::note_previous_decl)
             << Entity.getName();
       } else {
         S.Diag(Kind.getLocation(), diag::err_default_init_const)
             << DestType << (bool)DestType->getAs<RecordType>();
       }
       break;
 
     case FK_Incomplete:
       S.RequireCompleteType(Kind.getLocation(), FailedIncompleteType,
                             diag::err_init_incomplete_type);
       break;
 
     case FK_ListInitializationFailed: {
       // Run the init list checker again to emit diagnostics.
       InitListExpr *InitList = cast<InitListExpr>(Args[0]);
       diagnoseListInit(S, Entity, InitList);
       break;
     }
 
     case FK_PlaceholderType: {
       // FIXME: Already diagnosed!
       break;
     }
 
     case FK_ExplicitConstructor: {
       S.Diag(Kind.getLocation(), diag::err_selected_explicit_constructor)
           << Args[0]->getSourceRange();
       OverloadCandidateSet::iterator Best;
-    OverloadingResult Ovl
-      = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best);
+      OverloadingResult Ovl =
+          FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best);
       (void)Ovl;
-    assert(Ovl == OR_Success && "Inconsistent overload resolution");
+      assert((Ovl == OR_Success || Ovl == OR_Deleted) &&
+             "Inconsistent overload resolution");
       CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
       S.Diag(CtorDecl->getLocation(),
-           diag::note_explicit_ctor_deduction_guide_here) << false;
+             diag::note_explicit_ctor_deduction_guide_here)
+          << false;
       break;
     }
     }
-
+  }
   PrintInitLocationNote(S, Entity);
   return true;
 }
 
 void InitializationSequence::dump(raw_ostream &OS) const {
   switch (SequenceKind) {
   case FailedSequence: {
     OS << "Failed sequence: ";
+    for (auto Failure : Failures) {
       switch (Failure) {
       case FK_TooManyInitsForReference:
         OS << "too many initializers for reference";
         break;
 
       case FK_ParenthesizedListInitForReference:
         OS << "parenthesized list init for reference";
         break;
 
       case FK_ArrayNeedsInitList:
         OS << "array requires initializer list";
         break;
 
       case FK_AddressOfUnaddressableFunction:
         OS << "address of unaddressable function was taken";
         break;
 
       case FK_ArrayNeedsInitListOrStringLiteral:
         OS << "array requires initializer list or string literal";
         break;
 
       case FK_ArrayNeedsInitListOrWideStringLiteral:
         OS << "array requires initializer list or wide string literal";
         break;
 
       case FK_NarrowStringIntoWideCharArray:
         OS << "narrow string into wide char array";
         break;
 
       case FK_WideStringIntoCharArray:
         OS << "wide string into char array";
         break;
 
       case FK_IncompatWideStringIntoWideChar:
         OS << "incompatible wide string into wide char array";
         break;
 
       case FK_PlainStringIntoUTF8Char:
         OS << "plain string literal into char8_t array";
         break;
 
       case FK_UTF8StringIntoPlainChar:
         OS << "u8 string literal into char array";
         break;
 
       case FK_ArrayTypeMismatch:
         OS << "array type mismatch";
         break;
 
       case FK_NonConstantArrayInit:
         OS << "non-constant array initializer";
         break;
 
       case FK_AddressOfOverloadFailed:
         OS << "address of overloaded function failed";
         break;
 
       case FK_ReferenceInitOverloadFailed:
         OS << "overload resolution for reference initialization failed";
         break;
 
       case FK_NonConstLValueReferenceBindingToTemporary:
         OS << "non-const lvalue reference bound to temporary";
         break;
 
       case FK_NonConstLValueReferenceBindingToBitfield:
         OS << "non-const lvalue reference bound to bit-field";
         break;
 
       case FK_NonConstLValueReferenceBindingToVectorElement:
         OS << "non-const lvalue reference bound to vector element";
         break;
 
       case FK_NonConstLValueReferenceBindingToMatrixElement:
         OS << "non-const lvalue reference bound to matrix element";
         break;
 
       case FK_NonConstLValueReferenceBindingToUnrelated:
         OS << "non-const lvalue reference bound to unrelated type";
         break;
 
       case FK_RValueReferenceBindingToLValue:
         OS << "rvalue reference bound to an lvalue";
         break;
 
       case FK_ReferenceInitDropsQualifiers:
         OS << "reference initialization drops qualifiers";
         break;
 
       case FK_ReferenceAddrspaceMismatchTemporary:
         OS << "reference with mismatching address space bound to temporary";
         break;
 
       case FK_ReferenceInitFailed:
         OS << "reference initialization failed";
         break;
 
       case FK_ConversionFailed:
         OS << "conversion failed";
         break;
 
       case FK_ConversionFromPropertyFailed:
         OS << "conversion from property failed";
         break;
 
       case FK_TooManyInitsForScalar:
         OS << "too many initializers for scalar";
         break;
 
       case FK_ParenthesizedListInitForScalar:
         OS << "parenthesized list init for reference";
         break;
 
       case FK_ReferenceBindingToInitList:
         OS << "referencing binding to initializer list";
         break;
 
       case FK_InitListBadDestinationType:
         OS << "initializer list for non-aggregate, non-scalar type";
         break;
 
       case FK_UserConversionOverloadFailed:
         OS << "overloading failed for user-defined conversion";
         break;
 
       case FK_ConstructorOverloadFailed:
         OS << "constructor overloading failed";
         break;
 
       case FK_DefaultInitOfConst:
         OS << "default initialization of a const variable";
         break;
 
       case FK_Incomplete:
         OS << "initialization of incomplete type";
         break;
 
       case FK_ListInitializationFailed:
         OS << "list initialization checker failure";
         break;
 
       case FK_VariableLengthArrayHasInitializer:
         OS << "variable length array has an initializer";
         break;
 
       case FK_PlaceholderType:
         OS << "initializer expression isn't contextually valid";
         break;
 
       case FK_ListConstructorOverloadFailed:
         OS << "list constructor overloading failed";
         break;
 
       case FK_ExplicitConstructor:
         OS << "list copy initialization chose explicit constructor";
         break;
       }
       OS << '\n';
+    }
     return;
   }
 
   case DependentSequence:
     OS << "Dependent sequence\n";
     return;
 
   case NormalSequence:

clang/test/SemaCXX/diagnostic-overload-resolution.cpp

+// RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions -verify=expected %s
+
+namespace std {
+typedef decltype(sizeof(int)) size_t;
+
+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;
+
+  initializer_list() : __begin_(nullptr), __size_(0) {}
+
+  size_t size() const { return __size_; }
+  const _E *begin() const { return __begin_; }
+  const _E *end() const { return __begin_ + __size_; }
+};
+} // namespace std
+
+// C++11 [over.match.list]p1:
+//   In copy-list-initialization, if an explicit constructor is chosen, the
+//   initializer is ill-formed.
+struct A {
+  explicit A(std::initializer_list<int>) = delete;
+  // expected-note@-1 {{'A' has been explicitly marked deleted here}}
+  // expected-note@-2 {{explicit constructor declared here}}
+};
+
+A a = {1, 2, 3};
+// expected-error@-1 {{call to deleted constructor of 'A'}}
+// expected-error@-2 {{chosen constructor is explicit in copy-initialization}}