[clang][NFC] Adjust qualification conversion API

[urnathan]

Summary

This adjusts the IsQualificationConversion API to return an enum of bit flags, along the lines discussed in D102645. I rename IsQualificationConversion to TryQualificationConversion, as it's no longer returning a bool. We drop the ObjCLifetimeConversion parm, as it's one of the bit flags that may be returned. The SemaOverload-local isQualificationConversionStep gets a similar rename and adjustment.

The plan is that we'll grow a QCK_IncludesArrayBoundConversion flag for p0388.

I changed the sense of a preserved FIXME, AFAICT we /are/ tracking the objc lifetime of inner conversions.

Questions:
a) perhaps we should also track address space changes during conversion.
b) do you want bit op overloads on the new enum, rather than have to use explicit casts on the few places we or bits into it?

clang/include/clang/Sema/Sema.h

bool CheckPointerConversion(Expr *From, QualType ToType,
                               bool Diagnose = true);
   bool IsMemberPointerConversion(Expr *From, QualType FromType, QualType ToType,
                                  bool InOverloadResolution,
                                  QualType &ConvertedType);
   bool CheckMemberPointerConversion(Expr *From, QualType ToType,
                                     CastKind &Kind,
                                     CXXCastPath &BasePath,
                                     bool IgnoreBaseAccess);
