[clang] Replaced some manual pointer tagging with llvm::PointerIntPair.

[haberman]

Summary

There is no functional change here (hence no new tests). The only change
is to replace a couple uintptr_t members with llvm::PointerIntPair<> to
clean up the code, making it more readable and less error prone.

This cleanup highlighted that the old code was effectively casting away
const. This is fixed by changing some function signatures.

[rsmith]

Thanks! Do we need InitializedEntity::getDecl to return a pointer to non-const? Looks good assuming we do.

clang/include/clang/Sema/Initialization.h

189–190

Here and below, consider updating "the low[er] bit" to "the integer" or similar.

[haberman]

Updated comment "the low bit" -> "the integer".

[haberman]

Thanks! Do we need InitializedEntity::getDecl to return a pointer to non-const?

Yes, if I try to propagate const the change starts to snowball.

[haberman]

Updated change to reflect all diffs since main.

clang/include/clang/Sema/Initialization.h

union {
     /// When Kind == EK_Variable, EK_Member, EK_Binding, or
     /// EK_TemplateParameter, the variable, binding, or template parameter.
     VD Variable;
 
     /// When Kind == EK_RelatedResult, the ObjectiveC method where
     /// result type was implicitly changed to accommodate ARC semantics.
     ObjCMethodDecl *MethodDecl;
 
     /// When Kind == EK_Parameter, the ParmVarDecl, with the
-    /// low bit indicating whether the parameter is "consumed".
-    uintptr_t Parameter;
+    /// integer indicating whether the parameter is "consumed".
+    llvm::PointerIntPair<ParmVarDecl *, 1> Parameter;
 
     /// When Kind == EK_Temporary or EK_CompoundLiteralInit, the type
     /// source information for the temporary.
     TypeSourceInfo *TypeInfo;
 
     struct LN LocAndNRVO;
 
     /// When Kind == EK_Base, the base specifier that provides the
-    /// base class. The lower bit specifies whether the base is an inherited
+    /// base class. The integer specifies whether the base is an inherited
     /// virtual base.
-    uintptr_t Base;
+    llvm::PointerIntPair<const CXXBaseSpecifier *, 1> Base;
 
     /// When Kind == EK_ArrayElement, EK_VectorElement, or
     /// EK_ComplexElement, the index of the array or vector element being
     /// initialized.
     unsigned Index;
 
     struct C Capture;
   };

 public:
   /// Create the initialization entity for a variable.
   static InitializedEntity InitializeVariable(VarDecl *Var) {
     return InitializedEntity(Var);
   }
 
   /// Create the initialization entity for a parameter.
   static InitializedEntity InitializeParameter(ASTContext &Context,
-                                               const ParmVarDecl *Parm) {
+                                               ParmVarDecl *Parm) {
     return InitializeParameter(Context, Parm, Parm->getType());
   }
 
   /// Create the initialization entity for a parameter, but use
   /// another type.
