Make LValuePathEntry a discriminated union

[sepavloff]

Summary

APValue::LValuePathEntry was implemented as non-discriminated union. It
complicated operations on it and inspection in debugger. This change
turns it into discriminated union.

No functional changed intended.

clang/include/clang/AST/APValue.h

 //===--- APValue.h - Union class for APFloat/APSInt/Complex -----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines the APValue class.
union {
       void *DynamicAllocType;
     };
   };
 
   /// A FieldDecl or CXXRecordDecl, along with a flag indicating whether we
   /// mean a virtual or non-virtual base class subobject.
   typedef llvm::PointerIntPair<const Decl *, 1, bool> BaseOrMemberType;
 
-  /// A non-discriminated union of a base, field, or array index.
+  /// A discriminated union of a base, field, or array index.
   class LValuePathEntry {
-    static_assert(sizeof(uintptr_t) <= sizeof(uint64_t),
-                  "pointer doesn't fit in 64 bits?");
-    uint64_t Value;
+    enum class Kind {
+      Base,
+      VirtualBase,
+      Field,
+      Index
+    };
+    llvm::PointerIntPair<const void *, 2, Kind> Value;
 
   public:
     LValuePathEntry() : Value() {}
-    LValuePathEntry(BaseOrMemberType BaseOrMember);
+    LValuePathEntry(const CXXRecordDecl *Base, bool Virtual);
+    LValuePathEntry(const FieldDecl *Field);
+    LValuePathEntry(size_t Index);
     static LValuePathEntry ArrayIndex(uint64_t Index) {
-      LValuePathEntry Result;
-      Result.Value = Index;
-      return Result;
+      return LValuePathEntry(static_cast<size_t>(Index));
     }
+    static LValuePathEntry Declaration(const Decl *D, bool Virtual);
+
+    bool isBase() const { return Value.getInt() == Kind::Base; }
+    bool isVirtualBase() const { return Value.getInt() == Kind::VirtualBase; }
+    bool isAnyBase() const { return isBase() || isVirtualBase(); }
+    bool isField() const { return Value.getInt() == Kind::Field; }
+    bool isArrayIndex() const { return Value.getInt() == Kind::Index; }
 
-    BaseOrMemberType getAsBaseOrMember() const {
-      return BaseOrMemberType::getFromOpaqueValue(
-          reinterpret_cast<void *>(Value));
+    const CXXRecordDecl *getAsBase() const {
+      assert(isAnyBase() && "Not a base class");
+      return static_cast<const CXXRecordDecl *>(Value.getPointer());
+    }
+    const FieldDecl *getAsField() const {
+      assert(isField() && "Not a field");
+      return static_cast<const FieldDecl *>(Value.getPointer());
+    }
+    uint64_t getAsArrayIndex() const {
+      assert((Value.getInt() == Kind::Index) && "Not an index");
+      return reinterpret_cast<uintptr_t>(Value.getOpaqueValue()) >> 2;
+    }
+    const Decl *getAsBaseOrMember() const {
+      assert((isAnyBase() || isField()) && "Not a declaration");
+      return static_cast<const Decl *>(Value.getPointer());
+    }
+
+    const CXXRecordDecl *getAsBaseOrNull() const {
+      return isAnyBase() ? getAsBase() : nullptr;
+    }
+    const FieldDecl *getAsFieldOrNull() const {
+      return isField() ? getAsField() : nullptr;
     }
-    uint64_t getAsArrayIndex() const { return Value; }
 
     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) {
-      return llvm::hash_value(A.Value);
+      return llvm::hash_value(A.Value.getOpaqueValue());
     }
   };
   class LValuePathSerializationHelper {
     const void *ElemTy;
 
   public:
     ArrayRef<LValuePathEntry> Path;
 

clang/include/clang/AST/AbstractBasicReader.h

public:
   }
 
   APValue::LValuePathSerializationHelper readLValuePathSerializationHelper(
       SmallVectorImpl<APValue::LValuePathEntry> &path) {
     auto elemTy = asImpl().readQualType();
     unsigned pathLength = asImpl().readUInt32();
     for (unsigned i = 0; i < pathLength; ++i) {
       if (elemTy->template getAs<RecordType>()) {
-        unsigned int_ = asImpl().readUInt32();
-        Decl *decl = asImpl().template readDeclAs<Decl>();
-        if (auto *recordDecl = dyn_cast<CXXRecordDecl>(decl))
-          elemTy = getASTContext().getRecordType(recordDecl);
-        else
-          elemTy = cast<ValueDecl>(decl)->getType();
-        path.push_back(
-            APValue::LValuePathEntry(APValue::BaseOrMemberType(decl, int_)));
+        unsigned IsVirtualBase = asImpl().readUInt32();
+        Decl *D = asImpl().template readDeclAs<Decl>();
+        if (auto *RD = dyn_cast<CXXRecordDecl>(D)) {
+          elemTy = getASTContext().getRecordType(RD);
+          path.push_back(APValue::LValuePathEntry(RD, IsVirtualBase));
+        } else {
+          auto FD = cast<FieldDecl>(D);
+          elemTy = FD->getType();
+          path.push_back(APValue::LValuePathEntry(FD));
+        }
       } else {
         elemTy = getASTContext().getAsArrayType(elemTy)->getElementType();
         path.push_back(
             APValue::LValuePathEntry::ArrayIndex(asImpl().readUInt32()));
       }
     }
     return APValue::LValuePathSerializationHelper(path, elemTy);
   }