-  bool IsQualificationConversion(QualType FromType, QualType ToType,
-                                 bool CStyle, bool &ObjCLifetimeConversion);
+  enum QualificationConversionKind {
+    QCK_NotQualificationConversion = 0,          // Not a conversion
+    QCK_QualificationConversion = 1 << 0,        // Is a qualification
+    QCK_IncludesObjCLifetimeConversion = 1 << 1, // ... with ObjC lifetime
+  };
+  QualificationConversionKind
+  TryQualificationConversion(QualType FromType, QualType ToType, bool CStyle);
   bool IsFunctionConversion(QualType FromType, QualType ToType,
                             QualType &ResultTy);
   bool DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType);
   bool isSameOrCompatibleFunctionType(CanQualType Param, CanQualType Arg);
 
   ExprResult PerformMoveOrCopyInitialization(const InitializedEntity &Entity,
                                              const VarDecl *NRVOCandidate,
                                              QualType ResultType,

clang/lib/Sema/SemaExceptionSpec.cpp

if (HandlerType->isPointerType() || HandlerType->isMemberPointerType()) {
     if (ExceptionType->isNullPtrType())
       return true;
 
     // -- the handler is of type cv T or const T& where T is a pointer or
     //    pointer to member type and E is a pointer or pointer to member type
     //    that can be converted to T by one or more of
     //    -- a qualification conversion
     //    -- a function pointer conversion
-    bool LifetimeConv;
     QualType Result;
     // FIXME: Should we treat the exception as catchable if a lifetime
     // conversion is required?
-    if (IsQualificationConversion(ExceptionType, HandlerType, false,
-                                  LifetimeConv) ||
+    if (TryQualificationConversion(ExceptionType, HandlerType, false) ||
         IsFunctionConversion(ExceptionType, HandlerType, Result))
       return true;
 
     //    -- a standard pointer conversion [...]
     if (!ExceptionType->isPointerType() || !HandlerType->isPointerType())
       return false;
 
     // Handle the "qualification conversion" portion.

clang/lib/Sema/SemaOverload.cpp

static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType,
   } else {
     // No second conversion required.
     SCS.Second = ICK_Identity;
   }
   SCS.setToType(1, FromType);
 
   // The third conversion can be a function pointer conversion or a
   // qualification conversion (C++ [conv.fctptr], [conv.qual]).
-  bool ObjCLifetimeConversion;
   if (S.IsFunctionConversion(FromType, ToType, FromType)) {
     // Function pointer conversions (removing 'noexcept') including removal of
     // 'noreturn' (Clang extension).
     SCS.Third = ICK_Function_Conversion;
-  } else if (S.IsQualificationConversion(FromType, ToType, CStyle,
-                                         ObjCLifetimeConversion)) {
+  } else if (auto qck =
+                 S.TryQualificationConversion(FromType, ToType, CStyle)) {
     SCS.Third = ICK_Qualification;
-    SCS.QualificationIncludesObjCLifetime = ObjCLifetimeConversion;
+    SCS.QualificationIncludesObjCLifetime =
+        bool(qck & Sema::QCK_IncludesObjCLifetimeConversion);
     FromType = ToType;
   } else {
     // No conversion required
     SCS.Third = ICK_Identity;
   }
 
   // C++ [over.best.ics]p6:
   //   [...] Any difference in top-level cv-qualification is

 }
 
 /// Perform a single iteration of the loop for checking if a qualification
 /// conversion is valid.
 ///
 /// Specifically, check whether any change between the qualifiers of \p
 /// FromType and \p ToType is permissible, given knowledge about whether every
 /// outer layer is const-qualified.
-static bool isQualificationConversionStep(QualType FromType, QualType ToType,
-                                          bool CStyle, bool IsTopLevel,
-                                          bool &PreviousToQualsIncludeConst,
-                                          bool &ObjCLifetimeConversion) {
+static Sema::QualificationConversionKind
+tryQualificationConversionStep(QualType FromType, QualType ToType, bool CStyle,
+                               bool IsTopLevel,
+                               bool &PreviousToQualsIncludeConst) {
   Qualifiers FromQuals = FromType.getQualifiers();
   Qualifiers ToQuals = ToType.getQualifiers();
+  Sema::QualificationConversionKind result = Sema::QCK_QualificationConversion;
 
   // Ignore __unaligned qualifier if this type is void.
   if (ToType.getUnqualifiedType()->isVoidType())
     FromQuals.removeUnaligned();
 
   // Objective-C ARC:
   //   Check Objective-C lifetime conversions.
   if (FromQuals.getObjCLifetime() != ToQuals.getObjCLifetime()) {
     if (ToQuals.compatiblyIncludesObjCLifetime(FromQuals)) {
       if (isNonTrivialObjCLifetimeConversion(FromQuals, ToQuals))
-        ObjCLifetimeConversion = true;
+        result = Sema::QualificationConversionKind(
+            result | Sema::QCK_IncludesObjCLifetimeConversion);
       FromQuals.removeObjCLifetime();
       ToQuals.removeObjCLifetime();
     } else {
       // Qualification conversions cannot cast between different
       // Objective-C lifetime qualifiers.
-      return false;
+      return Sema::QCK_NotQualificationConversion;
     }
   }
 
   // Allow addition/removal of GC attributes but not changing GC attributes.
   if (FromQuals.getObjCGCAttr() != ToQuals.getObjCGCAttr() &&
       (!FromQuals.hasObjCGCAttr() || !ToQuals.hasObjCGCAttr())) {
     FromQuals.removeObjCGCAttr();
     ToQuals.removeObjCGCAttr();
   }
 
   //   -- for every j > 0, if const is in cv 1,j then const is in cv
   //      2,j, and similarly for volatile.
   if (!CStyle && !ToQuals.compatiblyIncludes(FromQuals))
-    return false;
+    return Sema::QCK_NotQualificationConversion;
 
   // If address spaces mismatch:
   //  - in top level it is only valid to convert to addr space that is a
   //    superset in all cases apart from C-style casts where we allow
   //    conversions between overlapping address spaces.
   //  - in non-top levels it is not a valid conversion.
   if (ToQuals.getAddressSpace() != FromQuals.getAddressSpace() &&
       (!IsTopLevel ||
        !(ToQuals.isAddressSpaceSupersetOf(FromQuals) ||
          (CStyle && FromQuals.isAddressSpaceSupersetOf(ToQuals)))))
-    return false;
+    return Sema::QCK_NotQualificationConversion;
 
   //   -- if the cv 1,j and cv 2,j are different, then const is in
   //      every cv for 0 < k < j.
   if (!CStyle && FromQuals.getCVRQualifiers() != ToQuals.getCVRQualifiers() &&
       !PreviousToQualsIncludeConst)
-    return false;
+    return Sema::QCK_NotQualificationConversion;
 
   // Keep track of whether all prior cv-qualifiers in the "to" type
   // include const.
   PreviousToQualsIncludeConst =
       PreviousToQualsIncludeConst && ToQuals.hasConst();
-  return true;
+
+  return result;
 }
 
-/// IsQualificationConversion - Determines whether the conversion from
+/// TryQualificationConversion - Determines whether the conversion from
 /// an rvalue of type FromType to ToType is a qualification conversion
 /// (C++ 4.4).
 ///
-/// \param ObjCLifetimeConversion Output parameter that will be set to indicate
-/// when the qualification conversion involves a change in the Objective-C
-/// object lifetime.
-bool
-Sema::IsQualificationConversion(QualType FromType, QualType ToType,
-                                bool CStyle, bool &ObjCLifetimeConversion) {
+/// \result An enum of bits describing additional features of the qualification
+/// conversion.  Contextually convertable to a bool.
+Sema::QualificationConversionKind
+Sema::TryQualificationConversion(QualType FromType, QualType ToType,
+                                 bool CStyle) {
   FromType = Context.getCanonicalType(FromType);
   ToType = Context.getCanonicalType(ToType);
-  ObjCLifetimeConversion = false;
-
   // If FromType and ToType are the same type, this is not a
   // qualification conversion.
   if (FromType.getUnqualifiedType() == ToType.getUnqualifiedType())
-    return false;
+    return QCK_NotQualificationConversion;
 
   // (C++ 4.4p4):
   //   A conversion can add cv-qualifiers at levels other than the first
   //   in multi-level pointers, subject to the following rules: [...]
   bool PreviousToQualsIncludeConst = true;
   bool UnwrappedAnyPointer = false;
+  QualificationConversionKind result = QCK_QualificationConversion;
   while (Context.UnwrapSimilarTypes(FromType, ToType)) {
-    if (!isQualificationConversionStep(
+    if (auto qck = tryQualificationConversionStep(
             FromType, ToType, CStyle, !UnwrappedAnyPointer,
-            PreviousToQualsIncludeConst, ObjCLifetimeConversion))
-      return false;
+            PreviousToQualsIncludeConst)) {
+      result = QualificationConversionKind(result | qck);
+    } else {
+      return QCK_NotQualificationConversion;
+    }
     UnwrappedAnyPointer = true;
   }
 
   // We are left with FromType and ToType being the pointee types
   // after unwrapping the original FromType and ToType the same number
   // of times. If we unwrapped any pointers, and if FromType and
   // ToType have the same unqualified type (since we checked
   // qualifiers above), then this is a qualification conversion.
-  return UnwrappedAnyPointer && Context.hasSameUnqualifiedType(FromType,ToType);
+  if (!(UnwrappedAnyPointer &&
+        Context.hasSameUnqualifiedType(FromType, ToType)))
+    return QCK_NotQualificationConversion;
+
+  return result;
 }
 
 /// - Determine whether this is a conversion from a scalar type to an
 /// atomic type.
 ///
 /// If successful, updates \c SCS's second and third steps in the conversion
 /// sequence to finish the conversion.
 static bool tryAtomicConversion(Sema &S, Expr *From, QualType ToType,
if (!TopLevel)
       Conv |= ReferenceConversions::NestedQualification;
 
     // MS compiler ignores __unaligned qualifier for references; do the same.
     T1 = withoutUnaligned(Context, T1);
     T2 = withoutUnaligned(Context, T2);
 
     // If we find a qualifier mismatch, the types are not reference-compatible,
     // but are still be reference-related if they're similar.
-    bool ObjCLifetimeConversion = false;
-    if (!isQualificationConversionStep(T2, T1, /*CStyle=*/false, TopLevel,
-                                       PreviousToQualsIncludeConst,
-                                       ObjCLifetimeConversion))
+    if (auto qck = tryQualificationConversionStep(
+            T2, T1, /*CStyle=*/false, TopLevel, PreviousToQualsIncludeConst)) {
+      // FIXME: Should we be tracking this for inner levels?
+      if (bool(qck & QCK_IncludesObjCLifetimeConversion))
+        Conv |= ReferenceConversions::ObjCLifetime;
+    } else {
       return (ConvertedReferent || Context.hasSimilarType(T1, T2))
                  ? Ref_Related
                  : Ref_Incompatible;
-
-    // FIXME: Should we track this for any level other than the first?
-    if (ObjCLifetimeConversion)
-      Conv |= ReferenceConversions::ObjCLifetime;
+    }
 
     TopLevel = false;
   } while (Context.UnwrapSimilarTypes(T1, T2));
 
   // At this point, if the types are reference-related, we must either have the
   // same inner type (ignoring qualifiers), or must have already worked out how
   // to convert the referent.
   return (ConvertedReferent || Context.hasSameUnqualifiedType(T1, T2))
static bool isAllowableExplicitConversion(Sema &S,
                                           bool AllowObjCPointerConversion) {
   QualType ToNonRefType = ToType.getNonReferenceType();
 
   // Easy case: the types are the same.
   if (S.Context.hasSameUnqualifiedType(ConvType, ToNonRefType))
     return true;
 
   // Allow qualification conversions.
-  bool ObjCLifetimeConversion;
-  if (S.IsQualificationConversion(ConvType, ToNonRefType, /*CStyle*/false,
-                                  ObjCLifetimeConversion))
+  if (S.TryQualificationConversion(ConvType, ToNonRefType, /*CStyle*/ false))
     return true;
 
   // If we're not allowed to consider Objective-C pointer conversions,
   // we're done.
   if (!AllowObjCPointerConversion)
     return false;
 
   // Is this an Objective-C pointer conversion?

clang/lib/Sema/SemaTemplate.cpp

isNullPointerValueTemplateArgument(Sema &S, NonTypeTemplateParmDecl *Param,
 
   //   - a constant expression that evaluates to a null pointer value (4.10); or
   //   - a constant expression that evaluates to a null member pointer value
   //     (4.11); or
   if ((EvalResult.Val.isLValue() && !EvalResult.Val.getLValueBase()) ||
       (EvalResult.Val.isMemberPointer() &&
        !EvalResult.Val.getMemberPointerDecl())) {
     // If our expression has an appropriate type, we've succeeded.
-    bool ObjCLifetimeConversion;
     if (S.Context.hasSameUnqualifiedType(Arg->getType(), ParamType) ||
-        S.IsQualificationConversion(Arg->getType(), ParamType, false,
-                                     ObjCLifetimeConversion))
+        S.TryQualificationConversion(Arg->getType(), ParamType, false))
       return NPV_NullPointer;
 
     // The types didn't match, but we know we got a null pointer; complain,
     // then recover as if the types were correct.
     S.Diag(Arg->getExprLoc(), diag::err_template_arg_wrongtype_null_constant)
       << Arg->getType() << ParamType << Arg->getSourceRange();
     S.Diag(Param->getLocation(), diag::note_template_param_here);
     return NPV_NullPointer;
isNullPointerValueTemplateArgument(Sema &S, NonTypeTemplateParmDecl *Param,
   return NPV_NotNullPointer;
 }
 
 /// Checks whether the given template argument is compatible with its
 /// template parameter.
 static bool CheckTemplateArgumentIsCompatibleWithParameter(
     Sema &S, NonTypeTemplateParmDecl *Param, QualType ParamType, Expr *ArgIn,
     Expr *Arg, QualType ArgType) {
-  bool ObjCLifetimeConversion;
   if (ParamType->isPointerType() &&
       !ParamType->castAs<PointerType>()->getPointeeType()->isFunctionType() &&
-      S.IsQualificationConversion(ArgType, ParamType, false,
-                                  ObjCLifetimeConversion)) {
+      S.TryQualificationConversion(ArgType, ParamType, false)) {
     // For pointer-to-object types, qualification conversions are
     // permitted.
   } else {
     if (const ReferenceType *ParamRef = ParamType->getAs<ReferenceType>()) {
       if (!ParamRef->getPointeeType()->isFunctionType()) {
         // C++ [temp.arg.nontype]p5b3:
         //   For a non-type template-parameter of type reference to
         //   object, no conversions apply. The type referred to by the

 static bool CheckTemplateArgumentPointerToMember(Sema &S,
                                                  NonTypeTemplateParmDecl *Param,
                                                  QualType ParamType,
                                                  Expr *&ResultArg,
                                                  TemplateArgument &Converted) {
   bool Invalid = false;
 
   Expr *Arg = ResultArg;
-  bool ObjCLifetimeConversion;
 
   // C++ [temp.arg.nontype]p1:
   //
   //   A template-argument for a non-type, non-template
   //   template-parameter shall be one of: [...]
   //
   //     -- a pointer to member expressed as described in 5.3.1.
   DeclRefExpr *DRE = nullptr;
case NPV_NullPointer:
     S.Diag(ResultArg->getExprLoc(), diag::warn_cxx98_compat_template_arg_null);
     Converted = TemplateArgument(S.Context.getCanonicalType(ParamType),
                                  /*isNullPtr*/true);
     return false;
   case NPV_NotNullPointer:
     break;
   }
 
-  if (S.IsQualificationConversion(ResultArg->getType(),
-                                  ParamType.getNonReferenceType(), false,
-                                  ObjCLifetimeConversion)) {
+  if (S.TryQualificationConversion(ResultArg->getType(),
+                                   ParamType.getNonReferenceType(), false)) {
     ResultArg = S.ImpCastExprToType(ResultArg, ParamType, CK_NoOp,
                                     ResultArg->getValueKind())
                     .get();
   } else if (!S.Context.hasSameUnqualifiedType(
                  ResultArg->getType(), ParamType.getNonReferenceType())) {
     // We can't perform this conversion.
     S.Diag(ResultArg->getBeginLoc(), diag::err_template_arg_not_convertible)
         << ResultArg->getType() << ParamType << ResultArg->getSourceRange();

clang/lib/Sema/SemaTemplateDeduction.cpp

CheckOriginalCallArgDeduction(Sema &S, TemplateDeductionInfo &Info,
   }
 
   //    - The transformed A can be another pointer or pointer to member
   //      type that can be converted to the deduced A via a function pointer
   //      conversion and/or a qualification conversion.
   //
   // Also allow conversions which merely strip __attribute__((noreturn)) from
   // function types (recursively).
-  bool ObjCLifetimeConversion = false;
   QualType ResultTy;
   if ((A->isAnyPointerType() || A->isMemberPointerType()) &&
-      (S.IsQualificationConversion(A, DeducedA, false,
-                                   ObjCLifetimeConversion) ||
+      (S.TryQualificationConversion(A, DeducedA, false) ||
        S.IsFunctionConversion(A, DeducedA, ResultTy)))
     return Sema::TDK_Success;
 
   //    - If P is a class and P has the form simple-template-id, then the
   //      transformed A can be a derived class of the deduced A. [...]
   //     [...] Likewise, if P is a pointer to a class of the form
   //      simple-template-id, the transformed A can be a pointer to a
   //      derived class pointed to by the deduced A.