[NFC] Correct name of profile function to Profile in APValue

[Tyker]

Summary

Capitalize the profile function of APValue such that it can be used by FoldingSetNodeID

[rsmith]

Good idea. (My use for this in class type non-type template parameters doesn't directly use APValues as values in a folding set, but that seems like a reasonable use case for this functionality.)

clang/include/clang/AST/APValue.h

369–370

These ones shouldn't be capitalized :)

clang/include/clang/AST/APValue.h

public:
 
   public:
     LValueBase() : Local{} {}
     LValueBase(const ValueDecl *P, unsigned I = 0, unsigned V = 0);
     LValueBase(const Expr *P, unsigned I = 0, unsigned V = 0);
     static LValueBase getDynamicAlloc(DynamicAllocLValue LV, QualType Type);
     static LValueBase getTypeInfo(TypeInfoLValue LV, QualType TypeInfo);
 
-    void profile(llvm::FoldingSetNodeID &ID) const;
+    void Profile(llvm::FoldingSetNodeID &ID) const;
 
     template <class T>
     bool is() const { return Ptr.is<T>(); }
 
     template <class T>
     T get() const { return Ptr.get<T>(); }
 
     template <class T>
public:
     }
 
     BaseOrMemberType getAsBaseOrMember() const {
       return BaseOrMemberType::getFromOpaqueValue(
           reinterpret_cast<void *>(Value));
     }
     uint64_t getAsArrayIndex() const { return Value; }
 
-    void profile(llvm::FoldingSetNodeID &ID) const;
+    void Profile(llvm::FoldingSetNodeID &ID) const;
 
     friend bool operator==(LValuePathEntry A, LValuePathEntry B) {
       return A.Value == B.Value;
     }
     friend bool operator!=(LValuePathEntry A, LValuePathEntry B) {
       return A.Value != B.Value;
     }
     friend llvm::hash_code hash_value(LValuePathEntry A) {
public:
   /// If APValues are constructed via placement new, \c needsCleanup()
   /// indicates whether the destructor must be called in order to correctly
   /// free all allocated memory.
   bool needsCleanup() const;
 
   /// Swaps the contents of this and the given APValue.
   void swap(APValue &RHS);
 
-  /// Profile this value. There is no guarantee that values of different
+  /// profile this value. There is no guarantee that values of different
   /// types will not produce the same profiled value, so the type should
   /// typically also be profiled if it's not implied by the context.
-  void profile(llvm::FoldingSetNodeID &ID) const;
+  void Profile(llvm::FoldingSetNodeID &ID) const;
 
   ValueKind getKind() const { return Kind; }
 
   bool isAbsent() const { return Kind == None; }
   bool isIndeterminate() const { return Kind == Indeterminate; }
   bool hasValue() const { return Kind != None && Kind != Indeterminate; }
 
   bool isInt() const { return Kind == Int; }
   bool isFloat() const { return Kind == Float; }

clang/lib/AST/APValue.cpp

QualType APValue::LValueBase::getTypeInfoType() const {
   return QualType::getFromOpaquePtr(TypeInfoType);
 }
 
 QualType APValue::LValueBase::getDynamicAllocType() const {
   assert(is<DynamicAllocLValue>() && "not a dynamic allocation lvalue");
   return QualType::getFromOpaquePtr(DynamicAllocType);
 }
 
-void APValue::LValueBase::profile(llvm::FoldingSetNodeID &ID) const {
+void APValue::LValueBase::Profile(llvm::FoldingSetNodeID &ID) const {
   ID.AddPointer(Ptr.getOpaqueValue());
   if (is<TypeInfoLValue>() || is<DynamicAllocLValue>())
     return;
   ID.AddInteger(Local.CallIndex);
   ID.AddInteger(Local.Version);
 }
 
 namespace clang {

 }
 
 APValue::LValuePathEntry::LValuePathEntry(BaseOrMemberType BaseOrMember) {
   if (const Decl *D = BaseOrMember.getPointer())
     BaseOrMember.setPointer(D->getCanonicalDecl());
   Value = reinterpret_cast<uintptr_t>(BaseOrMember.getOpaqueValue());
 }
 
-void APValue::LValuePathEntry::profile(llvm::FoldingSetNodeID &ID) const {
+void APValue::LValuePathEntry::Profile(llvm::FoldingSetNodeID &ID) const {
   ID.AddInteger(Value);
 }
 
 namespace {
   struct LVBase {
     APValue::LValueBase Base;
     CharUnits Offset;
     unsigned PathLength;
bool APValue::needsCleanup() const {
   llvm_unreachable("Unknown APValue kind!");
 }
 
 void APValue::swap(APValue &RHS) {
   std::swap(Kind, RHS.Kind);
   std::swap(Data, RHS.Data);
 }
 
-void APValue::profile(llvm::FoldingSetNodeID &ID) const {
+void APValue::Profile(llvm::FoldingSetNodeID &ID) const {
   ID.AddInteger(Kind);
 
   switch (Kind) {
   case None:
   case Indeterminate:
     return;
 
   case AddrLabelDiff:
     ID.AddPointer(getAddrLabelDiffLHS()->getLabel()->getCanonicalDecl());
     ID.AddPointer(getAddrLabelDiffRHS()->getLabel()->getCanonicalDecl());
     return;
 
   case Struct:
     ID.AddInteger(getStructNumBases());
     for (unsigned I = 0, N = getStructNumBases(); I != N; ++I)
-      getStructBase(I).profile(ID);
+      getStructBase(I).Profile(ID);
     ID.AddInteger(getStructNumFields());
     for (unsigned I = 0, N = getStructNumFields(); I != N; ++I)
-      getStructField(I).profile(ID);
+      getStructField(I).Profile(ID);
     return;
 
   case Union:
     if (!getUnionField()) {
       ID.AddPointer(nullptr);
       return;
     }
     ID.AddPointer(getUnionField()->getCanonicalDecl());
-    getUnionValue().profile(ID);
+    getUnionValue().Profile(ID);
     return;
 
   case Array: {
     ID.AddInteger(getArraySize());
     if (getArraySize() == 0)
       return;
 
     // The profile should not depend on whether the array is expanded or
     // not, but we don't want to profile the array filler many times for
     // a large array. So treat all equal trailing elements as the filler.
     // Elements are profiled in reverse order to support this, and the
     // first profiled element is followed by a count. For example:
     //
     //   ['a', 'c', 'x', 'x', 'x'] is profiled as
     //   [5, 'x', 3, 'c', 'a']
     llvm::FoldingSetNodeID FillerID;
-    (hasArrayFiller() ? getArrayFiller() :
-     getArrayInitializedElt(getArrayInitializedElts() -
-       1)).profile(FillerID);
+    (hasArrayFiller() ? getArrayFiller()
+                      : getArrayInitializedElt(getArrayInitializedElts() - 1))
+        .Profile(FillerID);
     ID.AddNodeID(FillerID);
     unsigned NumFillers = getArraySize() - getArrayInitializedElts();
     unsigned N = getArrayInitializedElts();
 
     // Count the number of elements equal to the last one. This loop ends
     // by adding an integer indicating the number of such elements, with
     // N set to the number of elements left to profile.
     while (true) {
       if (N == 0) {
         // All elements are fillers.
         assert(NumFillers == getArraySize());
         ID.AddInteger(NumFillers);
         break;
       }
 
       // No need to check if the last element is equal to the last
       // element.
       if (N != getArraySize()) {
         llvm::FoldingSetNodeID ElemID;
-        getArrayInitializedElt(N - 1).profile(ElemID);
+        getArrayInitializedElt(N - 1).Profile(ElemID);
         if (ElemID != FillerID) {
           ID.AddInteger(NumFillers);
           ID.AddNodeID(ElemID);
           --N;
           break;
         }
       }
 
       // This is a filler.
       ++NumFillers;
       --N;
     }
 
     // Emit the remaining elements.
     for (; N != 0; --N)
-      getArrayInitializedElt(N - 1).profile(ID);
+      getArrayInitializedElt(N - 1).Profile(ID);
     return;
   }
 
   case Vector:
     ID.AddInteger(getVectorLength());
     for (unsigned I = 0, N = getVectorLength(); I != N; ++I)
-      getVectorElt(I).profile(ID);
+      getVectorElt(I).Profile(ID);
     return;
 
   case Int:
     // We don't need to include the sign bit; it's implied by the type.
     getInt().APInt::Profile(ID);
     return;
 
   case Float:
case ComplexFloat:
     return;
 
   case ComplexInt:
     getComplexIntReal().APInt::Profile(ID);
     getComplexIntImag().APInt::Profile(ID);
     return;
 
   case LValue:
-    getLValueBase().profile(ID);
+    getLValueBase().Profile(ID);
     ID.AddInteger(getLValueOffset().getQuantity());
     ID.AddInteger(isNullPointer());
     ID.AddInteger(isLValueOnePastTheEnd());
     // For uniqueness, we only need to profile the entries corresponding
     // to union members, but we don't have the type here so we don't know
     // how to interpret the entries.
     for (LValuePathEntry E : getLValuePath())
-      E.profile(ID);
+      E.Profile(ID);
     return;
 
   case MemberPointer:
     ID.AddPointer(getMemberPointerDecl());
     ID.AddInteger(isMemberPointerToDerivedMember());
     for (const CXXRecordDecl *D : getMemberPointerPath())
       ID.AddPointer(D);
     return;