[clang] [NFC] Rename Sema::DiagnoseMultipleUserConversion to DiagnoseAmbiguousUserConversion

[logan-5]

Summary

This is to avoid confusion in an upcoming patch that uses the term "multiple user-defined conversions" to refer to (invalid) implicit conversion sequences that involve applying more than one user conversion.

clang/include/clang/Sema/Sema.h

public:
   bool CheckMemberPointerConversion(Expr *From, QualType ToType,
                                     CastKind &Kind,
                                     CXXCastPath &BasePath,
                                     bool IgnoreBaseAccess);
   bool IsQualificationConversion(QualType FromType, QualType ToType,
                                  bool CStyle, bool &ObjCLifetimeConversion);
   bool IsFunctionConversion(QualType FromType, QualType ToType,
                             QualType &ResultTy);
-  bool DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType);
+  bool DiagnoseAmbiguousUserDefinedConversion(Expr *From, QualType ToType);
   bool isSameOrCompatibleFunctionType(CanQualType Param, CanQualType Arg);
 
   ExprResult PerformMoveOrCopyInitialization(const InitializedEntity &Entity,
                                              const VarDecl *NRVOCandidate,
                                              QualType ResultType,
                                              Expr *Value,
                                              bool AllowNRVO = true);
 

clang/lib/Sema/SemaOverload.cpp

IsUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
   case OR_Ambiguous:
     return OR_Ambiguous;
   }
 
   llvm_unreachable("Invalid OverloadResult!");
 }
 
 bool
-Sema::DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType) {
+Sema::DiagnoseAmbiguousUserDefinedConversion(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);
 
   if (!(OvResult == OR_Ambiguous ||

 ExprResult Sema::PerformContextuallyConvertToBool(Expr *From) {
   if (checkPlaceholderForOverload(*this, From))
     return ExprError();
 
   ImplicitConversionSequence ICS = TryContextuallyConvertToBool(*this, From);
   if (!ICS.isBad())
     return PerformImplicitConversion(From, Context.BoolTy, ICS, AA_Converting);
 
-  if (!DiagnoseMultipleUserDefinedConversion(From, Context.BoolTy))
+  if (!DiagnoseAmbiguousUserDefinedConversion(From, Context.BoolTy))
     return Diag(From->getBeginLoc(), diag::err_typecheck_bool_condition)
            << From->getType() << From->getSourceRange();
   return ExprError();
 }
 
 /// Check that the specified conversion is permitted in a converted constant
 /// expression, according to C++11 [expr.const]p3. Return true if the conversion
 /// is acceptable.
case ImplicitConversionSequence::StandardConversion:
     break;
   case ImplicitConversionSequence::UserDefinedConversion:
     // We are converting to a non-class type, so the Before sequence
     // must be trivial.
     SCS = &ICS.UserDefined.After;
     break;
   case ImplicitConversionSequence::AmbiguousConversion:
   case ImplicitConversionSequence::BadConversion:
-    if (!S.DiagnoseMultipleUserDefinedConversion(From, T))
+    if (!S.DiagnoseAmbiguousUserDefinedConversion(From, T))
       return S.Diag(From->getBeginLoc(),
                     diag::err_typecheck_converted_constant_expression)
              << From->getType() << From->getSourceRange() << T;
     return ExprError();
 
   case ImplicitConversionSequence::EllipsisConversion:
     llvm_unreachable("ellipsis conversion in converted constant expression");
   }