-  static InitializedEntity InitializeParameter(ASTContext &Context,
-                                               const ParmVarDecl *Parm,
-                                               QualType Type) {
+  static InitializedEntity
+  InitializeParameter(ASTContext &Context, ParmVarDecl *Parm, QualType Type) {
     bool Consumed = (Context.getLangOpts().ObjCAutoRefCount &&
                      Parm->hasAttr<NSConsumedAttr>());
 
     InitializedEntity Entity;
     Entity.Kind = EK_Parameter;
     Entity.Type =
       Context.getVariableArrayDecayedType(Type.getUnqualifiedType());
     Entity.Parent = nullptr;
-    Entity.Parameter
-      = (static_cast<uintptr_t>(Consumed) | reinterpret_cast<uintptr_t>(Parm));
+    Entity.Parameter = {Parm, Consumed};
     return Entity;
   }
 
   /// Create the initialization entity for a parameter that is
   /// only known by its type.
   static InitializedEntity InitializeParameter(ASTContext &Context,
                                                QualType Type,
                                                bool Consumed) {
     InitializedEntity Entity;
     Entity.Kind = EK_Parameter;
     Entity.Type = Context.getVariableArrayDecayedType(Type);
     Entity.Parent = nullptr;
-    Entity.Parameter = (Consumed);
+    Entity.Parameter = {nullptr, Consumed};
     return Entity;
   }
 
   /// Create the initialization entity for a template parameter.
   static InitializedEntity
   InitializeTemplateParameter(QualType T, NonTypeTemplateParmDecl *Param) {
     InitializedEntity Entity;
     Entity.Kind = EK_TemplateParameter;
public:
   bool isParamOrTemplateParamKind() const {
     return isParameterKind() || getKind() == EK_TemplateParameter;
   }
 
   /// Determine whether this initialization consumes the
   /// parameter.
   bool isParameterConsumed() const {
     assert(isParameterKind() && "Not a parameter");
-    return (Parameter & 1);
+    return Parameter.getInt();
   }
 
   /// Retrieve the base specifier.
   const CXXBaseSpecifier *getBaseSpecifier() const {
     assert(getKind() == EK_Base && "Not a base specifier");
-    return reinterpret_cast<const CXXBaseSpecifier *>(Base & ~0x1);
+    return Base.getPointer();
   }
 
   /// Return whether the base is an inherited virtual base.
   bool isInheritedVirtualBase() const {
     assert(getKind() == EK_Base && "Not a base specifier");
-    return Base & 0x1;
+    return Base.getInt();
   }
 
   /// Determine whether this is an array new with an unknown bound.
   bool isVariableLengthArrayNew() const {
     return getKind() == EK_New && dyn_cast_or_null<IncompleteArrayType>(
                                       getType()->getAsArrayTypeUnsafe());
   }
 

clang/include/clang/Sema/Sema.h

ParmVarDecl *CheckParameter(DeclContext *DC, SourceLocation StartLoc,
                               QualType T, TypeSourceInfo *TSInfo,
                               StorageClass SC);
   void ActOnParamDefaultArgument(Decl *param,
                                  SourceLocation EqualLoc,
                                  Expr *defarg);
   void ActOnParamUnparsedDefaultArgument(Decl *param, SourceLocation EqualLoc,
                                          SourceLocation ArgLoc);
   void ActOnParamDefaultArgumentError(Decl *param, SourceLocation EqualLoc);
-  ExprResult ConvertParamDefaultArgument(const ParmVarDecl *Param,
-                                         Expr *DefaultArg,
+  ExprResult ConvertParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg,
                                          SourceLocation EqualLoc);
   void SetParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg,
                                SourceLocation EqualLoc);
 
   // Contexts where using non-trivial C union types can be disallowed. This is
   // passed to err_non_trivial_c_union_in_invalid_context.
   enum NonTrivialCUnionContext {
     // Function parameter.

clang/lib/Sema/SemaDeclCXX.cpp

void Sema::ImplicitExceptionSpecification::CalledStmt(Stmt *S) {
   // specification should be the set of exceptions which can be thrown by the
   // implicit definition. For now, we assume that any non-nothrow expression can
   // throw any exception.
 
   if (Self->canThrow(S))
     ComputedEST = EST_None;
 }
 
-ExprResult Sema::ConvertParamDefaultArgument(const ParmVarDecl *Param,
-                                             Expr *Arg,
+ExprResult Sema::ConvertParamDefaultArgument(ParmVarDecl *Param, Expr *Arg,
                                              SourceLocation EqualLoc) {
   if (RequireCompleteType(Param->getLocation(), Param->getType(),
                           diag::err_typecheck_decl_incomplete_type))
     return true;
 
   // C++ [dcl.fct.default]p5
   //   A default argument expression is implicitly converted (clause
   //   4) to the parameter type. The default argument expression has

clang/lib/Sema/SemaInit.cpp

 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Sema/Designator.h"
 #include "clang/Sema/Initialization.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/SemaInternal.h"
 #include "llvm/ADT/APInt.h"
+#include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace clang;
 
 //===----------------------------------------------------------------------===//
 // Sema Initialization Checking

 InitializedEntity
 InitializedEntity::InitializeBase(ASTContext &Context,
                                   const CXXBaseSpecifier *Base,
                                   bool IsInheritedVirtualBase,
                                   const InitializedEntity *Parent) {
   InitializedEntity Result;
   Result.Kind = EK_Base;
   Result.Parent = Parent;
-  Result.Base = reinterpret_cast<uintptr_t>(Base);
-  if (IsInheritedVirtualBase)
-    Result.Base |= 0x01;
-
+  Result.Base = {Base, IsInheritedVirtualBase};
   Result.Type = Base->getType();
   return Result;
 }
 
 DeclarationName InitializedEntity::getName() const {
   switch (getKind()) {
   case EK_Parameter:
   case EK_Parameter_CF_Audited: {
-    ParmVarDecl *D = reinterpret_cast<ParmVarDecl*>(Parameter & ~0x1);
+    ParmVarDecl *D = Parameter.getPointer();
     return (D ? D->getDeclName() : DeclarationName());
   }
 
   case EK_Variable:
   case EK_Member:
   case EK_Binding:
   case EK_TemplateParameter:
     return Variable.VariableOrMember->getDeclName();
ValueDecl *InitializedEntity::getDecl() const {
   case EK_Variable:
   case EK_Member:
   case EK_Binding:
   case EK_TemplateParameter:
     return Variable.VariableOrMember;
 
   case EK_Parameter:
   case EK_Parameter_CF_Audited:
-    return reinterpret_cast<ParmVarDecl*>(Parameter & ~0x1);
+    return Parameter.getPointer();
 
   case EK_Result:
   case EK_StmtExprResult:
   case EK_Exception:
   case EK_New:
   case EK_Temporary:
   case EK_Base:
   case EK_Delegating: