[clang] Improve diagnostic note for implicit conversions that are disallowed because they involve more than one user-defined conversion.

[logan-5]

Summary

The current text of the 'note' diagnostic for bad conversions is confusing in the presence of user-defined conversion operations: https://godbolt.org/z/zrgeHH
For the first error, the conversion function is simply pointed at in a note without any further explanation. For the second error, the final note claims there is no conversion from X2 to Y2, even though it is plainly visible in the source code. The reason for the error is that only one implicit user-defined conversion may be applied in these circumstances, but the error message is misleading to those who may not know this rule.

This patch clarifies this situation with a better diagnostic message. It does so by finding user conversions even where they are not allowed, and then discarding them afterward as invalid, but keeping a record that they existed. There is also a stronger mode (UDC_Skip) for skipping the search for user-defined conversions outright, which matches the old behavior and is retained to prevent infinite recursions.

[jkorous]

Hi @logan-5!
I suggest you split the patch into two smaller ones so it is easier to review.

1. A NFC patch with refactoring of the interface (bool -> UserDefinedConversionsKind).
2. Patch that introduces and uses diag::note_ovl_candidate_bad_user_defined_conv.

[rsmith]

This is an interesting idea. Have you looked into whether you can defer the check for conversion via multiple user-defined conversions until we come to call CompleteNonViableCandidate after finding no viable functions? That'd give me a lot more confidence that this won't introduce a noticeable performance regression for pathological cases (eg, considering a quadratic -- or worse -- number of combinations of constructors and conversion functions).

clang/include/clang/Basic/DiagnosticSemaKinds.td

4068

applies -> would apply

clang/include/clang/Sema/Sema.h

2947–2956

Please use an enum class here, so that call sites are more meaningful (UserDefinedConversions::Allow vs UDC_Allow).

[logan-5]

In D74009#1858353, @rsmith wrote:

Have you looked into whether you can defer the check for conversion via multiple user-defined conversions until we come to call CompleteNonViableCandidate after finding no viable functions?

That's a good idea, and does seem more efficient than checking for multiple conversions every time. I'll look into that, and also split this patch into two as @jkorous suggested.

[logan-5]

I split this patch into multiple, and reworked the implementation. The new stuff lives here and here and here: D74238 D74234 D74235

clang/include/clang/Basic/DiagnosticSemaKinds.td

def note_ovl_candidate_bad_conv : Note<
     "candidate %sub{select_ovl_candidate_kind}0,1,2 not viable: "
     "no known conversion "
     "%diff{from $ to $|from argument type to parameter type}3,4 for "
     "%select{%ordinal6 argument|object argument}5"
     "%select{|; dereference the argument with *|"
     "; take the address of the argument with &|"
     "; remove *|"
     "; remove &}7">;
+def note_ovl_candidate_bad_user_defined_conv : Note<
+    "candidate %sub{select_ovl_candidate_kind}0,1,2 not viable: "
+    "converting "
+    "%diff{from $ to $|from argument type to parameter type}3,4 "
+    "applies more than one implicit user-defined conversion"
+    >;
 def note_ovl_candidate_bad_arc_conv : Note<
     "candidate %sub{select_ovl_candidate_kind}0,1,2 not viable: "
     "cannot implicitly convert argument "
     "%diff{of type $ to $|type to parameter type}3,4 for "
     "%select{%ordinal6 argument|object argument}5 under ARC">;
 def note_ovl_candidate_bad_lvalue : Note<
     "candidate %sub{select_ovl_candidate_kind}0,1,2 not viable: "
     "expects an l-value for "

clang/include/clang/Sema/Overload.h

struct AmbiguousConversionSequence {
     void copyFrom(const AmbiguousConversionSequence &);
   };
 
   /// BadConversionSequence - Records information about an invalid
   /// conversion sequence.
   struct BadConversionSequence {
     enum FailureKind {
       no_conversion,
+      suppressed_user_conversion,
       unrelated_class,
       bad_qualifiers,
       lvalue_ref_to_rvalue,
       rvalue_ref_to_lvalue
     };
 
     // This can be null, e.g. for implicit object arguments.
     Expr *FromExpr;

clang/include/clang/Sema/Sema.h

public:
   enum class AllowedExplicit {
     /// Allow no explicit functions to be used.
     None,
     /// Allow explicit conversion functions but not explicit constructors.
     Conversions,
     /// Allow both explicit conversion functions and explicit constructors.
     All
   };
+  enum UserDefinedConversionsKind {
+    /// Allow user-defined conversions.
+    UDC_Allow,
+    
+    /// Find user-defined conversions but mark as invalid.
+    UDC_Suppress,
+    
+    /// Don't attempt to find user-defined conversions.
+    UDC_Skip,
+  };
 
   ImplicitConversionSequence
   TryImplicitConversion(Expr *From, QualType ToType,
-                        bool SuppressUserConversions,
+                        UserDefinedConversionsKind UserConversions,
                         AllowedExplicit AllowExplicit,
                         bool InOverloadResolution,
                         bool CStyle,
                         bool AllowObjCWritebackConversion);
 
   bool IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType);
   bool IsFloatingPointPromotion(QualType FromType, QualType ToType);
   bool IsComplexPromotion(QualType FromType, QualType ToType);
public:
   typedef llvm::SmallSetVector<DeclContext   *, 16> AssociatedNamespaceSet;
   typedef llvm::SmallSetVector<CXXRecordDecl *, 16> AssociatedClassSet;
 
   using ADLCallKind = CallExpr::ADLCallKind;
 
   void AddOverloadCandidate(FunctionDecl *Function, DeclAccessPair FoundDecl,
                             ArrayRef<Expr *> Args,
                             OverloadCandidateSet &CandidateSet,
-                            bool SuppressUserConversions = false,
+                            UserDefinedConversionsKind UserConversions 
+                                = UDC_Allow,
                             bool PartialOverloading = false,
                             bool AllowExplicit = true,
                             bool AllowExplicitConversion = false,
                             ADLCallKind IsADLCandidate = ADLCallKind::NotADL,
                             ConversionSequenceList EarlyConversions = None,
                             OverloadCandidateParamOrder PO = {});
   void AddFunctionCandidates(const UnresolvedSetImpl &Functions,
                       ArrayRef<Expr *> Args,
                       OverloadCandidateSet &CandidateSet,
                       TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr,
-                      bool SuppressUserConversions = false,
+                      UserDefinedConversionsKind UserConversions = UDC_Allow,
                       bool PartialOverloading = false,
                       bool FirstArgumentIsBase = false);
   void AddMethodCandidate(DeclAccessPair FoundDecl,
                           QualType ObjectType,
                           Expr::Classification ObjectClassification,
                           ArrayRef<Expr *> Args,
                           OverloadCandidateSet& CandidateSet,
-                          bool SuppressUserConversion = false,
+                          UserDefinedConversionsKind UserConversion 
+                              = UDC_Allow,
                           OverloadCandidateParamOrder PO = {});
   void AddMethodCandidate(CXXMethodDecl *Method,
                           DeclAccessPair FoundDecl,
                           CXXRecordDecl *ActingContext, QualType ObjectType,
                           Expr::Classification ObjectClassification,
                           ArrayRef<Expr *> Args,
                           OverloadCandidateSet& CandidateSet,
-                          bool SuppressUserConversions = false,
+                          UserDefinedConversionsKind UserConversion 
+                              = UDC_Allow,
                           bool PartialOverloading = false,
                           ConversionSequenceList EarlyConversions = None,
                           OverloadCandidateParamOrder PO = {});
   void AddMethodTemplateCandidate(FunctionTemplateDecl *MethodTmpl,
                                   DeclAccessPair FoundDecl,
                                   CXXRecordDecl *ActingContext,
                                  TemplateArgumentListInfo *ExplicitTemplateArgs,
                                   QualType ObjectType,
                                   Expr::Classification ObjectClassification,
                                   ArrayRef<Expr *> Args,
                                   OverloadCandidateSet& CandidateSet,
-                                  bool SuppressUserConversions = false,
+                                  UserDefinedConversionsKind UserConversions 
+                                      = UDC_Allow,
                                   bool PartialOverloading = false,
                                   OverloadCandidateParamOrder PO = {});
   void AddTemplateOverloadCandidate(
       FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl,
       TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args,
-      OverloadCandidateSet &CandidateSet, bool SuppressUserConversions = false,
+      OverloadCandidateSet &CandidateSet,
+      UserDefinedConversionsKind UserConversions = UDC_Allow,
       bool PartialOverloading = false, bool AllowExplicit = true,
       ADLCallKind IsADLCandidate = ADLCallKind::NotADL,
       OverloadCandidateParamOrder PO = {});
   bool CheckNonDependentConversions(
       FunctionTemplateDecl *FunctionTemplate, ArrayRef<QualType> ParamTypes,
       ArrayRef<Expr *> Args, OverloadCandidateSet &CandidateSet,
-      ConversionSequenceList &Conversions, bool SuppressUserConversions,
+      ConversionSequenceList &Conversions, 
+      UserDefinedConversionsKind UserConversions,
       CXXRecordDecl *ActingContext = nullptr, QualType ObjectType = QualType(),
       Expr::Classification ObjectClassification = {},
       OverloadCandidateParamOrder PO = {});
   void AddConversionCandidate(
       CXXConversionDecl *Conversion, DeclAccessPair FoundDecl,
       CXXRecordDecl *ActingContext, Expr *From, QualType ToType,
       OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit,
       bool AllowExplicit, bool AllowResultConversion = true);

clang/lib/Sema/SemaCodeComplete.cpp

else if (auto UME = dyn_cast<UnresolvedMemberExpr>(NakedFn)) {
     // Add the base as first argument (use a nullptr if the base is implicit).
     SmallVector<Expr *, 12> ArgExprs(
         1, UME->isImplicitAccess() ? nullptr : UME->getBase());
     ArgExprs.append(Args.begin(), Args.end());
     UnresolvedSet<8> Decls;
     Decls.append(UME->decls_begin(), UME->decls_end());
     const bool FirstArgumentIsBase = !UME->isImplicitAccess() && UME->getBase();
     AddFunctionCandidates(Decls, ArgExprs, CandidateSet, TemplateArgs,
-                          /*SuppressUserConversions=*/false,
+                          UDC_Allow,
                           /*PartialOverloading=*/true, FirstArgumentIsBase);
   } else {
     FunctionDecl *FD = nullptr;
     if (auto *MCE = dyn_cast<MemberExpr>(NakedFn))
       FD = dyn_cast<FunctionDecl>(MCE->getMemberDecl());
     else if (auto *DRE = dyn_cast<DeclRefExpr>(NakedFn))
       FD = dyn_cast<FunctionDecl>(DRE->getDecl());
     if (FD) { // We check whether it's a resolved function declaration.
       if (!getLangOpts().CPlusPlus ||
           !FD->getType()->getAs<FunctionProtoType>())
         Results.push_back(ResultCandidate(FD));
       else
         AddOverloadCandidate(FD, DeclAccessPair::make(FD, FD->getAccess()),
                              Args, CandidateSet,
-                             /*SuppressUserConversions=*/false,
+                             UDC_Allow,
                              /*PartialOverloading=*/true);
 
     } else if (auto DC = NakedFn->getType()->getAsCXXRecordDecl()) {
       // If expression's type is CXXRecordDecl, it may overload the function
       // call operator, so we check if it does and add them as candidates.
       // A complete type is needed to lookup for member function call operators.
       if (isCompleteType(Loc, NakedFn->getType())) {
         DeclarationName OpName =
             Context.DeclarationNames.getCXXOperatorName(OO_Call);
         LookupResult R(*this, OpName, Loc, LookupOrdinaryName);
         LookupQualifiedName(R, DC);
         R.suppressDiagnostics();
         SmallVector<Expr *, 12> ArgExprs(1, NakedFn);
         ArgExprs.append(Args.begin(), Args.end());
         AddFunctionCandidates(R.asUnresolvedSet(), ArgExprs, CandidateSet,
-                              /*ExplicitArgs=*/nullptr,
-                              /*SuppressUserConversions=*/false,
+                              /*ExplicitArgs=*/nullptr, UDC_Allow,
                               /*PartialOverloading=*/true);
       }
     } else {
       // Lastly we check whether expression's type is function pointer or
       // function.
       QualType T = NakedFn->getType();
       if (!T->getPointeeType().isNull())
         T = T->getPointeeType();
QualType Sema::ProduceConstructorSignatureHelp(Scope *S, QualType Type,
   // FIXME: Provide support for member initializers.
   // FIXME: Provide support for variadic template constructors.
 
   OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
 
   for (NamedDecl *C : LookupConstructors(RD)) {
     if (auto *FD = dyn_cast<FunctionDecl>(C)) {
       AddOverloadCandidate(FD, DeclAccessPair::make(FD, C->getAccess()), Args,
-                           CandidateSet,
-                           /*SuppressUserConversions=*/false,
+                           CandidateSet, UDC_Allow,
                            /*PartialOverloading=*/true,
                            /*AllowExplicit*/ true);
     } else if (auto *FTD = dyn_cast<FunctionTemplateDecl>(C)) {
       AddTemplateOverloadCandidate(
           FTD, DeclAccessPair::make(FTD, C->getAccess()),
-          /*ExplicitTemplateArgs=*/nullptr, Args, CandidateSet,
-          /*SuppressUserConversions=*/false,
+          /*ExplicitTemplateArgs=*/nullptr, Args, 
+          CandidateSet, UDC_Allow,
           /*PartialOverloading=*/true);
     }
   }
 
   SmallVector<ResultCandidate, 8> Results;
   mergeCandidatesWithResults(*this, Results, CandidateSet, Loc);
   return ProduceSignatureHelp(*this, S, Results, Args.size(), OpenParLoc);
 }

clang/lib/Sema/SemaExpr.cpp

if (!LHSType->isRecordType() && !LHSType->isAtomicType()) {
       // cv-unqualified type of the left operand.
       QualType RHSType = RHS.get()->getType();
       if (Diagnose) {
         RHS = PerformImplicitConversion(RHS.get(), LHSType.getUnqualifiedType(),
                                         AA_Assigning);
       } else {
         ImplicitConversionSequence ICS =
             TryImplicitConversion(RHS.get(), LHSType.getUnqualifiedType(),
-                                  /*SuppressUserConversions=*/false,
+                                  Sema::UDC_Allow,
                                   AllowedExplicit::None,
                                   /*InOverloadResolution=*/false,
                                   /*CStyle=*/false,
                                   /*AllowObjCWritebackConversion=*/false);
         if (ICS.isFailure())
           return Incompatible;
         RHS = PerformImplicitConversion(RHS.get(), LHSType.getUnqualifiedType(),
                                         ICS, AA_Assigning);

clang/lib/Sema/SemaExprCXX.cpp

for (LookupResult::iterator Alloc = R.begin(), AllocEnd = R.end();
        Alloc != AllocEnd; ++Alloc) {
     // Even member operator new/delete are implicitly treated as
     // static, so don't use AddMemberCandidate.
     NamedDecl *D = (*Alloc)->getUnderlyingDecl();
 
     if (FunctionTemplateDecl *FnTemplate = dyn_cast<FunctionTemplateDecl>(D)) {
       S.AddTemplateOverloadCandidate(FnTemplate, Alloc.getPair(),
                                      /*ExplicitTemplateArgs=*/nullptr, Args,
-                                     Candidates,
-                                     /*SuppressUserConversions=*/false);
+                                     Candidates, Sema::UDC_Allow);
       continue;
     }
 
     FunctionDecl *Fn = cast<FunctionDecl>(D);
     S.AddOverloadCandidate(Fn, Alloc.getPair(), Args, Candidates,
-                           /*SuppressUserConversions=*/false);
+                           Sema::UDC_Allow);
   }
 
   // Do the resolution.
   OverloadCandidateSet::iterator Best;
   switch (Candidates.BestViableFunction(S, R.getNameLoc(), Best)) {
   case OR_Success: {
     // Got one!
     FunctionDecl *FnDecl = Best->Function;
for (LookupResult::iterator FnOvl = R.begin(), FnOvlEnd = R.end();
        FnOvl != FnOvlEnd; ++FnOvl) {
     // Even member operator new/delete are implicitly treated as
     // static, so don't use AddMemberCandidate.
     NamedDecl *D = (*FnOvl)->getUnderlyingDecl();
 
     if (FunctionTemplateDecl *FnTemplate = dyn_cast<FunctionTemplateDecl>(D)) {
       S.AddTemplateOverloadCandidate(FnTemplate, FnOvl.getPair(),
                                      /*ExplicitTemplateArgs=*/nullptr, Args,
-                                     Candidates,
-                                     /*SuppressUserConversions=*/false);
+                                     Candidates, Sema::UDC_Allow);
       continue;
     }
 
     FunctionDecl *Fn = cast<FunctionDecl>(D);
-    S.AddOverloadCandidate(Fn, FnOvl.getPair(), Args, Candidates,
-                           /*SuppressUserConversions=*/false);
+    S.AddOverloadCandidate(Fn, FnOvl.getPair(), Args, 
+                           Candidates, Sema::UDC_Allow);
   }
 
   SourceRange Range = TheCall->getSourceRange();
 
   // Do the resolution.
   OverloadCandidateSet::iterator Best;
   switch (Candidates.BestViableFunction(S, R.getNameLoc(), Best)) {
   case OR_Success: {

clang/lib/Sema/SemaInit.cpp

for (NamedDecl *D : Ctors) {
     //   - 13.3.1.3, when the argument is the temporary in the second step
     //     of a class copy-initialization, or
     //   - 13.3.1.4, 13.3.1.5, or 13.3.1.6 (in all cases), [not handled here]
     //   - the second phase of 13.3.1.7 when the initializer list has exactly
     //     one element that is itself an initializer list, and the target is
     //     the first parameter of a constructor of class X, and the conversion
     //     is to X or reference to (possibly cv-qualified X),
     //   user-defined conversion sequences are not considered.
-    bool SuppressUserConversions =
+    Sema::UserDefinedConversionsKind UserConversions =
         SecondStepOfCopyInit ||
         (IsListInit && Args.size() == 1 && isa<InitListExpr>(Args[0]) &&
-         hasCopyOrMoveCtorParam(S.Context, Info));
+         hasCopyOrMoveCtorParam(S.Context, Info)) 
+            ? Sema::UDC_Suppress 
+            : Sema::UDC_Allow;
 
     if (Info.ConstructorTmpl)
       S.AddTemplateOverloadCandidate(
           Info.ConstructorTmpl, Info.FoundDecl,
-          /*ExplicitArgs*/ nullptr, Args, CandidateSet, SuppressUserConversions,
+          /*ExplicitArgs*/ nullptr, Args, CandidateSet, UserConversions,
           /*PartialOverloading=*/false, AllowExplicit);
     else {
       // C++ [over.match.copy]p1:
       //   - When initializing a temporary to be bound to the first parameter
       //     of a constructor [for type T] that takes a reference to possibly
       //     cv-qualified T as its first argument, called with a single
       //     argument in the context of direct-initialization, explicit
       //     conversion functions are also considered.
       // FIXME: What if a constructor template instantiates to such a signature?
       bool AllowExplicitConv = AllowExplicit && !CopyInitializing &&
                                Args.size() == 1 &&
                                hasCopyOrMoveCtorParam(S.Context, Info);
       S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl, Args,
-                             CandidateSet, SuppressUserConversions,
+                             CandidateSet, UserConversions,
                              /*PartialOverloading=*/false, AllowExplicit,
                              AllowExplicitConv);
     }
   }
 
   // FIXME: Work around a bug in C++17 guaranteed copy elision.
   //
   // When initializing an object of class type T by constructor
for (NamedDecl *D : S.LookupConstructors(T1RecordDecl)) {
         continue;
 
       if (!Info.Constructor->isInvalidDecl() &&
           Info.Constructor->isConvertingConstructor(/*AllowExplicit*/true)) {
         if (Info.ConstructorTmpl)
           S.AddTemplateOverloadCandidate(
               Info.ConstructorTmpl, Info.FoundDecl,
               /*ExplicitArgs*/ nullptr, Initializer, CandidateSet,
-              /*SuppressUserConversions=*/true,
+              Sema::UDC_Suppress,
               /*PartialOverloading*/ false, AllowExplicitCtors);
         else
           S.AddOverloadCandidate(
               Info.Constructor, Info.FoundDecl, Initializer, CandidateSet,
-              /*SuppressUserConversions=*/true,
+              Sema::UDC_Suppress,
               /*PartialOverloading*/ false, AllowExplicitCtors);
       }
     }
   }
   if (T1RecordType && T1RecordType->getDecl()->isInvalidDecl())
     return OR_No_Viable_Function;
 
   const RecordType *T2RecordType = nullptr;
static void TryReferenceInitializationCore(Sema &S,
 
   InitializedEntity TempEntity =
       InitializedEntity::InitializeTemporary(cv1T1IgnoreAS);
 
   // FIXME: Why do we use an implicit conversion here rather than trying
   // copy-initialization?
   ImplicitConversionSequence ICS
     = S.TryImplicitConversion(Initializer, TempEntity.getType(),
-                              /*SuppressUserConversions=*/false,
+                              Sema::UDC_Allow,
                               Sema::AllowedExplicit::None,
                               /*FIXME:InOverloadResolution=*/false,
                               /*CStyle=*/Kind.isCStyleOrFunctionalCast(),
                               /*AllowObjCWritebackConversion=*/false);
 
   if (ICS.isBad()) {
     // FIXME: Use the conversion function set stored in ICS to turn
     // this into an overloading ambiguity diagnostic. However, we need
if (S.isCompleteType(Kind.getLocation(), DestType)) {
           continue;
 
         if (!Info.Constructor->isInvalidDecl() &&
             Info.Constructor->isConvertingConstructor(/*AllowExplicit*/true)) {
           if (Info.ConstructorTmpl)
             S.AddTemplateOverloadCandidate(
                 Info.ConstructorTmpl, Info.FoundDecl,
                 /*ExplicitArgs*/ nullptr, Initializer, CandidateSet,
-                /*SuppressUserConversions=*/true,
+                Sema::UDC_Suppress,
                 /*PartialOverloading*/ false, AllowExplicit);
           else
             S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl,
                                    Initializer, CandidateSet,
-                                   /*SuppressUserConversions=*/true,
+                                   Sema::UDC_Suppress,
                                    /*PartialOverloading*/ false, AllowExplicit);
         }
       }
     }
   }
 
   SourceLocation DeclLoc = Initializer->getBeginLoc();
 
void InitializationSequence::InitializeFrom(Sema &S,
   //    - Otherwise, the initial value of the object being initialized is the
   //      (possibly converted) value of the initializer expression. Standard
   //      conversions (Clause 4) will be used, if necessary, to convert the
   //      initializer expression to the cv-unqualified version of the
   //      destination type; no user-defined conversions are considered.
 
   ImplicitConversionSequence ICS
     = S.TryImplicitConversion(Initializer, DestType,
-                              /*SuppressUserConversions*/true,
+                              Sema::UDC_Suppress,
                               Sema::AllowedExplicit::None,
                               /*InOverloadResolution*/ false,
                               /*CStyle=*/Kind.isCStyleOrFunctionalCast(),
                               allowObjCWritebackConversion);
 
   if (ICS.isStandard() &&
       ICS.Standard.Second == ICK_Writeback_Conversion) {
     // Objective-C ARC writeback conversion.
for (auto I = Guides.begin(), E = Guides.end(); I != E; ++I) {
       //   the object being initialized
 
       // C++ [over.best.ics]p4:
       //   When [...] the constructor [...] is a candidate by
       //    - [over.match.copy] (in all cases)
       // FIXME: The "second phase of [over.match.list] case can also
       // theoretically happen here, but it's not clear whether we can
       // ever have a parameter of the right type.
-      bool SuppressUserConversions = Kind.isCopyInit();
+      UserDefinedConversionsKind UserConversions 
+          = Kind.isCopyInit() ? Sema::UDC_Suppress : Sema::UDC_Allow;
 
       if (TD)
         AddTemplateOverloadCandidate(TD, I.getPair(), /*ExplicitArgs*/ nullptr,
-                                     Inits, Candidates, SuppressUserConversions,
+                                     Inits, Candidates, UserConversions,
                                      /*PartialOverloading*/ false,
                                      AllowExplicit);
       else
         AddOverloadCandidate(GD, I.getPair(), Inits, Candidates,
-                             SuppressUserConversions,
+                             UserConversions,
                              /*PartialOverloading*/ false, AllowExplicit);
     }
     return Candidates.BestViableFunction(*this, Kind.getLocation(), Best);
   };
 
   OverloadingResult Result = OR_No_Viable_Function;
 
   // C++11 [over.match.list]p1, per DR1467: for list-initialization, first

clang/lib/Sema/SemaLookup.cpp

for (NamedDecl *CandDecl : Candidates) {
     if (CandDecl->isInvalidDecl())
       continue;
 
     DeclAccessPair Cand = DeclAccessPair::make(CandDecl, AS_public);
     auto CtorInfo = getConstructorInfo(Cand);
     if (CXXMethodDecl *M = dyn_cast<CXXMethodDecl>(Cand->getUnderlyingDecl())) {
       if (SM == CXXCopyAssignment || SM == CXXMoveAssignment)
         AddMethodCandidate(M, Cand, RD, ThisTy, Classification,
-                           llvm::makeArrayRef(&Arg, NumArgs), OCS, true);
+                           llvm::makeArrayRef(&Arg, NumArgs), OCS, 
+                           Sema::UDC_Suppress);
       else if (CtorInfo)
         AddOverloadCandidate(CtorInfo.Constructor, CtorInfo.FoundDecl,
                              llvm::makeArrayRef(&Arg, NumArgs), OCS,
-                             /*SuppressUserConversions*/ true);
+                             Sema::UDC_Suppress);
       else
         AddOverloadCandidate(M, Cand, llvm::makeArrayRef(&Arg, NumArgs), OCS,
-                             /*SuppressUserConversions*/ true);
+                             Sema::UDC_Suppress);
     } else if (FunctionTemplateDecl *Tmpl =
                  dyn_cast<FunctionTemplateDecl>(Cand->getUnderlyingDecl())) {
       if (SM == CXXCopyAssignment || SM == CXXMoveAssignment)
         AddMethodTemplateCandidate(
             Tmpl, Cand, RD, nullptr, ThisTy, Classification,
-            llvm::makeArrayRef(&Arg, NumArgs), OCS, true);
+            llvm::makeArrayRef(&Arg, NumArgs), OCS, Sema::UDC_Suppress);
       else if (CtorInfo)
         AddTemplateOverloadCandidate(
             CtorInfo.ConstructorTmpl, CtorInfo.FoundDecl, nullptr,
-            llvm::makeArrayRef(&Arg, NumArgs), OCS, true);
+            llvm::makeArrayRef(&Arg, NumArgs), OCS, Sema::UDC_Suppress);
       else
         AddTemplateOverloadCandidate(
-            Tmpl, Cand, nullptr, llvm::makeArrayRef(&Arg, NumArgs), OCS, true);
+            Tmpl, Cand, nullptr, llvm::makeArrayRef(&Arg, NumArgs), OCS, 
+            Sema::UDC_Suppress);
     } else {
       assert(isa<UsingDecl>(Cand.getDecl()) &&
              "illegal Kind of operator = Decl");
     }
   }
 
   OverloadCandidateSet::iterator Best;
   switch (OCS.BestViableFunction(*this, LookupLoc, Best)) {

clang/lib/Sema/SemaOpenMP.cpp

if (Method && !Method->isStatic()) {
         return None;
       }
       VariantRef = ER.get();
     } else {
       FnPtrType = Context.getPointerType(FD->getType());
     }
     ImplicitConversionSequence ICS =
         TryImplicitConversion(VariantRef, FnPtrType.getUnqualifiedType(),
-                              /*SuppressUserConversions=*/false,
+                              Sema::UDC_Allow,
                               AllowedExplicit::None,
                               /*InOverloadResolution=*/false,
                               /*CStyle=*/false,
                               /*AllowObjCWritebackConversion=*/false);
     if (ICS.isFailure()) {
       Diag(VariantRef->getExprLoc(),
            diag::err_omp_declare_variant_incompat_types)
           << VariantRef->getType()

clang/lib/Sema/SemaOverload.cpp

static bool IsTransparentUnionStandardConversion(Sema &S, Expr* From,
                                                  QualType &ToType,
                                                  bool InOverloadResolution,
                                                  StandardConversionSequence &SCS,
                                                  bool CStyle);
 static OverloadingResult
 IsUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
                         UserDefinedConversionSequence& User,
                         OverloadCandidateSet& Conversions,
+                        Sema::UserDefinedConversionsKind UserConversions,
                         AllowedExplicit AllowExplicit,
                         bool AllowObjCConversionOnExplicit);
 
 static ImplicitConversionSequence::CompareKind
 CompareStandardConversionSequences(Sema &S, SourceLocation Loc,
                                    const StandardConversionSequence& SCS1,
                                    const StandardConversionSequence& SCS2);
 

 }
 
 /// Tries a user-defined conversion from From to ToType.
 ///
 /// Produces an implicit conversion sequence for when a standard conversion
 /// is not an option. See TryImplicitConversion for more information.
 static ImplicitConversionSequence
 TryUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
-                         bool SuppressUserConversions,
+                         Sema::UserDefinedConversionsKind UserConversions,
                          AllowedExplicit AllowExplicit,
                          bool InOverloadResolution,
                          bool CStyle,
                          bool AllowObjCWritebackConversion,
                          bool AllowObjCConversionOnExplicit) {
   ImplicitConversionSequence ICS;
   
-  if (SuppressUserConversions) {
-    // We're not in the case above, so there is no conversion that
-    // we can perform.
+  if (UserConversions == Sema::UDC_Skip) {
     ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
     return ICS;
   }
 
   // Attempt user-defined conversion.
   OverloadCandidateSet Conversions(From->getExprLoc(),
                                    OverloadCandidateSet::CSK_Normal);
   switch (IsUserDefinedConversion(S, From, ToType, ICS.UserDefined,
-                                  Conversions, AllowExplicit,
+                                  Conversions, UserConversions, AllowExplicit,
                                   AllowObjCConversionOnExplicit)) {
   case OR_Success:
   case OR_Deleted:
     ICS.setUserDefined();
     // C++ [over.ics.user]p4:
     //   A conversion of an expression of class type to the same class
     //   type is given Exact Match rank, and a conversion of an
     //   expression of class type to a base class of that type is
case OR_Ambiguous:
     ICS.Ambiguous.setFromType(From->getType());
     ICS.Ambiguous.setToType(ToType);
     for (OverloadCandidateSet::iterator Cand = Conversions.begin();
          Cand != Conversions.end(); ++Cand)
       if (Cand->Best)
         ICS.Ambiguous.addConversion(Cand->FoundDecl, Cand->Function);
     break;
 
-    // Fall through.
   case OR_No_Viable_Function:
     ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
     break;
   }
 
+  // If we found a viable conversion but user conversions are not allowed,
+  // throw it out and mark it as such.
+  if (UserConversions == Sema::UDC_Suppress && !ICS.isBad())
+    ICS.setBad(BadConversionSequence::suppressed_user_conversion, 
+               From, ToType);
+
   return ICS;
 }
 
 /// TryImplicitConversion - Attempt to perform an implicit conversion
 /// from the given expression (Expr) to the given type (ToType). This
 /// function returns an implicit conversion sequence that can be used
 /// to perform the initialization. Given
 ///

 /// If @p AllowExplicit, then explicit user-defined conversions are
 /// permitted.
 ///
 /// \param AllowObjCWritebackConversion Whether we allow the Objective-C
 /// writeback conversion, which allows __autoreleasing id* parameters to
 /// be initialized with __strong id* or __weak id* arguments.
 static ImplicitConversionSequence
 TryImplicitConversion(Sema &S, Expr *From, QualType ToType,
-                      bool SuppressUserConversions,
+                      Sema::UserDefinedConversionsKind UserConversions,
                       AllowedExplicit AllowExplicit,
                       bool InOverloadResolution,
                       bool CStyle,
                       bool AllowObjCWritebackConversion,
                       bool AllowObjCConversionOnExplicit) {
   ImplicitConversionSequence ICS;
   if (IsStandardConversion(S, From, ToType, InOverloadResolution,
                            ICS.Standard, CStyle, AllowObjCWritebackConversion)){
if (ToType->getAs<RecordType>() && FromType->getAs<RecordType>() &&
 
     // Determine whether this is considered a derived-to-base conversion.
     if (!S.Context.hasSameUnqualifiedType(FromType, ToType))
       ICS.Standard.Second = ICK_Derived_To_Base;
 
     return ICS;
   }
 
-  return TryUserDefinedConversion(S, From, ToType, SuppressUserConversions,
+  return TryUserDefinedConversion(S, From, ToType, UserConversions,
                                   AllowExplicit, InOverloadResolution, CStyle,
                                   AllowObjCWritebackConversion,
                                   AllowObjCConversionOnExplicit);
 }
 
 ImplicitConversionSequence
 Sema::TryImplicitConversion(Expr *From, QualType ToType,
-                            bool SuppressUserConversions,
+                            UserDefinedConversionsKind UserConversions,
                             AllowedExplicit AllowExplicit,
                             bool InOverloadResolution,
                             bool CStyle,
                             bool AllowObjCWritebackConversion) {
-  return ::TryImplicitConversion(*this, From, ToType, SuppressUserConversions,
-                                 AllowExplicit, InOverloadResolution, CStyle,
+  return ::TryImplicitConversion(*this, From, ToType,
+                                 UserConversions, AllowExplicit,
+                                 InOverloadResolution, CStyle,
                                  AllowObjCWritebackConversion,
                                  /*AllowObjCConversionOnExplicit=*/false);
 }
 
 /// PerformImplicitConversion - Perform an implicit conversion of the
 /// expression From to the type ToType. Returns the
 /// converted expression. Flavor is the kind of conversion we're
 /// performing, used in the error message. If @p AllowExplicit,
Sema::PerformImplicitConversion(Expr *From, QualType ToType,
   // Objective-C ARC: Determine whether we will allow the writeback conversion.
   bool AllowObjCWritebackConversion
     = getLangOpts().ObjCAutoRefCount &&
       (Action == AA_Passing || Action == AA_Sending);
   if (getLangOpts().ObjC)
     CheckObjCBridgeRelatedConversions(From->getBeginLoc(), ToType,
                                       From->getType(), From);
   ICS = ::TryImplicitConversion(*this, From, ToType,
-                                /*SuppressUserConversions=*/false,
+                                UDC_Allow,
                                 AllowExplicit ? AllowedExplicit::All
                                               : AllowedExplicit::None,
                                 /*InOverloadResolution=*/false,
                                 /*CStyle=*/false, AllowObjCWritebackConversion,
                                 /*AllowObjCConversionOnExplicit=*/false);
   return PerformImplicitConversion(From, ToType, ICS, Action);
 }
 
for (auto *D : S.LookupConstructors(To)) {
     if (!Info)
       continue;
 
     bool Usable = !Info.Constructor->isInvalidDecl() &&
                   S.isInitListConstructor(Info.Constructor);
     if (Usable) {
       // If the first argument is (a reference to) the target type,
       // suppress conversions.
-      bool SuppressUserConversions = isFirstArgumentCompatibleWithType(
-          S.Context, Info.Constructor, ToType);
+      Sema::UserDefinedConversionsKind UserConversions 
+          = isFirstArgumentCompatibleWithType(
+                S.Context, Info.Constructor, ToType)
+                    ? Sema::UDC_Suppress
+                    : Sema::UDC_Allow;
       if (Info.ConstructorTmpl)
         S.AddTemplateOverloadCandidate(Info.ConstructorTmpl, Info.FoundDecl,
                                        /*ExplicitArgs*/ nullptr, From,
-                                       CandidateSet, SuppressUserConversions,
+                                       CandidateSet, UserConversions,
                                        /*PartialOverloading*/ false,
                                        AllowExplicit);
       else
         S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl, From,
-                               CandidateSet, SuppressUserConversions,
+                               CandidateSet, UserConversions,
                                /*PartialOverloading*/ false, AllowExplicit);
     }
   }
 
   bool HadMultipleCandidates = (CandidateSet.size() > 1);
 
   OverloadCandidateSet::iterator Best;
   switch (auto Result =
case OR_No_Viable_Function:
     return OR_No_Viable_Function;
   case OR_Ambiguous:
     return OR_Ambiguous;
   }
 
   llvm_unreachable("Invalid OverloadResult!");
 }
 
+static Sema::UserDefinedConversionsKind
+StrengthenUserConversionSuppression(bool Suppress, 
+                                    Sema::UserDefinedConversionsKind K) {
+  if (!Suppress)
+    return Sema::UDC_Allow;
+  
+  switch (K) {
+  case Sema::UDC_Allow:
+    return Sema::UDC_Suppress;
+  
+  case Sema::UDC_Suppress:
+  case Sema::UDC_Skip:
+    return Sema::UDC_Skip;
+  }
+}
+
 /// Determines whether there is a user-defined conversion sequence
 /// (C++ [over.ics.user]) that converts expression From to the type
 /// ToType. If such a conversion exists, User will contain the
 /// user-defined conversion sequence that performs such a conversion
 /// and this routine will return true. Otherwise, this routine returns
 /// false and User is unspecified.
 ///
 /// \param AllowExplicit  true if the conversion should consider C++0x
 /// "explicit" conversion functions as well as non-explicit conversion
 /// functions (C++0x [class.conv.fct]p2).
 ///
 /// \param AllowObjCConversionOnExplicit true if the conversion should
 /// allow an extra Objective-C pointer conversion on uses of explicit
 /// constructors. Requires \c AllowExplicit to also be set.
 static OverloadingResult
 IsUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
                         UserDefinedConversionSequence &User,
                         OverloadCandidateSet &CandidateSet,
+                        Sema::UserDefinedConversionsKind UserConversions,
                         AllowedExplicit AllowExplicit,
                         bool AllowObjCConversionOnExplicit) {
   assert(AllowExplicit != AllowedExplicit::None ||
          !AllowObjCConversionOnExplicit);
   CandidateSet.clear(OverloadCandidateSet::CSK_InitByUserDefinedConversion);
 
   // Whether we will only visit constructors.
   bool ConstructorsOnly = false;
if (!S.isCompleteType(From->getExprLoc(), ToType)) {
               SuppressUserConversions = isFirstArgumentCompatibleWithType(
                   S.Context, Info.Constructor, ToType);
             }
           }
           if (Info.ConstructorTmpl)
             S.AddTemplateOverloadCandidate(
                 Info.ConstructorTmpl, Info.FoundDecl,
                 /*ExplicitArgs*/ nullptr, llvm::makeArrayRef(Args, NumArgs),
-                CandidateSet, SuppressUserConversions,
+                CandidateSet, 
+                StrengthenUserConversionSuppression(
+                    SuppressUserConversions, UserConversions),
                 /*PartialOverloading*/ false,
                 AllowExplicit == AllowedExplicit::All);
           else
             // Allow one user-defined conversion when user specifies a
             // From->ToType conversion via an static cast (c-style, etc).
             S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl,
                                    llvm::makeArrayRef(Args, NumArgs),
-                                   CandidateSet, SuppressUserConversions,
+                                   CandidateSet,
+                                   StrengthenUserConversionSuppression(
+                                     SuppressUserConversions, UserConversions),
                                    /*PartialOverloading*/ false,
                                    AllowExplicit == AllowedExplicit::All);
         }
       }
     }
   }
 
   // Enumerate conversion functions, if we're allowed to.

 
 bool
 Sema::DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType) {
   ImplicitConversionSequence ICS;
   OverloadCandidateSet CandidateSet(From->getExprLoc(),
                                     OverloadCandidateSet::CSK_Normal);
   OverloadingResult OvResult =
     IsUserDefinedConversion(*this, From, ToType, ICS.UserDefined,
-                            CandidateSet, AllowedExplicit::None, false);
+                            CandidateSet, UDC_Allow, AllowedExplicit::None, false);
 
   if (!(OvResult == OR_Ambiguous ||
         (OvResult == OR_No_Viable_Function && !CandidateSet.empty())))
     return false;
 
   auto Cands = CandidateSet.CompleteCandidates(
       *this,
       OvResult == OR_Ambiguous ? OCD_AmbiguousCandidates : OCD_AllCandidates,
TryReferenceInit(Sema &S, Expr *Init, QualType DeclType,
   //   an argument expression, the conversion sequence is the one
   //   required to convert the argument expression to the
   //   underlying type of the reference according to
   //   13.3.3.1. Conceptually, this conversion sequence corresponds
   //   to copy-initializing a temporary of the underlying type with
   //   the argument expression. Any difference in top-level
   //   cv-qualification is subsumed by the initialization itself
   //   and does not constitute a conversion.
-  ICS = TryImplicitConversion(S, Init, T1, SuppressUserConversions,
+  ICS = TryImplicitConversion(S, Init, T1, 
+                              SuppressUserConversions 
+                                  ? Sema::UDC_Suppress 
+                                  : Sema::UDC_Allow,
                               AllowedExplicit::None,
                               /*InOverloadResolution=*/false,
                               /*CStyle=*/false,
                               /*AllowObjCWritebackConversion=*/false,
                               /*AllowObjCConversionOnExplicit=*/false);
 
   // Of course, that's still a reference binding.
   if (ICS.isStandard()) {
if (ICS.isStandard()) {
     ICS.UserDefined.After.ObjCLifetimeConversionBinding = false;
   }
 
   return ICS;
 }
 
 static ImplicitConversionSequence
 TryCopyInitialization(Sema &S, Expr *From, QualType ToType,
-                      bool SuppressUserConversions,
+                      Sema::UserDefinedConversionsKind UserConversions,
                       bool InOverloadResolution,
                       bool AllowObjCWritebackConversion,
                       bool AllowExplicit = false);
 
 /// TryListConversion - Try to copy-initialize a value of type ToType from the
 /// initializer list From.
 static ImplicitConversionSequence
 TryListConversion(Sema &S, InitListExpr *From, QualType ToType,
-                  bool SuppressUserConversions,
+                  Sema::UserDefinedConversionsKind UserConversions,
                   bool InOverloadResolution,
                   bool AllowObjCWritebackConversion) {
   // C++11 [over.ics.list]p1:
   //   When an argument is an initializer list, it is not an expression and
   //   special rules apply for converting it to a parameter type.
 
   ImplicitConversionSequence Result;
   Result.setBad(BadConversionSequence::no_conversion, From, ToType);
TryListConversion(Sema &S, InitListExpr *From, QualType ToType,
   //   appropriately-typed string literal (8.5.2 [dcl.init.string]), the
   //   implicit conversion sequence is the identity conversion.
   if (From->getNumInits() == 1) {
     if (ToType->isRecordType()) {
       QualType InitType = From->getInit(0)->getType();
       if (S.Context.hasSameUnqualifiedType(InitType, ToType) ||
           S.IsDerivedFrom(From->getBeginLoc(), InitType, ToType))
         return TryCopyInitialization(S, From->getInit(0), ToType,
-                                     SuppressUserConversions,
+                                     UserConversions,
                                      InOverloadResolution,
                                      AllowObjCWritebackConversion);
     }
     // FIXME: Check the other conditions here: array of character type,
     // initializer is a string literal.
     if (ToType->isArrayType()) {
       InitializedEntity Entity =
         InitializedEntity::InitializeParameter(S.Context, ToType,
TryListConversion(Sema &S, InitListExpr *From, QualType ToType,
   if (ToType->isArrayType())
     X = S.Context.getAsArrayType(ToType)->getElementType();
   else
     toStdInitializerList = S.isStdInitializerList(ToType, &X);
   if (!X.isNull()) {
     for (unsigned i = 0, e = From->getNumInits(); i < e; ++i) {
       Expr *Init = From->getInit(i);
       ImplicitConversionSequence ICS =
-          TryCopyInitialization(S, Init, X, SuppressUserConversions,
+          TryCopyInitialization(S, Init, X, UserConversions,
                                 InOverloadResolution,
                                 AllowObjCWritebackConversion);
       // If a single element isn't convertible, fail.
       if (ICS.isBad()) {
         Result = ICS;
         break;
       }
       // Otherwise, look for the worst conversion.
TryListConversion(Sema &S, InitListExpr *From, QualType ToType,
   // C++11 [over.ics.list]p3:
   //   Otherwise, if the parameter is a non-aggregate class X and overload
   //   resolution chooses a single best constructor [...] the implicit
   //   conversion sequence is a user-defined conversion sequence. If multiple
   //   constructors are viable but none is better than the others, the
   //   implicit conversion sequence is a user-defined conversion sequence.
   if (ToType->isRecordType() && !ToType->isAggregateType()) {
     // This function can deal with initializer lists.
-    return TryUserDefinedConversion(S, From, ToType, SuppressUserConversions,
+    return TryUserDefinedConversion(S, From, ToType, UserConversions,
                                     AllowedExplicit::None,
                                     InOverloadResolution, /*CStyle=*/false,
                                     AllowObjCWritebackConversion,
                                     /*AllowObjCConversionOnExplicit=*/false);
   }
 
   // C++14 [over.ics.list]p5:
   // C++11 [over.ics.list]p4:
if (From->getNumInits() == 1) {
       }
 
       // Compute some basic properties of the types and the initializer.
       Sema::ReferenceCompareResult RefRelationship =
           S.CompareReferenceRelationship(From->getBeginLoc(), T1, T2);
 
       if (RefRelationship >= Sema::Ref_Related) {
         return TryReferenceInit(S, Init, ToType, /*FIXME*/ From->getBeginLoc(),
-                                SuppressUserConversions,
+                                UserConversions,
                                 /*AllowExplicit=*/false);
       }
     }
 
     // Otherwise, we bind the reference to a temporary created from the
     // initializer list.
-    Result = TryListConversion(S, From, T1, SuppressUserConversions,
+    Result = TryListConversion(S, From, T1, UserConversions,
                                InOverloadResolution,
                                AllowObjCWritebackConversion);
     if (Result.isFailure())
       return Result;
     assert(!Result.isEllipsis() &&
            "Sub-initialization cannot result in ellipsis conversion.");
 
     // Can we even bind to a temporary?
TryListConversion(Sema &S, InitListExpr *From, QualType ToType,
   //   Otherwise, if the parameter type is not a class:
   if (!ToType->isRecordType()) {
     //    - if the initializer list has one element that is not itself an
     //      initializer list, the implicit conversion sequence is the one
     //      required to convert the element to the parameter type.
     unsigned NumInits = From->getNumInits();
     if (NumInits == 1 && !isa<InitListExpr>(From->getInit(0)))
       Result = TryCopyInitialization(S, From->getInit(0), ToType,
-                                     SuppressUserConversions,
+                                     UserConversions,
                                      InOverloadResolution,
                                      AllowObjCWritebackConversion);
     //    - if the initializer list has no elements, the implicit conversion
     //      sequence is the identity conversion.
     else if (NumInits == 0) {
       Result.setStandard();
       Result.Standard.setAsIdentityConversion();
       Result.Standard.setFromType(ToType);

 /// TryCopyInitialization - Try to copy-initialize a value of type
 /// ToType from the expression From. Return the implicit conversion
 /// sequence required to pass this argument, which may be a bad
 /// conversion sequence (meaning that the argument cannot be passed to
 /// a parameter of this type). If @p SuppressUserConversions, then we
 /// do not permit any user-defined conversion sequences.
 static ImplicitConversionSequence
 TryCopyInitialization(Sema &S, Expr *From, QualType ToType,
-                      bool SuppressUserConversions,
+                      Sema::UserDefinedConversionsKind UserConversions,
                       bool InOverloadResolution,
                       bool AllowObjCWritebackConversion,
                       bool AllowExplicit) {
   if (InitListExpr *FromInitList = dyn_cast<InitListExpr>(From))
-    return TryListConversion(S, FromInitList, ToType, SuppressUserConversions,
+    return TryListConversion(S, FromInitList, ToType, UserConversions,
                              InOverloadResolution,AllowObjCWritebackConversion);
 
   if (ToType->isReferenceType())
     return TryReferenceInit(S, From, ToType,
                             /*FIXME:*/ From->getBeginLoc(),
-                            SuppressUserConversions, AllowExplicit);
+                            UserConversions, AllowExplicit);
 
   return TryImplicitConversion(S, From, ToType,
-                               SuppressUserConversions,
+                               UserConversions,
                                AllowedExplicit::None,
                                InOverloadResolution,
                                /*CStyle=*/false,
                                AllowObjCWritebackConversion,
                                /*AllowObjCConversionOnExplicit=*/false);
 }
 
 static bool TryCopyInitialization(const CanQualType FromQTy,
                                   const CanQualType ToQTy,
                                   Sema &S,
                                   SourceLocation Loc,
                                   ExprValueKind FromVK) {
   OpaqueValueExpr TmpExpr(Loc, FromQTy, FromVK);
   ImplicitConversionSequence ICS =
-    TryCopyInitialization(S, &TmpExpr, ToQTy, true, true, false);
+    TryCopyInitialization(S, &TmpExpr, ToQTy, Sema::UDC_Suppress, true, false);
 
   return !ICS.isBad();
 }
 
 /// TryObjectArgumentInitialization - Try to initialize the object
 /// parameter of the given member function (@c Method) from the
 /// expression @p From.
 static ImplicitConversionSequence
case BadConversionSequence::rvalue_ref_to_lvalue: {
           << IsRValueQualified;
       Diag(Method->getLocation(), diag::note_previous_decl)
         << Method->getDeclName();
       return ExprError();
     }
 
     case BadConversionSequence::no_conversion:
     case BadConversionSequence::unrelated_class:
+    case BadConversionSequence::suppressed_user_conversion:
       break;
     }
 
     return Diag(From->getBeginLoc(), diag::err_member_function_call_bad_type)
            << ImplicitParamRecordType << FromRecordType
            << From->getSourceRange();
   }
 
Sema::PerformObjectArgumentInitialization(Expr *From,
   return From;
 }
 
 /// TryContextuallyConvertToBool - Attempt to contextually convert the
 /// expression From to bool (C++0x [conv]p3).
 static ImplicitConversionSequence
 TryContextuallyConvertToBool(Sema &S, Expr *From) {
   return TryImplicitConversion(S, From, S.Context.BoolTy,
-                               /*SuppressUserConversions=*/false,
+                               Sema::UDC_Allow,
                                AllowedExplicit::Conversions,
                                /*InOverloadResolution=*/false,
                                /*CStyle=*/false,
                                /*AllowObjCWritebackConversion=*/false,
                                /*AllowObjCConversionOnExplicit=*/false);
 }
 
 /// PerformContextuallyConvertToBool - Perform a contextual conversion
static ExprResult CheckConvertedConstantExpression(Sema &S, Expr *From,
   // C++1z [stmt.if]p2:
   //  If the if statement is of the form if constexpr, the value of the
   //  condition shall be a contextually converted constant expression of type
   //  bool.
   ImplicitConversionSequence ICS =
       CCE == Sema::CCEK_ConstexprIf || CCE == Sema::CCEK_ExplicitBool
           ? TryContextuallyConvertToBool(S, From)
           : TryCopyInitialization(S, From, T,
-                                  /*SuppressUserConversions=*/false,
+                                  Sema::UDC_Allow,
                                   /*InOverloadResolution=*/false,
                                   /*AllowObjCWritebackConversion=*/false,
                                   /*AllowExplicit=*/false);
   StandardConversionSequence *SCS = nullptr;
   switch (ICS.getKind()) {
   case ImplicitConversionSequence::StandardConversion:
     SCS = &ICS.Standard;
     break;

 /// convert the expression From to an Objective-C pointer type.
 static ImplicitConversionSequence
 TryContextuallyConvertToObjCPointer(Sema &S, Expr *From) {
   // Do an implicit conversion to 'id'.
   QualType Ty = S.Context.getObjCIdType();
   ImplicitConversionSequence ICS
     = TryImplicitConversion(S, From, Ty,
                             // FIXME: Are these flags correct?
-                            /*SuppressUserConversions=*/false,
+                            Sema::UDC_Allow,
                             AllowedExplicit::Conversions,
                             /*InOverloadResolution=*/false,
                             /*CStyle=*/false,
                             /*AllowObjCWritebackConversion=*/false,
                             /*AllowObjCConversionOnExplicit=*/true);
 
   // Strip off any final conversions to 'id'.
   switch (ICS.getKind()) {

 /// @p SuppressUserConversions, then don't allow user-defined
 /// conversions via constructors or conversion operators.
 ///
 /// \param PartialOverloading true if we are performing "partial" overloading
 /// based on an incomplete set of function arguments. This feature is used by
 /// code completion.
 void Sema::AddOverloadCandidate(
     FunctionDecl *Function, DeclAccessPair FoundDecl, ArrayRef<Expr *> Args,
-    OverloadCandidateSet &CandidateSet, bool SuppressUserConversions,
+    OverloadCandidateSet &CandidateSet, 
+    UserDefinedConversionsKind UserConversions,
     bool PartialOverloading, bool AllowExplicit, bool AllowExplicitConversions,
     ADLCallKind IsADLCandidate, ConversionSequenceList EarlyConversions,
     OverloadCandidateParamOrder PO) {
   const FunctionProtoType *Proto
     = dyn_cast<FunctionProtoType>(Function->getType()->getAs<FunctionType>());
   assert(Proto && "Functions without a prototype cannot be overloaded");
   assert(!Function->getDescribedFunctionTemplate() &&
          "Use AddTemplateOverloadCandidate for function templates");
 
   if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Function)) {
     if (!isa<CXXConstructorDecl>(Method)) {
       // If we get here, it's because we're calling a member function
       // that is named without a member access expression (e.g.,
       // "this->f") that was either written explicitly or created
       // implicitly. This can happen with a qualified call to a member
       // function, e.g., X::f(). We use an empty type for the implied
       // object argument (C++ [over.call.func]p3), and the acting context
       // is irrelevant.
       AddMethodCandidate(Method, FoundDecl, Method->getParent(), QualType(),
                          Expr::Classification::makeSimpleLValue(), Args,
-                         CandidateSet, SuppressUserConversions,
+                         CandidateSet, UserConversions,
                          PartialOverloading, EarlyConversions, PO);
       return;
     }
     // We treat a constructor like a non-member function, since its object
     // argument doesn't participate in overload resolution.
   }
 
   if (!CandidateSet.isNewCandidate(Function, PO))
if (Candidate.Conversions[ConvIdx].isInitialized()) {
       // template argument deduction.
     } else if (ArgIdx < NumParams) {
       // (C++ 13.3.2p3): for F to be a viable function, there shall
       // exist for each argument an implicit conversion sequence
       // (13.3.3.1) that converts that argument to the corresponding
       // parameter of F.
       QualType ParamType = Proto->getParamType(ArgIdx);
       Candidate.Conversions[ConvIdx] = TryCopyInitialization(
-          *this, Args[ArgIdx], ParamType, SuppressUserConversions,
+          *this, Args[ArgIdx], ParamType, UserConversions,
           /*InOverloadResolution=*/true,
           /*AllowObjCWritebackConversion=*/
           getLangOpts().ObjCAutoRefCount, AllowExplicitConversions);
       if (Candidate.Conversions[ConvIdx].isBad()) {
         Candidate.Viable = false;
         Candidate.FailureKind = ovl_fail_bad_conversion;
         return;
       }
for (unsigned i = 0; i < NumNamedArgs; i++) {
       // If the parameter is __unknown_anytype, move on to the next method.
       if (param->getType() == Context.UnknownAnyTy) {
         Match = false;
         break;
       }
 
       ImplicitConversionSequence ConversionState
         = TryCopyInitialization(*this, argExpr, param->getType(),
-                                /*SuppressUserConversions*/false,
+                                UDC_Allow,
                                 /*InOverloadResolution=*/true,
                                 /*AllowObjCWritebackConversion=*/
                                 getLangOpts().ObjCAutoRefCount,
                                 /*AllowExplicit*/false);
       // This function looks for a reasonably-exact match, so we consider
       // incompatible pointer conversions to be a failure here.
       if (ConversionState.isBad() ||
           (ConversionState.isStandard() &&

 }
 
 /// Add all of the function declarations in the given function set to
 /// the overload candidate set.
 void Sema::AddFunctionCandidates(const UnresolvedSetImpl &Fns,
                                  ArrayRef<Expr *> Args,
                                  OverloadCandidateSet &CandidateSet,
                                  TemplateArgumentListInfo *ExplicitTemplateArgs,
-                                 bool SuppressUserConversions,
+                                 UserDefinedConversionsKind UserConversions,
                                  bool PartialOverloading,
                                  bool FirstArgumentIsBase) {
   for (UnresolvedSetIterator F = Fns.begin(), E = Fns.end(); F != E; ++F) {
     NamedDecl *D = F.getDecl()->getUnderlyingDecl();
     ArrayRef<Expr *> FunctionArgs = Args;
 
     FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D);
     FunctionDecl *FD =
if (isa<CXXMethodDecl>(FD) && !cast<CXXMethodDecl>(FD)->isStatic()) {
         } // .. else there is an implicit base.
         FunctionArgs = Args.slice(1);
       }
       if (FunTmpl) {
         AddMethodTemplateCandidate(
             FunTmpl, F.getPair(),
             cast<CXXRecordDecl>(FunTmpl->getDeclContext()),
             ExplicitTemplateArgs, ObjectType, ObjectClassification,
-            FunctionArgs, CandidateSet, SuppressUserConversions,
+            FunctionArgs, CandidateSet, UserConversions,
             PartialOverloading);
       } else {
         AddMethodCandidate(cast<CXXMethodDecl>(FD), F.getPair(),
                            cast<CXXMethodDecl>(FD)->getParent(), ObjectType,
                            ObjectClassification, FunctionArgs, CandidateSet,
-                           SuppressUserConversions, PartialOverloading);
+                           UserConversions, PartialOverloading);
       }
     } else {
       // This branch handles both standalone functions and static methods.
 
       // Slice the first argument (which is the base) when we access
       // static method as non-static.
       if (Args.size() > 0 &&
           (!Args[0] || (FirstArgumentIsBase && isa<CXXMethodDecl>(FD) &&
                         !isa<CXXConstructorDecl>(FD)))) {
         assert(cast<CXXMethodDecl>(FD)->isStatic());
         FunctionArgs = Args.slice(1);
       }
       if (FunTmpl) {
         AddTemplateOverloadCandidate(FunTmpl, F.getPair(),
                                      ExplicitTemplateArgs, FunctionArgs,
-                                     CandidateSet, SuppressUserConversions,
+                                     CandidateSet, UserConversions,
                                      PartialOverloading);
       } else {
         AddOverloadCandidate(FD, F.getPair(), FunctionArgs, CandidateSet,
-                             SuppressUserConversions, PartialOverloading);
+                             UserConversions, PartialOverloading);
       }
     }
   }
 }
 
 /// AddMethodCandidate - Adds a named decl (which is some kind of
 /// method) as a method candidate to the given overload set.
 void Sema::AddMethodCandidate(DeclAccessPair FoundDecl, QualType ObjectType,
                               Expr::Classification ObjectClassification,
                               ArrayRef<Expr *> Args,
                               OverloadCandidateSet &CandidateSet,
-                              bool SuppressUserConversions,
+                              UserDefinedConversionsKind UserConversions,
                               OverloadCandidateParamOrder PO) {
   NamedDecl *Decl = FoundDecl.getDecl();
   CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(Decl->getDeclContext());
 
   if (isa<UsingShadowDecl>(Decl))
     Decl = cast<UsingShadowDecl>(Decl)->getTargetDecl();
 
   if (FunctionTemplateDecl *TD = dyn_cast<FunctionTemplateDecl>(Decl)) {
     assert(isa<CXXMethodDecl>(TD->getTemplatedDecl()) &&
            "Expected a member function template");
     AddMethodTemplateCandidate(TD, FoundDecl, ActingContext,
                                /*ExplicitArgs*/ nullptr, ObjectType,
                                ObjectClassification, Args, CandidateSet,
-                               SuppressUserConversions, false, PO);
+                               UserConversions, false, PO);
   } else {
     AddMethodCandidate(cast<CXXMethodDecl>(Decl), FoundDecl, ActingContext,
                        ObjectType, ObjectClassification, Args, CandidateSet,
-                       SuppressUserConversions, false, None, PO);
+                       UserConversions, false, None, PO);
   }
 }
 
 /// AddMethodCandidate - Adds the given C++ member function to the set
 /// of candidate functions, using the given function call arguments
 /// and the object argument (@c Object). For example, in a call
 /// @c o.f(a1,a2), @c Object will contain @c o and @c Args will contain
 /// both @c a1 and @c a2. If @p SuppressUserConversions, then don't
 /// allow user-defined conversions via constructors or conversion
 /// operators.
 void
 Sema::AddMethodCandidate(CXXMethodDecl *Method, DeclAccessPair FoundDecl,
                          CXXRecordDecl *ActingContext, QualType ObjectType,
                          Expr::Classification ObjectClassification,
                          ArrayRef<Expr *> Args,
                          OverloadCandidateSet &CandidateSet,
-                         bool SuppressUserConversions,
+                         UserDefinedConversionsKind UserConversions,
                          bool PartialOverloading,
                          ConversionSequenceList EarlyConversions,
                          OverloadCandidateParamOrder PO) {
   const FunctionProtoType *Proto
     = dyn_cast<FunctionProtoType>(Method->getType()->getAs<FunctionType>());
   assert(Proto && "Methods without a prototype cannot be overloaded");
   assert(!isa<CXXConstructorDecl>(Method) &&
          "Use AddOverloadCandidate for constructors");
for (unsigned ArgIdx = 0; ArgIdx < Args.size(); ++ArgIdx) {
     } else if (ArgIdx < NumParams) {
       // (C++ 13.3.2p3): for F to be a viable function, there shall
       // exist for each argument an implicit conversion sequence
       // (13.3.3.1) that converts that argument to the corresponding
       // parameter of F.
       QualType ParamType = Proto->getParamType(ArgIdx);
       Candidate.Conversions[ConvIdx]
         = TryCopyInitialization(*this, Args[ArgIdx], ParamType,
-                                SuppressUserConversions,
+                                UserConversions,
                                 /*InOverloadResolution=*/true,
                                 /*AllowObjCWritebackConversion=*/
                                   getLangOpts().ObjCAutoRefCount);
       if (Candidate.Conversions[ConvIdx].isBad()) {
         Candidate.Viable = false;
         Candidate.FailureKind = ovl_fail_bad_conversion;
         return;
       }

 /// Add a C++ member function template as a candidate to the candidate
 /// set, using template argument deduction to produce an appropriate member
 /// function template specialization.
 void Sema::AddMethodTemplateCandidate(
     FunctionTemplateDecl *MethodTmpl, DeclAccessPair FoundDecl,
     CXXRecordDecl *ActingContext,
     TemplateArgumentListInfo *ExplicitTemplateArgs, QualType ObjectType,
     Expr::Classification ObjectClassification, ArrayRef<Expr *> Args,
-    OverloadCandidateSet &CandidateSet, bool SuppressUserConversions,
+    OverloadCandidateSet &CandidateSet, 
+    UserDefinedConversionsKind UserConversions,
     bool PartialOverloading, OverloadCandidateParamOrder PO) {
   if (!CandidateSet.isNewCandidate(MethodTmpl, PO))
     return;
 
   // C++ [over.match.funcs]p7:
   //   In each case where a candidate is a function template, candidate
   //   function template specializations are generated using template argument
   //   deduction (14.8.3, 14.8.2). Those candidates are then handled as
   //   candidate functions in the usual way.113) A given name can refer to one
   //   or more function templates and also to a set of overloaded non-template
   //   functions. In such a case, the candidate functions generated from each
   //   function template are combined with the set of non-template candidate
   //   functions.
   TemplateDeductionInfo Info(CandidateSet.getLocation());
   FunctionDecl *Specialization = nullptr;
   ConversionSequenceList Conversions;
   if (TemplateDeductionResult Result = DeduceTemplateArguments(
           MethodTmpl, ExplicitTemplateArgs, Args, Specialization, Info,
           PartialOverloading, [&](ArrayRef<QualType> ParamTypes) {
             return CheckNonDependentConversions(
                 MethodTmpl, ParamTypes, Args, CandidateSet, Conversions,
-                SuppressUserConversions, ActingContext, ObjectType,
+                UserConversions, ActingContext, ObjectType,
                 ObjectClassification, PO);
           })) {
     OverloadCandidate &Candidate =
         CandidateSet.addCandidate(Conversions.size(), Conversions);
     Candidate.FoundDecl = FoundDecl;
     Candidate.Function = MethodTmpl->getTemplatedDecl();
     Candidate.Viable = false;
     Candidate.RewriteKind =
void Sema::AddMethodTemplateCandidate(
 
   // Add the function template specialization produced by template argument
   // deduction as a candidate.
   assert(Specialization && "Missing member function template specialization?");
   assert(isa<CXXMethodDecl>(Specialization) &&
          "Specialization is not a member function?");
   AddMethodCandidate(cast<CXXMethodDecl>(Specialization), FoundDecl,
                      ActingContext, ObjectType, ObjectClassification, Args,
-                     CandidateSet, SuppressUserConversions, PartialOverloading,
+                     CandidateSet, UserConversions, PartialOverloading,
                      Conversions, PO);
 }
 
 /// Determine whether a given function template has a simple explicit specifier
 /// or a non-value-dependent explicit-specification that evaluates to true.
 static bool isNonDependentlyExplicit(FunctionTemplateDecl *FTD) {
   return ExplicitSpecifier::getFromDecl(FTD->getTemplatedDecl()).isExplicit();
 }
 
 /// Add a C++ function template specialization as a candidate
 /// in the candidate set, using template argument deduction to produce
 /// an appropriate function template specialization.
 void Sema::AddTemplateOverloadCandidate(
     FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl,
     TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args,
-    OverloadCandidateSet &CandidateSet, bool SuppressUserConversions,
+    OverloadCandidateSet &CandidateSet, 
+    UserDefinedConversionsKind UserConversions,
     bool PartialOverloading, bool AllowExplicit, ADLCallKind IsADLCandidate,
     OverloadCandidateParamOrder PO) {
   if (!CandidateSet.isNewCandidate(FunctionTemplate, PO))
     return;
 
   // If the function template has a non-dependent explicit specification,
   // exclude it now if appropriate; we are not permitted to perform deduction
   // and substitution in this case.
void Sema::AddTemplateOverloadCandidate(
   TemplateDeductionInfo Info(CandidateSet.getLocation());
   FunctionDecl *Specialization = nullptr;
   ConversionSequenceList Conversions;
   if (TemplateDeductionResult Result = DeduceTemplateArguments(
           FunctionTemplate, ExplicitTemplateArgs, Args, Specialization, Info,
           PartialOverloading, [&](ArrayRef<QualType> ParamTypes) {
             return CheckNonDependentConversions(
                 FunctionTemplate, ParamTypes, Args, CandidateSet, Conversions,
-                SuppressUserConversions, nullptr, QualType(), {}, PO);
+                UserConversions, nullptr, QualType(), {}, PO);
           })) {
     OverloadCandidate &Candidate =
         CandidateSet.addCandidate(Conversions.size(), Conversions);
     Candidate.FoundDecl = FoundDecl;
     Candidate.Function = FunctionTemplate->getTemplatedDecl();
     Candidate.Viable = false;
     Candidate.RewriteKind =
       CandidateSet.getRewriteInfo().getRewriteKind(Candidate.Function, PO);
if (TemplateDeductionResult Result = DeduceTemplateArguments(
     }
     return;
   }
 
   // Add the function template specialization produced by template argument
   // deduction as a candidate.
   assert(Specialization && "Missing function template specialization?");
   AddOverloadCandidate(
-      Specialization, FoundDecl, Args, CandidateSet, SuppressUserConversions,
+      Specialization, FoundDecl, Args, CandidateSet, UserConversions,
       PartialOverloading, AllowExplicit,
       /*AllowExplicitConversions*/ false, IsADLCandidate, Conversions, PO);
 }
 
 /// Check that implicit conversion sequences can be formed for each argument
 /// whose corresponding parameter has a non-dependent type, per DR1391's
 /// [temp.deduct.call]p10.
 bool Sema::CheckNonDependentConversions(
     FunctionTemplateDecl *FunctionTemplate, ArrayRef<QualType> ParamTypes,
     ArrayRef<Expr *> Args, OverloadCandidateSet &CandidateSet,
-    ConversionSequenceList &Conversions, bool SuppressUserConversions,
+    ConversionSequenceList &Conversions, 
+    UserDefinedConversionsKind UserConversions,
     CXXRecordDecl *ActingContext, QualType ObjectType,
     Expr::Classification ObjectClassification, OverloadCandidateParamOrder PO) {
   // FIXME: The cases in which we allow explicit conversions for constructor
   // arguments never consider calling a constructor template. It's not clear
   // that is correct.
   const bool AllowExplicit = false;
 
   auto *FD = FunctionTemplate->getTemplatedDecl();
for (unsigned I = 0, N = std::min(ParamTypes.size(), Args.size()); I != N;
        ++I) {
     QualType ParamType = ParamTypes[I];
     if (!ParamType->isDependentType()) {
       unsigned ConvIdx = PO == OverloadCandidateParamOrder::Reversed
                              ? 0
                              : (ThisConversions + I);
       Conversions[ConvIdx]
         = TryCopyInitialization(*this, Args[I], ParamType,
-                                SuppressUserConversions,
+                                UserConversions,
                                 /*InOverloadResolution=*/true,
                                 /*AllowObjCWritebackConversion=*/
                                   getLangOpts().ObjCAutoRefCount,
                                 AllowExplicit);
       if (Conversions[ConvIdx].isBad())
         return true;
     }
   }
void Sema::AddConversionCandidate(
   QualType CallResultType = ConversionType.getNonLValueExprType(Context);
 
   alignas(CallExpr) char Buffer[sizeof(CallExpr) + sizeof(Stmt *)];
   CallExpr *TheTemporaryCall = CallExpr::CreateTemporary(
       Buffer, &ConversionFn, CallResultType, VK, From->getBeginLoc());
 
   ImplicitConversionSequence ICS =
       TryCopyInitialization(*this, TheTemporaryCall, ToType,
-                            /*SuppressUserConversions=*/true,
+                            Sema::UDC_Suppress,
                             /*InOverloadResolution=*/false,
                             /*AllowObjCWritebackConversion=*/false);
 
   switch (ICS.getKind()) {
   case ImplicitConversionSequence::StandardConversion:
     Candidate.FinalConversion = ICS.Standard;
 
     // C++ [over.ics.user]p3:
if (ToType->isRValueReferenceType() &&
         ICS.Standard.First == ICK_Lvalue_To_Rvalue) {
       Candidate.Viable = false;
       Candidate.FailureKind = ovl_fail_bad_final_conversion;
       return;
     }
     break;
 
   case ImplicitConversionSequence::BadConversion:
+    if (ICS.Bad.Kind == BadConversionSequence::suppressed_user_conversion)
+      Candidate.Conversions[0].setBad(BadConversionSequence::suppressed_user_conversion,
+                                      ICS.Bad.getFromType(), ICS.Bad.getToType());
     Candidate.Viable = false;
     Candidate.FailureKind = ovl_fail_bad_final_conversion;
     return;
 
   default:
     llvm_unreachable(
            "Can only end up with a standard conversion sequence or failure");
   }
for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
     if (ArgIdx < NumParams) {
       // (C++ 13.3.2p3): for F to be a viable function, there shall
       // exist for each argument an implicit conversion sequence
       // (13.3.3.1) that converts that argument to the corresponding
       // parameter of F.
       QualType ParamType = Proto->getParamType(ArgIdx);
       Candidate.Conversions[ArgIdx + 1]
         = TryCopyInitialization(*this, Args[ArgIdx], ParamType,
-                                /*SuppressUserConversions=*/false,
+                                Sema::UDC_Allow,
                                 /*InOverloadResolution=*/false,
                                 /*AllowObjCWritebackConversion=*/
                                   getLangOpts().ObjCAutoRefCount);
       if (Candidate.Conversions[ArgIdx + 1].isBad()) {
         Candidate.Viable = false;
         Candidate.FailureKind = ovl_fail_bad_conversion;
         return;
       }
assert(!isa<CXXMethodDecl>(FD) &&
            "unqualified operator lookup found a member function");
 
     if (FunTmpl) {
       AddTemplateOverloadCandidate(FunTmpl, F.getPair(), ExplicitTemplateArgs,
                                    FunctionArgs, CandidateSet);
       if (CandidateSet.getRewriteInfo().shouldAddReversed(Context, FD))
         AddTemplateOverloadCandidate(
             FunTmpl, F.getPair(), ExplicitTemplateArgs,
-            {FunctionArgs[1], FunctionArgs[0]}, CandidateSet, false, false,
+            {FunctionArgs[1], FunctionArgs[0]}, CandidateSet, UDC_Allow, false,
             true, ADLCallKind::NotADL, OverloadCandidateParamOrder::Reversed);
     } else {
       if (ExplicitTemplateArgs)
         continue;
       AddOverloadCandidate(FD, F.getPair(), FunctionArgs, CandidateSet);
       if (CandidateSet.getRewriteInfo().shouldAddReversed(Context, FD))
         AddOverloadCandidate(FD, F.getPair(),
                              {FunctionArgs[1], FunctionArgs[0]}, CandidateSet,
-                             false, false, true, false, ADLCallKind::NotADL,
+                             UDC_Allow, false, true, false, ADLCallKind::NotADL,
                              None, OverloadCandidateParamOrder::Reversed);
     }
   }
 }
 
 /// Add overload candidates for overloaded operators that are
 /// member functions.
 ///
if (const RecordType *T1Rec = T1->getAs<RecordType>()) {
     Operators.suppressDiagnostics();
 
     for (LookupResult::iterator Oper = Operators.begin(),
                              OperEnd = Operators.end();
          Oper != OperEnd;
          ++Oper)
       AddMethodCandidate(Oper.getPair(), Args[0]->getType(),
                          Args[0]->Classify(Context), Args.slice(1),
-                         CandidateSet, /*SuppressUserConversion=*/false, PO);
+                         CandidateSet, Sema::UDC_Allow, PO);
   }
 }
 
 /// AddBuiltinCandidate - Add a candidate for a built-in
 /// operator. ResultTy and ParamTys are the result and parameter types
 /// of the built-in candidate, respectively. Args and NumArgs are the
 /// arguments being passed to the candidate. IsAssignmentOperator
 /// should be true when this built-in candidate is an assignment
for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
     if (ArgIdx < NumContextualBoolArguments) {
       assert(ParamTys[ArgIdx] == Context.BoolTy &&
              "Contextual conversion to bool requires bool type");
       Candidate.Conversions[ArgIdx]
         = TryContextuallyConvertToBool(*this, Args[ArgIdx]);
     } else {
       Candidate.Conversions[ArgIdx]
         = TryCopyInitialization(*this, Args[ArgIdx], ParamTys[ArgIdx],
-                                ArgIdx == 0 && IsAssignmentOperator,
+                                ArgIdx == 0 && IsAssignmentOperator 
+                                    ? Sema::UDC_Suppress 
+                                    : Sema::UDC_Allow,
                                 /*InOverloadResolution=*/false,
                                 /*AllowObjCWritebackConversion=*/
                                   getLangOpts().ObjCAutoRefCount);
     }
     if (Candidate.Conversions[ArgIdx].isBad()) {
       Candidate.Viable = false;
       Candidate.FailureKind = ovl_fail_bad_conversion;
       break;
Sema::AddArgumentDependentLookupCandidates(DeclarationName Name,
   // set.
   for (ADLResult::iterator I = Fns.begin(), E = Fns.end(); I != E; ++I) {
     DeclAccessPair FoundDecl = DeclAccessPair::make(*I, AS_none);
 
     if (FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
       if (ExplicitTemplateArgs)
         continue;
 
-      AddOverloadCandidate(
-          FD, FoundDecl, Args, CandidateSet, /*SuppressUserConversions=*/false,
-          PartialOverloading, /*AllowExplicit=*/true,
-          /*AllowExplicitConversions=*/false, ADLCallKind::UsesADL);
+      AddOverloadCandidate(FD, FoundDecl, Args, CandidateSet,
+                           Sema::UDC_Allow, PartialOverloading,
+                           /*AllowExplicit*/ true,
+                           /*AllowExplicitConversions*/ false,
+                           ADLCallKind::UsesADL);
       if (CandidateSet.getRewriteInfo().shouldAddReversed(Context, FD)) {
         AddOverloadCandidate(
             FD, FoundDecl, {Args[1], Args[0]}, CandidateSet,
-            /*SuppressUserConversions=*/false, PartialOverloading,
+            UDC_Allow, PartialOverloading,
             /*AllowExplicit=*/true, /*AllowExplicitConversions=*/false,
             ADLCallKind::UsesADL, None, OverloadCandidateParamOrder::Reversed);
       }
     } else {
       auto *FTD = cast<FunctionTemplateDecl>(*I);
       AddTemplateOverloadCandidate(
           FTD, FoundDecl, ExplicitTemplateArgs, Args, CandidateSet,
-          /*SuppressUserConversions=*/false, PartialOverloading,
+          UDC_Allow, PartialOverloading,
           /*AllowExplicit=*/true, ADLCallKind::UsesADL);
       if (CandidateSet.getRewriteInfo().shouldAddReversed(
               Context, FTD->getTemplatedDecl())) {
         AddTemplateOverloadCandidate(
             FTD, FoundDecl, ExplicitTemplateArgs, {Args[1], Args[0]},
-            CandidateSet, /*SuppressUserConversions=*/false, PartialOverloading,
+            CandidateSet, UDC_Allow, PartialOverloading,
             /*AllowExplicit=*/true, ADLCallKind::UsesADL,
             OverloadCandidateParamOrder::Reversed);
-      }
+      }    
     }
   }
 }
 
 namespace {
 enum class Comparison { Equal, Better, Worse };
 }
 
if (isa<ObjCObjectPointerType>(CFromTy) &&
         return;
       }
   }
 
   if (TakingCandidateAddress &&
       !checkAddressOfCandidateIsAvailable(S, Cand->Function))
     return;
 
+  if (Conv.Bad.Kind == BadConversionSequence::suppressed_user_conversion) {
+    S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_user_defined_conv)
+        << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second
+        << FnDesc << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
+        << FromTy << ToTy;
+    return;
+  }
+
   // Emit the generic diagnostic and, optionally, add the hints to it.
   PartialDiagnostic FDiag = S.PDiag(diag::note_ovl_candidate_bad_conv);
   FDiag << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc
         << (FromExpr ? FromExpr->getSourceRange() : SourceRange()) << FromTy
         << ToTy << (unsigned)isObjectArgument << I + 1
         << (unsigned)(Cand->Fix.Kind);
 
   // If we can fix the conversion, suggest the FixIts.
S.Diag(Fn->getLocation(),
         << QualsForPrinting;
     MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
     return;
   }
 
   case ovl_fail_trivial_conversion:
   case ovl_fail_bad_final_conversion:
   case ovl_fail_final_conversion_not_exact:
-    return S.NoteOverloadCandidate(Cand->FoundDecl, Fn, Cand->getRewriteKind());
-
   case ovl_fail_bad_conversion: {
     unsigned I = (Cand->IgnoreObjectArgument ? 1 : 0);
     for (unsigned N = Cand->Conversions.size(); I != N; ++I)
       if (Cand->Conversions[I].isBad())
         return DiagnoseBadConversion(S, Cand, I, TakingCandidateAddress);
 
     // FIXME: this currently happens when we're called from SemaInit
     // when user-conversion overload fails.  Figure out how to handle
if (Cand->Conversions[ConvIdx].isInitialized()) {
       // We've already checked this conversion.
     } else if (ParamIdx < ParamTypes.size()) {
       if (ParamTypes[ParamIdx]->isDependentType())
         Cand->Conversions[ConvIdx].setAsIdentityConversion(
             Args[ArgIdx]->getType());
       else {
         Cand->Conversions[ConvIdx] =
             TryCopyInitialization(S, Args[ArgIdx], ParamTypes[ParamIdx],
-                                  SuppressUserConversions,
+                                  SuppressUserConversions 
+                                      ? Sema::UDC_Suppress 
+                                      : Sema::UDC_Allow,
                                   /*InOverloadResolution=*/true,
                                   /*AllowObjCWritebackConversion=*/
                                   S.getLangOpts().ObjCAutoRefCount);
         // Store the FixIt in the candidate if it exists.
         if (!Unfixable && Cand->Conversions[ConvIdx].isBad())
           Unfixable = !Cand->TryToFixBadConversion(ConvIdx, S);
       }
     } else
if (ExplicitTemplateArgs) {
       assert(!KnownValid && "Explicit template arguments?");
       return;
     }
     // Prevent ill-formed function decls to be added as overload candidates.
     if (!dyn_cast<FunctionProtoType>(Func->getType()->getAs<FunctionType>()))
       return;
 
     S.AddOverloadCandidate(Func, FoundDecl, Args, CandidateSet,
-                           /*SuppressUserConversions=*/false,
+                           Sema::UDC_Allow,
                            PartialOverloading);
     return;
   }
 
   if (FunctionTemplateDecl *FuncTemplate
       = dyn_cast<FunctionTemplateDecl>(Callee)) {
     S.AddTemplateOverloadCandidate(FuncTemplate, FoundDecl,
                                    ExplicitTemplateArgs, Args, CandidateSet,
-                                   /*SuppressUserConversions=*/false,
+                                   Sema::UDC_Allow,
                                    PartialOverloading);
     return;
   }
 
   assert(!KnownValid && "unhandled case in overloaded call candidate");
 }
 
 /// Add the overload candidates named by callee and/or found by argument
for (UnresolvedMemberExpr::decls_iterator I = UnresExpr->decls_begin(),
       if (isa<UsingShadowDecl>(Func))
         Func = cast<UsingShadowDecl>(Func)->getTargetDecl();
 
 
       // Microsoft supports direct constructor calls.
       if (getLangOpts().MicrosoftExt && isa<CXXConstructorDecl>(Func)) {
         AddOverloadCandidate(cast<CXXConstructorDecl>(Func), I.getPair(), Args,
                              CandidateSet,
-                             /*SuppressUserConversions*/ false);
+                             Sema::UDC_Allow);
       } else if ((Method = dyn_cast<CXXMethodDecl>(Func))) {
         // If explicit template arguments were provided, we can't call a
         // non-template member function.
         if (TemplateArgs)
           continue;
 
         AddMethodCandidate(Method, I.getPair(), ActingDC, ObjectType,
                            ObjectClassification, Args, CandidateSet,
-                           /*SuppressUserConversions=*/false);
+                           Sema::UDC_Allow);
       } else {
         AddMethodTemplateCandidate(
             cast<FunctionTemplateDecl>(Func), I.getPair(), ActingDC,
             TemplateArgs, ObjectType, ObjectClassification, Args, CandidateSet,
-            /*SuppressUserConversions=*/false);
+            Sema::UDC_Allow);
       }
     }
 
     DeclarationName DeclName = UnresExpr->getMemberName();
 
     UnbridgedCasts.restore();
 
     OverloadCandidateSet::iterator Best;
Sema::BuildCallToObjectOfClassType(Scope *S, Expr *Obj,
   LookupResult R(*this, OpName, LParenLoc, LookupOrdinaryName);
   LookupQualifiedName(R, Record->getDecl());
   R.suppressDiagnostics();
 
   for (LookupResult::iterator Oper = R.begin(), OperEnd = R.end();
        Oper != OperEnd; ++Oper) {
     AddMethodCandidate(Oper.getPair(), Object.get()->getType(),
                        Object.get()->Classify(Context), Args, CandidateSet,
-                       /*SuppressUserConversion=*/false);
+                       Sema::UDC_Allow);
   }
 
   // C++ [over.call.object]p2:
   //   In addition, for each (non-explicit in C++0x) conversion function
   //   declared in T of the form
   //
   //        operator conversion-type-id () cv-qualifier;
   //
Sema::BuildOverloadedArrowExpr(Scope *S, Expr *Base, SourceLocation OpLoc,
 
   LookupResult R(*this, OpName, OpLoc, LookupOrdinaryName);
   LookupQualifiedName(R, Base->getType()->castAs<RecordType>()->getDecl());
   R.suppressDiagnostics();
 
   for (LookupResult::iterator Oper = R.begin(), OperEnd = R.end();
        Oper != OperEnd; ++Oper) {
     AddMethodCandidate(Oper.getPair(), Base->getType(), Base->Classify(Context),
-                       None, CandidateSet, /*SuppressUserConversion=*/false);
+                       None, CandidateSet, Sema::UDC_Allow);
   }
 
   bool HadMultipleCandidates = (CandidateSet.size() > 1);
 
   // Perform overload resolution.
   OverloadCandidateSet::iterator Best;
   switch (CandidateSet.BestViableFunction(*this, OpLoc, Best)) {
   case OR_Success:

clang/test/CXX/drs/dr0xx.cpp

 }
 
 namespace dr84 { // dr84: yes
   struct B;
   struct A { operator B() const; };
   struct C {};
   struct B {
     B(B&); // expected-note 0-1{{candidate}}
-    B(C); // expected-note 0-1{{no known conversion from 'dr84::B' to 'dr84::C'}}
+    B(C); // expected-note 0-1{{'dr84::B' to 'dr84::C' applies more than one implicit user-defined conversion}}
     operator C() const;
   };
   A a;
   // Cannot use B(C) / operator C() pair to construct the B from the B temporary
   // here. In C++17, we initialize the B object directly using 'A::operator B()'.
   B b = a;
 #if __cplusplus <= 201402L
   // expected-error@-2 {{no viable}}

clang/test/SemaCXX/user-defined-conversions.cpp

private:
     A(int i); // expected-note{{declared private here}}
   };
 
   void testA(A a) {
     int b = 10;
     a = b; // expected-error{{calling a private constructor of class 'rdar10202900::A'}}
   }
 }
+
+namespace more_than_one {
+  struct X {
+    operator int();
+  };
+
+  struct Y {
+    operator X(); // expected-note{{converting from 'more_than_one::X' to 'int' applies more than one implicit user-defined conversion}}
+  };
+
+  Y a;
+  int b = a; // expected-error{{no viable conversion}}
+  int c = X(a);
+
+  struct X2 {};
+
+  struct Y2 {
+    Y2(X2);
+  };
+
+  struct Z { // expected-note 2{{candidate constructor (the implicit}}
+    Z(Y2); // expected-note{{converting from 'more_than_one::X2' to 'more_than_one::Y2' applies more than one implicit user-defined conversion}}
+  };
+
+  X2 x;
+  Z z = x; // expected-error{{no viable conversion}}
+  Z z2 = Y2(x);
+}