clang/include/clang/AST/AbstractBasicWriter.h

void writeLValuePathSerializationHelper(
       APValue::LValuePathSerializationHelper lvaluePath) {
     ArrayRef<APValue::LValuePathEntry> path = lvaluePath.Path;
     QualType elemTy = lvaluePath.getType();
     asImpl().writeQualType(elemTy);
     asImpl().writeUInt32(path.size());
     auto &ctx = ((BasicWriterBase<Impl> *)this)->getASTContext();
     for (auto elem : path) {
       if (elemTy->getAs<RecordType>()) {
-        asImpl().writeUInt32(elem.getAsBaseOrMember().getInt());
-        const Decl *baseOrMember = elem.getAsBaseOrMember().getPointer();
-        if (const auto *recordDecl = dyn_cast<CXXRecordDecl>(baseOrMember)) {
-          asImpl().writeDeclRef(recordDecl);
-          elemTy = ctx.getRecordType(recordDecl);
-        } else {
-          const auto *valueDecl = cast<ValueDecl>(baseOrMember);
-          asImpl().writeDeclRef(valueDecl);
-          elemTy = valueDecl->getType();
+        asImpl().writeUInt32(elem.isVirtualBase());
+        if (elem.isAnyBase()) {
+          const CXXRecordDecl *D = elem.getAsBase();
+          asImpl().writeDeclRef(D);
+          elemTy = ctx.getRecordType(D);
+        } else if (elem.isField()) {
+          const FieldDecl *D = elem.getAsField();
+          asImpl().writeDeclRef(D);
+          elemTy = D->getType();
         }
       } else {
         asImpl().writeUInt32(elem.getAsArrayIndex());
         elemTy = ctx.getAsArrayType(elemTy)->getElementType();
       }
     }
   }
 

clang/lib/AST/APValue.cpp

if (LHS.Ptr != RHS.Ptr)
     return false;
   if (LHS.is<TypeInfoLValue>() || LHS.is<DynamicAllocLValue>())
     return true;
   return LHS.Local.CallIndex == RHS.Local.CallIndex &&
          LHS.Local.Version == RHS.Local.Version;
 }
 }
 
-APValue::LValuePathEntry::LValuePathEntry(BaseOrMemberType BaseOrMember) {
-  if (const Decl *D = BaseOrMember.getPointer())
-    BaseOrMember.setPointer(D->getCanonicalDecl());
-  Value = reinterpret_cast<uintptr_t>(BaseOrMember.getOpaqueValue());
+APValue::LValuePathEntry::LValuePathEntry(const CXXRecordDecl *Base,
+                                          bool Virtual) {
+  Value.setPointerAndInt(Base, Virtual ? Kind::VirtualBase : Kind::Base);
+}
+
+APValue::LValuePathEntry::LValuePathEntry(const FieldDecl *Field) {
+  Value.setPointerAndInt(Field, Kind::Field);
+}
+
+APValue::LValuePathEntry::LValuePathEntry(size_t Index) {
+  Value.setPointerAndInt(reinterpret_cast<void *>(Index << 2), Kind::Index);
+}
+
+APValue::LValuePathEntry APValue::LValuePathEntry::Declaration(const Decl *D,
+                                                               bool Virtual) {
+  if (auto RD = dyn_cast<CXXRecordDecl>(D))
+    return LValuePathEntry(RD, Virtual);
+  return LValuePathEntry(cast<FieldDecl>(D));
 }
 
 void APValue::LValuePathEntry::Profile(llvm::FoldingSetNodeID &ID) const {
-  ID.AddInteger(Value);
+  ID.AddPointer(Value.getOpaqueValue());
 }
 
 APValue::LValuePathSerializationHelper::LValuePathSerializationHelper(
     ArrayRef<LValuePathEntry> Path, QualType ElemTy)
     : ElemTy((const void *)ElemTy.getTypePtrOrNull()), Path(Path) {}
 
 QualType APValue::LValuePathSerializationHelper::getType() {
   return QualType::getFromOpaquePtr(ElemTy);
case APValue::LValue: {
     }
 
     ArrayRef<LValuePathEntry> Path = getLValuePath();
     const CXXRecordDecl *CastToBase = nullptr;
     for (unsigned I = 0, N = Path.size(); I != N; ++I) {
       if (ElemTy->isRecordType()) {
         // The lvalue refers to a class type, so the next path entry is a base
         // or member.
-        const Decl *BaseOrMember = Path[I].getAsBaseOrMember().getPointer();
-        if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(BaseOrMember)) {
+        if (const CXXRecordDecl *RD = Path[I].getAsBaseOrNull()) {
           CastToBase = RD;
           // Leave ElemTy referring to the most-derived class. The actual type
           // doesn't matter except for array types.
         } else {
-          const ValueDecl *VD = cast<ValueDecl>(BaseOrMember);
+          const FieldDecl *VD = Path[I].getAsField();
           Out << ".";
           if (CastToBase)
             Out << *CastToBase << "::";
           Out << *VD;
           ElemTy = VD->getType();
         }
       } else {
         // The lvalue must refer to an array.

clang/lib/AST/ASTImporter.cpp

case APValue::LValue:
     if (FromValue.hasLValuePath()) {
       MutableArrayRef<APValue::LValuePathEntry> ToPath = Result.setLValueUninit(
           Base, Offset, PathLength, FromValue.isLValueOnePastTheEnd(),
           FromValue.isNullPointer());
       llvm::ArrayRef<APValue::LValuePathEntry> FromPath =
           FromValue.getLValuePath();
       for (unsigned LoopIdx = 0; LoopIdx < PathLength; LoopIdx++) {
         if (FromElemTy->isRecordType()) {
-          const Decl *FromDecl =
-              FromPath[LoopIdx].getAsBaseOrMember().getPointer();
+          const Decl *FromDecl = FromPath[LoopIdx].getAsBaseOrMember();
           const Decl *ImpDecl = importChecked(Err, FromDecl);
           if (Err)
             return std::move(Err);
-          if (auto *RD = dyn_cast<CXXRecordDecl>(FromDecl))
+          if (auto *RD = dyn_cast<CXXRecordDecl>(FromDecl)) {
             FromElemTy = Importer.FromContext.getRecordType(RD);
-          else
+            ToPath[LoopIdx] =
+                APValue::LValuePathEntry(cast<CXXRecordDecl>(ImpDecl),
+                                         FromPath[LoopIdx].isVirtualBase());
+          } else {
             FromElemTy = cast<ValueDecl>(FromDecl)->getType();
-          ToPath[LoopIdx] = APValue::LValuePathEntry(APValue::BaseOrMemberType(
-              ImpDecl, FromPath[LoopIdx].getAsBaseOrMember().getInt()));
+            ToPath[LoopIdx] =
+                APValue::LValuePathEntry(cast<FieldDecl>(ImpDecl));
+          }
         } else {
           FromElemTy =
               Importer.FromContext.getAsArrayType(FromElemTy)->getElementType();
           ToPath[LoopIdx] = APValue::LValuePathEntry::ArrayIndex(
               FromPath[LoopIdx].getAsArrayIndex());
         }
       }
     } else

clang/lib/AST/ExprConstant.cpp

namespace {
 
   using SourceLocExprScopeGuard =
       CurrentSourceLocExprScope::SourceLocExprScopeGuard;
 
   static QualType getType(APValue::LValueBase B) {
     return B.getType();
   }
 
-  /// Get an LValue path entry, which is known to not be an array index, as a
-  /// field declaration.
-  static const FieldDecl *getAsField(APValue::LValuePathEntry E) {
-    return dyn_cast_or_null<FieldDecl>(E.getAsBaseOrMember().getPointer());
-  }
-  /// Get an LValue path entry, which is known to not be an array index, as a
-  /// base class declaration.
-  static const CXXRecordDecl *getAsBaseClass(APValue::LValuePathEntry E) {
-    return dyn_cast_or_null<CXXRecordDecl>(E.getAsBaseOrMember().getPointer());
-  }
-  /// Determine whether this LValue path entry for a base class names a virtual
-  /// base class.
-  static bool isVirtualBaseClass(APValue::LValuePathEntry E) {
-    return E.getAsBaseOrMember().getInt();
-  }
-
   /// Given an expression, determine the type used to store the result of
   /// evaluating that expression.
   static QualType getStorageType(const ASTContext &Ctx, const Expr *E) {
     if (E->isRValue())
       return E->getType();
     return Ctx.getLValueReferenceType(E->getType());
   }
 
for (unsigned I = 0, N = Path.size(); I != N; ++I) {
           ArraySize = AssumedSizeForUnsizedArray;
         }
       } else if (Type->isAnyComplexType()) {
         const ComplexType *CT = Type->castAs<ComplexType>();
         Type = CT->getElementType();
         ArraySize = 2;
         MostDerivedLength = I + 1;
         IsArray = true;
-      } else if (const FieldDecl *FD = getAsField(Path[I])) {
+      } else if (const FieldDecl *FD = Path[I].getAsFieldOrNull()) {
         Type = FD->getType();
         ArraySize = 0;
         MostDerivedLength = I + 1;
         IsArray = false;
       } else {
         // Path[I] describes a base class.
         ArraySize = 0;
         IsArray = false;
struct SubobjectDesignator {
     /// relevant diagnostic and set the designator as invalid.
     bool checkSubobject(EvalInfo &Info, const Expr *E, CheckSubobjectKind CSK);
 
     /// Get the type of the designated object.
     QualType getType(ASTContext &Ctx) const {
       assert(!Invalid && "invalid designator has no subobject type");
       return MostDerivedPathLength == Entries.size()
                  ? MostDerivedType
-                 : Ctx.getRecordType(getAsBaseClass(Entries.back()));
+                 : Ctx.getRecordType(Entries.back().getAsBase());
     }
 
     /// Update this designator to refer to the first element within this array.
     void addArrayUnchecked(const ConstantArrayType *CAT) {
       Entries.push_back(PathEntry::ArrayIndex(0));
 
       // This is a most-derived object.
       MostDerivedType = CAT->getElementType();
void addUnsizedArrayUnchecked(QualType ElemTy) {
       // to an arbitrary value that's likely to loudly break things if it's
       // used.
       MostDerivedArraySize = AssumedSizeForUnsizedArray;
       MostDerivedPathLength = Entries.size();
     }
     /// Update this designator to refer to the given base or member of this
     /// object.
     void addDeclUnchecked(const Decl *D, bool Virtual = false) {
-      Entries.push_back(APValue::BaseOrMemberType(D, Virtual));
+      Entries.push_back(APValue::LValuePathEntry::Declaration(D, Virtual));
 
       // If this isn't a base class, it's a new most-derived object.
       if (const FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
         MostDerivedType = FD->getType();
         MostDerivedIsArrayElement = false;
         MostDerivedArraySize = 0;
         MostDerivedPathLength = Entries.size();
       }
static bool CastToDerivedClass(EvalInfo &Info, const Expr *E, LValue &Result,
   if (!Result.checkSubobject(Info, E, CSK_Derived))
     return false;
 
   // Truncate the path to the subobject, and remove any derived-to-base offsets.
   const RecordDecl *RD = TruncatedType;
   for (unsigned I = TruncatedElements, N = D.Entries.size(); I != N; ++I) {
     if (RD->isInvalidDecl()) return false;
     const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
-    const CXXRecordDecl *Base = getAsBaseClass(D.Entries[I]);
-    if (isVirtualBaseClass(D.Entries[I]))
+    const CXXRecordDecl *Base = D.Entries[I].getAsBase();
+    if (D.Entries[I].isVirtualBase())
       Result.Offset -= Layout.getVBaseClassOffset(Base);
     else
       Result.Offset -= Layout.getBaseClassOffset(Base);
     RD = Base;
   }
   D.Entries.resize(TruncatedElements);
   return true;
 }
if (ObjType->isArrayType()) {
       if (O->isComplexInt()) {
         return handler.found(Index ? O->getComplexIntImag()
                                    : O->getComplexIntReal(), ObjType);
       } else {
         assert(O->isComplexFloat());
         return handler.found(Index ? O->getComplexFloatImag()
                                    : O->getComplexFloatReal(), ObjType);
       }
-    } else if (const FieldDecl *Field = getAsField(Sub.Entries[I])) {
+    } else if (const FieldDecl *Field = Sub.Entries[I].getAsFieldOrNull()) {
       if (Field->isMutable() &&
           !Obj.mayAccessMutableMembers(Info, handler.AccessKind)) {
         Info.FFDiag(E, diag::note_constexpr_access_mutable, 1)
           << handler.AccessKind << Field;
         Info.Note(Field->getLocation(), diag::note_declared_at);
         return handler.failed();
       }
 
if (ObjType->isArrayType()) {
 
       ObjType = getSubobjectType(ObjType, Field->getType(), Field->isMutable());
       LastField = Field;
       if (Field->getType().isVolatileQualified())
         VolatileField = Field;
     } else {
       // Next subobject is a base class.
       const CXXRecordDecl *Derived = ObjType->getAsCXXRecordDecl();
-      const CXXRecordDecl *Base = getAsBaseClass(Sub.Entries[I]);
+      const CXXRecordDecl *Base = Sub.Entries[I].getAsBase();
       O = &O->getStructBase(getBaseIndex(Derived, Base));
 
       ObjType = getSubobjectType(ObjType, Info.Ctx.getRecordType(Base));
     }
   }
 }
 
 namespace {
if (!ObjType.isNull() &&
       else
         ObjType = ObjType->castAsArrayTypeUnsafe()->getElementType();
     } else {
       if (A.Entries[I].getAsBaseOrMember() !=
           B.Entries[I].getAsBaseOrMember()) {
         WasArrayIndex = false;
         return I;
       }
-      if (const FieldDecl *FD = getAsField(A.Entries[I]))
+      if (const FieldDecl *FD = A.Entries[I].getAsFieldOrNull())
         // Next subobject is a field.
         ObjType = FD->getType();
       else
         // Next subobject is a base class.
         ObjType = QualType();
     }
   }
   WasArrayIndex = false;
if (MemPtr.isDerivedMember()) {
     if (LV.Designator.MostDerivedPathLength + MemPtr.Path.size() >
         LV.Designator.Entries.size()) {
       Info.FFDiag(RHS);
       return nullptr;
     }
     unsigned PathLengthToMember =
         LV.Designator.Entries.size() - MemPtr.Path.size();
     for (unsigned I = 0, N = MemPtr.Path.size(); I != N; ++I) {
-      const CXXRecordDecl *LVDecl = getAsBaseClass(
-          LV.Designator.Entries[PathLengthToMember + I]);
+      const CXXRecordDecl *LVDecl =
+          LV.Designator.Entries[PathLengthToMember + I].getAsBase();
       const CXXRecordDecl *MPDecl = MemPtr.Path[I];
       if (LVDecl->getCanonicalDecl() != MPDecl->getCanonicalDecl()) {
         Info.FFDiag(RHS);
         return nullptr;
       }
     }
 
     // Truncate the lvalue to the appropriate derived class.
static bool HandleBaseToDerivedCast(EvalInfo &Info, const CastExpr *E,
   // Check the type of the final cast. We don't need to check the path,
   // since a cast can only be formed if the path is unique.
   unsigned NewEntriesSize = D.Entries.size() - E->path_size();
   const CXXRecordDecl *TargetType = TargetQT->getAsCXXRecordDecl();
   const CXXRecordDecl *FinalType;
   if (NewEntriesSize == D.MostDerivedPathLength)
     FinalType = D.MostDerivedType->getAsCXXRecordDecl();
   else
-    FinalType = getAsBaseClass(D.Entries[NewEntriesSize - 1]);
+    FinalType = D.Entries[NewEntriesSize - 1].getAsBase();
   if (FinalType->getCanonicalDecl() != TargetType->getCanonicalDecl()) {
     Info.CCEDiag(E, diag::note_constexpr_invalid_downcast)
       << D.MostDerivedType << TargetQT;
     return false;
   }
 
   // Truncate the lvalue to the appropriate derived class.
   return CastToDerivedClass(Info, E, Result, TargetType, NewEntriesSize);

 };
 
 static const CXXRecordDecl *getBaseClassType(SubobjectDesignator &Designator,
                                              unsigned PathLength) {
   assert(PathLength >= Designator.MostDerivedPathLength && PathLength <=
       Designator.Entries.size() && "invalid path length");
   return (PathLength == Designator.MostDerivedPathLength)
              ? Designator.MostDerivedType->getAsCXXRecordDecl()
-             : getAsBaseClass(Designator.Entries[PathLength - 1]);
+             : Designator.Entries[PathLength - 1].getAsBase();
 }
 
 /// Determine the dynamic type of an object.
 static Optional<DynamicType> ComputeDynamicType(EvalInfo &Info, const Expr *E,
                                                 LValue &This, AccessKinds AK) {
   // If we don't have an lvalue denoting an object of class type, there is no
   // meaningful dynamic type. (We consider objects of non-class type to have no
   // dynamic type.)
if (auto *ME = dyn_cast<MemberExpr>(E)) {
         auto *RD =
             FD->getType()->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
         if (!RD || RD->hasTrivialDefaultConstructor())
           UnionPathLengths.push_back({PathLength - 1, FD});
       }
 
       E = ME->getBase();
       --PathLength;
-      assert(declaresSameEntity(FD,
-                                LHS.Designator.Entries[PathLength]
-                                    .getAsBaseOrMember().getPointer()));
+      assert(declaresSameEntity(
+          FD, LHS.Designator.Entries[PathLength].getAsBaseOrMember()));
 
       //   -- If E is of the form A[B] and is interpreted as a built-in array
       //      subscripting operator, S(E) is [S(the array operand, if any)].
     } else if (auto *ASE = dyn_cast<ArraySubscriptExpr>(E)) {
       // Step over an ArrayToPointerDecay implicit cast.
       auto *Base = ASE->getBase()->IgnoreImplicit();
       if (!Base->getType()->isArrayType())
         break;
 
       E = Base;
       --PathLength;
 
     } else if (auto *ICE = dyn_cast<ImplicitCastExpr>(E)) {
       // Step over a derived-to-base conversion.
       E = ICE->getSubExpr();
       if (ICE->getCastKind() == CK_NoOp)
         continue;
       if (ICE->getCastKind() != CK_DerivedToBase &&
           ICE->getCastKind() != CK_UncheckedDerivedToBase)
         break;
       // Walk path backwards as we walk up from the base to the derived class.
       for (const CXXBaseSpecifier *Elt : llvm::reverse(ICE->path())) {
         --PathLength;
         (void)Elt;
-        assert(declaresSameEntity(Elt->getType()->getAsCXXRecordDecl(),
-                                  LHS.Designator.Entries[PathLength]
-                                      .getAsBaseOrMember().getPointer()));
+        assert(
+            declaresSameEntity(Elt->getType()->getAsCXXRecordDecl(),
+                               LHS.Designator.Entries[PathLength].getAsBase()));
       }
 
     //   -- Otherwise, S(E) is empty.
     } else {
       break;
     }
   }
 
if (BaseType->isArrayType()) {
         return false;
       BaseType = CAT->getElementType();
     } else if (BaseType->isAnyComplexType()) {
       const auto *CT = BaseType->castAs<ComplexType>();
       uint64_t Index = Entry.getAsArrayIndex();
       if (Index != 1)
         return false;
       BaseType = CT->getElementType();
-    } else if (auto *FD = getAsField(Entry)) {
+    } else if (auto *FD = Entry.getAsFieldOrNull()) {
       bool Invalid;
       if (!IsLastOrInvalidFieldDecl(FD, Invalid))
         return Invalid;
       BaseType = FD->getType();
     } else {
-      assert(getAsBaseClass(Entry) && "Expecting cast to a base class");
+      assert(Entry.getAsBase() && "Expecting cast to a base class");
       return false;
     }
   }
   return true;
 }
 
 /// Tests to see if the LValue has a user-specified designator (that isn't
 /// necessarily valid). Note that this always returns 'true' if the LValue has
if (!LHSDesignator.Invalid && !RHSDesignator.Invalid && IsRelational) {
       // At the point where the designators diverge, the comparison has a
       // specified value if:
       //  - we are comparing array indices
       //  - we are comparing fields of a union, or fields with the same access
       // Otherwise, the result is unspecified and thus the comparison is not a
       // constant expression.
       if (!WasArrayIndex && Mismatch < LHSDesignator.Entries.size() &&
           Mismatch < RHSDesignator.Entries.size()) {
-        const FieldDecl *LF = getAsField(LHSDesignator.Entries[Mismatch]);
-        const FieldDecl *RF = getAsField(RHSDesignator.Entries[Mismatch]);
+        const FieldDecl *LF =
+            LHSDesignator.Entries[Mismatch].getAsFieldOrNull();
+        const FieldDecl *RF =
+            RHSDesignator.Entries[Mismatch].getAsFieldOrNull();
         if (!LF && !RF)
           Info.CCEDiag(E, diag::note_constexpr_pointer_comparison_base_classes);
         else if (!LF)
           Info.CCEDiag(E, diag::note_constexpr_pointer_comparison_base_field)
-              << getAsBaseClass(LHSDesignator.Entries[Mismatch])
-              << RF->getParent() << RF;
+              << LHSDesignator.Entries[Mismatch].getAsBase() << RF->getParent()
+              << RF;
         else if (!RF)
           Info.CCEDiag(E, diag::note_constexpr_pointer_comparison_base_field)
-              << getAsBaseClass(RHSDesignator.Entries[Mismatch])
-              << LF->getParent() << LF;
+              << RHSDesignator.Entries[Mismatch].getAsBase() << LF->getParent()
+              << LF;
         else if (!LF->getParent()->isUnion() &&
                  LF->getAccess() != RF->getAccess())
           Info.CCEDiag(E,
                        diag::note_constexpr_pointer_comparison_differing_access)
               << LF << LF->getAccess() << RF << RF->getAccess()
               << LF->getParent();
       }
     }

clang/lib/AST/Interp/Pointer.cpp

if (isUnknownSizeArray()) {
           Path.push_back(APValue::LValuePathEntry::ArrayIndex(Ptr.getIndex()));
           Ptr = Ptr.getArray();
         } else {
           // TODO: figure out if base is virtual
           bool IsVirtual = false;
 
           // Create a path entry for the field.
           Descriptor *Desc = Ptr.getFieldDesc();
-          if (auto *BaseOrMember = Desc->asDecl()) {
-            Path.push_back(APValue::LValuePathEntry({BaseOrMember, IsVirtual}));
+          if (auto *D = Desc->asDecl()) {
+            Path.push_back(APValue::LValuePathEntry::Declaration(D, IsVirtual));
             Ptr = Ptr.getBase();
             continue;
           }
           llvm_unreachable("Invalid field type");
         }
       }
 
       IsOnePastEnd = isOnePastEnd();

clang/lib/AST/ItaniumMangle.cpp

static bool isZeroInitialized(QualType T, const APValue &V) {
   llvm_unreachable("Unhandled APValue::ValueKind enum");
 }
 
 static QualType getLValueType(ASTContext &Ctx, const APValue &LV) {
   QualType T = LV.getLValueBase().getType();
   for (APValue::LValuePathEntry E : LV.getLValuePath()) {
     if (const ArrayType *AT = Ctx.getAsArrayType(T))
       T = AT->getElementType();
-    else if (const FieldDecl *FD =
-                 dyn_cast<FieldDecl>(E.getAsBaseOrMember().getPointer()))
+    else if (const FieldDecl *FD = E.getAsFieldOrNull())
       T = FD->getType();
     else
-      T = Ctx.getRecordType(
-          cast<CXXRecordDecl>(E.getAsBaseOrMember().getPointer()));
+      T = Ctx.getRecordType(E.getAsBase());
   }
   return T;
 }
 
 void CXXNameMangler::mangleValueInTemplateArg(QualType T, const APValue &V,
                                               bool TopLevel,
                                               bool NeedExactType) {
   // Ignore all top-level cv-qualifiers, to match GCC.
case Path:
       bool OnePastTheEnd = V.isLValueOnePastTheEnd();
 
       for (APValue::LValuePathEntry E : V.getLValuePath()) {
         if (auto *AT = TypeSoFar->getAsArrayTypeUnsafe()) {
           if (auto *CAT = dyn_cast<ConstantArrayType>(AT))
             OnePastTheEnd |= CAT->getSize() == E.getAsArrayIndex();
           TypeSoFar = AT->getElementType();
         } else {
-          const Decl *D = E.getAsBaseOrMember().getPointer();
-          if (auto *FD = dyn_cast<FieldDecl>(D)) {
+          if (const FieldDecl *FD = E.getAsFieldOrNull()) {
             // <union-selector> ::= _ <number>
             if (FD->getParent()->isUnion()) {
               Out << '_';
               if (FD->getFieldIndex())
                 Out << (FD->getFieldIndex() - 1);
             }
             TypeSoFar = FD->getType();
           } else {
-            TypeSoFar = Ctx.getRecordType(cast<CXXRecordDecl>(D));
+            TypeSoFar = Ctx.getRecordType(E.getAsBase());
           }
         }
       }
 
       if (OnePastTheEnd)
         Out << 'p';
       Out << 'E';
       break;

clang/lib/AST/MicrosoftMangle.cpp

if (!V.hasLValuePath() || V.getLValuePath().empty()) {
       }
 
       QualType T = Base.getType();
       for (APValue::LValuePathEntry E : V.getLValuePath()) {
         // We don't know how to mangle array subscripting yet.
         if (T->isArrayType())
           goto mangling_unknown;
 
-        const Decl *D = E.getAsBaseOrMember().getPointer();
-        auto *FD = dyn_cast<FieldDecl>(D);
+        const FieldDecl *FD = E.getAsFieldOrNull();
         // We don't know how to mangle derived-to-base conversions yet.
         if (!FD)
           goto mangling_unknown;
 
         Out << "6";
         ++NumAts;
         T = FD->getType();
       }
 
       auto *VD = Base.dyn_cast<const ValueDecl*>();
       if (!VD)
         break;
       Out << "E";
       mangle(VD);
 
-      for (APValue::LValuePathEntry E : V.getLValuePath()) {
-        const Decl *D = E.getAsBaseOrMember().getPointer();
-        mangleUnqualifiedName(cast<FieldDecl>(D));
-      }
+      for (APValue::LValuePathEntry E : V.getLValuePath())
+        mangleUnqualifiedName(E.getAsField());
       for (unsigned I = 0; I != NumAts; ++I)
         Out << '@';
     }
 
     return;
   }
 
   case APValue::MemberPointer: {